2. Controller, Actions, Routing
Dieses Kapitel untersucht den Weg, den eine Anfrage vom Browser bis zur Action nimmt, die sie verarbeitet, sowie die Antwort, die diese Action zurückgibt. Views werden erst in Kapitel 4 eingeführt: Hier geben Actions Text oder JSON direkt zurück.
2.1. Beispiel 01: Die Struktur einer ASP.NET-Core-MVC-Anwendung
Das erste Beispiel ist die kleinstmögliche [ASP.NET Core MVC]-Anwendung. Zusätzlich zu den in der Einleitung vorgestellten Dateien [Example01.csproj] und [appsettings.json] hat sie zwei Dateien:
2.1.1. Der Einstiegspunkt: Program.cs
Gehen wir diesen Code durch:
- Zeile 2: [WebApplication.CreateBuilder] erstellt den „Builder“ der Anwendung. Er liest die Konfiguration (die Datei [appsettings.json], Umgebungsvariablen usw.), richtet die Protokollierung ein und bereitet die Liste der Services der Anwendung vor, [builder.Services]. Der Parameter [args] enthält die Kommandozeilenargumente;
- Zeile 5: Die Services, die [MVC] benötigt, um die Controller der Anwendung zu finden und ihre Actions auszuführen, werden der Liste hinzugefügt;
- Zeile 8: Die Anwendung wird erstellt. Nach dieser Zeile kann die Liste der Services nicht mehr geändert werden;
- Zeile 11: Die von den Controllern deklarierten Routen (die Attribute [[HttpGet]], [[Route]] ..., die wir noch besprechen werden) werden aktiviert: Ohne diese Zeile würde keine Action jemals aufgerufen;
- Zeile 14: Startet den Webserver [Kestrel] und wartet auf Anfragen, bis die Anwendung beendet wird ([Ctrl-C]). Sofern nichts anderes angegeben ist, lauscht der Server auf Port 5000.
Diese Datei enthält weder eine Klasse noch eine Methode namens [Main]: Es handelt sich um ein Programm mit Top-Level-Anweisungen. Der [C#]-Compiler verpackt diese Anweisungen selbst in eine Methode namens [Main], die als Einstiegspunkt des Programms dient. Beachten Sie auch das Fehlen von [using]-Direktiven: [WebApplication] gehört zum Namespace [Microsoft.AspNetCore.Builder], der automatisch importiert wird (siehe [ImplicitUsings] in der Einleitung).
2.1.2. Der Controller: Controllers/HomeController.cs
- Zeile 1: der Namespace, der die Klasse [Controller] und die Attribute von [MVC] enthält;
- Zeile 3: der Namespace für die Klassen dieser Datei. Üblicherweise enthält er den Projektnamen ([Example01]) und das Verzeichnis der Datei ([Controllers]). Die Form [namespace X;] (ohne geschweifte Klammern) gilt für die gesamte Datei;
- Zeile 6: Ein Controller ist eine public-Klasse, die von der Klasse [Controller] erbt. Üblicherweise endet ihr Name auf [Controller]. [ASP.NET Core] findet die Controller der Anwendung automatisch – sie müssen nicht deklariert werden;
- Zeile 9: Das Attribut [[HttpGet("/")]] ordnet die Methode [Index] den Anfragen [GET /] zu. Eine auf diese Weise einer Route zugeordnete Methode ist eine Action. Ein [C#]-Attribut wird in eckigen Klammern geschrieben, unmittelbar vor dem, was es beschreibt: Es fügt der Methode Informationen hinzu, die das Framework beim Start liest;
- Zeile 13: Der von der Action zurückgegebene Wert ist die Antwort, die an den Browser gesendet wird.
2.1.3. Ausführung
Geben Sie in einem Terminalfenster, das im Verzeichnis [01-structure] geöffnet ist, [dotnet run] ein. Nach der Kompilierung startet der Server:
Die Startmeldungen zeigen die Adresse, auf der der Server lauscht ([http://localhost:5000]), und die Laufzeitumgebung: [Production], die Standardumgebung. Wir werden sehen, dass bestimmte Verhaltensweisen von [ASP.NET Core] von der Umgebung abhängen ([Development] oder [Production]). Rufen wir die URL [http://localhost:5000/] mit einem Browser auf:

Dann mit [curl]. Die Option [-i] zeigt auch die HTTP-Header der Antwort an (wir geben hier nur einige davon wieder):
Eine von einer Action zurückgegebene Zeichenkette wird mit dem Header [Content-Type: text/plain] gesendet: Der Browser zeigt sie als reinen Text an, ohne sie zu interpretieren. Das unterscheidet sich von [NestJS], wo sie als HTML gesendet wurde ([text/html]). Beispiel 03 zeigt, wie HTML gesendet wird.
2.2. Beispiel 02: Routing
Das Routing ordnet eine URL und eine HTTP-Methode (GET, POST ...) einer Action zu. Beispiel 02 hat zwei Controller:
Die Datei [Program.cs] ist mit der aus Beispiel 01 identisch: Das gilt für alle Beispiele dieses Kapitels mit Ausnahme des letzten. Die Datei [Controllers/HomeController.cs]:
- Zeile 9: Die Action gibt nun keine Zeichenkette mehr zurück, sondern ein [ContentResult]: eine Antwort, deren Inhalt und Typ angegeben sind;
- Zeilen 11–22: ein [C#]-Rohzeichenfolgenliteral [raw string literal], begrenzt durch drei Anführungszeichen. Es kann mehrere Zeilen umfassen und Anführungszeichen enthalten, ohne dass diese maskiert werden müssen. Leerzeichen vor dem schließenden ["""] werden aus jeder Zeile entfernt;
- Zeile 24: Die Methode [Content(text, type)] der Klasse [Controller] erzeugt ein [ContentResult]. Der Typ [text/html] weist den Browser an, den Text als HTML zu interpretieren.
Die Action [Index] liefert somit eine HTML-Seite, die Links zu den Actions des anderen Controllers enthält:

Die Datei [Controllers/FirstController.cs]:
Gehen wir diesen Code durch:
- Zeile 6: Das auf die Klasse angewendete Attribut [[Route("first")]] legt das allen Routen des Controllers gemeinsame Präfix fest: Seine Actions bearbeiten URL-Pfade, die mit [/first] beginnen;
- Zeilen 10–11: [[HttpGet("")]]: Die Action [Index] bearbeitet [GET /first]. Die URL einer Action ist die Verkettung des Controller-Präfixes und des Action-Pfads;
- Zeilen 17–18: Die Action [Action01] bearbeitet [GET /first/action01];
- Zeilen 24–25: derselbe Pfad, aber für die Methode POST: [[HttpPost]] ersetzt [[HttpGet]]. Es gibt außerdem [[HttpPut]], [[HttpDelete]], [[HttpPatch]] ... Der Name der [C#] -Methode ([Action01Post]) ist beliebig: Für das Routing zählen nur die Attribute. Außerdem können innerhalb derselben Klasse zwei Methoden nicht denselben Namen mit denselben Parametern haben;
- Zeilen 31–32: [{id}] ist ein Routenparameter: Dieses URL-Segment kann verschiedene Werte annehmen. [:int] ist eine Einschränkung: Das Segment muss eine ganze Zahl sein, andernfalls passt die Route nicht. Der Wert des Segments wird an den gleichnamigen Parameter der Action übergeben, [id], der bereits in [int] konvertiert wurde: Für [/first/products/17] ist [id] gleich der Zahl 17. Das ist das Model Binding ([model binding]), das das nächste Kapitel ausführlich behandelt;
- Zeilen 38–39: zwei Routenparameter, die an zwei Parameter der Action übergeben werden;
- Zeilen 44–46: [{**path}] ist ein „Catch-all“-Parameter ([catch-all]): Er akzeptiert jedes Ende einer URL, einschließlich [/].
Hier sind die Ergebnisse einiger Anfragen:
Um eine POST-Anfrage zu senden, verwenden Sie die Option [-X POST] von [curl]:
Eine HTTP-Methode, die von keiner Action für diesen Pfad bearbeitet wird, führt zu einem Fehler 405 ([Method Not Allowed]). Der Header [Allow] listet die akzeptierten Methoden auf:
Eine URL, die von keiner Route bearbeitet wird, führt schließlich zu einem Fehler 404. Das gilt auch für eine Kennung, die die Einschränkung [:int] nicht erfüllt: Keine Route passt zu [/first/products/abc].
Die 404-Antwort von [ASP.NET Core] hat keinen Inhalt ([Content-Length: 0]): Der Browser zeigt seine eigene Fehlerseite an.

Kapitel 7 zeigt, wie sich diese leere Antwort durch eine HTML-Seite ersetzen lässt.
2.3. Beispiel 03: Antworten einer Action
Was eine Action zurückgibt, bestimmt die HTTP-Antwort. Beispiel 03 geht die wichtigsten Fälle durch. Die Datei [Controllers/ResponsesController.cs]:
Gehen wir diesen Code durch:
- Zeilen 9–12: Eine Zeichenkette wird unverändert gesendet, mit dem Header [Content-Type: text/plain; charset=utf-8];
- Zeilen 16–19: dieselbe Zeichenkette, als HTML deklariert (siehe Beispiel 02): Der Browser interpretiert sie;
- Zeilen 23–26: Ein Objekt wird als JSON serialisiert, mit dem Header [Content-Type: application/json]. [new { lastName = ..., firstName = ... }] erzeugt ein Objekt eines anonymen Typs: eines namenlosen, vom Compiler erzeugten Typs, der sich für Daten eignet, die nur einmal verwendet werden. Die Eigenschaftsnamen von JSON werden in „camelCase“ geschrieben (erster Buchstabe klein), nach der Konvention von [JavaScript];
- Zeilen 30–33: Auch ein Array wird als JSON serialisiert. [["Mme", "Melle", "Mr"]] ist ein Collection-Ausdruck ([C#] 12), der hier ein Array von Zeichenketten erzeugt;
- Zeilen 39–41: Wenn die Action den Statuscode selbst festlegen muss, gibt sie ein [IActionResult] zurück: ein Objekt, das die vollständige Antwort beschreibt. Die Methoden der Klasse [Controller] erzeugen viele davon: [StatusCode(201, object)] erzeugt eine Antwort mit dem Code 201 ([Created]), deren Inhalt das in JSON serialisierte Objekt ist;
- Zeilen 46–48: [NoContent()] gibt den Statuscode 204 zurück ([No Content]): „kein Inhalt“;
- Zeilen 53–57: Eine Action kann asynchron ([async]) sein: Sie gibt dann einen Task zurück ([Task<T>]), das Äquivalent eines Promise ([JavaScript]), und [ASP.NET Core] wartet, bis der Task abgeschlossen ist, bevor es antwortet. [await Task.Delay(500)] wartet 500 ms, ohne den Server zu blockieren: Während des Wartens wird der Thread, der die Action ausgeführt hat, an den Server zurückgegeben, der ihn für die Bearbeitung anderer Anfragen nutzen kann. So werden alle Actions geschrieben, die eine Datenbank abfragen;
- Zeilen 62–64: Ein vom Programm erwarteter Fehler: [NotFound(object)] gibt eine 404-Antwort mit JSON-Inhalt zurück. Entsprechend gibt es [BadRequest(...)] (400), [Unauthorized()] (401), [Forbid()] (403), [Ok(...)] (200) ...;
- Zeilen 69–71: ein unerwarteter Fehler: Die Action löst eine Ausnahme aus, die sie nicht behandelt. [ASP.NET Core] antwortet dann mit einem Fehler 500 ([Internal Server Error]).
Empfangene Antworten:
In diesem Ausnahmefall liefert die Antwort keine Informationen über den Fehler: Die Details könnten einem Angreifer helfen. Sie werden in der Serverkonsole protokolliert (wir geben hier nur den Anfang wieder):
In einem Browser ist der Unterschied zwischen [text/plain] und [text/html] sichtbar:


2.4. Beispiel 04: Weiterleitungen
Eine Action kann mit einer Weiterleitung antworten: einem Statuscode 301 oder 302 und einem Header [Location], der dem Browser mitteilt, welche URL er als Nächstes anfordern soll. Der Browser fordert sie sofort an, ohne Zutun des Benutzers. Weiterleitungen sind in einer Webanwendung allgegenwärtig: nach dem erfolgreichen Absenden eines Formulars, nach der Anmeldung, nach dem Wechsel der Sprache ...
Die Datei [Controllers/RedirectsController.cs]:
Gehen wir diesen Code durch:
- Zeilen 9–11: [RedirectPermanent(url)] erzeugt eine dauerhafte Weiterleitung (Statuscode 301, [Moved Permanently]): Die Adresse der Seite hat sich dauerhaft geändert. Browser und Suchmaschinen können die neue Adresse zwischenspeichern;
- Zeilen 22–24: [Redirect(url)] erzeugt eine vorübergehende Weiterleitung (Statuscode 302, [Found]), hier an eine berechnete Adresse. [$"/page/{destination}"] ist eine interpolierte Zeichenkette: Der Ausdruck in den geschweiften Klammern wird durch seinen Wert ersetzt;
- Zeilen 29–31: [RedirectToAction(action, values)] leitet an eine Action weiter, nicht an eine URL: [ASP.NET Core] erzeugt die URL der Action [Page] selbst anhand ihrer Route ([page/{name}]) und der übergebenen Werte ([name = destination]). Wenn sich der Pfad der Action jemals ändert, folgt die Weiterleitung automatisch. [nameof(Page)] gibt den Methodennamen zurück (["Page"]): Ein Tippfehler würde einen Kompilierungsfehler verursachen, was bei einer von Hand geschriebenen Zeichenkette nicht der Fall ist;
- Zeilen 42–44: Sie können auf eine andere Website weiterleiten.
[curl] zeigt die Weiterleitung, ohne ihr zu folgen:
Mit der Option [-L] folgt [curl] der Weiterleitung, genau wie ein Browser. Wir sehen dann die beiden aufeinanderfolgenden Antworten:
Beide Actions führen zur selben Weiterleitung: die eine mit einer von Hand geschriebenen URL, die andere mit einer von [ASP.NET Core] erzeugten URL. Im Browser ist nur die endgültige Seite sichtbar; die Adressleiste zeigt die neue URL:

2.5. Beispiel 05: Die Objekte Request und Response
Jede Anfrage wird durch ein [HttpContext]-Objekt dargestellt, das die Anfrage ([Request]) und die gerade erzeugte Antwort ([Response]) enthält. Eine Action greift direkt über die Eigenschaften [HttpContext], [Request] und [Response] der Klasse [Controller] darauf zu. Das ist manchmal notwendig, und wir tun es in der Fallstudie (zum Beispiel, um ein Cookie zu lesen oder zu setzen), aber man muss wissen, was man tut.
Die Datei [Controllers/HttpController.cs]:
Gehen wir diesen Code durch:
- Zeilen 10–18: die Anfrage: die HTTP-Methode ([Request.Method]), der Pfad ([Request.Path]), die URL-Parameter ([Request.QueryString]), die Header ([Request.Headers]) und, über [HttpContext.Connection], die Adresse (IP) des Clients. [?.] ist der „Null-conditional“-Operator: Wenn [RemoteIpAddress] gleich [null] ist, ergibt der Ausdruck [null] , statt einen Fehler zu verursachen;
- Zeilen 24–27: Die Action fügt der Antwort einen Header hinzu und gibt dann ganz normal ihren Wert zurück, den [ASP.NET Core] sendet. Das ist die häufigste Verwendung von [Response];
- Zeilen 32–36: Die Action schreibt die Antwort selbst – Statuscode, Typ, dann den Body – mit [Response.WriteAsync]. Sie gibt nichts zurück ([Task], nicht [Task<T>]);
- Zeilen 41–45: der zu vermeidende Fehler: einen Teil der Antwort zu schreiben und dann ein Ergebnis zurückzugeben. Sobald die ersten Bytes des Bodys an den Browser gesendet wurden, können der Statuscode und die Header – die vor dem Body gesendet wurden – nicht mehr geändert werden.
Die erhaltenen Antworten:
(Die Option [-A] von [curl] legt den Header [User-Agent] fest, der den Browser identifiziert)
Bei der letzten Action erhält der Browser den Statuscode 200 und den Anfang der Antwort statt des erwarteten 404. Die Serverkonsole meldet den Fehler:
Im weiteren Verlauf des Dokuments geben die Actions fast immer ein Ergebnis zurück ([IActionResult]) und überlassen es [ASP.NET Core], die Antwort zu schreiben. [Request] und [Response] werden nur noch verwendet, um die Anfrage zu lesen und Cookies zu setzen.
2.6. Beispiel 06: Services und Dependency Injection
Controller sollten keine Anwendungslogik enthalten; sie delegieren sie an Services. Ein Service ist ein gewöhnliches Objekt, das [ASP.NET Core] erstellt und den Klassen bereitstellt, die es benötigen: Das ist Dependency Injection. Beispiel 06 teilt eine kleine Anwendung in zwei Teile auf: Produkte und Kunden:
2.6.1. Das Produkt
Ein Record: eine in einer einzigen Zeile deklarierte Datenklasse. Der Compiler erzeugt die Eigenschaften [Id], [Name] und [Price], einen Konstruktor, der sie initialisiert, und Hilfsmethoden (Vergleich, Anzeige). Der Typ [decimal] stellt Beträge ohne Rundungsfehler dar.
2.6.2. Der Vertrag des Services: IProductsService
- Zeile 4: Eine Schnittstelle beschreibt, was der Service kann, ohne festzulegen, wie. Klassen, die den Service verwenden, kennen nur diese Schnittstelle;
- Zeile 6: [IReadOnlyList<Product>]: eine Liste, die der Aufrufer lesen, aber nicht ändern kann;
- Zeile 7: [Product?]: ein Produkt oder [null] , wenn kein Produkt diese Kennung hat (siehe [Nullable] in der Einleitung).
2.6.3. Die Implementierung: ProductsService
- Zeile 4: Die Klasse implementiert die Schnittstelle: Sie muss alle ihre Methoden bereitstellen;
- Zeilen 6–11: die Daten, hier im Speicher, in einer Liste, die durch einen Collection-Ausdruck initialisiert wird;
- Zeilen 13–15: die beiden Methoden, geschrieben mit der Syntax [=>] (eine Methode, deren Rumpf aus einem einzigen Ausdruck besteht). [FirstOrDefault] ([LINQ]) gibt das erste Ergebnis zurück, das die Bedingung erfüllt, oder [null] , wenn es keines gibt.
2.6.4. Der Controller ProductsController
- Zeilen 11–13: Dependency Injection. Der Controller deklariert in seinem Konstruktor, dass er einen [IProductsService] benötigt; [ASP.NET Core] stellt ihm das für diesen Typ registrierte Objekt bereit (siehe unten). Der Controller ruft niemals [new ProductsService()] auf: Er kennt diese Klasse nicht einmal, nur die Schnittstelle. Die Implementierung könnte ersetzt werden (durch eine Version, die eine Datenbank liest, oder durch eine Testversion), ohne den Controller zu ändern;
- Zeilen 17–19: Die Action delegiert an den Service. Die Liste wird mit JSON serialisiert;
- Zeilen 23–30: [{id:int}] konvertiert die Kennung; für ein nicht vorhandenes Produkt wird eine 404-Antwort zurückgegeben. [Ok(object)] gibt eine 200-Antwort zurück, deren Inhalt das in JSON serialisierte Objekt ist. [is null] prüft, ob ein Wert null ist.
2.6.5. Der Controller ClientsController
- Zeile 9: ein primärer Konstruktor ([C#] 12): Der Konstruktorparameter wird direkt hinter dem Klassennamen geschrieben. Er kann in der gesamten Klasse verwendet werden: Er muss nicht in ein Feld kopiert werden. Das ist die kompakteste Form der Dependency Injection; sie wird im weiteren Verlauf dieses Dokuments durchgängig verwendet. [ClientsController] erhält denselben Service wie [ProductsController];
- Zeilen 12–15: Er verwendet ihn, um die Summe eines Warenkorbs zu berechnen. [Sum] ([LINQ]) addiert die Preise.
2.6.6. Registrierung der Services
[ASP.NET Core] kann einen Service nur bereitstellen, wenn es ihn kennt: Jeder Service wird registriert in [builder.Services], zusammen mit seiner Lebensdauer. Die Datei [Products/ProductsExtensions.cs]:
- Zeile 6: eine statische Klasse, die nur statische Methoden enthält;
- Zeile 8: eine Erweiterungsmethode. Das Schlüsselwort [this] vor dem ersten Parameter erlaubt es, sie aufzurufen, als gehörte sie zum Typ dieses Parameters: [builder.Services.AddProducts()]. So fügen die Bibliotheken von [ASP.NET Core] ihre Services hinzu ([AddControllers], [AddAuthentication] ...), und es ist eine gute Möglichkeit, die Registrierungen eines bestimmten Anwendungsteils zusammenzufassen;
- Zeile 12: „Wenn eine Klasse einen [IProductsService] anfordert, stelle ihr einen [ProductsService] bereit.“ [Singleton] ist die Lebensdauer des Services: eine einzige Instanz, die bei der ersten Anfrage erstellt und von allen Anfragen gemeinsam genutzt wird. Es gibt zwei weitere Lebensdauern: [Scoped] (eine Instanz pro Anfrage) und [Transient] (eine neue Instanz bei jeder Anforderung). Kapitel 6 kommt auf dieses Thema zurück;
- Zeile 13: Die Methode gibt die Liste der Services zurück, damit Aufrufe verkettet werden können.
Die Datei [Program.cs]:
- Zeile 1: der Namespace der Erweiterungsmethode;
- Zeile 8: die Registrierung des Produkt-Services.
Controller dagegen werden nicht einzeln registriert: [AddControllers] findet sie alle, und [ASP.NET Core] erstellt für jede Anfrage ein neues Controller-Objekt und injiziert die von ihm angeforderten Services.
2.6.7. Ausführung
Die Fallstudie ist genau so aufgebaut: schlanke Controller, die an injizierte Services delegieren, die durch Schnittstellen beschrieben und in [Program.cs] registriert werden.