4. Die View und ihr Modell
Bisher haben die Actions ihre Antworten selbst erzeugt. In einer MVC-Anwendung ist das die Aufgabe einer View: einer Datei, die die HTML-Seite beschreibt, mit Platzhaltern für die Daten, die ihr die Action übergibt – das Modell der View. [ASP.NET Core MVC] verwendet die [Razor]-View-Engine: Eine View ist eine [.cshtml]-Datei, abgeleitet von HTML, in die [C#]-Code eingefügt wird, eingeleitet durch das Zeichen [@]. [Razor] ist Teil des Frameworks: Es muss nichts installiert werden.
4.1. Beispiel 13: Eine erste View
Die Datei [Program.cs]:
| var builder = WebApplication.CreateBuilder(args);
// die MVC-Services: Controller UND Razor-Views
builder.Services.AddControllersWithViews();
var app = builder.Build();
app.MapControllers();
app.Run();
|
- Zeile 4: [AddControllersWithViews] ersetzt [AddControllers] aus den vorherigen Beispielen. Es fügt den Controller-Services die View-Services hinzu: die [Razor]-Engine, die Suche nach View-Dateien und die Tag Helper (Beispiel 15).
Das Modell der View ist eine einfache Klasse. Die Datei [Models/PageModel.cs]:
| namespace Example13.Models;
// das View-Modell: die Daten, die die Action an die View übergibt
public record PageModel(string Title, string Message, string Time);
|
- Zeile 4: Ein [record] ist eine Klasse, deren Eigenschaften vom Konstruktor gesetzt werden; hier drei Zeichenketten: [Title], [Message] und [Time]. Das ist eine knappe Möglichkeit, eine Klasse zu definieren, die lediglich Daten transportiert.
Die Datei [Controllers/ViewsController.cs]:
| using Example13.Models;
using Microsoft.AspNetCore.Mvc;
namespace Example13.Controllers;
public class ViewsController : Controller
{
// View(model): die View, die den Namen der Action trägt (Views/Views/Index.cshtml)
[HttpGet("/")]
public IActionResult Index()
{
var model = new PageModel(
"My first view",
"This page was built by Razor, on the server.",
DateTime.Now.ToString("HH:mm:ss"));
return View(model);
}
// View(name, model): die View wird von der Action gewählt
[HttpGet("hello/{name}")]
public IActionResult Hello(string name)
{
if (name == "unknown")
{
Response.StatusCode = 404;
return View("Unknown", name);
}
var model = new PageModel(
$"Hello {name}",
"This time, the action designated the view by its name.",
DateTime.Now.ToString("HH:mm:ss"));
return View("Index", model);
}
}
|
Kommentieren wir diesen Code:
- Zeile 6: Der Controller leitet sich von der Klasse [Controller] ab und nicht von [ControllerBase]: [Controller] ergänzt [ControllerBase] um alles, was mit Views zu tun hat (die Methoden [View], [ViewData], [TempData] usw.);
- Zeilen 12–15: Die Action erzeugt das Modell der View: einen Titel, eine Nachricht und die aktuelle Uhrzeit;
- Zeile 16: [View(model)] gibt ein [ViewResult] zurück: Die Action erzeugt die Antwort nicht mehr selbst, sondern bestimmt eine View und übergibt ihr ein Modell. Wird kein View-Name angegeben, wird die View verwendet, die den gleichen Namen wie die Action trägt: [Index];
- Zeilen 23–26: Wenn die View von der Anfrage abhängt, wählt die Action die View aus. Hier zeigt der Name [unknown] die View [Unknown] mit dem Statuscode 404 an. Das Modell dieser View ist eine einfache Zeichenkette;
- Zeile 32: Die Action [Hello] gibt die View [Index] ausdrücklich mit Namen an: Zwei Actions teilen sich dieselbe View, mit unterschiedlichen Modellen.
Wo sucht [ASP.NET Core] die View [Index] für die Action [ViewsController.Index]? Per Konvention in zwei Ordnern, in dieser Reihenfolge:
- [Views/Views/Index.cshtml]: der nach dem Controller benannte Ordner (ohne das Suffix [Controller]);
- [Views/Shared/Index.cshtml]: der Ordner mit den Views, die von allen Controllern gemeinsam genutzt werden (siehe Beispiel 15).
Wird die View nirgends gefunden, listet eine Ausnahme die geprüften Pfade auf. Die Projektdateien:
| 13-first-view/
├── Controllers/
│ └── ViewsController.cs
├── Models/
│ └── PageModel.cs
├── Views/
│ ├── Views/
│ │ ├── Index.cshtml
│ │ └── Unknown.cshtml
│ └── _ViewImports.cshtml
├── appsettings.json
├── Example13.csproj
└── Program.cs
|
Die Datei [Views/_ViewImports.cshtml]:
| @* die "using"-Direktiven, die alle Views des Ordners Views gemeinsam nutzen *@
@using Example13.Models
|
- Zeile 1: [@* ... *@] ist ein [Razor]-Kommentar: Er erscheint nicht auf der erzeugten Seite (anders als ein HTML-Kommentar [<!-- -->]);
- Zeile 2: Die Direktiven in der Datei [_ViewImports.cshtml] gelten für alle Views in ihrem Ordner und seinen Unterordnern. [@using Example13.Models] erlaubt es, in den Views [PageModel] anstelle von [Example13.Models.PageModel] zu schreiben.
Die Datei [Views/Views/Index.cshtml]:
| @* der Typ des Modells dieser View *@
@model PageModel
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>@Model.Title</title>
</head>
<body>
<h1>@Model.Title</h1>
<p>@Model.Message</p>
<p>Page built at @Model.Time.</p>
</body>
</html>
|
- Zeile 2: Die Direktive [@model] deklariert den Typ des Modells der View. In der View hat die Eigenschaft [Model] dann den Typ [PageModel], und der Compiler prüft, ob [Model.Title] existiert;
- Zeilen 7–12: Jeder Ausdruck [@Model.Title] wird durch den entsprechenden Wert aus dem Modell ersetzt. [Razor] erkennt das Ende eines Ausdrucks selbstständig: In [@Model.Time.] folgt auf den Punkt ein Tag, es handelt sich also nicht um einen Eigenschaftszugriff.
Eine View ist eine getarnte [C#]-Datei: Beim Kompilieren des Projekts ([dotnet build]) wird jede [.cshtml]-Datei in eine [C#]-Klasse übersetzt, die zusammen mit dem Rest der Anwendung kompiliert wird. Ein Fehler in einer View ([@Model.Titl]) wird daher bereits beim Kompilieren gemeldet. Das Ergebnis unter der URL http://localhost:5000/:

Der Quellcode der vom Browser empfangenen Seite enthält keine Spur von [Razor] mehr:
| curl http://localhost:5000/
|
| <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>My first view</title>
</head>
<body>
<h1>My first view</h1>
<p>This page was built by Razor, on the server.</p>
<p>Page built at 12:12:36.</p>
</body>
</html>
|
Beachten Sie, dass akzentuierte Zeichen, die durch einen [@]-Ausdruck eingefügt werden, codiert würden (diese Seite enthält keine): Ein französischer Titel wie [Ma première vue] würde als [Ma première vue] gesendet, wobei [è] der Code für das Zeichen [è] ist, während direkt in die View getippter akzentuierter Text unverändert bliebe. Der Browser zeigt beides korrekt an, aber der HTML-Code ist schwer lesbar. In Beispiel 15 werden wir sehen, wie sich das vermeiden lässt. Die URL http://localhost:5000/hello/martin zeigt dieselbe View mit einem anderen Modell an:

und http://localhost:5000/hello/unknown zeigt eine andere View an:
| curl -i http://localhost:5000/hello/unknown
|
| HTTP/1.1 404 Not Found
Content-Type: text/html; charset=utf-8
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Unknown</title>
</head>
<body>
<h1>Nobody is called [unknown] here.</h1>
</body>
</html>
|
Die Datei [Views/Views/Unknown.cshtml]:
| @* das Modell dieser View ist ein einfacher String: der angeforderte Name *@
@model string
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Unknown</title>
</head>
<body>
<h1>Nobody is called [@Model] here.</h1>
</body>
</html>
|
- Zeile 2: Das Modell dieser View ist eine Zeichenkette;
- Zeile 10: [@Model] ist die Zeichenkette selbst.
4.2. Beispiel 14: Die Sprache Razor
[Razor] ist keine „logikfreie“ Template-Sprache wie [Handlebars]: Sie können [C#]-Code in einer View schreiben (Bedingungen, Schleifen, Variablen, Methodenaufrufe). Diese Freiheit erfordert Disziplin: Die View muss rein der Formatierung dienen; Berechnungen und Entscheidungen gehören in die Action und die Services. Beispiel 14 gibt einen Überblick über die Syntax. Das Modell, Datei [Models/BasicsModel.cs]:
| namespace Example14.Models;
public record Product(string Name, decimal Price, bool InStock);
public record Address(string Street, string City);
public class BasicsModel
{
public string Title { get; set; } = "";
public string Name { get; set; } = "";
public string? Nickname { get; set; }
public string Html { get; set; } = "";
public bool LoggedIn { get; set; }
public string Currency { get; set; } = "";
public List<Product> Products { get; set; } = [];
public List<Product> Cart { get; set; } = [];
public Address Address { get; set; } = new("", "");
}
|
Die Datei [Controllers/BasicsController.cs]:
| using Example14.Models;
using Microsoft.AspNetCore.Mvc;
namespace Example14.Controllers;
public class BasicsController : Controller
{
[HttpGet("/")]
public IActionResult Index()
{
var model = new BasicsModel
{
Title = "Razor basics",
Name = "Martin",
Nickname = null,
Html = "<b>this is HTML</b>",
LoggedIn = true,
Currency = "€",
Products =
[
new Product("Keyboard", 25m, true),
new Product("Mouse", 12.5m, false),
new Product("Screen", 149m, true),
],
Cart = [],
Address = new Address("12 rue des Lilas", "Angers"),
};
return View(model);
}
}
|
- Zeilen 11–26: Die Action füllt das Modell: einige Zeichenketten, einen booleschen Wert, eine Liste mit drei Produkten, einen leeren Warenkorb und eine Adresse. [Nickname] ist absichtlich gleich [null].
Die View, Datei [Views/Basics/Index.cshtml]:
| @model BasicsModel
@* ein C#-Codeblock: er erzeugt nichts in der Seite *@
@{
var total = Model.Products.Sum(p => p.Price);
var count = Model.Products.Count;
}
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>@Model.Title</title>
</head>
<body>
<h1>@Model.Title</h1>
@* 1. einen Wert des Modells anzeigen; ein null-Wert zeigt nichts an *@
<p>1. Name: @Model.Name - nickname: [@Model.Nickname]</p>
@* 2. @ maskiert HTML, @Html.Raw fügt es unverändert ein *@
<p>2a. @Model.Html</p>
<p>2b. @Html.Raw(Model.Html)</p>
@* 3. eine Bedingung *@
@if (Model.LoggedIn)
{
<p>3. You are logged in.</p>
}
else
{
<p>3. You are not logged in.</p>
}
@* 4. eine Schleife; die Schleifenvariablen sind C#-Variablen *@
<p>4. Our products:</p>
<ul>
@for (var i = 0; i < Model.Products.Count; i++)
{
var product = Model.Products[i];
<li>no. @i: @product.Name, @product.Price @Model.Currency
@(product.InStock ? "(in stock)" : "(sold out)")
@if (i == 0) { <text>- the first one</text> }
@if (i == Model.Products.Count - 1) { @:- the last one, seen by @Model.Name
}
</li>
}
</ul>
@* 5. die leere Liste *@
<p>5. Your cart:
@if (Model.Cart.Count == 0)
{
<text>it is empty.</text>
}
else
{
foreach (var p in Model.Cart) { <span>@p.Name</span> }
}
</p>
@* 6. ein expliziter Ausdruck @( ... ) und die Variablen des Blocks @{ } *@
<p>6. @count products, for a total of @(total) @Model.Currency; average price: @((total / count).ToString("0.00")) @Model.Currency</p>
<p>7. Address: @Model.Address.Street, @Model.Address.City.ToUpper()</p>
<p>8. An email address: contact@example.com</p>
</body>
</html>
|
Kommentieren wir diesen Code:
- Zeilen 2–5: Ein Codeblock mit dem Namen [@{ ... }] enthält [C#]-Anweisungen. Er erzeugt nichts auf der Seite. Die darin deklarierten Variablen ([total], [count]) können später in der View verwendet werden;
- Zeile 16: Ein [null] -Wert ([@Model.Nickname]) zeigt nichts an, ohne Fehler;
- Zeilen 18–19: Ein Ausdruck [@...] maskiert die Sonderzeichen in HTML ([<] wird zu [<] ...): Der Text wird unverändert angezeigt. [@Html.Raw(...)] fügt ihn ohne Maskierung ein: Er wird als HTML interpretiert. [Html.Raw] wird nur für HTML verwendet, das von der Anwendung erzeugt wurde, niemals für Daten, die ein Benutzer eingegeben hat: Der Benutzer könnte sonst HTML oder sogar [JavaScript] in die Seite einschleusen (ein Angriff, der als [XSS] bekannt ist, [cross-site scripting]);
- Zeilen 21–27: eine Bedingung. Nach [@if (...)] ist der Inhalt innerhalb der geschweiften Klammern HTML: [Razor] erkennt den Beginn eines Tags und wechselt in den HTML-Modus zurück. Zu [C#] kehren wir über [@] zurück;
- Zeilen 32–40: eine [for]-Schleife in [C#]. [var product = ...] ist eine [C#]-Anweisung, [<li>] ist HTML: [Razor] wechselt ohne besondere Markierung zwischen beiden;
- Zeile 36: ein expliziter Ausdruck [@( ... )]. Klammern sind immer dann erforderlich, wenn der Ausdruck Leerzeichen oder Operatoren enthält (hier der Bedingungsoperator [? :]);
- Zeile 37: Um unformatierten Text innerhalb eines [C#]-Blocks zu schreiben, wird er in das spezielle Tag [<text>] eingeschlossen, das auf der Seite nicht erscheint;
- Zeile 38: [@:] leistet dasselbe für den Rest der Zeile;
- Zeilen 45–51: Eine leere Liste ist einfach ein [if]. Im [else]-Block, der sich bereits im [C#]-Modus befindet, wird [foreach] ohne [@] geschrieben;
- Zeile 55: die Variablen des [@{ }]-Blocks und explizite Ausdrücke, einschließlich eines Methodenaufrufs: [ToString("0.00")] formatiert eine Zahl mit zwei Nachkommastellen;
- Zeile 56: ein Pfad in Punktnotation [@Model.Address.Street] und ein Methodenaufruf [ToUpper()];
- Zeile 57: [Razor] erkennt, dass ein [@] zwischen zwei alphanumerischen Zeichen kein Code ist: [contact@example.com] ist eine E-Mail-Adresse. Um ein [@] zu schreiben, das mehrdeutig wäre, verdoppeln wir es: [@@].
Das Ergebnis unter der URL http://localhost:5000/ lautet:

Der erzeugte HTML-Code:
| curl http://localhost:5000/
|
| <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Razor basics</title>
</head>
<body>
<h1>Razor basics</h1>
<p>1. Name: Martin - nickname: []</p>
<p>2a. <b>this is HTML</b></p>
<p>2b. <b>this is HTML</b></p>
<p>3. You are logged in.</p>
<p>4. Our products:</p>
<ul>
<li>no. 0: Keyboard, 25 €
(in stock)
- the first one </li>
<li>no. 1: Mouse, 12.5 €
(sold out)
</li>
<li>no. 2: Screen, 149 €
(in stock)
- the last one, seen by Martin
</li>
</ul>
<p>5. Your cart:
it is empty. </p>
<p>6. 3 products, for a total of 186.5 €; average price: 62.17 €</p>
<p>7. Address: 12 rue des Lilas, ANGERS</p>
<p>8. An email address: contact@example.com</p>
</body>
</html>
|
Beachten Sie die Leerzeichen und Leerzeilen, die von den [C#]-Anweisungen übrig bleiben: Sie haben keinen Einfluss auf die Anzeige. Außerdem sehen wir die Kodierung von Zeichen mit Akzent, die aus Ausdrücken stammen ([€] für [€]), was im folgenden Beispiel korrigiert wird.
4.3. Beispiel 15: Template, Partial Views, statische Dateien
Die Seiten einer Website teilen sich ein gemeinsames Template (Kopfzeile, Navigationsleiste, Fußzeile). [Razor] bezeichnet dieses Template als „Layout“: Jede View wird darin eingefügt. Wiederverwendbare Seitenkomponenten sind die Partial Views. Schließlich benötigen Seiten statische Dateien (Stylesheets, Bilder, Skripte), die unverändert ausgeliefert werden, ohne einen Controller zu durchlaufen. Die Dateien des Beispiels:
| 15-layout/
├── Controllers/
│ └── PagesController.cs
├── Views/
│ ├── Pages/
│ │ ├── Home.cshtml
│ │ ├── Raw.cshtml
│ │ └── Team.cshtml
│ ├── Shared/
│ │ ├── _Card.cshtml
│ │ ├── _Layout.cshtml
│ │ └── _Navbar.cshtml
│ ├── _ViewImports.cshtml
│ └── _ViewStart.cshtml
├── wwwroot/
│ └── css/
│ └── styles.css
├── appsettings.json
├── Example15.csproj
└── Program.cs
|
Die Datei [Program.cs]:
| using System.Text.Encodings.Web;
using System.Text.Unicode;
using Microsoft.Extensions.FileProviders;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
// Razor schreibt Zeichen mit Akzenten unverändert (und nicht "é");
// < > & " ' bleiben maskiert
builder.Services.AddSingleton(HtmlEncoder.Create(UnicodeRanges.All));
var app = builder.Build();
// 1. die statischen Dateien des Ordners wwwroot: wwwroot/css/styles.css wird als /css/styles.css ausgeliefert
app.UseStaticFiles();
// 2. Bootstrap, von den Beispielen gemeinsam genutzt: der Ordner examples/common/bootstrap wird unter /bootstrap ausgeliefert
app.UseStaticFiles(new StaticFileOptions
{
FileProvider = new PhysicalFileProvider(Path.GetFullPath(Path.Combine(builder.Environment.ContentRootPath, "..", "common", "bootstrap"))),
RequestPath = "/bootstrap",
});
app.MapControllers();
app.Run();
|
Kommentieren wir diesen Code:
- Zeile 9: Der [HtmlEncoder]-Service wird von [Razor] verwendet, um die Ausdrücke in [@] zu maskieren. Standardmäßig lässt er nur Zeichen des einfachen lateinischen Alphabets unverändert passieren: Deshalb wird [é] als [é] kodiert (und [€] als [€]). Wir ersetzen diesen Service durch einen Encoder, der alle Zeichen durchlässt ([UnicodeRanges.All]). Die gefährlichen Zeichen ([<], [>], [&], ["], [']) bleiben maskiert: Der Schutz vor HTML-Injection bleibt vollständig erhalten. Alle folgenden Beispiele sowie die Fallstudie enthalten diese Zeile;
- Zeile 14: eine Middleware-Komponente (siehe Kapitel 7), die Dateien aus dem Ordner [wwwroot] des Projekts ausliefert: Die Datei [wwwroot/css/styles.css] wird unter der URL [/css/styles.css] ausgeliefert. Existiert die Datei nicht, wird die Anfrage an die Controller weitergereicht;
- Zeilen 16–19: Ein zweiter Service für statische Dateien. Das CSS-[Bootstrap]-Framework ist allen Beispielen gemeinsam: Es wird nur einmal im Ordner [examples/common/bootstrap] abgelegt und unter dem Präfix [/bootstrap] ausgeliefert. [PhysicalFileProvider] bezeichnet einen Ordner auf der Festplatte; [ContentRootPath] ist der Projektordner. So wird [examples/common/bootstrap/css/bootstrap.min.css] unter der URL [/bootstrap/css/bootstrap.min.css] ausgeliefert. Die Fallstudie hingegen legt [Bootstrap] in ihrem eigenen Ordner ab, [wwwroot].
Prüfen wir das:
| curl -i http://localhost:5000/css/styles.css
|
| HTTP/1.1 200 OK
Content-Length: 430
Content-Type: text/css
/* einige Einstellungen zusätzlich zu Bootstrap */
body {
background-color: #f5f7fa;
}
/* der Footer des Layouts */
.footer {
margin-top: 2rem;
font-size: 0.85rem;
color: #6c757d;
}
/* die Fehlermeldungen am Seitenende auf hellrosa Hintergrund */
.error-area {
margin-top: 1.5rem;
padding: 0.75rem 1rem;
background-color: #fdecef;
border: 1px solid #f5c2c7;
border-radius: 0.375rem;
color: #842029;
}
|
Die Datei [Views/_ViewStart.cshtml]:
| @* wird vor jeder View ausgeführt: alle Views verwenden das Layout _Layout *@
@{
Layout = "_Layout";
}
|
- Zeile 3: Die Datei [_ViewStart.cshtml] wird vor jeder View in ihrem Ordner und in den Unterordnern ausgeführt. Sie setzt die Eigenschaft [Layout]: Alle Views verwenden das Template [_Layout], das im Ordner der View und anschließend in [Views/Shared] gesucht wird.
Die Datei [Views/_ViewImports.cshtml]:
| @* die ASP.NET-Core-Tag-Helper: "angereicherte" HTML-Tags, wie <partial> *@
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
@using Example15.Controllers
|
- Zeile 2: Aktiviert die Tag Helper, die von [ASP.NET Core] bereitgestellt werden: HTML-Tags oder -Attribute, die vom Server verarbeitet werden. Das Tag [<partial>] ist ein Beispiel dafür. [*] bedeutet „alle Tag Helper der Assembly“ [Microsoft.AspNetCore.Mvc.TagHelpers];
- Zeile 3: Der Typ [Member] ist im Namespace der Controller deklariert.
Die Datei [Views/Shared/_Layout.cshtml]:
| <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
@* ViewData["Title"]: ein von der View gesetzter Wert, vom Layout gelesen *@
<title>@ViewData["Title"] - My site</title>
<link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
<link rel="stylesheet" href="/css/styles.css">
</head>
<body>
<div class="container py-3">
<partial name="_Navbar" />
@* die von der Action angeforderte View wird hier eingefügt *@
@RenderBody()
@* Context: die aktuelle Anfrage (HttpContext), in jeder View verfügbar *@
<footer class="footer">Page [@Context.Request.Path] - © @DateTime.Now.Year</footer>
</div>
</body>
</html>
|
- Zeile 7: [ViewData] ist ein Dictionary, das sich eine View und ihr Template teilen (sowie die Action, die ebenfalls Werte darin ablegen kann). Die View legt dort ihren Titel ab, und das Template zeigt ihn an;
- Zeilen 8–9: die Stylesheets, ausgeliefert von [UseStaticFiles];
- Zeile 13: Einfügen der Partial View [_Navbar], die im Ordner der View und anschließend in [Views/Shared] gesucht wird;
- Zeile 15: die Stelle, an der [Razor] die von der Action angeforderte View einfügt;
- Zeile 17: [Context] ist das [HttpContext]-Objekt der aktuellen Anfrage (siehe Beispiel 05), das jeder View zur Verfügung steht: Das Template zeigt den angeforderten Pfad an, ohne dass jede Action ihn weitergeben muss.
Die Datei [Views/Shared/_Navbar.cshtml]:
| <nav class="navbar navbar-expand bg-light rounded mb-3 px-3">
<span class="navbar-brand">My site</span>
<div class="navbar-nav">
<a class="nav-link" href="/">Home</a>
<a class="nav-link" href="/team">Team</a>
<a class="nav-link" href="/raw">Page without layout</a>
</div>
</nav>
|
Die Datei [Views/Shared/_Card.cshtml]:
| @* eine Bootstrap-"Card"; ihr Modell: ein Member (Name, Rolle) *@
@model Member
<div class="card">
<div class="card-body">
<h5 class="card-title">@Model.Name</h5>
<p class="card-text">@Model.Role</p>
</div>
</div>
|
Per Konvention beginnt der Name einer Partial View oder eines Templates mit [_]: Dies sind keine vollständigen Seiten. Die Partial View [_Card] hat ein eigenes Modell (Zeile 2), einen Namen und eine Rolle. Der Typ [Member] ist im Controller deklariert. Die Datei [Controllers/PagesController.cs]:
| using Microsoft.AspNetCore.Mvc;
namespace Example15.Controllers;
public record Member(string Name, string Role);
public class PagesController : Controller
{
[HttpGet("/")]
public IActionResult Home()
{
return View();
}
[HttpGet("team")]
public IActionResult Team()
{
List<Member> members =
[
new Member("Marie Pélissier", "Director"),
new Member("Jacques Bromard", "Developer"),
new Member("Philippe Jandot", "Graphic designer"),
];
return View(members);
}
[HttpGet("raw")]
public IActionResult Raw()
{
return View();
}
}
|
- Zeile 5: der Typ der Teammitglieder;
- Zeile 12: Die Action [Home] hat kein Modell: [View()] ohne Argumente;
- Zeilen 18–24: Die Action [Team] übergibt eine Liste von Mitgliedern.
Die Partial View wird auf zwei Arten verwendet. Die Datei [Views/Pages/Home.cshtml]:
| @{
ViewData["Title"] = "Home";
}
<h1>Welcome</h1>
<p>This page only contains its own content: the header, the navigation
bar and the footer come from the <code>_Layout.cshtml</code> layout.</p>
<partial name="_Card" model='new Member("A partial view", "inserted with a model built on the spot")' />
|
- Zeile 2: Die View legt ihren Titel für das Template in [ViewData] ab;
- Zeile 7: Das Attribut [model] des Tags [<partial>] liefert das Modell der Partial View: hier ein spontan erzeugtes Objekt. Es handelt sich um einen [C#]-Ausdruck: Er steht in Apostrophen, damit darin Anführungszeichen verwendet werden können.
Die Datei [Views/Pages/Team.cshtml]:
| @model List<Member>
@{
ViewData["Title"] = "Our team";
}
<h1>Our team</h1>
<div class="row g-3">
@foreach (var member in Model)
{
<div class="col-md-4">
@* die Partial View erhält das aktuelle Mitglied als Modell *@
<partial name="_Card" model="member" />
</div>
}
</div>
|
- Zeile 11: Die Partial View erhält die aktuelle Schleifeniteration als Modell.
Die Datei [Views/Pages/Raw.cshtml]:
| @* Layout = null: diese View verwendet das Layout nicht, sie ist eine vollständige Seite *@
@{
Layout = null;
}
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Raw page</title>
</head>
<body>
<p>This page does not use the layout: no Bootstrap, no navigation bar.</p>
<p><a href="/">Back to home</a></p>
</body>
</html>
|
- Zeile 3: Das Setzen von [Layout] auf [null] in einer View hebt die Auswahl aus [_ViewStart.cshtml] auf: Die View [Raw] ist eine vollständige HTML-Seite. Man könnte auch ein anderes Template angeben ([Layout = "_Other"]).
Die resultierenden Seiten unter den URLs http://localhost:5000/, http://localhost:5000/team, und http://localhost:5000/raw:



Das Template, die Partial Views und [ViewData] sind genau das, was die Fallstudie verwendet: ein [_Layout.cshtml]-Template, Partial Views für die Navigationsleiste, Meldungen und Bestätigungsfenster.
4.4. Beispiel 16: Helper
Eine View benötigt oft kleine Formatierungsfunktionen: ein Datum oder einen Preis formatieren, Text in Großbuchstaben umwandeln, ein HTML-Badge erzeugen ... Mit [Razor] sind dies einfache [C#]-Methoden, die innerhalb eines [@]-Ausdrucks aufgerufen werden. [ASP.NET Core] bietet außerdem Tag Helper: [C#]-Code, der beim Rendern der Seite auf ein HTML-Tag einwirkt.
Die Datei [Helpers/Formats.cs]:
| using System.Globalization;
using System.Text.Encodings.Web;
using Microsoft.AspNetCore.Html;
namespace Example16.Helpers;
// gewöhnliche C#-Funktionen, aus den Views aufrufbar: @Formats.Money(...)
public static class Formats
{
// "keyboard" -> "KEYBOARD"
public static string Uppercase(string? text) => (text ?? "").ToUpperInvariant();
// ein Betrag in einer Währung, im Format der aktuellen Sprache (CultureInfo.CurrentCulture)
// "C" = Währung; das Objekt NumberFormatInfo legt das Währungssymbol fest
public static string Money(decimal amount, string currency = "EUR")
{
var format = (NumberFormatInfo)CultureInfo.CurrentCulture.NumberFormat.Clone();
format.CurrencySymbol = currency == "USD" ? "$" : "€";
return amount.ToString("C", format);
}
// ein ausgeschriebenes Datum in der aktuellen Sprache: "Wednesday, September 23, 2026"
public static string Date(DateTime when) => when.ToString("D", CultureInfo.CurrentCulture);
// ein Helper, der HTML erzeugt: er gibt ein IHtmlContent zurück, das Razor nicht maskiert.
// Der Helper muss dann selbst die eingefügten Daten maskieren (HtmlEncoder)
public static IHtmlContent Badge(int stock)
{
var cssClass = stock > 0 ? "text-bg-success" : "text-bg-danger";
var text = HtmlEncoder.Default.Encode(stock > 0 ? $"{stock} in stock" : "sold out");
return new HtmlString($"<span class=\"badge {cssClass}\">{text}</span>");
}
}
|
Gehen wir diesen Code durch:
- Zeile 8: eine statische Klasse – ihre Methoden werden aufgerufen, ohne ein Objekt zu erzeugen, [Formats.Uppercase(...)];
- Zeile 11: Umwandlung in Großbuchstaben. [ToUpperInvariant] ist unabhängig von der Sprache des Benutzers;
- Zeilen 15–19: ein Betrag in einer Währung. Das Format ["C"] ([currency]) formatiert einen Betrag gemäß der aktuellen Locale ([CultureInfo.CurrentCulture]): Dezimaltrennzeichen, Tausendertrennzeichen und Position des Währungssymbols. Die Regeln der Locale werden kopiert ([Clone]), um das Währungssymbol zu ändern;
- Zeile 23: ein ausgeschriebenes Datum (Format ["D"]) in der Sprache der aktuellen Kultur;
- Zeilen 27–31: ein Helper, der HTML erzeugt. Die Ausgabe eines [@]-Ausdrucks wird maskiert, es sei denn, es handelt sich um ein [IHtmlContent]: vorab erzeugtes HTML. [HtmlString] ist die einfachste Implementierung davon. Der Helper muss dann die Daten, die er in sein HTML einfügt, selbst maskieren ([HtmlEncoder.Default.Encode]).
Die Datei [TagHelpers/ActiveTagHelper.cs]:
| using System.Text.Encodings.Web;
using Microsoft.AspNetCore.Mvc.TagHelpers;
using Microsoft.AspNetCore.Razor.TagHelpers;
namespace Example16.TagHelpers;
// ein Tag Helper: er wird auf die <a>-Tags angewendet, die das Attribut "active-path" tragen
// <a href="/products" active-path="/products"> erhält die Klasse "active", wenn die
// aktuelle Seite unter diesem Pfad liegt
[HtmlTargetElement("a", Attributes = "active-path")]
public class ActiveTagHelper(IHttpContextAccessor accessor) : TagHelper
{
// der Wert des Attributs active-path="..."
public string ActivePath { get; set; } = "";
public override void Process(TagHelperContext context, TagHelperOutput output)
{
var path = accessor.HttpContext?.Request.Path.Value ?? "/";
var isActive = ActivePath == "/" ? path == "/" : path.StartsWith(ActivePath, StringComparison.Ordinal);
if (isActive)
{
output.AddClass("active", HtmlEncoder.Default); // fügt die Klasse zum Attribut class hinzu
}
}
}
|
Gehen wir diesen Code durch:
- Zeile 10: Der Tag Helper gilt für [<a>]-Tags, die das Attribut [active-path] besitzen;
- Zeile 11: Ein Tag Helper leitet sich von der Klasse [TagHelper] ab. Er ist ein Service: Er erhält per Injection einen [IHttpContextAccessor], der Zugriff auf die aktuelle Anfrage bietet;
- Zeile 14: Der Wert des Attributs [active-path="..."] wird der gleichnamigen Eigenschaft ([ActivePath]) zugewiesen;
- Zeilen 16–22: Die Methode [Process] wird für jedes betroffene Tag aufgerufen. Beginnt der Pfad der Seite mit dem Wert des Attributs, wird die CSS-Klasse [active] zum Tag hinzugefügt ([AddClass]). Das Attribut [active-path] selbst erscheint nicht in der erzeugten Seite: Der Tag Helper hat es verbraucht.
Die Datei [Program.cs]:
| using System.Globalization;
using System.Text.Encodings.Web;
using System.Text.Unicode;
using Microsoft.Extensions.FileProviders;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
builder.Services.AddSingleton(HtmlEncoder.Create(UnicodeRanges.All));
// IHttpContextAccessor: gibt Zugriff auf die aktuelle Anfrage (von ActiveTagHelper verwendet)
builder.Services.AddHttpContextAccessor();
var app = builder.Build();
// eine Middleware: die Formatierungssprache stammt aus dem URL-Parameter ?lang=fr
app.Use(async (context, next) =>
{
var language = context.Request.Query["lang"] == "fr" ? "fr-FR" : "en-US";
CultureInfo.CurrentCulture = new CultureInfo(language);
await next(context); // an die nächste Middleware übergeben
});
app.UseStaticFiles();
app.UseStaticFiles(new StaticFileOptions
{
FileProvider = new PhysicalFileProvider(Path.GetFullPath(Path.Combine(builder.Environment.ContentRootPath, "..", "common", "bootstrap"))),
RequestPath = "/bootstrap",
});
app.MapControllers();
app.Run();
|
- Zeile 10: registriert den [IHttpContextAccessor]-Service, der vom Tag Helper verwendet wird;
- Zeilen 15–19: direkt in [Program.cs] geschriebene Middleware, die bei jeder Anfrage ausgeführt wird. Sie wählt die Kultur anhand des Parameters [lang] der URL aus und übergibt dann die Kontrolle an die nächste Middleware ([next]). Das ist eine einfache Möglichkeit zum Testen; das nächste Kapitel behandelt das besser.
Die Datei [Views/_ViewImports.cshtml]:
| @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
@* unsere eigenen Tag Helper, die der Assembly Example16 *@
@addTagHelper *, Example16
@using Example16.Helpers
@using Example16.Controllers
|
- Zeile 3: Wir aktivieren die Tag Helper für unser eigenes Projekt (die Assembly [Example16]);
- Zeile 4: Views können [Formats.Money(...)] schreiben.
Die Datei [Views/Shared/_Navbar.cshtml]:
| <nav class="navbar navbar-expand bg-light rounded mb-3 px-3">
<span class="navbar-brand">Helpers</span>
<div class="navbar-nav">
@* 1. eine in der View geschriebene Bedingung *@
<a class="nav-link @(Context.Request.Path == "/" ? "active" : "")" href="/">Home</a>
@* 2. unser Tag Helper: das Attribut active-path="..." *@
<a class="nav-link" href="/products" active-path="/products">Products</a>
@* 3. ein ASP.NET-Tag-Helper: asp-action erzeugt die URL der Action *@
<a class="nav-link" asp-controller="Pages" asp-action="Products" asp-route-lang="fr">Produits (fr)</a>
</div>
</nav>
|
- Zeilen 4–5: Erste Möglichkeit, den Link der aktuellen Seite hervorzuheben: eine in der View geschriebene Bedingung;
- Zeile 7: zweite, prägnantere Möglichkeit: unser Tag Helper. Dieser wird in der Fallstudie verwendet;
- Zeile 9: ein Tag Helper für [ASP.NET Core]. Die Attribute [asp-controller] und [asp-action] bezeichnen eine Action; der Tag Helper berechnet deren URL anhand der Routen (hier [/products]) und schreibt sie in das Attribut [href]. [asp-route-lang="fr"] fügt einen Parameter hinzu, der in die URL ([?lang=fr]) aufgenommen wird, da die Route keinen Parameter [lang] enthält. Ändert sich die URL der Action, folgt der Link automatisch.
Der HTML-Code der Navigationsleiste, von der URL bis [/products]:
| <nav class="navbar navbar-expand bg-light rounded mb-3 px-3">
<span class="navbar-brand">Helpers</span>
<div class="navbar-nav">
<a class="nav-link " href="/">Home</a>
<a class="nav-link active" href="/products">Products</a>
<a class="nav-link" href="/products?lang=fr">Produits (fr)</a>
</div>
</nav>
|
Die Datei [Views/Pages/Products.cshtml]:
| @model List<Product>
@{
ViewData["Title"] = "Products";
}
<h1>Products</h1>
<table class="table table-sm w-auto">
<thead><tr><th>Product</th><th>Price</th><th>Price in dollars</th><th>Stock</th></tr></thead>
<tbody>
@foreach (var product in Model)
{
<tr>
<td>@Formats.Uppercase(product.Name)</td>
<td>@Formats.Money(product.Price)</td>
<td>@Formats.Money(product.Price, "USD")</td>
<td>@Formats.Badge(product.Stock)</td>
</tr>
}
</tbody>
</table>
|
- Zeilen 12–15: Die Helper werden innerhalb von [@]-Ausdrücken aufgerufen. [Badge] liefert HTML zurück, das ohne Maskierung eingefügt wird.
Die resultierenden Seiten auf Englisch (http://localhost:5000/, http://localhost:5000/products) und anschließend auf Französisch (http://localhost:5000/products?lang=fr):



Die Preise ändern ihr Format je nach Sprache: [1 149,90 €] auf Französisch, [€1,149.90] auf Englisch.
Ein HTML-Formular, das mit der Methode GET gesendet wird, legt seine Felder in der URL ab. Dies ist die passende Methode für eine Suche: Sie verändert nichts, und die resultierende URL kann als Lesezeichen gespeichert oder weitergegeben werden. Die Fallstudie verwendet sie, um einen Arzt und ein Datum auszuwählen.
Die Datei [Models/Book.cs]:
| namespace Example17.Models;
public record Book(string Title, string Author, string Genre);
// das View-Modell: die Eingabe (zur erneuten Anzeige), die Genres, die Ergebnisse
public record SearchModel(string Keyword, string Genre, string[] Genres, List<Book> Results);
|
- Zeile 6: Das Modell der View enthält die eingegebenen Werte ([Keyword], [Genre]), damit das Formular sie erneut anzeigen kann, zusammen mit der Liste der Genres und den Ergebnissen.
Die Datei [Controllers/BooksController.cs]:
| using Example17.Models;
using Microsoft.AspNetCore.Mvc;
namespace Example17.Controllers;
public class BooksController : Controller
{
private static readonly List<Book> Books =
[
new Book("Le Rouge et le Noir", "Stendhal", "novel"),
new Book("Les Fleurs du mal", "Baudelaire", "poetry"),
new Book("Madame Bovary", "Flaubert", "novel"),
new Book("Alcools", "Apollinaire", "poetry"),
new Book("Le Cid", "Corneille", "drama"),
];
private static readonly string[] Genres = ["novel", "poetry", "drama"];
// GET / und GET /search?keyword=...&genre=...: das Formular UND seine Ergebnisse
[HttpGet("/")]
[HttpGet("search")]
public IActionResult Search(string? keyword, string? genre)
{
var word = (keyword ?? "").Trim().ToLower();
var results = Books
.Where(b => word == "" || b.Title.ToLower().Contains(word) || b.Author.ToLower().Contains(word))
.Where(b => string.IsNullOrEmpty(genre) || b.Genre == genre)
.ToList();
return View(new SearchModel(keyword ?? "", genre ?? "", Genres, results));
}
}
|
- Zeilen 8–14: die Bücher, im Arbeitsspeicher;
- Zeilen 20–21: zwei Route-Attribute: Die Action verarbeitet [GET /] und [GET /search];
- Zeile 22: Die Parameter [keyword] und [genre] werden an die gleichnamigen Parameter der URL gebunden. Beim ersten Aufruf wurde das Formular noch nicht gesendet: Ihre Werte sind [null];
- Zeilen 25–28: Filterung mit [LINQ]. Ein leeres Stichwort oder eine leere Kategorie filtert nichts;
- Zeile 29: das Modell der View.
Die Datei [Views/Books/Search.cshtml]:
| @model SearchModel
<h1 class="h3">Book search</h1>
@* method="get": die Felder werden in der URL gesendet (?keyword=...&genre=...) *@
<form method="get" action="/search" class="row g-2 align-items-end mb-3">
<div class="col-auto">
<label class="form-label" for="keyword">Title or author</label>
@* value="@Model.Keyword": das Feld zeigt erneut an, was eingegeben wurde *@
<input class="form-control" id="keyword" name="keyword" value="@Model.Keyword">
</div>
<div class="col-auto">
<label class="form-label" for="genre">Genre</label>
<select class="form-select" id="genre" name="genre">
<option value="">(all)</option>
@foreach (var genre in Model.Genres)
{
@* ein boolesches Attribut: wird geschrieben, wenn die Bedingung wahr ist, sonst weggelassen *@
<option value="@genre" selected="@(genre == Model.Genre)">@genre</option>
}
</select>
</div>
<div class="col-auto">
<button class="btn btn-primary" type="submit">Search</button>
</div>
</form>
<p>@Model.Results.Count book(s) found.</p>
<ul>
@foreach (var book in Model.Results)
{
<li><i>@book.Title</i>, @book.Author (@book.Genre)</li>
}
</ul>
|
- Zeile 4: [method="get"] und [action="/search"]: Das Absenden des Formulars ist eine [GET /search?keyword=...&genre=...]-Anfrage. Die Parameternamen sind das Attribut [name] der einzelnen Felder;
- Zeile 8: Das Attribut [value] zeigt die Eingabe erneut an;
- Zeile 17: In der Dropdown-Liste erhält die Option, die dem ausgewählten Genre entspricht, das Attribut [selected]. [Razor] behandelt boolesche Attribute auf besondere Weise: Ist der Wert [true], schreibt es [selected="selected"]; ist er [false], schreibt es das Attribut überhaupt nicht. Genau das verlangt HTML, wo das bloße Vorhandensein des Attributs [selected] genügt, um die Option auszuwählen.
Bei der ersten Anzeige (http://localhost:5000/) und dann nach einer Suche:


Die Adressleiste zeigt die gesendeten Parameter. Zeichen mit Akzent und Leerzeichen werden dort kodiert ([%C3%A9] ...): Das ist die URL-Kodierung, die [ASP.NET Core] vor dem Model Binding dekodiert.
Beispiel 18 enthält alle Arten von HTML-Feldern: Text, Passwort, Datum, Optionsfelder, Kontrollkästchen, Dropdown-Liste, Mehrfachauswahlliste, Textbereich und verstecktes Feld. Es zeigt, wie der Server sie empfängt und wie die View sie anzeigt.
Die Datei [Services/ListsService.cs]:
| namespace Example18.Services;
public record Country(string Code, string Name);
// die vom Formular angebotenen Listen. In einer echten Anwendung würden sie
// aus einer Datenbank stammen: wir würden sie EINMAL beim Start lesen,
// da sie für alle Benutzer gleich sind
public class ListsService
{
public string[] Titles { get; } = ["Mr", "Mme", "Melle"];
public Country[] Countries { get; } =
[
new Country("fr", "France"),
new Country("be", "Belgium"),
new Country("ch", "Switzerland"),
new Country("ca", "Canada"),
];
public string[] Hobbies { get; } = ["reading", "music", "sport", "cinema"];
public string[] Languages { get; } = ["French", "English", "Spanish", "German"];
}
|
Die vom Formular angebotenen Listen werden von einem Service bereitgestellt. Sie sind für alle Benutzer gleich: Ein nur einmal instanziierter Service (ein Singleton; siehe Kapitel 6) ist der natürliche Ort, um sie zu speichern. Er wird in [Program.cs] registriert:
| using System.Text.Encodings.Web;
using System.Text.Unicode;
using Example18.Services;
using Microsoft.Extensions.FileProviders;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
// Razor schreibt Zeichen mit Akzenten unverändert (und nicht "é");
// < > & " ' bleiben maskiert
builder.Services.AddSingleton(HtmlEncoder.Create(UnicodeRanges.All));
// die Listen des Formulars: für alle gleich, ein einziges Objekt (Singleton)
builder.Services.AddSingleton<ListsService>();
var app = builder.Build();
// 1. die statischen Dateien des Ordners wwwroot: wwwroot/css/styles.css wird als /css/styles.css ausgeliefert
app.UseStaticFiles();
// 2. Bootstrap, von den Beispielen gemeinsam genutzt: der Ordner examples/common/bootstrap wird unter /bootstrap ausgeliefert
app.UseStaticFiles(new StaticFileOptions
{
FileProvider = new PhysicalFileProvider(Path.GetFullPath(Path.Combine(builder.Environment.ContentRootPath, "..", "common", "bootstrap"))),
RequestPath = "/bootstrap",
});
app.MapControllers();
app.Run();
|
- Zeile 12: eine einzige Instanz von [ListsService], die von allen Anfragen gemeinsam genutzt wird.
Die Datei [Models/Input.cs]:
| namespace Example18.Models;
// was der Benutzer eingegeben hat: das Model Binding füllt jede Eigenschaft
// mit dem gleichnamigen Feld (die Arrays erhalten alle angekreuzten Werte)
public class Input
{
public string? Name { get; set; }
public string? Password { get; set; }
public string? Comment { get; set; }
public string? Title { get; set; }
public string[] Hobbies { get; set; } = [];
public string? Country { get; set; }
public string[] Languages { get; set; } = [];
public DateOnly? BirthDate { get; set; }
public string? Token { get; set; }
}
// eine Option einer Liste und ihr Zustand (angekreuzt / ausgewählt)
public record Option(string Value, string Label, bool Chosen);
// das View-Modell
public class FormModel
{
public required Input Input { get; init; }
public required List<Option> Titles { get; init; }
public required List<Option> Hobbies { get; init; }
public required List<Option> Countries { get; init; }
public required List<Option> Languages { get; init; }
public string? Received { get; init; } // was der Server empfangen hat, zur Anzeige
}
|
Kommentieren wir diesen Code:
- Zeilen 5–15: die Eingabe. Das Model Binding füllt jede Eigenschaft mit dem gleichnamigen Feld. Die Kontrollkästchen und die Dropdown-Liste sind Arrays ([string[]]): Sie erhalten alle gesendeten Werte (siehe Beispiel 10). Das Geburtsdatum wird in [DateOnly] umgewandelt;
- Zeile 19: eine Option aus einer Liste: ihr Wert, ihre Beschriftung und ein boolescher Wert, der angibt, ob sie angekreuzt oder ausgewählt ist;
- Zeilen 22–29: das Modell der View. Das Schlüsselwort [required] verlangt, dass die Eigenschaft bei der Erzeugung des Objekts angegeben wird; [init] verhindert, dass sie anschließend geändert wird.
Die Datei [Controllers/FormController.cs]:
| using Example18.Models;
using Example18.Services;
using Microsoft.AspNetCore.Mvc;
namespace Example18.Controllers;
[Route("form")]
public class FormController(ListsService lists) : Controller
{
// GET: das Formular mit Anfangswerten
[HttpGet("")]
public IActionResult Display()
{
var initial = new Input { Title = "Mme", Country = "fr", Languages = ["French"], Token = "A7X2" };
return View("Form", Model(initial, null));
}
// POST: das Model Binding füllt [input]; wir zeigen das Formular erneut an
[HttpPost("")]
public IActionResult Process(Input input)
{
// was der Browser tatsächlich gesendet hat, Feld für Feld
var received = string.Join("\n", Request.Form.Select(c => $"{c.Key} = [{string.Join(", ", c.Value.ToArray())}]"));
return View("Form", Model(input, received));
}
// das View-Modell: die Listen, wobei jede Option je nach Eingabe als angekreuzt /
// ausgewählt markiert ist. Die View muss nur noch einen Boolean testen.
private FormModel Model(Input input, string? received) => new()
{
Input = input,
Titles = lists.Titles.Select(t => new Option(t, t, t == input.Title)).ToList(),
Hobbies = lists.Hobbies.Select(h => new Option(h, h, input.Hobbies.Contains(h))).ToList(),
Countries = lists.Countries.Select(c => new Option(c.Code, c.Name, c.Code == input.Country)).ToList(),
Languages = lists.Languages.Select(l => new Option(l, l, input.Languages.Contains(l))).ToList(),
Received = received,
};
}
|
Kommentieren wir diesen Code:
- Zeile 8: Der Listen-Service wird injiziert;
- Zeilen 11–15: [GET /form] zeigt das Formular mit Anfangswerten an;
- Zeilen 19–24: [POST /form] empfängt die Benutzereingabe – vom Model Binding befüllt – und zeichnet das Formular neu. [Request.Form] bietet ebenfalls Zugriff auf die Felder, so wie sie gesendet wurden: Es wandelt sie für die Anzeige in Text um, eine Zeile pro Feld;
- Zeilen 29–36: das Modell der View. Für jede Liste berechnet die Action, welche Optionen angekreuzt oder ausgewählt sein sollen: Die View muss dann nur noch einen booleschen Wert prüfen.
Die Datei [Views/Form/Form.cshtml]:
| @model FormModel
<h1 class="h3">A complete form</h1>
<form method="post" action="/form" style="max-width: 40rem">
@* verstecktes Feld: wird mit dem Formular gesendet, ist aber unsichtbar *@
<input type="hidden" name="token" value="@Model.Input.Token">
<div class="mb-2">
<span class="form-label me-3">Title</span>
@foreach (var title in Model.Titles)
{
@* Radiobuttons: gleicher [name], es wird ein einziger Wert gesendet *@
<div class="form-check form-check-inline">
<input class="form-check-input" type="radio" name="title" id="title-@title.Value"
value="@title.Value" checked="@title.Chosen">
<label class="form-check-label" for="title-@title.Value">@title.Label</label>
</div>
}
</div>
<div class="row g-2 mb-2">
<div class="col">
<label class="form-label" for="name">Name</label>
<input class="form-control" type="text" id="name" name="name" value="@Model.Input.Name">
</div>
<div class="col">
<label class="form-label" for="password">Password</label>
@* ein Passwort wird NIEMALS in der Seite zurückgesendet *@
<input class="form-control" type="password" id="password" name="password">
</div>
<div class="col">
<label class="form-label" for="birthDate">Date of birth</label>
@* ein Datumsfeld tauscht seine Werte im Format yyyy-mm-dd aus *@
<input class="form-control" type="date" id="birthDate" name="birthDate"
value="@Model.Input.BirthDate?.ToString("yyyy-MM-dd")">
</div>
</div>
<div class="mb-2">
<span class="form-label me-3">Hobbies</span>
@for (var i = 0; i < Model.Hobbies.Count; i++)
{
var hobby = Model.Hobbies[i];
@* Checkboxen: gleicher [name], mehrere Werte möglich *@
<div class="form-check form-check-inline">
<input class="form-check-input" type="checkbox" name="hobbies" id="hobby-@i"
value="@hobby.Value" checked="@hobby.Chosen">
<label class="form-check-label" for="hobby-@i">@hobby.Label</label>
</div>
}
</div>
<div class="row g-2 mb-2">
<div class="col">
<label class="form-label" for="country">Country</label>
<select class="form-select" id="country" name="country">
@foreach (var country in Model.Countries)
{
<option value="@country.Value" selected="@country.Chosen">@country.Label</option>
}
</select>
</div>
<div class="col">
<label class="form-label" for="languages">Spoken languages</label>
@* Mehrfachauswahlliste: mehrere Werte möglich *@
<select class="form-select" id="languages" name="languages" multiple size="4">
@foreach (var language in Model.Languages)
{
<option value="@language.Value" selected="@language.Chosen">@language.Label</option>
}
</select>
</div>
</div>
<div class="mb-2">
<label class="form-label" for="comment">Comment</label>
@* ein Textbereich: der Wert steht ZWISCHEN den Tags *@
<textarea class="form-control" id="comment" name="comment" rows="2">@Model.Input.Comment</textarea>
</div>
<button class="btn btn-primary" type="submit">Send</button>
</form>
@if (Model.Received is not null)
{
<h2 class="h5 mt-3">What the server received</h2>
<pre class="bg-light p-2 border">@Model.Received</pre>
}
|
Kommentieren wir diesen Code:
- Zeile 3: Das Formular wird per POST gesendet: Seine Felder sind im Anfragetext enthalten;
- Zeile 5: Ein verstecktes Feld wird mit dem Formular gesendet, aber nicht angezeigt. Es dient dazu, Informationen von einer Seite zur nächsten weiterzugeben (in der Fallstudie enthält es zum Beispiel die Version eines Datensatzes). Achtung: Der Benutzer kann es ändern;
- Zeilen 9–15: Optionsfelder haben denselben [name]; nur eines kann ausgewählt werden, und nur ein Wert wird gesendet. Das boolesche Attribut [checked="@title.Chosen"] wählt die Schaltfläche aus (siehe [selected], Beispiel 17);
- Zeile 28: Ein Passwort wird nie in einer Seite zurückgeschickt: Das Feld hat kein [value]-Attribut;
- Zeilen 33–34: ein Datumsfeld. Der Browser zeigt das Datum im Format des Benutzers an, sendet und empfängt aber immer [yyyy-mm-dd];
- Zeilen 40–46: Kontrollkästchen mit demselben [name]-Attribut: Jedes angekreuzte Kästchen sendet seinen Wert; der Parameter wird daher wiederholt;
- Zeilen 55–60: eine Dropdown-Liste. Die ausgewählte Option hat das Attribut [selected];
- Zeile 65: Das Attribut [multiple] erlaubt die Auswahl mehrerer Optionen;
- Zeile 77: Der Wert eines Textbereichs steht zwischen seinen Tags, nicht in einem [value]-Attribut;
- Zeilen 83–86: Was der Server empfangen hat, angezeigt innerhalb eines [<pre>]-Tags, das Zeilenumbrüche beibehält.
Das anfängliche Formular (http://localhost:5000/form), dann nach dem Absenden:


Beachten Sie, dass das Textfeld [Hello <b>everyone</b>] exakt so wieder angezeigt wurde, wie es eingegeben wurde: Dank der Maskierung der [@]-Ausdrücke werden die eingegebenen Tags nicht interpretiert. Das Passwort wurde empfangen, wird aber nicht angezeigt. Mit [curl] sehen wir den Unterschied, wenn ein Kontrollkästchen ausgewählt ist:
| curl -d "token=A7X2&title=Mr&name=Martin&hobbies=sport" http://localhost:5000/form
|
| token = [A7X2]
title = [Mr]
name = [Martin]
hobbies = [sport]
|
und zwei angekreuzte Kästchen:
| curl -d "token=A7X2&title=Mr&name=Martin&hobbies=sport&hobbies=music" http://localhost:5000/form
|
| token = [A7X2]
title = [Mr]
name = [Martin]
hobbies = [sport, music]
|
(nur der Inhalt des [<pre>]-Tags der Seite ist wiedergegeben, so wie ihn ein Browser anzeigt). Ein nicht angekreuztes Kästchen wird überhaupt nicht gesendet: [Request.Form] enthält das Feld nicht, und die Eigenschaft [Hobbies] der Eingabe behält ihren Anfangswert – das leere Array.
Ein ungültiges Formular muss erneut angezeigt werden, mit den eingegebenen Werten und einer Meldung unter jedem fehlerhaften Feld. Beispiel 19 wendet die Technik aus Beispiel 09 (von der Action durchgeführte Validierung mit [ModelState]) auf ein Registrierungsformular an.
Die Datei [Models/RegistrationModel.cs]:
| using System.ComponentModel.DataAnnotations;
namespace Example19.Models;
// die Formularfelder und ihre Einschränkungen
public class RegistrationModel
{
// entfernt überflüssige Leerzeichen aus einer Eingabe (der "Setter" wird vom Model Binding aufgerufen)
private string? name;
[Required(ErrorMessage = "The name is required.")]
[MaxLength(20, ErrorMessage = "The name must not exceed 20 characters.")]
public string? Name
{
get => name;
set => name = value?.Trim();
}
[Required(ErrorMessage = "The email address is required.")]
[EmailAddress(ErrorMessage = "Invalid email address.")]
public string? Email { get; set; }
// alles, was aus einem Formular kommt, ist ein String: "42" -> 42
[Required(ErrorMessage = "The age is required.")]
[Range(18, 120, ErrorMessage = "The age must be between 18 and 120 years.")]
public int? Age { get; set; }
[Required(ErrorMessage = "The password is required.")]
[MinLength(6, ErrorMessage = "The password must have at least 6 characters.")]
public string? Password { get; set; }
// eine Regel über ZWEI Felder: [Compare] vergleicht mit Password
[Compare(nameof(Password), ErrorMessage = "The confirmation does not match the password.")]
public string? Confirmation { get; set; }
}
// das View-Modell: die erneut anzuzeigenden Werte, die Fehler pro Feld
public class RegistrationForm
{
public RegistrationModel Values { get; init; } = new();
public Dictionary<string, string> Errors { get; init; } = new(StringComparer.OrdinalIgnoreCase);
public bool Html5 { get; init; }
}
// das Modell der Partial View _Field: ein Eingabefeld
public record FieldModel(string Name, string Label, string Type, string? Value, string? Error, string Attributes);
|
Kommentieren wir diesen Code:
- Zeilen 9–16: eine Eigenschaft mit einem privaten Feld. Ihr Accessor [set] – vom Model Binding aufgerufen – entfernt überflüssige Leerzeichen aus der Eingabe: [" Martin "] wird zu ["Martin"]. Ein Name, der nur aus Leerzeichen besteht, wird vom Model Binding selbst in [null] umgewandelt und von [[Required]] abgelehnt;
- Zeile 12: [[MaxLength]] begrenzt die Länge einer Zeichenkette, genau wie [[StringLength]];
- Zeilen 25–26: Das Alter wird in eine Ganzzahl umgewandelt und dann validiert;
- Zeile 29: mindestens 6 Zeichen;
- Zeile 33: Die Regel „Die Bestätigung stimmt mit dem Passwort überein“ betrifft zwei Felder. Das Attribut [[Compare]] vergleicht die Eigenschaft, die es dekoriert, mit einer anderen Eigenschaft, die über ihren Namen angegeben wird ([nameof(Password)]: der Eigenschaftsname, vom Compiler geprüft);
- Zeilen 38–42: das Modell der View: die erneut anzuzeigenden Werte, nach Feldern sortierte Fehler (ein Dictionary, dessen Schlüssel Groß- und Kleinschreibung nicht unterscheiden) und ein boolescher Wert, der weiter unten erklärt wird;
- Zeile 46: die Partial View, die ein Feld anzeigt.
Die Datei [Controllers/RegistrationController.cs]:
| using Example19.Models;
using Microsoft.AspNetCore.Mvc;
namespace Example19.Controllers;
[Route("register")]
public class RegistrationController : Controller
{
// ?html5=1: wir lassen den Browser das Formular vor dem Senden validieren
[HttpGet("")]
public IActionResult Display(bool html5)
{
return View("Registration", new RegistrationForm { Html5 = html5 });
}
[HttpPost("")]
public IActionResult Register(RegistrationModel input, [FromQuery] bool html5)
{
if (!ModelState.IsValid)
{
// die Fehler pro Feld, um jede Meldung unter ihrem Feld anzuzeigen
var errors = ModelState
.Where(c => c.Value!.Errors.Count > 0)
.ToDictionary(c => c.Key, c => c.Value!.Errors[0].ErrorMessage, StringComparer.OrdinalIgnoreCase);
// wir zeigen das Formular ERNEUT an: eingegebene Werte (außer den Passwörtern)
// und eine Meldung unter jedem ungültigen Feld
input.Password = input.Confirmation = null;
ViewData["Error"] = "The form contains errors.";
return View("Registration", new RegistrationForm { Values = input, Errors = errors, Html5 = html5 });
}
return View("Welcome", input);
}
}
|
Kommentieren wir diesen Code:
- Zeilen 11–13: das leere Formular. Der Parameter [html5] wird später erklärt;
- Zeile 17: Das Model Binding füllt [input] anhand der Formularfelder und validiert es. [[FromQuery]] liest [html5] aus der URL;
- Zeilen 19–24: Gibt es Fehler, werden sie nach Feldern organisiert. Ein Feld kann mehrere Einschränkungen verletzen: Nur die erste Fehlermeldung ([Errors[0]]) wird beibehalten;
- Zeilen 27–29: Das Formular wird erneut angezeigt: die eingegebenen Werte (außer Passwörtern), die Fehler nach Feldern und eine allgemeine Meldung, die für das Template in [ViewData] abgelegt wird;
- Zeile 31: andernfalls die Willkommensseite mit den umgewandelten Werten (das Alter ist eine Zahl, der Name wurde bereinigt).
Ein Konvertierungsfehler (ein Alter [abc]) erzeugt standardmäßig eine englische Meldung: [The value 'abc' is not valid for Age.] (siehe Beispiel 08). Die Datei [Program.cs] ersetzt sie:
| using System.Text.Encodings.Web;
using System.Text.Unicode;
using Microsoft.Extensions.FileProviders;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews(options =>
{
// die Meldungen der KONVERTIERUNGSFEHLER (z. B. age "abc"), die die Standardmeldungen ersetzen
var messages = options.ModelBindingMessageProvider;
messages.SetAttemptedValueIsInvalidAccessor((value, field) => $"The value [{value}] is not valid.");
messages.SetValueMustNotBeNullAccessor(field => "This field is required.");
});
// Razor schreibt Zeichen mit Akzenten unverändert (und nicht "é");
// < > & " ' bleiben maskiert
builder.Services.AddSingleton(HtmlEncoder.Create(UnicodeRanges.All));
var app = builder.Build();
// 1. die statischen Dateien des Ordners wwwroot: wwwroot/css/styles.css wird als /css/styles.css ausgeliefert
app.UseStaticFiles();
// 2. Bootstrap, von den Beispielen gemeinsam genutzt: der Ordner examples/common/bootstrap wird unter /bootstrap ausgeliefert
app.UseStaticFiles(new StaticFileOptions
{
FileProvider = new PhysicalFileProvider(Path.GetFullPath(Path.Combine(builder.Environment.ContentRootPath, "..", "common", "bootstrap"))),
RequestPath = "/bootstrap",
});
app.MapControllers();
app.Run();
|
- Zeilen 6–11: Die Meldungen für Fehler beim Model Binding werden vom Objekt [ModelBindingMessageProvider] aus den MVC-Optionen bereitgestellt. Jede Methode [Set...Accessor] ersetzt eine davon durch eine Funktion, die die Meldung erzeugt. [SetAttemptedValueIsInvalidAccessor] behandelt einen Wert, der nicht konvertiert werden kann; sie erhält den Wert und den Feldnamen. Die Fallstudie ersetzt auf diese Weise alle diese Meldungen.
Die Felder werden alle nach demselben Muster aufgebaut: Eine Partial View lagert sie aus. Die Datei [Views/Shared/_Field.cshtml]:
| @* ein Eingabefeld; sein Modell: Name, Label, Typ, Wert, Fehler und die
HTML5-Validierungsattribute (required, maxlength...) *@
@model FieldModel
<div class="mb-2">
<label class="form-label" for="@Model.Name">@Model.Label</label>
<input class="form-control @(Model.Error is null ? "" : "is-invalid")" id="@Model.Name" name="@Model.Name"
type="@Model.Type" value="@Model.Value" @Html.Raw(Model.Attributes)>
@if (Model.Error is not null)
{
<div class="invalid-feedback">@Model.Error</div>
}
</div>
|
- Zeile 6: Die [Bootstrap]-Klasse [is-invalid] hebt ein ungültiges Feld rot hervor;
- Zeile 7: Die HTML5-Validierungsattribute werden als Parameter übergeben und ohne Maskierung eingefügt ([Html.Raw]): Sie werden vom Entwickler geschrieben und nicht vom Benutzer eingegeben;
- Zeile 10: die Fehlermeldung unterhalb des Feldes ([Bootstrap]-Klasse [invalid-feedback]).
Die Datei [Views/Registration/Registration.cshtml]:
| @model RegistrationForm
@{
// der Fehler eines Feldes oder null
string? Error(string field) => Model.Errors.GetValueOrDefault(field);
}
<h1 class="h3">Registration</h1>
@if (Model.Html5)
{
<p>Browser validation <b>enabled</b> - <a href="/register">disable it</a></p>
}
else
{
<p>Browser validation <b>disabled</b> - <a href="/register?html5=true">enable it</a></p>
}
@* novalidate: der Browser ignoriert die Attribute required, min... und
sendet das Formular unverändert; nur der Server validiert *@
<form method="post" action="/register@(Model.Html5 ? "?html5=true" : "")" novalidate="@(!Model.Html5)">
<partial name="_Field" model='new FieldModel("name", "Name", "text", Model.Values.Name, Error("name"), "required maxlength=\"20\"")' />
<partial name="_Field" model='new FieldModel("email", "Email address", "email", Model.Values.Email, Error("email"), "required")' />
<partial name="_Field" model='new FieldModel("age", "Age", "number", Model.Values.Age?.ToString(), Error("age"), "required min=\"18\" max=\"120\"")' />
<partial name="_Field" model='new FieldModel("password", "Password", "password", null, Error("password"), "required minlength=\"6\"")' />
<partial name="_Field" model='new FieldModel("confirmation", "Confirmation", "password", null, Error("confirmation"), "required")' />
<button class="btn btn-primary" type="submit">Register</button>
</form>
|
- Zeile 4: eine lokale Funktion [C#], deklariert im Block [@{ }]: Sie liefert den Fehler zu einem Feld oder [null];
- Zeile 17: Das boolesche Attribut [novalidate] wird gesetzt, wenn [Html5] den Wert false hat;
- Zeilen 18–22: Jedes Feld ist eine Einbindung der Partial View mit einem spontan erzeugten Modell.
Die Datei [Views/Shared/_Layout.cshtml]:
| <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Registration</title>
<link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
<link rel="stylesheet" href="/css/styles.css">
</head>
<body>
<div class="container py-3" style="max-width: 36rem">
@RenderBody()
@* der globale Fehler am Seitenende auf hellrosa Hintergrund;
ViewData["Error"] wird von der Action gesetzt *@
@if (ViewData["Error"] is string error)
{
<div class="error-area" role="alert">@error</div>
}
</div>
</body>
</html>
|
- Zeilen 14–16: Die globale Meldung wird am unteren Seitenrand auf hellrosa Hintergrund angezeigt (Klasse [error-area] aus [wwwroot/css/styles.css]), wie in der Fallstudie. [is string error] prüft den Typ des Wertes und speichert ihn in einer Variablen.
Senden wir das Formular (http://localhost:5000/register) mit mehreren Fehlern ab:

dann korrekt ausgefüllt (mit Leerzeichen um den Namen):

Und mit einem nicht numerischen Alter, gesendet über [curl] (der Browser hätte es in einem [type="number"]-Feld abgelehnt):
| curl -i -d "name=Martin&email=xx&age=abc" http://localhost:5000/register
|
| HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Registration</title>
<link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
<link rel="stylesheet" href="/css/styles.css">
</head>
<body>
<div class="container py-3" style="max-width: 36rem">
<h1 class="h3">Registration</h1>
<p>Browser validation <b>disabled</b> - <a href="/register?html5=true">enable it</a></p>
<form method="post" action="/register" novalidate="novalidate">
<div class="mb-2">
<label class="form-label" for="name">Name</label>
<input class="form-control " id="name" name="name"
type="text" value="Martin" required maxlength="20">
</div>
<div class="mb-2">
<label class="form-label" for="email">Email address</label>
<input class="form-control is-invalid" id="email" name="email"
type="email" value="xx" required>
<div class="invalid-feedback">Invalid email address.</div>
</div>
<div class="mb-2">
<label class="form-label" for="age">Age</label>
<input class="form-control is-invalid" id="age" name="age"
type="number" required min="18" max="120">
<div class="invalid-feedback">The value [abc] is not valid.</div>
</div>
<div class="mb-2">
<label class="form-label" for="password">Password</label>
<input class="form-control is-invalid" id="password" name="password"
type="password" required minlength="6">
<div class="invalid-feedback">The password is required.</div>
</div>
<div class="mb-2">
<label class="form-label" for="confirmation">Confirmation</label>
<input class="form-control " id="confirmation" name="confirmation"
type="password" required>
</div>
<button class="btn btn-primary" type="submit">Register</button>
</form>
<div class="error-area" role="alert">The form contains errors.</div>
</div>
</body>
</html>
|
4.7.1. Validierung durch den Browser
Die Attribute [required], [maxlength], [min], [max], [type="email"] ... weisen den Browser an, das Formular vor dem Absenden zu validieren: Der Benutzer wird sofort über einen Tooltip benachrichtigt, ohne jeglichen Datenaustausch mit dem Server. Dieses Verhalten erreicht man durch einen Klick auf den Link „enable it“ (http://localhost:5000/register?html5=true), der das Attribut [novalidate] aus dem Formular entfernt.
Diese Validierung ist eine Komfortfunktion, keine Sicherheitsmaßnahme: Man kann sie umgehen, indem man einfach das Attribut [required] mit den Entwicklertools des Browsers entfernt oder die Anfrage mit [curl] sendet. Die serverseitige Validierung bleibt unverzichtbar. Deshalb deaktiviert das Beispiel die Browser-Validierung standardmäßig: um die Funktionsweise des Servers zu demonstrieren. Die Fallstudie behält dagegen beide bei: das HTML5-Attribut aus Komfortgründen und die serverseitige Validierung für die Sicherheit.
4.8. Beispiel 20: Das Post/Redirect/Get-Muster
Wenn ein POST-Formular erfolgreich gesendet wurde, kann die Action direkt eine Seite anzeigen. Das Problem entsteht, wenn der Benutzer diese Seite anschließend aktualisiert (Taste F5): Der Browser sendet das Formular erneut, und die Operation wird ein zweites Mal ausgeführt (eine doppelt aufgegebene Bestellung, ein doppelt vereinbarter Termin ...). Das Muster Post / Redirect / Get (PRG) verhindert dieses Problem: Eine erfolgreiche POST-Action erzeugt keine Seite, sondern leitet auf eine GET-Seite um. Das Neuladen dieser Seite löst lediglich einen weiteren GET aus, ohne Auswirkung.
Ein Detail bleibt: Die GET-Seite muss eine Meldung anzeigen („Die Aufgabe wurde hinzugefügt“), obwohl diese Meldung von der POST-Action in einer anderen Anfrage erzeugt wurde. Hierfür [ASP.NET Core] stellt [TempData] bereit: ein Dictionary, dessen Inhalt bis zur nächsten Anfrage erhalten bleibt und verschwindet, sobald er gelesen wurde. Es handelt sich um eine Flash-Meldung. Standardmäßig wird [TempData] in einem Cookie gespeichert, das vom Server verschlüsselt wird.
Die Datei [Services/TasksService.cs]:
| namespace Example20.Services;
// die Aufgabenliste im Speicher, für alle gemeinsam (Singleton)
public class TasksService
{
private readonly List<string> tasks = ["Read chapter 3"];
public IReadOnlyList<string> List() => tasks;
public void Add(string label) => tasks.Add(label);
}
|
Die Datei [Controllers/TasksController.cs]:
| using Example20.Services;
using Microsoft.AspNetCore.Mvc;
namespace Example20.Controllers;
[Route("tasks")]
public class TasksController(TasksService tasks) : Controller
{
// GET /tasks: die Liste und das Formular zum Hinzufügen
[HttpGet("")]
public IActionResult Display()
{
return View("Tasks", tasks.List());
}
// POST /tasks: das Muster Post / Redirect / Get
[HttpPost("")]
public IActionResult Add(string? label)
{
var text = (label ?? "").Trim();
if (text == "" || text.Length > 40)
{
// ungültige Eingabe: wir zeigen die Seite erneut an, ohne Weiterleitung
ViewData["Label"] = label;
ViewData["Error"] = "The label must have 1 to 40 characters.";
return View("Tasks", tasks.List());
}
tasks.Add(text);
// TempData: eine Meldung, die die Weiterleitung überlebt, für die NÄCHSTE Anfrage
TempData["Flash"] = $"The task [{text}] has been added.";
// keine Seite: eine Weiterleitung auf die GET-Seite
return RedirectToAction(nameof(Display));
}
// POST /tasks/without-prg: das Gegenbeispiel (eine Seite als Antwort auf das POST)
[HttpPost("without-prg")]
public IActionResult AddWithoutPrg(string? label)
{
tasks.Add(string.IsNullOrWhiteSpace(label) ? "(untitled)" : label.Trim());
ViewData["WithoutPrg"] = true;
return View("Tasks", tasks.List());
}
}
|
Gehen wir diesen Code durch:
- Zeilen 11–13: die Listenseite;
- Zeilen 21–26: eine ungültige Eingabe: Die Seite wird neu geladen (keine Umleitung – die Eingabe und die Fehlermeldung müssen erhalten bleiben);
- Zeilen 28–32: eine gültige Eingabe: die Operation, die Meldung wird in [TempData] als Flash-Meldung abgelegt, dann eine 302-Umleitung auf die Action [Display]. [RedirectToAction] berechnet die URL der Action anhand ihrer Route (siehe Beispiel 04). [nameof(Display)] ist der Methodenname, der vom Compiler geprüft wird;
- Zeilen 36–41: das Gegenbeispiel zum Vergleich.
Die Datei [Views/Tasks/Tasks.cshtml]:
| @model IReadOnlyList<string>
<h1 class="h3">My tasks</h1>
<ol>
@foreach (var task in Model)
{
<li>@task</li>
}
</ol>
<form method="post" action="/tasks" class="d-flex gap-2">
<input class="form-control" name="label" value="@ViewData["Label"]" placeholder="New task">
<button class="btn btn-primary text-nowrap" type="submit">Add</button>
@* formaction: dieser Button sendet DASSELBE Formular an eine andere Adresse *@
<button class="btn btn-outline-secondary text-nowrap" type="submit" formaction="/tasks/without-prg">Add without PRG</button>
</form>
@if (ViewData["WithoutPrg"] is true)
{
<p class="text-danger mt-2">Page displayed in response to a POST: press F5 and the task will be added a second time.</p>
}
|
- Zeile 13: Das Attribut [formaction] einer Schaltfläche sendet das Formular an eine andere Adresse als die, die das Attribut [action] des Formulars angibt. Das Formular hat somit zwei Schaltflächen, die zwei verschiedene Actions auslösen. Die Fallstudie verwendet diesen Ansatz auf ihrer Anmeldeseite.
Die Datei [Views/Shared/_Layout.cshtml]:
| <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Tasks</title>
<link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
<link rel="stylesheet" href="/css/styles.css">
</head>
<body>
<div class="container py-3" style="max-width: 36rem">
@* die Flash-Nachricht am Seitenanfang: sie zu LESEN entfernt sie aus TempData *@
@if (TempData["Flash"] is string flash)
{
<div class="alert alert-success" role="status">@flash</div>
}
@RenderBody()
@if (ViewData["Error"] is string error)
{
<div class="error-area" role="alert">@error</div>
}
</div>
</body>
</html>
|
Die Flash-Meldung wird oben auf der Seite angezeigt (Zeilen 12–14) und die Fehlermeldung unten (Zeilen 17–19). Das Lesen von [TempData["Flash"]] markiert den Wert als verbraucht: Er wird am Ende der Anfrage gelöscht.
Das sieht [curl] beim erfolgreichen Absenden des Formulars. Die Option [-c file] speichert die empfangenen Cookies, [-b file] sendet sie zurück; [--data-urlencode] kodiert Leerzeichen und Akzente im Feld:
| curl -i -c cookies.txt -b cookies.txt --data-urlencode "label=Review ASP.NET" http://localhost:5000/tasks
|
| HTTP/1.1 302 Found
Content-Length: 0
Location: /tasks
Set-Cookie: .AspNetCore.Mvc.CookieTempDataProvider=CfDJ8Mr17zLSwO9AhYlPOJdkD8mjtY...; path=/; samesite=lax; httponly
|
Die Antwort ist eine Umleitung mit dem Cookie [.AspNetCore.Mvc.CookieTempDataProvider], das die verschlüsselte Flash-Meldung enthält (sein sehr langer Wert wurde gekürzt). Die nächste Anfrage sendet das Cookie; die Antwort löscht es (Ablaufdatum in der Vergangenheit):
| curl -i -c cookies.txt -b cookies.txt http://localhost:5000/tasks
|
| HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Set-Cookie: .AspNetCore.Mvc.CookieTempDataProvider=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/; samesite=lax; httponly
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Tasks</title>
<link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
<link rel="stylesheet" href="/css/styles.css">
</head>
<body>
<div class="container py-3" style="max-width: 36rem">
<div class="alert alert-success" role="status">The task [Review ASP.NET] has been added.</div>
<h1 class="h3">My tasks</h1>
<ol>
<li>Read chapter 3</li>
<li>Review ASP.NET</li>
</ol>
<form method="post" action="/tasks" class="d-flex gap-2">
<input class="form-control" name="label" placeholder="New task">
<button class="btn btn-primary text-nowrap" type="submit">Add</button>
<button class="btn btn-outline-secondary text-nowrap" type="submit" formaction="/tasks/without-prg">Add without PRG</button>
</form>
</div>
</body>
</html>
|
Im Browser (http://localhost:5000/tasks) nach dem Hinzufügen einer Aufgabe:

Die Adressleiste zeigt [/tasks]: Das ist die GET-Seite. Man kann sie gefahrlos neu laden; die Meldung verschwindet. Eine leere Eingabe:

Und das Gegenbeispiel:

Hier löst das Neuladen der Seite eine Browserwarnung aus („Formularübermittlung bestätigen“) und fügt die Aufgabe dann ein zweites Mal hinzu. Alle POST-Formulare der Fallstudie folgen dem PRG-Muster.
4.9. Beispiel 21: Links, Schaltflächen und Bestätigung
Eine einfache Regel leitet die Wahl zwischen einem Link und einer Schaltfläche:
- Ein Link ([<a href>]) erzeugt eine GET-Anfrage. Eine GET-Anfrage darf nichts verändern: Browser, Suchmaschinen und Virenscanner können Links von sich aus aufrufen, um eine Seite vorzubereiten oder zu analysieren;
- Eine Operation, die Daten verändert (hinzufügen, bearbeiten, löschen, abmelden), ist eine Schaltfläche in einem POST-Formular.
Beispiel 21 verwaltet eine Kontaktliste: Man kann einen Kontakt über einen Link ansehen und über eine Schaltfläche löschen, die ein Bestätigungsfenster öffnet. Die Dateien dieses Beispiels:
| 21-links-buttons/
├── Controllers/
│ └── ContactsController.cs
├── Services/
│ └── ContactsService.cs
├── Views/
│ ├── Contacts/
│ │ ├── Details.cshtml
│ │ └── List.cshtml
│ ├── Shared/
│ │ ├── _Confirmation.cshtml
│ │ └── _Layout.cshtml
│ ├── _ViewImports.cshtml
│ └── _ViewStart.cshtml
├── wwwroot/
│ ├── css/
│ │ └── styles.css
│ └── js/
│ └── app.js
├── appsettings.json
├── Example21.csproj
└── Program.cs
|
Die Datei [Services/ContactsService.cs]:
| namespace Example21.Services;
// ein Kontakt: eine Kennung, ein Name, eine Telefonnummer
public record Contact(int Id, string Name, string Phone);
// die Kontakte im Speicher, für alle gemeinsam (Singleton)
public class ContactsService
{
private readonly List<Contact> contacts =
[
new(1, "Marie Durand", "01 23 45 67 89"),
new(2, "Paul Martin", "06 12 34 56 78"),
new(3, "Philippe Jandot", "02 98 76 54 32"),
];
private int lastId = 3;
public IReadOnlyList<Contact> List() => contacts;
// null, wenn der Kontakt nicht existiert
public Contact? Read(int id) => contacts.Find(c => c.Id == id);
public Contact? Edit(int id, string name, string phone)
{
var index = contacts.FindIndex(c => c.Id == id);
if (index < 0) return null;
// ein Record ist unveränderlich: wir ersetzen ihn durch eine geänderte Kopie (mit with)
contacts[index] = contacts[index] with { Name = name, Phone = phone };
return contacts[index];
}
public Contact Add(string name, string phone)
{
var contact = new Contact(++lastId, name, phone);
contacts.Add(contact);
return contact;
}
public Contact? Delete(int id)
{
var contact = Read(id);
if (contact is not null) contacts.Remove(contact);
return contact;
}
}
|
- Zeile 4: ein Kontakt;
- Zeile 20: [Find] liefert [null], wenn kein Kontakt diese ID hat;
- Zeilen 22–28: Ein [record] ist unveränderlich: Seine Eigenschaften werden nicht geändert, stattdessen wird er durch eine geänderte Kopie ersetzt. Der Ausdruck [with { ... }] erzeugt diese Kopie;
- Zeilen 31–35: [++lastId] erhöht den Zähler vor seiner Verwendung: Die Bezeichner sind 4, 5 ...
Die Datei [Controllers/ContactsController.cs]:
| using Example21.Services;
using Microsoft.AspNetCore.Mvc;
namespace Example21.Controllers;
[Route("contacts")]
public class ContactsController(ContactsService contacts) : Controller
{
// ein LINK (<a href>): eine GET-Anfrage, die nichts verändert
[HttpGet("")]
public IActionResult List()
{
return View(contacts.List());
}
[HttpGet("{id:int}")]
public IActionResult Details(int id)
{
var contact = contacts.Read(id);
return contact is null ? NotFound() : View(contact);
}
// ein BUTTON in einem POST-Formular: eine Anfrage, die Daten verändert
[HttpPost("{id:int}")]
public IActionResult Save(int id, string name, string phone)
{
var contact = contacts.Edit(id, name, phone);
if (contact is null) return NotFound();
TempData["Flash"] = $"The contact [{contact.Name}] has been edited.";
return RedirectToAction(nameof(List));
}
// gleiches Formular, anderer Button (Attribut formaction): andere Action
[HttpPost("{id:int}/duplicate")]
public IActionResult Duplicate(int id, string name, string phone)
{
var copy = contacts.Add($"{name} (copy)", phone);
TempData["Flash"] = $"The contact [{copy.Name}] has been created.";
return RedirectToAction(nameof(List));
}
[HttpPost("{id:int}/delete")]
public IActionResult Delete(int id)
{
var contact = contacts.Delete(id);
if (contact is null) return NotFound();
TempData["Flash"] = $"The contact [{contact.Name}] has been deleted.";
return RedirectToAction(nameof(List));
}
}
|
Kommentieren wir diesen Code:
- Zeilen 11–20: die beiden Seiten: die Liste und die Detailseite eines Kontakts. Die Routeneinschränkung [:int] (siehe Beispiel 02) akzeptiert nur einen ganzzahligen Bezeichner; ein nicht vorhandener Kontakt führt zu einem 404-Fehler;
- Zeilen 24–30: Speichern eines Datensatzes mit PRG;
- Zeilen 34–39: Duplizierung, ausgelöst durch eine zweite Schaltfläche im selben Formular (Attribut [formaction]);
- Zeilen 42–48: Löschen per POST.
Die Datei [Views/Contacts/List.cshtml]:
| @model IReadOnlyList<Contact>
<h1 class="h3">Contacts</h1>
<table class="table align-middle">
<tbody>
@foreach (var contact in Model)
{
<tr>
<td>@contact.Name</td>
<td>@contact.Phone</td>
<td class="text-end">
@* anzeigen: ein einfacher Link *@
<a class="btn btn-sm btn-outline-primary" href="/contacts/@contact.Id">View</a>
@* löschen: ein POST-Formular, dessen Absenden bestätigt werden muss *@
<form method="post" action="/contacts/@contact.Id/delete" class="d-inline"
data-confirmation="Delete the contact @contact.Name?">
<button class="btn btn-sm btn-outline-danger" type="submit">Delete</button>
</form>
</td>
</tr>
}
</tbody>
</table>
|
- Zeile 12: ansehen: ein Link, der von [Bootstrap] als Schaltfläche dargestellt wird;
- Zeilen 14–17: löschen: ein kleines Formular (POST), reduziert auf seine Schaltfläche. Das Attribut [data-confirmation] enthält die Frage, die vor dem Absenden gestellt werden soll. Die [data-*]-Attribute sind optional: HTML ignoriert sie, während [JavaScript] auf der Seite sie lesen kann.
Die Datei [Views/Contacts/Details.cshtml]:
| @model Contact
<h1 class="h3">Contact no. @Model.Id</h1>
<form method="post" action="/contacts/@Model.Id">
<div class="mb-2">
<label class="form-label" for="name">Name</label>
<input class="form-control" id="name" name="name" value="@Model.Name">
</div>
<div class="mb-3">
<label class="form-label" for="phone">Phone</label>
<input class="form-control" id="phone" name="phone" value="@Model.Phone">
</div>
@* zwei Submit-Buttons für dasselbe Formular *@
<button class="btn btn-primary" type="submit">Save</button>
<button class="btn btn-outline-primary" type="submit" formaction="/contacts/@Model.Id/duplicate">Duplicate</button>
<a class="btn btn-link" href="/contacts">Back to the list</a>
</form>
|
- Zeilen 13–14: zwei Absende-Schaltflächen für dasselbe Formular.
4.9.1. Das Bestätigungsfenster
Das Dialogfeld des Browsers ([window.confirm]) lässt sich weder formatieren noch übersetzen: Seine Schaltflächen bleiben in der Sprache des Browsers. Es wird durch ein [Bootstrap]-Fenster ersetzt, das in die Seite eingebettet und bis zum Bedarfsfall verborgen ist. Die Datei [Views/Shared/_Confirmation.cshtml]:
| @* ein einziges Fenster für die ganze Seite, zunächst ausgeblendet (d-none) *@
<div id="confirmation-modal" class="d-none">
<div class="modal-backdrop fade show"></div>
<div class="modal fade show d-block" tabindex="-1" role="alertdialog" aria-modal="true">
<div class="modal-dialog modal-dialog-centered">
<div class="modal-content">
<div class="modal-header">
<h5 class="modal-title">Confirmation</h5>
</div>
<div class="modal-body">
<p class="mb-0" id="confirmation-modal-message"></p>
</div>
<div class="modal-footer">
<button type="button" class="btn btn-secondary" data-action="no">No, go back</button>
<button type="button" class="btn btn-danger" data-action="yes">Yes, confirm</button>
</div>
</div>
</div>
</div>
</div>
|
- Zeile 2: Die Klasse [d-none] verbirgt das Fenster;
- Zeile 3: der graue Hintergrund;
- Zeile 11: die Position der Frage;
- Zeilen 14–15: die beiden Schaltflächen, die über das Attribut [data-action] identifiziert werden.
Die Datei [Views/Shared/_Layout.cshtml]:
| <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Contacts</title>
<link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
<link rel="stylesheet" href="/css/styles.css">
</head>
<body>
<div class="container py-3" style="max-width: 40rem">
@if (TempData["Flash"] is string flash)
{
<div class="alert alert-success" role="status">@flash</div>
}
@RenderBody()
</div>
@* das Bestätigungsfenster, in jeder Seite vorhanden *@
<partial name="_Confirmation" />
@* das Skript am Seitenende: die Elemente, die es sucht, existieren bereits *@
<script src="/js/app.js"></script>
</body>
</html>
|
- Zeile 18: Das Fenster ist auf allen Seiten vorhanden;
- Zeile 20: Das Skript wird am Ende der Seite geladen; wenn es ausgeführt wird, existieren die gesuchten Elemente bereits. Es wird von [UseStaticFiles] aus [wwwroot/js/app.js] ausgeliefert.
Ein kleiner Teil [JavaScript] verbindet die Formulare mit dem Fenster. Die Datei [wwwroot/js/app.js]:
| // Bestätigung der Formulare, die das Attribut data-confirmation="..." tragen
// Ohne JavaScript werden diese Formulare einfach ohne Bestätigung gesendet.
(() => {
const modal = document.getElementById('confirmation-modal');
const message = document.getElementById('confirmation-modal-message');
let pending = null; // das Formular, das bei Bestätigung durch den Benutzer gesendet wird
// 1. wir fangen das Absenden der zu bestätigenden Formulare ab
document.querySelectorAll('form[data-confirmation]').forEach((form) => {
form.addEventListener('submit', (event) => {
event.preventDefault(); // das Absenden wird ausgesetzt
pending = form;
message.textContent = form.dataset.confirmation;
modal.classList.remove('d-none'); // das Fenster erscheint
});
});
// 2. die beiden Buttons des Fensters
modal.addEventListener('click', (event) => {
const action = event.target.dataset.action;
if (action === 'yes') {
pending.submit(); // Absenden, OHNE das Ereignis 'submit' erneut auszulösen
} else if (action === 'no') {
modal.classList.add('d-none');
pending = null;
}
});
})();
|
- Zeile 3: Der Code ist in eine Funktion eingeschlossen, die sofort ausgeführt wird, um keine globalen Variablen zu erzeugen;
- Zeilen 9–14: Das Absenden jedes Formulars mit dem Attribut [data-confirmation] wird abgefangen. [preventDefault()] setzt das Absenden aus; das Formular wird gespeichert, die Frage wird im Fenster platziert ([textContent], nicht [innerHTML]: Die Frage wird als Text angezeigt und nie als HTML interpretiert), und das Fenster wird angezeigt;
- Zeilen 19–25: „Ja“ sendet das zwischengespeicherte Formular ab. Die Methode [submit()] eines Formulars sendet es ab, ohne das Ereignis [submit] auszulösen: Es erscheint keine erneute Bestätigungsabfrage. „Nein“ verbirgt das Fenster.
Ist [JavaScript] deaktiviert, werden die Formulare einfach ohne Bestätigung gesendet: Die Anwendung funktioniert weiterhin. Das ist das Prinzip der schrittweisen Verbesserung: [JavaScript] bietet zusätzlichen Komfort, ist aber nicht unerlässlich. Die Fallstudie folgt diesem Prinzip (ihr Skript [wwwroot/js/app.js] ergänzt die Tastaturbedienung: die Esc-Taste und den Fokus). Die resultierenden Seiten, erzeugt ausgehend von http://localhost:5000/contacts: die Liste, die Bestätigungsabfrage, die Liste nach dem Löschen und das Profil eines Kontakts:




Schließlich prüfen wir, dass das Löschen nicht durch eine GET-Anfrage ausgelöst werden kann:
| curl -i http://localhost:5000/contacts/2/delete
|
| HTTP/1.1 405 Method Not Allowed
Content-Length: 0
Allow: POST
|
Der Pfad existiert, aber nicht für die Methode GET: [ASP.NET Core] liefert [405 Method Not Allowed] zurück, und der Header [Allow] nennt die akzeptierte Methode. Mit POST:
| curl -i -X POST http://localhost:5000/contacts/2/delete
|
| HTTP/1.1 302 Found
Content-Length: 0
Location: /contacts
Set-Cookie: .AspNetCore.Mvc.CookieTempDataProvider=CfDJ8Mr17zLSwO9AhYlPOJdkD8nJg8...; path=/; samesite=lax; httponly
|