C# Academy · Leçon

Comportements du pipeline

Ajoutez une logique transversale avec des comportements.

Leçon 3 sur 413 étapes

Comportements du pipeline 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.

Préoccupations transversales

La journalisation, la validation, le chronométrage et les transactions s’appliquent à de nombreux handlers. Copier ce code dans chaque handler est répétitif et source d’erreurs.

Les comportements de la chaîne de traitement de MediatR vous permettent d’entourer chaque requête d’une logique commune.

// One behavior runs around all handlers

IPipelineBehavior

Un comportement implémente IPipelineBehavior<TRequest, TResponse>. Sa méthode Handle reçoit la requête et un délégué next qui appelle le reste de la chaîne de traitement.

public class LoggingBehavior<TRequest, TResponse>
    : IPipelineBehavior<TRequest, TResponse>
    where TRequest : notnull
{
    public async Task<TResponse> Handle(
        TRequest request,
        RequestHandlerDelegate<TResponse> next,
        CancellationToken ct)
    {
        // before
        var response = await next();
        // after
        return response;
    }
}

Le délégué suivant

next() appelle le comportement suivant, ou le handler réel s’il s’agit du dernier. Le code placé avant l’appel s’exécute à l’aller ; le code placé après s’exécute au retour.

// [Behavior A in] -> [Behavior B in] -> [Handler]
//               <- [Behavior B out] <- [A out]

Un comportement de journalisation

Un comportement concret de journalisation consigne le nom de la requête à l’aller et le temps écoulé au retour.

public async Task<TResponse> Handle(
    TRequest request,
    RequestHandlerDelegate<TResponse> next,
    CancellationToken ct)
{
    var name = typeof(TRequest).Name;
    _logger.LogInformation("Handling {Name}", name);
    var sw = Stopwatch.StartNew();
    var response = await next();
    _logger.LogInformation("{Name} took {Ms}ms", name, sw.ElapsedMilliseconds);
    return response;
}

Enregistrer un comportement

Enregistrez le comportement générique ouvert dans DI. MediatR l’applique à chaque requête.

builder.Services.AddTransient(
    typeof(IPipelineBehavior<,>),
    typeof(LoggingBehavior<,>));

Un comportement de validation

La validation des requêtes avec FluentValidation est une utilisation courante. Le comportement exécute tous les validateurs avant l’exécution du handler et lève une exception en cas d’échec.

public async Task<TResponse> Handle(
    TRequest request,
    RequestHandlerDelegate<TResponse> next,
    CancellationToken ct)
{
    var context = new ValidationContext<TRequest>(request);
    var failures = _validators
        .Select(v => v.Validate(context))
        .SelectMany(r => r.Errors)
        .Where(f => f is not null)
        .ToList();
    if (failures.Count != 0)
        throw new ValidationException(failures);
    return await next();
}

Court-circuitage

Un comportement peut ignorer entièrement le handler en renvoyant un résultat sans appeler next() ; c’est utile pour mettre en cache les résultats de requêtes ou refuser les requêtes non valides.

if (_cache.TryGet(key, out TResponse cached))
    return cached;          // handler never runs
var response = await next();
_cache.Set(key, response);
return response;

Ordre d’exécution des comportements

Les comportements s’exécutent dans l’ordre de leur enregistrement. Placez la journalisation à l’extérieur, puis la validation et enfin les transactions, afin que chacun entoure correctement le suivant.

services.AddTransient(typeof(IPipelineBehavior<,>), typeof(LoggingBehavior<,>));
services.AddTransient(typeof(IPipelineBehavior<,>), typeof(ValidationBehavior<,>));
services.AddTransient(typeof(IPipelineBehavior<,>), typeof(TransactionBehavior<,>));

Un comportement transactionnel

Entourez les gestionnaires de commandes d’une transaction de base de données afin que toute l’opération soit validée ou annulée de manière atomique.

await using var tx = await _db.Database.BeginTransactionAsync(ct);
try
{
    var response = await next();
    await tx.CommitAsync(ct);
    return response;
}
catch
{
    await tx.RollbackAsync(ct);
    throw;
}

Cibler des requêtes précises

Utilisez une interface marqueur et une contrainte générique afin qu’un comportement ne s’applique qu’aux requêtes qui choisissent de l’utiliser ; par exemple, seules les commandes bénéficient des transactions.

public interface ITransactional { }
public record CreateOrderCommand(...) : IRequest<int>, ITransactional;

// where TRequest : ITransactional

Pourquoi les comportements sont préférables à l’intergiciel

Contrairement à l’intergiciel HTTP, les comportements s’exécutent per message, disposent de la requête et de la réponse typées et fonctionnent même lorsqu’une requête est distribuée en dehors de HTTP (par exemple depuis une tâche en arrière-plan).

// Strongly typed, transport-independent cross-cutting logic

Vérification rapide

Vérifiez que vous comprenez le fonctionnement des comportements.

Réponds-y dans la leçon interactive

Récapitulatif

Vous avez découvert les comportements de la chaîne de traitement :

IPipelineBehavior<TRequest, TResponse> entoure chaque requête d’une logique commune.
Le délégué next fait avancer la chaîne de traitement ; ne pas l’appeler court-circuite le handler.
Utilisations courantes : journalisation, validation, transactions et mise en cache.
Les comportements s’exécutent dans l’ordre d’enregistrement et sont fortement typés.

Ensuite : les notifications et les événements.

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 « Comportements du pipeline » est-elle gratuite ?

Oui — le texte complet de « Comportements du pipeline » 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 « Comportements du pipeline » ?

Ajoutez une logique transversale avec des comportements. 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 « Comportements du pipeline » ?

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

← Retour à C# Academy