C# Academy · Leçon

Échéances, annulation et intercepteurs

Appliquez des délais avec des échéances, propagez CancellationToken et ajoutez des préoccupations transversales avec les intercepteurs gRPC.

Leçon 4 sur 412 étapes

Échéances, annulation et intercepteurs est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Fiabilité avec gRPC : délais et annulation

Les services gRPC en production doivent gérer deux aspects essentiels de la fiabilité : les délais (la durée pendant laquelle le client attendra) et l’annulation (l’arrêt anticipé du travail). Ensemble, ils empêchent l’épuisement des ressources et les défaillances en cascade.

Définir un délai pour un appel

Un délai est un instant absolu avant lequel l’appel doit être terminé. Définissez-le avec CallOptions. S’il est dépassé, le serveur reçoit une annulation et le client obtient StatusCode.DeadlineExceeded.

var deadline = DateTime.UtcNow.AddSeconds(5);

var reply = await client.GetOrderAsync(
    new GetOrderRequest { Id = 42 },
    deadline: deadline);

// Or via CallOptions:
var options = new CallOptions(deadline: deadline);
var reply2 = await client.GetOrderAsync(
    new GetOrderRequest { Id = 42 }, options);

Gérer DeadlineExceeded sur le client

Interceptez RpcException et vérifiez le code d’état afin de distinguer l’expiration du délai des autres erreurs.

try
{
    var reply = await client.GetOrderAsync(
        new GetOrderRequest { Id = 42 },
        deadline: DateTime.UtcNow.AddSeconds(3));
}
catch (RpcException ex) when (ex.StatusCode == StatusCode.DeadlineExceeded)
{
    Console.WriteLine("Call timed out");
}
catch (RpcException ex)
{
    Console.WriteLine($"gRPC error: {ex.Status.Detail}");
}

Respecter les délais sur le serveur

Le serveur doit vérifier context.CancellationToken pendant les traitements longs. Lorsque le délai expire, ce jeton est automatiquement annulé.

public override async Task<ReportResponse> GenerateReport(
    ReportRequest request,
    ServerCallContext context)
{
    var ct = context.CancellationToken;

    // Pass ct to every async call — work stops when deadline hits
    var data = await _db.FetchLargeDatasetAsync(request.Filters, ct);
    var report = await _reportEngine.BuildAsync(data, ct);

    ct.ThrowIfCancellationRequested(); // explicit check before CPU work
    return MapToResponse(report);
}

Propagation de CancellationToken

Propagez toujours le jeton d’annulation du serveur dans chaque chaîne d’appels async. Si vous l’ignorez, les appels annulés continuent inutilement à consommer des ressources.

// GOOD: token flows through the call chain
await _db.Products.AsNoTracking()
    .Where(p => p.IsActive)
    .ToListAsync(context.CancellationToken); // cancels if client disconnects

// BAD: ignores cancellation
await _db.Products.ToListAsync(); // keeps running after deadline

Intercepteurs gRPC : concept

Les intercepteurs sont l’équivalent gRPC de l’intergiciel ASP.NET Core : ils s’exécutent avant et après les appels RPC et peuvent inspecter ou modifier les requêtes, les réponses et les exceptions. Ils sont idéaux pour la journalisation, l’authentification et la logique de nouvelle tentative.

Créer un intercepteur côté serveur

Héritez de Interceptor et remplacez le type de méthode que vous souhaitez intercepter. Appelez continuation pour poursuivre vers le handler réel.

using Grpc.Core.Interceptors;

public class LoggingInterceptor : Interceptor
{
    private readonly ILogger<LoggingInterceptor> _logger;
    public LoggingInterceptor(ILogger<LoggingInterceptor> l) => _logger = l;

    public override async Task<TResponse> UnaryServerHandler<TRequest, TResponse>(
        TRequest request,
        ServerCallContext context,
        UnaryServerMethod<TRequest, TResponse> continuation)
    {
        _logger.LogInformation("gRPC call: {Method}", context.Method);
        var sw = System.Diagnostics.Stopwatch.StartNew();
        var response = await continuation(request, context);
        _logger.LogInformation("Completed in {Ms}ms", sw.ElapsedMilliseconds);
        return response;
    }
}

Enregistrer des intercepteurs côté serveur

Enregistrez les intercepteurs globalement (pour tous les services) ou par service dans Program.cs. Le conteneur DI résout les dépendances du constructeur.

// Globally for all gRPC services:
builder.Services.AddGrpc(opt =>
    opt.Interceptors.Add<LoggingInterceptor>());

// Or per service:
builder.Services.AddGrpc();
builder.Services.AddSingleton<LoggingInterceptor>();

app.MapGrpcService<OrderService>()
   .AddInterceptor<LoggingInterceptor>();

Intercepteurs côté client

Les intercepteurs côté client encapsulent les appels sortants : ils permettent d’ajouter des en-têtes d’authentification, une logique de nouvelle tentative ou des identifiants de corrélation sans modifier chaque point d’appel.

public class AuthInterceptor : Interceptor
{
    private readonly ITokenProvider _tokens;
    public AuthInterceptor(ITokenProvider t) => _tokens = t;

    public override AsyncUnaryCall<TResponse> AsyncUnaryCall<TRequest, TResponse>(
        TRequest request,
        ClientInterceptorContext<TRequest, TResponse> context,
        AsyncUnaryCallContinuation<TRequest, TResponse> continuation)
    {
        var headers = context.Options.Headers ?? new Metadata();
        headers.Add("authorization", $"Bearer {_tokens.GetToken()}");
        var newContext = new ClientInterceptorContext<TRequest, TResponse>(
            context.Method, context.Host,
            context.Options.WithHeaders(headers));
        return continuation(request, newContext);
    }
}

// Attach to channel:
var invoker = channel.Intercept(new AuthInterceptor(tokenProvider));
var client = new OrderService.OrderServiceClient(invoker);

Intercepteur d’exception

Un intercepteur d’exception côté serveur convertit les exceptions non gérées en RpcExceptions, empêchant la divulgation de détails internes aux clients.

public class ExceptionInterceptor : Interceptor
{
    public override async Task<TResponse> UnaryServerHandler<TRequest, TResponse>(
        TRequest request,
        ServerCallContext context,
        UnaryServerMethod<TRequest, TResponse> continuation)
    {
        try
        {
            return await continuation(request, context);
        }
        catch (NotFoundException ex)
        {
            throw new RpcException(new Status(StatusCode.NotFound, ex.Message));
        }
        catch (Exception ex)
        {
            throw new RpcException(new Status(StatusCode.Internal, "Internal error"));
        }
    }
}

Vérification rapide

Que se passe-t-il lorsqu’un appel gRPC dépasse son délai ?

Réponds-y dans la leçon interactive

Récapitulatif : délais, annulation et intercepteurs

Points clés à retenir :

Définissez toujours des délais sur les appels client pour empêcher les attentes sans limite
Vérifiez context.CancellationToken sur le serveur et transmettez-le à tous les appels async
Les intercepteurs gèrent les préoccupations transversales (journalisation, authentification, mappage des erreurs) sans encombrer le code du service
Intercepteurs côté serveur : remplacez les méthodes de gestion Unary/Stream et appelez continuation
Intercepteurs côté client : rattachez-les à la chaîne d’invocation du channel

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 « Échéances, annulation et intercepteurs » est-elle gratuite ?

Oui — le texte complet de « Échéances, annulation et intercepteurs » 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 « Échéances, annulation et intercepteurs » ?

Appliquez des délais avec des échéances, propagez CancellationToken et ajoutez des préoccupations transversales avec les intercepteurs gRPC. 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 4 sur 4.

Combien de temps prend la leçon « Échéances, annulation et intercepteurs » ?

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