7. Der Lebenszyklus einer Anfrage
Zwischen dem Eintreffen einer Anfrage und der Ausführung der Action setzt [ASP.NET Core] mehrere Arten von Objekten ein, jedes mit einer bestimmten Rolle. Einigen davon sind wir bereits begegnet: Middleware ([UseStaticFiles], [UseRequestLocalization], die Middleware aus Beispiel 23) und das Model Binding ([IModelBinder], Beispiel 12). Die MVC-Komponente fügt Filter hinzu, die rund um die Action laufen. Die Fallstudie verwendet jeden davon:

Objekt | Rolle | In der Fallstudie |
Middleware | Bereitet die Anfrage vor; kennt die Action noch nicht | statische Dateien, Sprache, Authentifizierung (Lesen des Tokens), Fehlerseiten |
Autorisierungsfilter | erlaubt oder verweigert den Zugriff auf die Action | [[Authorize]], [[Authorize(Roles = ...)]] |
Model Binding | Parameter konvertieren und validieren | Formulare, [ModelState] |
Action-Filter | Code vor und nach der Action | (nicht verwendet: Services und die Eltern-Klasse der Views genügen) |
Exception-Filter | Wandelt eine Exception in eine Antwort um | Sitzung abgelaufen: Umleitung auf /login |
7.1. Beispiel 24: Die Schritte der Verarbeitung einer Anfrage
Beispiel 24 enthält eine Action, die das Quadrat einer Zahl berechnet, und je ein Objekt jeder Art. Jedes schreibt eine Zeile auf die Konsole, sodass wir die Reihenfolge ihrer Ausführung sehen können.
| 24-lifecycle/
├── Controllers/
│ ├── CalcController.cs
│ └── ErrorController.cs
├── Filters/
│ ├── BlockAttribute.cs
│ ├── ErrorPageFilter.cs
│ ├── IntegerBinder.cs
│ ├── LoggerMiddleware.cs
│ └── TimingAttribute.cs
├── Views/
│ ├── Calc/
│ │ └── Result.cshtml
│ ├── Shared/
│ │ ├── _Layout.cshtml
│ │ └── Error.cshtml
│ └── _ViewStart.cshtml
├── appsettings.json
├── Example24.csproj
└── Program.cs
|
Die Datei [Filters/LoggerMiddleware.cs]:
| namespace Example24.Filters;
// eine als Klasse geschriebene Middleware: sie erhält den Rest der Pipeline
// (next) in ihrem Konstruktor und verarbeitet jede Anfrage in InvokeAsync
public class LoggerMiddleware(RequestDelegate next)
{
public async Task InvokeAsync(HttpContext context)
{
Console.WriteLine();
Console.WriteLine($"--- {context.Request.Method} {context.Request.Path}{context.Request.QueryString}");
Console.WriteLine("1. middleware (before)");
await next(context); // der gesamte Rest: Routing, Filter, Action, View
Console.WriteLine($"8. middleware (after: code {context.Response.StatusCode})");
}
}
|
- Zeile 5: Eine Middleware kann eine Klasse sein. Ihr Konstruktor erhält einen [RequestDelegate]: den Rest der Pipeline (die nachfolgenden Middlewares, gefolgt von MVC);
- Zeile 7: Die Methode [InvokeAsync] wird für jede Anfrage aufgerufen;
- Zeile 12: Die Middleware ruft den Rest der Pipeline auf und wartet darauf, dass dieser abgeschlossen ist. Würde sie ihn nicht aufrufen, endete die Anfrage dort (sie müsste dann die Antwort selbst erzeugen). Der Code vor diesem Aufruf wird auf dem Hinweg der Anfrage ausgeführt, der Code danach auf dem Rückweg: Die Middleware „umhüllt“ alles andere und sieht den endgültigen Statuscode der Antwort.
Die Datei [Filters/BlockAttribute.cs]:
| using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Controllers;
using Microsoft.AspNetCore.Mvc.Filters;
namespace Example24.Filters;
// ein AUTORISIERUNGS-Filter: er entscheidet, ob die Action ausgeführt werden darf.
// Er ist zugleich ein Attribut: man setzt ihn auf einen Controller oder eine Action.
public class BlockAttribute : Attribute, IAuthorizationFilter
{
public void OnAuthorization(AuthorizationFilterContext context)
{
// der Filter kennt die angesteuerte Action, anders als die Middleware
var action = (ControllerActionDescriptor)context.ActionDescriptor;
Console.WriteLine($"2. authorization filter (targeted action: {action.ActionName})");
if (context.HttpContext.Request.Query.ContainsKey("block"))
{
// das Setzen von Result schließt den Rest kurz: kein Binding, keine Action
context.Result = new StatusCodeResult(StatusCodes.Status403Forbidden);
}
}
}
|
- Zeile 9: Ein Autorisierungsfilter implementiert [IAuthorizationFilter]. Die Klasse leitet sich außerdem von [Attribute] ab: Sie kann in eckigen Klammern auf einen Controller oder eine Action angewendet werden;
- Zeilen 14–15: Anders als eine Middleware kennt der Filter die Ziel-Action ([ActionDescriptor]). Dadurch kann das Attribut [[Authorize(Roles = "ADMIN")]] (siehe nächstes Kapitel) nur bestimmte Actions schützen;
- Zeilen 16–19: Ein Filter lehnt die Anfrage ab, indem er [context.Result] setzt: Die Abfolge (Binding, Action) wird nicht ausgeführt, und dieses Ergebnis wird zur Antwort. Hier eine 403-Antwort (Zugriff verweigert) ohne Inhalt.
Die Datei [Filters/IntegerBinder.cs]:
| using Microsoft.AspNetCore.Mvc.ModelBinding;
namespace Example24.Filters;
// das Model Binding eines Integer-Parameters (siehe Beispiel 12)
public class IntegerBinder : IModelBinder
{
public Task BindModelAsync(ModelBindingContext context)
{
var value = context.ValueProvider.GetValue(context.ModelName).FirstValue;
Console.WriteLine($"3. model binding (received value: \"{value}\")");
if (int.TryParse(value, out var integer))
{
context.Result = ModelBindingResult.Success(integer);
}
else
{
context.ModelState.AddModelError(context.ModelName, $"\"{value}\" is not an integer.");
}
return Task.CompletedTask;
}
}
|
Ein benutzerdefiniertes Model Binding wie die aus Beispiel 12. Ein ungültiger Wert stoppt nichts: Der Fehler wird in [ModelState] protokolliert, und die Action bestimmt den Ausgang (Zeile 18).
Die Datei [Filters/TimingAttribute.cs]:
| using System.Diagnostics;
using Microsoft.AspNetCore.Mvc.Filters;
namespace Example24.Filters;
// ein ACTION-Filter: Code vor und nach der Action.
// ActionFilterAttribute: eine Framework-Klasse, deren nützliche Methoden wir überschreiben
public class TimingAttribute : ActionFilterAttribute
{
private const string Key = "timing";
public override void OnActionExecuting(ActionExecutingContext context)
{
// die Action-Parameter sind bereits gebunden: der Filter kann sie lesen
Console.WriteLine($"4. action filter (before; parameters: {string.Join(", ", context.ActionArguments.Values)})");
context.HttpContext.Items[Key] = Stopwatch.StartNew();
}
public override void OnActionExecuted(ActionExecutedContext context)
{
var timer = (Stopwatch)context.HttpContext.Items[Key]!;
// context.Exception: die Ausnahme, die die Action möglicherweise ausgelöst hat
var outcome = context.Exception is null ? "" : $", exception {context.Exception.GetType().Name}";
Console.WriteLine($"6. action filter (after, {timer.ElapsedMilliseconds} ms{outcome})");
}
}
|
- Zeile 8: ein Action-Filter. [ActionFilterAttribute] ist eine Framework-Klasse, die die notwendigen Schnittstellen bereits implementiert: Wir überschreiben ([override]) die relevanten Methoden;
- Zeilen 12–16: [OnActionExecuting] läuft vor der Action. Das Model Binding hat bereits stattgefunden: Die Parameter der Action sind verfügbar ([ActionArguments]). Ein Timer wird gestartet ([Stopwatch]) und in [HttpContext.Items] abgelegt (Anfrage-Scope; siehe Kapitel 6);
- Zeilen 19–24: [OnActionExecuted] läuft nach der Action. Hat die Action eine Exception ausgelöst, steht sie in [context.Exception] bereit. Ein Action-Filter kann auch das Ergebnis der Action überschreiben ([context.Result]).
Die Datei [Filters/ErrorPageFilter.cs]:
| using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using Microsoft.AspNetCore.Mvc.ViewFeatures;
namespace Example24.Filters;
// ein EXCEPTION-Filter: er wandelt eine Ausnahme in eine Antwort um
public class ErrorPageFilter(IModelMetadataProvider metadata) : IExceptionFilter
{
public void OnException(ExceptionContext context)
{
Console.WriteLine($"x. exception filter ({context.Exception.GetType().Name}: {context.Exception.Message})");
// statt der Standardfehlerseite unsere View Error, mit dem Code 500
context.Result = new ViewResult
{
ViewName = "Error",
StatusCode = StatusCodes.Status500InternalServerError,
ViewData = new ViewDataDictionary(metadata, context.ModelState) { Model = 500 },
};
context.ExceptionHandled = true; // die Ausnahme ist behandelt: sie wird nicht weitergereicht
}
}
|
- Zeile 9: Ein Exception-Filter implementiert [IExceptionFilter]. Er erhält die Exceptions, die vom Model Binding, von den Action-Filtern und von der Action ausgelöst werden. Er ist ein Service: Er erhält per Injection das Objekt [IModelMetadataProvider], das erforderlich ist, um das Dictionary [ViewData] für eine View zu erstellen;
- Zeilen 15–20: Anstelle der Standard-Fehlerseite erzeugt der Filter eine HTML-Seite: die View [Error] mit dem Statuscode 500. Das ist es, was die Methode [View] eines Controllers tut, hier von Hand geschrieben;
- Zeile 21: Die Exception wird als behandelt markiert; sie wird nicht weiter die Kette hinauf propagiert.
Die Datei [Program.cs]:
| using System.Text.Encodings.Web;
using System.Text.Unicode;
using Example24.Filters;
using Microsoft.Extensions.FileProviders;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews(options =>
{
// ein GLOBALER Filter: er gilt für alle Actions der Anwendung
options.Filters.Add<ErrorPageFilter>();
});
builder.Services.AddSingleton(HtmlEncoder.Create(UnicodeRanges.All));
var app = builder.Build();
// die Middlewares laufen in der Reihenfolge, in der sie hinzugefügt werden
app.UseMiddleware<LoggerMiddleware>();
// eine Fehlerantwort OHNE Inhalt (400, 403, 404...): die Anfrage wird
// mit der Adresse /error/{code} erneut ausgeführt, die eine Seite erstellt
app.UseStatusCodePagesWithReExecute("/error/{0}");
app.UseStaticFiles(new StaticFileOptions
{
FileProvider = new PhysicalFileProvider(Path.GetFullPath(Path.Combine(builder.Environment.ContentRootPath, "..", "common", "bootstrap"))),
RequestPath = "/bootstrap",
});
app.MapControllers();
app.Run();
|
- Zeile 10: Ein globaler Filter wird auf alle Actions der Anwendung angewendet. Er wird zu den MVC-Optionen hinzugefügt;
- Zeile 17: Eine klassenbasierte Middleware wird über [UseMiddleware] hinzugefügt. Middlewares werden in der Reihenfolge ausgeführt, in der sie hinzugefügt wurden: Diese hier steht an erster Stelle, also verarbeitet sie alle Anfragen;
- Zeile 20: eine Framework-Middleware. Wenn eine Fehlerantwort (Codes 400–599) keinen Inhalt hat, führt sie die Anfrage unter der Adresse [/error/{code}] erneut aus (wobei [{0}] durch den Code ersetzt wird) und liefert die resultierende Seite unter Beibehaltung des Fehlercodes zurück. So werden 403-Antworten des Autorisierungsfilters, 400-Antworten der Action und 404-Antworten des Routings zu HTML-Seiten.
Die Datei [Controllers/CalcController.cs]:
| using Example24.Filters;
using Microsoft.AspNetCore.Mvc;
namespace Example24.Controllers;
// zwei am Controller gesetzte Filter: sie gelten für alle seine Actions
[Block]
[Timing]
public class CalcController : Controller
{
[HttpGet("square/{n}")]
public IActionResult Square([ModelBinder(typeof(IntegerBinder))] int n)
{
Console.WriteLine($"5. action Square({n}); valid model: {ModelState.IsValid}");
if (!ModelState.IsValid)
{
return BadRequest(); // ein 400 ohne Inhalt: siehe UseStatusCodePagesWithReExecute
}
if (n == 13)
{
throw new InvalidOperationException("13 brings bad luck"); // ein "unerwarteter" Fehler
}
return View("Result", n * n);
}
}
|
- Zeilen 7–8: zwei auf den Controller angewendete Filter; sie gelten für alle seine Actions (sie können auch auf eine einzelne Action angewendet werden);
- Zeile 12: das benutzerdefinierte Parameter-Binding;
- Zeilen 15–17: ein ungültiger Parameter: eine 400-Antwort ohne Inhalt;
- Zeilen 19–21: ein „unerwarteter“ Fehler, um den Exception-Filter in Aktion zu sehen.
Die Datei [Controllers/ErrorController.cs]:
| using Microsoft.AspNetCore.Mvc;
namespace Example24.Controllers;
public class ErrorController : Controller
{
// [Route] ohne HTTP-Methode: die erneut ausgeführte Anfrage behält ihre ursprüngliche Methode
[Route("error/{code:int}")]
public IActionResult Display(int code)
{
Console.WriteLine($"7. error page {code} (re-executed request)");
Response.StatusCode = code; // die Seite behält den Fehlercode
return View("Error", code);
}
}
|
- Zeile 8: die Action für die Fehlerseite. [[Route]] ohne HTTP-Methode akzeptiert alle Methoden: Eine erneut ausgeführte POST-Anfrage bleibt eine POST-Anfrage;
- Zeile 12: Die Seite behält den ursprünglichen Fehlercode bei.
Die Datei [Views/Shared/Error.cshtml]:
| @* die Fehlerseite; ihr Modell: der Fehlercode *@
@model int
@{
var message = Model switch
{
400 => "Bad request.",
403 => "Access denied.",
404 => "Page not found.",
_ => "Internal server error.",
};
}
<div class="alert alert-danger">
<h1 class="h4">Error @Model</h1>
<p class="mb-0">@message</p>
</div>
|
- Zeilen 4–10: ein Switch-Ausdruck [C#]: Er liefert den Wert des ersten Zweigs, dessen Muster zum Wert passt. [_] steht für alles andere. Die View liegt in [Views/Shared]: Sie wird unabhängig vom Controller gefunden ([CalcController] beim Exception-Filter, [ErrorController] sonst).
Fünf Anfragen: eine normale Berechnung (http://localhost:5000/square/7), ein ungültiger Parameter ([/square/abc]), eine vom Autorisierungsfilter blockierte Anfrage ([/square/7?block=1]), ein unerwarteter Fehler ([/square/13]) und eine unbekannte Adresse ([/unknown]). Die Serverkonsole:
| --- GET /square/7
1. middleware (before)
2. authorization filter (targeted action: Square)
3. model binding (received value: "7")
4. action filter (before; parameters: 7)
5. action Square(7); valid model: True
6. action filter (after, 0 ms)
8. middleware (after: code 200)
--- GET /square/abc
1. middleware (before)
2. authorization filter (targeted action: Square)
3. model binding (received value: "abc")
4. action filter (before; parameters: )
5. action Square(0); valid model: False
6. action filter (after, 0 ms)
7. error page 400 (re-executed request)
8. middleware (after: code 400)
--- GET /square/7?block=1
1. middleware (before)
2. authorization filter (targeted action: Square)
7. error page 403 (re-executed request)
8. middleware (after: code 403)
--- GET /square/13
1. middleware (before)
2. authorization filter (targeted action: Square)
3. model binding (received value: "13")
4. action filter (before; parameters: 13)
5. action Square(13); valid model: True
6. action filter (after, 0 ms, exception InvalidOperationException)
x. exception filter (InvalidOperationException: 13 brings bad luck)
8. middleware (after: code 500)
--- GET /unknown
1. middleware (before)
7. error page 404 (re-executed request)
8. middleware (after: code 404)
|
Dieses Protokoll zeigt:
- die Reihenfolge der Schritte: Middleware, Autorisierungsfilter, Model Binding, Action-Filter (davor), Action, Action-Filter (danach) und dann wieder die Middleware, die den endgültigen Antwortcode sieht;
- der Autorisierungsfilter, der die Anfrage ablehnt, umgeht den Rest von MVC (kein Binding, keine Action);
- ein ungültiger Parameter verhindert die Ausführung der Action nicht: Die Action selbst entscheidet anhand von [ModelState] (siehe Beispiel 09);
- eine Exception der Action wird vom Exception-Filter behandelt, der die Antwort erzeugt;
- eine leere Fehlerantwort (400, 403, 404) wird durch erneutes Ausführen der Anfrage in eine Seite umgewandelt (Schritt 7). Bei einer unbekannten Adresse kommt MVC gar nicht erst ins Spiel: Keine Route passt.
Die resultierenden Seiten:




Prüfen wir, dass der Fehlercode erhalten bleibt:
| curl -i http://localhost:5000/square/7?block=1
|
| HTTP/1.1 403 Forbidden
Content-Type: text/html; charset=utf-8
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Lifecycle</title>
<link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
</head>
<body>
<div class="container py-3">
<div class="alert alert-danger">
<h1 class="h4">Error 403</h1>
<p class="mb-0">Access denied.</p>
</div>
</div>
</body>
</html>
|
Die Fallstudie kombiniert diese Mechanismen: [UseStatusCodePagesWithReExecute("/error/{0}")] und einen Controller ([ErrorController]) für die Seiten 400, 403 und 404; die Middleware [UseExceptionHandler("/error/500")], die ebenso jede Anfrage erneut ausführt, die mit einer unbehandelten Exception endet; und einen Exception-Filter ([Web/HtmlExceptionFilter.cs]) für einen Sonderfall: Eine abgelaufene Sitzung zeigt keine Fehlerseite an, sondern leitet auf die Anmeldeseite um.