C# Academy · Les

Deadlines, annulering en interceptors

Pas time-outs toe met deadlines, geef CancellationToken door en voeg cross-cutting concerns toe via gRPC-interceptors.

Les 4 van 412 stappen

Deadlines, annulering en interceptors is een gratis C# Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C# Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C# Academy bevat in totaal 4 lessen.

Betrouwbaarheid in gRPC: deadlines en annulering

gRPC-services in productie moeten twee cruciale betrouwbaarheidskwesties afhandelen: deadlines (hoe lang de client wacht) en annulering (werk voortijdig stoppen). Samen voorkomen ze uitputting van resources en kettingfouten.

Een deadline voor een aanroep instellen

Een deadline is een absoluut tijdstip waarop de aanroep uiterlijk voltooid moet zijn. Stel deze in met CallOptions. Als de deadline wordt overschreden, ontvangt de server een annulering en krijgt de client 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);

DeadlineExceeded op de client afhandelen

Vang RpcException op en controleer de statuscode om een verlopen deadline van andere fouten te onderscheiden.

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

Deadlines op de server respecteren

De server moet tijdens langdurig werk context.CancellationToken controleren. Zodra de deadline verstrijkt, wordt dit token automatisch geannuleerd.

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

CancellationToken doorgeven

Geef het annuleringstoken van de server altijd door via elke keten van asynchrone aanroepen. Als je het negeert, blijven geannuleerde aanroepen onnodig resources gebruiken.

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

gRPC-interceptors: concept

Interceptors zijn het gRPC-equivalent van ASP.NET Core-middleware: ze worden vóór en na RPC-aanroepen uitgevoerd en kunnen verzoeken, antwoorden en uitzonderingen inspecteren of aanpassen. Ideaal voor logboekregistratie, authenticatie en logica voor opnieuw proberen.

Een interceptor aan de serverzijde maken

Erf over van Interceptor en overschrijf het type methode dat je wilt onderscheppen. Roep continuation aan om door te gaan naar de eigenlijke afhandelaar.

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

Interceptors aan de serverzijde registreren

Registreer interceptors globaal (voor alle services) of per service in Program.cs. De DI-container lost constructorafhankelijkheden op.

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

Interceptors aan de clientzijde

Interceptors aan de clientzijde omwikkelen uitgaande aanroepen — handig voor het toevoegen van authenticatieheaders, logica voor opnieuw proberen of correlatie-ID's zonder elke aanroepplek aan te passen.

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

Uitzonderingsinterceptor

Een interceptor voor uitzonderingen aan de serverzijde zet niet-afgevangen uitzonderingen om in RpcExceptions, zodat er geen interne details naar clients lekken.

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

Korte controle

Wat gebeurt er wanneer een gRPC-aanroep zijn deadline overschrijdt?

Beantwoord dit in de interactieve les

Samenvatting: deadlines, annulering en interceptors

Belangrijkste punten:

Stel altijd deadlines in op clientaanroepen om onbeperkt wachten te voorkomen
Controleer context.CancellationToken op de server en geef deze door aan alle asynchrone aanroepen
Interceptors behandelen dwarsdoorsnijdende aandachtspunten (logboekregistratie, authenticatie en fouttoewijzing) zonder servicecode onoverzichtelijk te maken
Interceptors aan de serverzijde: overschrijf Unary/Stream-handlermethoden en roep continuation aan
Interceptors aan de clientzijde: koppel ze aan de aanroepketen van het kanaal

Gratis beginnen

Leer C# met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 93
Lessen: 346

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Deadlines, annulering en interceptors” gratis?

Ja — de volledige tekst van “Deadlines, annulering en interceptors” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus C# Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus C# Academy bevat in totaal 4 lessen.

Wat leer ik in “Deadlines, annulering en interceptors”?

Pas time-outs toe met deadlines, geef CancellationToken door en voeg cross-cutting concerns toe via gRPC-interceptors. Je oefent met C# Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met C# Academy te beginnen?

Ervaring vooraf is niet nodig. C# Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Deadlines, annulering en interceptors”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over C# Academy?

Ja. Elke les over C# Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar C# Academy