C# Academy · Leçon

Intergiciels et filtres dans les API Minimal

Ajoutez l’authentification, l’autorisation, la gestion des exceptions et les filtres de points de terminaison aux chaînes de traitement des API Minimal.

Leçon 3 sur 413 étapes

Intergiciels et filtres dans les API Minimal est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

Intergiciels et filtres de points de terminaison

ASP.NET Core possède deux couches d’extensibilité : les intergiciels (ils englobent toute la chaîne de traitement et s’exécutent pour chaque requête) et les filtres de points de terminaison (ils s’exécutent uniquement pour certains points de terminaison). Les deux fonctionnent dans les API minimales.

Ajouter un intergiciel aux API minimales

Les intergiciels standard d’ASP.NET Core sont ajoutés avec les méthodes app.Use*. L’ordre est important : les intergiciels s’exécutent dans l’ordre où ils sont enregistrés.

var app = builder.Build();

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

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

app.Run();

Filtres de points de terminaison intégrés au code

Les filtres de points de terminaison sont comparables à un intergiciel limité à un seul point de terminaison. Utilisez AddEndpointFilter pour ajouter un filtre directement dans le code. Les filtres peuvent interrompre prématurément le traitement en renvoyant un résultat sans appeler 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
   });

Filtres de points de terminaison fondés sur des classes

Implémentez IEndpointFilter pour créer des filtres réutilisables. Ils peuvent être appliqués à des points de terminaison individuels ou à des groupes de routes entiers.

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

Intergiciel de gestion des exceptions

Utilisez app.UseExceptionHandler ou l’intergiciel ProblemDetails intégré pour intercepter les exceptions non gérées et renvoyer des réponses décrivant le problème, conformes à la norme 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 });
    }));

Intergiciel à interruption prématurée

Utilisez app.MapShortCircuit() (.NET 8+) ou Results.StatusCode() dans un filtre pour renvoyer immédiatement une réponse sans exécuter toute la chaîne de traitement.

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

Limitation du débit dans .NET 7+

L’intergiciel intégré de limitation du débit protège les points de terminaison contre les abus. Appliquez des politiques globalement ou par point de terminaison avec 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");

Configuration de CORS

Configurez les politiques CORS dans les services et appliquez-les globalement ou par point de terminaison afin de contrôler les origines qui peuvent accéder à votre 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");

Intergiciel de mise en cache des réponses

AddOutputCache met les réponses en cache côté serveur. Appliquez-le à certains points de terminaison pour servir des réponses mises en cache sans interroger la base de données à chaque requête.

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

Ordre et chaînage des filtres

Les filtres s’exécutent dans l’ordre où ils sont ajoutés (le plus externe en premier, le plus interne en dernier, comme les intergiciels). Vous pouvez chaîner plusieurs filtres sur le même point de terminaison ou groupe.

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

Intergiciel de clé d’API

Un intergiciel réutilisable de clé d’API qui lit la clé dans un header et renvoie immédiatement une réponse 401 si elle est invalide.

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

Vérification rapide

Quelle est la principale différence entre les intergiciels et les filtres de points de terminaison dans les API minimales ?

Réponds-y dans la leçon interactive

Récapitulatif : intergiciels et filtres

Points clés :

Les intergiciels (UseX) s’exécutent globalement, dans l’ordre de la chaîne de traitement, pour chaque requête
Les filtres de points de terminaison (AddEndpointFilter) sont limités à certains points de terminaison ou groupes
Implémentez IEndpointFilter pour créer des classes de filtres réutilisables et compatibles avec DI
Intergiciels intégrés : limitation du débit, CORS, mise en cache des réponses et gestion des exceptions
L’ordre des filtres est important : ils s’imbriquent comme les intergiciels (le premier ajouté est le plus externe)

Gratuit pour commencer

Apprends C# avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 93
Leçons: 346

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Intergiciels et filtres dans les API Minimal » est-elle gratuite ?

Oui — le texte complet de « Intergiciels et filtres dans les API Minimal » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Intergiciels et filtres dans les API Minimal » ?

Ajoutez l’authentification, l’autorisation, la gestion des exceptions et les filtres de points de terminaison aux chaînes de traitement des API Minimal. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Intergiciels et filtres dans les API Minimal » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Créer votre première API Minimal
Groupes de routes, paramètres et validation
Intergiciels et filtres dans les API Minimal
OpenAPI, versionnement et déploiement

← Retour à C# Academy