C# Academy · Lekcja

Middleware i filtry w Minimal APIs

Dodaj uwierzytelnianie, autoryzację, obsługę wyjątków i filtry endpointów do potoków Minimal API.

Lekcja 3 z 413 kroki

Middleware i filtry w Minimal APIs to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C# Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C# Academy zawiera 4 lekcji w sumie.

Middleware a filtry endpointów

ASP.NET Core ma dwie warstwy rozszerzalności: middleware (obejmuje cały potok i działa dla każdego żądania) oraz filtry endpointów (działają tylko dla określonych endpointów). Oba rozwiązania działają w Minimal APIs.

Dodawanie middleware do Minimal APIs

Standardowe middleware ASP.NET Core dodaje się za pomocą metod app.Use*. Kolejność ma znaczenie — middleware jest wykonywane w kolejności rejestracji.

var app = builder.Build();

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

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

app.Run();

Filtry endpointów definiowane bezpośrednio

Filtry endpointów przypominają middleware ograniczone do pojedynczego endpointu. Należy użyć AddEndpointFilter, aby dodać filtr bezpośrednio. Filtry mogą zakończyć przetwarzanie wcześniej, zwracając wynik bez wywołania next.

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
   });

Filtry endpointów oparte na klasach

Należy zaimplementować IEndpointFilter, aby tworzyć filtry wielokrotnego użytku. Można je stosować do poszczególnych endpointów lub całych grup tras.

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 obsługi wyjątków

Należy użyć app.UseExceptionHandler lub wbudowanego middleware ProblemDetails, aby przechwytywać nieobsłużone wyjątki i zwracać odpowiedzi problemów zgodne z RFC 7807.

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 kończące przetwarzanie

Należy użyć app.MapShortCircuit() (.NET 8+) lub Results.StatusCode() w filtrze, aby natychmiast zwrócić odpowiedź bez uruchamiania pełnego potoku.

// 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)));

Ograniczanie liczby żądań w .NET 7+

Wbudowane middleware ograniczające liczbę żądań chroni endpointy przed nadużyciami. Polityki można stosować globalnie lub dla poszczególnych endpointów za pomocą RequireRateLimiting().

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");

Konfiguracja CORS

Polityki CORS należy skonfigurować w usługach i stosować globalnie lub dla poszczególnych endpointów, aby kontrolować, które źródła mogą uzyskiwać dostęp do interfejsu API.

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 buforowania odpowiedzi

AddOutputCache buforuje odpowiedzi po stronie serwera. Należy stosować je dla określonych endpointów, aby zwracać zapisane odpowiedzi bez odpytywania bazy danych przy każdym żądaniu.

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)));

Kolejność i łańcuchowanie filtrów

Filtry są wykonywane w kolejności, w której zostały dodane (najbardziej zewnętrzny jako pierwszy, najbardziej wewnętrzny jako ostatni — podobnie jak middleware). Na tym samym endpoincie lub w tej samej grupie można łączyć wiele filtrów.

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

Praktyczny przykład: middleware klucza API

Wielokrotnego użytku middleware klucza API, które odczytuje klucz z nagłówka i w przypadku nieprawidłowego klucza natychmiast zwraca odpowiedź 401.

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>();

Szybkie sprawdzenie

Jaka jest kluczowa różnica między middleware a filtrami endpointów w Minimal APIs?

Odpowiedz w interaktywnej lekcji

Podsumowanie: middleware i filtry

Najważniejsze informacje:

Middleware (UseX) działa globalnie, w kolejności potoku, dla każdego żądania
Filtry endpointów (AddEndpointFilter) są ograniczone do określonych endpointów lub grup
Interfejs IEndpointFilter pozwala tworzyć wielokrotnego użytku klasy filtrów obsługujące DI
Wbudowane middleware: ograniczanie liczby żądań, CORS, buforowanie odpowiedzi i obsługa wyjątków
Kolejność filtrów ma znaczenie — zagnieżdżają się jak middleware (pierwszy dodany = najbardziej zewnętrzny)

Bezpłatny start

Ucz się C# dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 93
Lekcje: 346

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Middleware i filtry w Minimal APIs” jest bezpłatna?

Tak — pełny tekst „Middleware i filtry w Minimal APIs” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C# Academy, przejdź na CoddyKit PRO. Kurs C# Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Middleware i filtry w Minimal APIs”?

Dodaj uwierzytelnianie, autoryzację, obsługę wyjątków i filtry endpointów do potoków Minimal API. Ćwiczysz C# Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C# Academy?

Nie wymagamy żadnego doświadczenia. C# Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Middleware i filtry w Minimal APIs”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C# Academy?

Tak. Każda lekcja C# Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do C# Academy