Überblick über die ASP.NET-Core-Pipeline
Verstehen Sie, wie Anfragen durch die Middleware-Pipeline und HttpContext fließen und wie Antworten schrittweise aufgebaut werden.
Überblick über die ASP.NET-Core-Pipeline ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.
Die Request-Pipeline
Jede HTTP-Anfrage in ASP.NET Core durchläuft eine Middleware-Pipeline. Jede Middleware-Komponente kann die Anfrage untersuchen, ändern, vorzeitig beenden oder an die nächste Komponente weiterleiten. Das Verständnis dieser Pipeline ist grundlegend für die Entwicklung von ASP.NET-Core-Anwendungen.
HttpContext: Der Umschlag der Anfrage
HttpContext enthält alle Informationen über eine Anfrage und ihre Antwort: Header, Cookies, den Body, Benutzer-Claims, Verbindungsinformationen und das Abbruchtoken. Jede Middleware arbeitet damit.
app.Use(async (context, next) =>
{
// Read request info
var method = context.Request.Method;
var path = context.Request.Path;
var headers = context.Request.Headers;
var user = context.User.Identity?.Name;
// Write to response
context.Response.Headers.Append("X-Processed-By", "MyMiddleware");
await next(context); // forward to next middleware
});Reihenfolge der Middleware-Registrierung
Middleware wird in der Reihenfolge ausgeführt, in der sie registriert wurde. Die Antwort wird in umgekehrter Reihenfolge verarbeitet, ähnlich wie bei einem Stack. Die Reihenfolge ist entscheidend: Die Authentifizierung muss vor der Autorisierung ausgeführt werden, das Routing vor der Endpunktzuordnung.
// Typical order for an ASP.NET Core app:
app.UseExceptionHandler("/error"); // outermost — catches everything
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseCors("policy");
app.UseAuthentication(); // must be before Authorization
app.UseAuthorization();
app.UseRateLimiter();
app.UseOutputCache();
// MapHub, MapControllers, MapGet etc.
app.Run();Use, Run und Map
Drei Methoden fügen Middleware hinzu: Use (ruft next auf), Run (terminal, ruft next niemals auf) und Map (verzweigt abhängig vom Pfad).
// Use: passes to next
app.Use(async (ctx, next) =>
{
Console.WriteLine("Before");
await next(ctx);
Console.WriteLine("After");
});
// Run: terminal — no next
app.Run(async ctx =>
await ctx.Response.WriteAsync("Terminal"));
// Map: branch on path prefix
app.Map("/api", apiApp =>
apiApp.Run(async ctx =>
await ctx.Response.WriteAsync("API branch")));Request- und Response-Bodies
Request- und Response-Bodies sind Streams. Der Request-Body kann nur einmal gelesen werden. Aktivieren Sie die Pufferung des Request-Bodys, wenn Sie ihn mehrfach lesen müssen, etwa in mehreren Middleware-Komponenten.
app.Use(async (ctx, next) =>
{
// Enable buffering so body can be read multiple times
ctx.Request.EnableBuffering();
using var reader = new StreamReader(
ctx.Request.Body,
leaveOpen: true);
var body = await reader.ReadToEndAsync();
ctx.Request.Body.Position = 0; // rewind for next middleware
Console.WriteLine($"Body: {body}");
await next(ctx);
});Vorzeitiges Beenden der Pipeline
Middleware kann die Pipeline vorzeitig beenden, indem sie die Antwort schreibt und next NICHT aufruft. Das ist beispielsweise für Authentifizierungssperren, Health Checks oder Wartungsseiten nützlich.
app.Use(async (ctx, next) =>
{
if (ctx.Request.Path == "/maintenance")
{
ctx.Response.StatusCode = 503;
await ctx.Response.WriteAsync("Service under maintenance");
return; // short-circuit — next is NOT called
}
await next(ctx);
});Die IMiddleware-Schnittstelle
Für klassenbasierte Middleware, die DI benötigt, implementieren Sie IMiddleware. Registrieren Sie die Implementierung in DI und verwenden Sie app.UseMiddleware<T>().
public class RequestTimingMiddleware : IMiddleware
{
private readonly ILogger<RequestTimingMiddleware> _logger;
public RequestTimingMiddleware(ILogger<RequestTimingMiddleware> l) => _logger = l;
public async Task InvokeAsync(HttpContext ctx, RequestDelegate next)
{
var sw = System.Diagnostics.Stopwatch.StartNew();
await next(ctx);
_logger.LogInformation("{Method} {Path}: {Ms}ms",
ctx.Request.Method, ctx.Request.Path, sw.ElapsedMilliseconds);
}
}
// Register:
builder.Services.AddTransient<RequestTimingMiddleware>();
app.UseMiddleware<RequestTimingMiddleware>();Middleware-Klassen nach Konvention
Alternativ können Sie eine Klasse mit einer Methode InvokeAsync(HttpContext, RequestDelegate) erstellen. Das Framework injiziert Abhängigkeiten, einschließlich des nächsten Delegaten, über den Konstruktor.
public class ApiKeyMiddleware
{
private readonly RequestDelegate _next;
private readonly string _key;
// RequestDelegate injected by framework
public ApiKeyMiddleware(RequestDelegate next, IConfiguration cfg)
{
_next = next;
_key = cfg["ApiKey"] ?? "";
}
public async Task InvokeAsync(HttpContext ctx)
{
if (ctx.Request.Headers["X-Api-Key"] != _key)
{
ctx.Response.StatusCode = 401;
return;
}
await _next(ctx);
}
}Antworten nach next ändern
Code nach await next(ctx) wird ausgeführt, nachdem mit dem Schreiben der Antwort begonnen wurde. Sie können vor next Antwort-Header hinzufügen, aber den Statuscode oder Body danach nicht mehr ändern.
app.Use(async (ctx, next) =>
{
// Before: add response headers (safe)
ctx.Response.OnStarting(() =>
{
ctx.Response.Headers.Append("X-Request-Id",
Guid.NewGuid().ToString("N"));
return Task.CompletedTask;
});
await next(ctx);
// After: response may already be sent
// SAFE: logging, metrics
// UNSAFE: changing status code or writing body
Console.WriteLine($"Response status: {ctx.Response.StatusCode}");
});Praxisbeispiel: Middleware für Korrelations-IDs
Eine produktive Middleware für Korrelations-IDs fügt jeder Anfrage eine Trace-ID für verteiltes Tracing und Logging hinzu.
public class CorrelationIdMiddleware
{
private readonly RequestDelegate _next;
private const string Header = "X-Correlation-Id";
public CorrelationIdMiddleware(RequestDelegate next) => _next = next;
public async Task InvokeAsync(HttpContext ctx)
{
var correlationId = ctx.Request.Headers[Header].FirstOrDefault()
?? Guid.NewGuid().ToString("N");
ctx.Items["CorrelationId"] = correlationId;
ctx.Response.OnStarting(() =>
{
ctx.Response.Headers.Append(Header, correlationId);
return Task.CompletedTask;
});
using (Serilog.Context.LogContext.PushProperty("CorrelationId", correlationId))
await _next(ctx);
}
}Kurztest
Was ist der Unterschied zwischen app.Use() und app.Run(), wenn Sie Middleware hinzufügen?
Zusammenfassung: Überblick über die ASP.NET-Core-Pipeline
Wichtige Erkenntnisse:
- Middleware wird in Registrierungsreihenfolge ausgeführt; Antworten werden in umgekehrter Reihenfolge abgearbeitet
- Use → ruft next auf; Run → terminal; Map → pfadbasierte Verzweigung
- HttpContext enthält Anfrage, Antwort, Benutzer und Abbruchtoken
- Aktivieren Sie die Pufferung, um den Request-Body mehrfach zu lesen
- Die IMiddleware-Schnittstelle ermöglicht DI-freundliche klassenbasierte Middleware
- Fügen Sie Antwort-Header über OnStarting() hinzu; ändern Sie den Status nicht nach next
Häufig gestellte Fragen
Ist die Lektion „Überblick über die ASP.NET-Core-Pipeline“ kostenlos?
Ja — der vollständige Text von „Überblick über die ASP.NET-Core-Pipeline“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Überblick über die ASP.NET-Core-Pipeline“?
Verstehen Sie, wie Anfragen durch die Middleware-Pipeline und HttpContext fließen und wie Antworten schrittweise aufgebaut werden. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um C# Academy zu starten?
Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.
Wie lange dauert die Lektion „Überblick über die ASP.NET-Core-Pipeline“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?
Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Überblick über die ASP.NET-Core-Pipeline
- Benutzerdefinierte Middleware schreiben
- Kurzschließen und Verzweigen
- Reihenfolge und integrierte Middleware