0Pricing
C# Academy · Lektion

Middleware und Filter in Minimal APIs

Fügen Sie Authentifizierung, Autorisierung, Ausnahmebehandlung und Endpunktfilter zu Minimal-API-Pipelines hinzu.

Middleware und Filter in Minimal APIs ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Middleware und Endpunktfilter

ASP.NET Core verfügt über zwei Erweiterungsebenen: Middleware (umschließt die gesamte Pipeline und wird für jede Anfrage ausgeführt) und Endpunktfilter (werden nur für bestimmte Endpunkte ausgeführt). Beide funktionieren in Minimal APIs.

Middleware zu Minimal APIs hinzufügen

Standardmäßige ASP.NET-Core-Middleware wird mit app.Use*-Methoden hinzugefügt. Die Reihenfolge ist entscheidend – Middleware wird in der Reihenfolge ausgeführt, in der sie registriert wurde.

var app = builder.Build();

app.UseHttpsRedirection();
app.UseAuthentication();
app.UseAuthorization();
app.UseRateLimiter();

app.MapGet("/secure", () => "Protected endpoint")
   .RequireAuthorization();

app.Run();

Inline-Endpunktfilter

Endpunktfilter ähneln Middleware, die auf einen einzelnen Endpunkt beschränkt ist. Verwenden Sie AddEndpointFilter, um inline einen Filter hinzuzufügen. Filter können die Verarbeitung vorzeitig beenden, indem sie ein Ergebnis zurückgeben, ohne next aufzurufen.

app.MapGet("/guarded", () => "Secret data")
   .AddEndpointFilter(async (ctx, next) =>
   {
       var header = ctx.HttpContext.Request.Headers["X-Api-Key"];
       if (header != "my-secret-key")
           return Results.Unauthorized();

       return await next(ctx); // proceed to handler
   });

Klassenbasierte Endpunktfilter

Implementieren Sie IEndpointFilter, um wiederverwendbare Filter zu erstellen. Sie können auf einzelne Endpunkte oder auf ganze Routengruppen angewendet werden.

public class LoggingFilter : IEndpointFilter
{
    private readonly ILogger<LoggingFilter> _logger;
    public LoggingFilter(ILogger<LoggingFilter> logger) => _logger = logger;

    public async ValueTask<object?> InvokeAsync(
        EndpointFilterInvocationContext ctx,
        EndpointFilterDelegate next)
    {
        _logger.LogInformation("Before: {Path}", ctx.HttpContext.Request.Path);
        var result = await next(ctx);
        _logger.LogInformation("After: {Path}",  ctx.HttpContext.Request.Path);
        return result;
    }
}

// Apply to a group
app.MapGroup("/api").AddEndpointFilter<LoggingFilter>();

Middleware zur Ausnahmebehandlung

Verwenden Sie app.UseExceptionHandler oder die integrierte ProblemDetails-Middleware, um nicht behandelte Ausnahmen abzufangen und Problemantworten gemäß RFC 7807 zurückzugeben.

builder.Services.AddProblemDetails();

var app = builder.Build();

app.UseExceptionHandler();
// OR for custom logic:
app.UseExceptionHandler(errApp =>
    errApp.Run(async ctx =>
    {
        var ex = ctx.Features.Get<IExceptionHandlerFeature>()?.Error;
        ctx.Response.StatusCode = 500;
        await ctx.Response.WriteAsJsonAsync(new { error = ex?.Message });
    }));

Middleware mit Short-Circuiting

Verwenden Sie app.MapShortCircuit() (.NET 8+) oder Results.StatusCode() in einem Filter, um sofort eine Antwort zurückzugeben, ohne die gesamte Pipeline auszuführen.

// Block known bad bots at the edge
app.MapGet("/robots.txt", () => "User-agent: *\nDisallow: /")
   .ShortCircuit(); // .NET 8: returns response immediately

// Or in a filter:
app.MapGet("/maintenance", () => "OK")
   .AddEndpointFilter((ctx, next) =>
       ValueTask.FromResult<object?>(Results.StatusCode(503)));

Ratenbegrenzung in .NET 7+

Die integrierte Middleware zur Ratenbegrenzung schützt Endpunkte vor Missbrauch. Wenden Sie Richtlinien global oder pro Endpunkt mit RequireRateLimiting() an.

using System.Threading.RateLimiting;

builder.Services.AddRateLimiter(opt =>
{
    opt.AddFixedWindowLimiter("fixed", o =>
    {
        o.PermitLimit     = 10;
        o.Window          = TimeSpan.FromSeconds(10);
        o.QueueLimit      = 0;
        o.QueueProcessingOrder = QueueProcessingOrder.OldestFirst;
    });
    opt.RejectionStatusCode = StatusCodes.Status429TooManyRequests;
});

app.UseRateLimiter();
app.MapGet("/search", Search).RequireRateLimiting("fixed");

CORS-Konfiguration

Konfigurieren Sie CORS-Richtlinien in den Diensten und wenden Sie sie global oder pro Endpunkt an, um zu steuern, welche Ursprünge auf Ihre API zugreifen dürfen.

builder.Services.AddCors(opt =>
    opt.AddPolicy("AllowFrontend", policy =>
        policy.WithOrigins("https://myapp.com")
              .AllowAnyHeader()
              .AllowAnyMethod()));

app.UseCors("AllowFrontend");

// Or per endpoint:
app.MapGet("/public-data", () => "data")
   .RequireCors("AllowFrontend");

Middleware für Output-Caching

AddOutputCache speichert Antworten serverseitig zwischen. Wenden Sie die Middleware auf bestimmte Endpunkte an, um zwischengespeicherte Antworten bereitzustellen, ohne bei jeder Anfrage die Datenbank abzufragen.

builder.Services.AddOutputCache();

app.UseOutputCache();

app.MapGet("/products", async (AppDbContext db) =>
    Results.Ok(await db.Products.AsNoTracking().ToListAsync()))
   .CacheOutput(p => p.Expire(TimeSpan.FromMinutes(5)));

Reihenfolge und Verkettung von Filtern

Filter werden in der Reihenfolge ausgeführt, in der sie hinzugefügt wurden (zuerst der äußerste, zuletzt der innerste – wie bei Middleware). Sie können mehrere Filter für denselben Endpunkt oder dieselbe Gruppe verketten.

app.MapPost("/orders", CreateOrder)
   .AddEndpointFilter<LoggingFilter>()      // runs first
   .AddEndpointFilter<ValidationFilter>()   // runs second
   .AddEndpointFilter<AuthFilter>()         // runs third
   .RequireAuthorization();                 // JWT checked by middleware

Praxisbeispiel: API-Key-Middleware

Eine wiederverwendbare API-Key-Middleware, die den Schlüssel aus einem Header liest und bei einem ungültigen Schlüssel die Verarbeitung mit 401 beendet.

public class ApiKeyMiddleware
{
    private readonly RequestDelegate _next;
    private readonly string _expectedKey;

    public ApiKeyMiddleware(RequestDelegate next, IConfiguration cfg)
    {
        _next = next;
        _expectedKey = cfg["ApiKey"] ?? throw new Exception("ApiKey not configured");
    }

    public async Task InvokeAsync(HttpContext ctx)
    {
        if (!ctx.Request.Headers.TryGetValue("X-Api-Key", out var key)
            || key != _expectedKey)
        {
            ctx.Response.StatusCode = 401;
            await ctx.Response.WriteAsync("Invalid API key");
            return;
        }
        await _next(ctx);
    }
}

app.UseMiddleware<ApiKeyMiddleware>();

Kurzer Check

Was ist der wesentliche Unterschied zwischen Middleware und Endpunktfiltern in Minimal APIs?

Zusammenfassung: Middleware und Filter

Wichtige Erkenntnisse:

  • Middleware (UseX) wird für jede Anfrage global und in Pipeline-Reihenfolge ausgeführt
  • Endpunktfilter (AddEndpointFilter) sind auf bestimmte Endpunkte oder Gruppen beschränkt
  • Implementieren Sie IEndpointFilter für wiederverwendbare, DI-fähige Filterklassen
  • Integrierte Middleware: Ratenbegrenzung, CORS, Output-Caching und Ausnahmebehandlung
  • Die Filterreihenfolge ist entscheidend – Filter werden wie Middleware verschachtelt (der zuerst hinzugefügte ist der äußerste)

Häufig gestellte Fragen

Ist die Lektion „Middleware und Filter in Minimal APIs“ kostenlos?

Ja — der vollständige Text von „Middleware und Filter in Minimal APIs“ 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 „Middleware und Filter in Minimal APIs“?

Fügen Sie Authentifizierung, Autorisierung, Ausnahmebehandlung und Endpunktfilter zu Minimal-API-Pipelines hinzu. 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 3 von 4.

Wie lange dauert die Lektion „Middleware und Filter in Minimal APIs“?

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

  1. Ihre erste Minimal API erstellen
  2. Route-Gruppen, Parameter und Validierung
  3. Middleware und Filter in Minimal APIs
  4. OpenAPI, Versionierung und Deployment
← Zurück zu C# Academy