imported>Import: Version 181

2026-02-15T23:58:57Z

Version 181

Neue Seite

''Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).''
----

Dieses Tutorial erklärt das Konzept der Middleware in ASP.NET Core, wie sie funktioniert, wie man sie konfiguriert und wie man eigene Middleware-Komponenten erstellt. Es basiert auf den bereitgestellten Notizen und ergänzendem Expertenwissen.

== Was ist Middleware? ==

Middleware in ASP.NET Core ist eine Software-Pipeline, durch die jede HTTP-Anfrage (Request) und jede Antwort (Response) fließt. Man kann sich diese Pipeline wie eine Reihe von hintereinander geschalteten Rohren oder Ventilen vorstellen.

Jede Middleware-Komponente hat drei Hauptaufgaben:

# '''Untersuchen''' der eingehenden Anfrage.
# '''Bearbeiten''' der Anfrage oder der Antwort.
# '''Weiterleiten''' an die nächste Middleware oder '''Beenden''' (Short-Circuit) der Pipeline.

Dies ermöglicht eine saubere Modularisierung von Funktionen wie Authentifizierung, Logging, Fehlerbehandlung und Routing.

-----

== Grundlagen: app.Use vs. app.Run ==

Es gibt zwei grundlegende Methoden, um Middleware zur Pipeline hinzuzufügen:

=== 1. <code>app.Run</code> (Terminale Middleware) ===

Diese Methode fügt eine '''terminale''' Middleware hinzu. Das bedeutet, sie beendet die Pipeline. Es wird kein <code>next</code>-Delegat aufgerufen, und nachfolgende Middleware-Komponenten werden nicht ausgeführt.

'''Beispiel:'''

<syntaxhighlight lang="csharp">app.Run(async (context) => {
await context.Response.WriteAsync("Ende der Pipeline");
});</syntaxhighlight>
Warnung: Wenn Sie zwei <code>app.Run</code>-Aufrufe hintereinander haben, wird nur der erste ausgeführt!

=== 2. <code>app.Use</code> (Verkettbare Middleware) ===

Diese Methode dient dazu, Aufgaben zu erledigen und dann (meistens) die nächste Komponente in der Kette aufzurufen.

'''Beispiel:'''

<syntaxhighlight lang="csharp">app.Use(async (context, next) => {
// Logik VOR dem nächsten Middleware-Aufruf (Request)
await context.Response.WriteAsync("Hallo ");

// Ruft die nächste Middleware auf
await next(context);

// Logik NACH dem nächsten Middleware-Aufruf (Response)
// Hier können wir die Antwort noch bearbeiten, nachdem der Rest der Pipeline fertig ist.
});</syntaxhighlight>

-----

== Die Reihenfolge der Middleware (The Middleware Order) ==

Die Reihenfolge, in der Middleware in <code>Program.cs</code> registriert wird, ist '''entscheidend'''. Die Pipeline wird in der Reihenfolge der Registrierung durchlaufen (für den Request) und in umgekehrter Reihenfolge wieder zurück (für die Response).

=== Empfohlene Reihenfolge ===

# '''Exception Handler''' (<code>UseDeveloperExceptionPage</code>, <code>UseExceptionHandler</code>): Sollte ganz oben stehen, um Fehler aus jedem Teil der Pipeline abzufangen.
# '''HSTS & HTTPS Redirection''' (<code>UseHsts</code>, <code>UseHttpsRedirection</code>): Sicherheit geht vor.
# '''Static Files''' (<code>UseStaticFiles</code>): Statische Dateien sollten schnell ausgeliefert werden, ohne unnötige Verarbeitung durch spätere Logik.
# '''Routing''' (<code>UseRouting</code>): Ermittelt, welcher Endpunkt passt.
# '''CORS''' (<code>UseCors</code>): Cross-Origin Resource Sharing.
# '''Authentication''' (<code>UseAuthentication</code>): Wer ist der Benutzer?
# '''Authorization''' (<code>UseAuthorization</code>): Darf der Benutzer das?
# '''Benutzerdefinierte Middleware''': Ihre eigene Logik.
# '''Endpunkte''' (<code>MapControllers</code>, <code>UseEndpoints</code>, <code>app.Run</code>): Die eigentliche Verarbeitung der Anfrage.

-----

== Custom Middleware erstellen ==

Es gibt zwei Hauptwege, eigene Middleware zu schreiben: als Klasse mit <code>IMiddleware</code> (Factory-based) oder als konventionelle Klasse.

=== 1. Middleware mit <code>IMiddleware</code> (Factory-based) ===

Diese Methode ist stark typisiert und nutzt Dependency Injection voll aus. Die Klasse muss im DI-Container registriert werden (z.B. als Transient).

<syntaxhighlight lang="csharp">using Microsoft.AspNetCore.Http;
using System.Threading.Tasks;

public class MyFactoryMiddleware : IMiddleware
{
public async Task InvokeAsync(HttpContext context, RequestDelegate next)
{
await context.Response.WriteAsync("Factory Middleware Start\n");
await next(context);
await context.Response.WriteAsync("Factory Middleware Ende\n");
}
}</syntaxhighlight>
'''Registrierung:'''

<syntaxhighlight lang="csharp">// In Program.cs
builder.Services.AddTransient<MyFactoryMiddleware>();
// ...
app.UseMiddleware<MyFactoryMiddleware>();</syntaxhighlight>
=== 2. Konventionelle Middleware ===

Dies ist der häufigste Weg. Die Klasse benötigt kein Interface, muss aber einer bestimmten Struktur folgen:

* Einen öffentlichen Konstruktor, der <code>RequestDelegate</code> als Parameter nimmt.
* Eine Methode <code>Invoke</code> oder <code>InvokeAsync</code>, die <code>HttpContext</code> nimmt und einen <code>Task</code> zurückgibt.

<syntaxhighlight lang="csharp">public class HelloCustomMiddleware
{
private readonly RequestDelegate _next;

public HelloCustomMiddleware(RequestDelegate next)
{
_next = next;
}

public async Task InvokeAsync(HttpContext httpContext)
{
// Beispiel: Prüfen auf Query-Parameter
if (httpContext.Request.Query.ContainsKey("firstname") &&
httpContext.Request.Query.ContainsKey("lastname"))
{
string fullName = $"{httpContext.Request.Query[\"firstname\"]} {httpContext.Request.Query[\"lastname\"]}";
await httpContext.Response.WriteAsync($"Hallo {fullName}\n");
}

// WICHTIG: Nächste Middleware aufrufen
await _next(httpContext);
}
}</syntaxhighlight>
'''Extension Method für saubere Registrierung:''' Es ist “Best Practice”, eine Extension-Methode für <code>IApplicationBuilder</code> zu erstellen.

<syntaxhighlight lang="csharp">public static class MiddlewareExtensions
{
public static IApplicationBuilder UseHelloCustomMiddleware(this IApplicationBuilder builder)
{
return builder.UseMiddleware<HelloCustomMiddleware>();
}
}

// Verwendung in Program.cs
app.UseHelloCustomMiddleware();</syntaxhighlight>

-----

== Bedingte Ausführung mit <code>UseWhen</code> ==

Mit <code>UseWhen</code> können Sie eine Verzweigung in der Pipeline erstellen, die nur unter bestimmten Bedingungen ausgeführt wird. Die Haupt-Pipeline wird danach wieder zusammengeführt (im Gegensatz zu <code>Map</code>, das oft eine Sackgasse ist).

'''Syntax:'''

<syntaxhighlight lang="csharp">app.UseWhen(
context => context.Request.Query.ContainsKey("username"), // Bedingung (Predicate)
appBuilder =>
{
// Diese Middleware läuft nur, wenn die Bedingung wahr ist
appBuilder.Use(async (context, next) =>
{
await context.Response.WriteAsync("Hallo vom Branch!\n");
await next();
});
}
);</syntaxhighlight>
'''Szenarien für UseWhen:'''

* Logging nur für bestimmte Pfade oder User.
* Spezielle Header nur für API-Requests setzen.
* Bedingte Diagnosetools.

-----

== Zusammenfassung ==

* '''Middleware''' bildet das Rückgrat einer ASP.NET Core Anwendung.
* '''Reihenfolge''' ist wichtig: Von globalen Anliegen (Error Handling) zu spezifischen (Routing, Auth) zu Endpunkten.
* <code>app.Use</code> kettet Komponenten aneinander, <code>app.Run</code> beendet die Kette.
* '''Custom Middleware''' kann einfach als Klasse implementiert werden, um wiederverwendbare Logik zu kapseln.

== Weblinks ==

* https://learn.microsoft.com/de-de/aspnet/core/fundamentals/middleware/

----
''Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).''

Webframeworkk/ASP.NET Core/Middleware - Versionsgeschichte

imported>Import: Version 181