C# Academy · Lektion

Deadlines, Abbruch und Interceptors

Wenden Sie mit Deadlines Zeitüberschreitungen an, propagieren Sie CancellationToken und ergänzen Sie querschnittliche Funktionen über gRPC-Interceptoren.

Deadlines, Abbruch und Interceptors ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Zuverlässigkeit in gRPC: Deadlines und Abbruch

Produktive gRPC-Dienste müssen zwei wichtige Aspekte der Zuverlässigkeit berücksichtigen: Deadlines (wie lange der Client wartet) und Abbruch (vorzeitiges Beenden der Arbeit). Zusammen verhindern sie die Erschöpfung von Ressourcen und Kaskadenausfälle.

Eine Deadline für einen Aufruf festlegen

Eine Deadline ist ein absoluter Zeitpunkt, bis zu dem der Aufruf abgeschlossen sein muss. Legen Sie sie mit CallOptions fest. Bei einer Überschreitung empfängt der Server eine Abbruchanforderung, und der Client erhält 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 auf dem Client behandeln

Fangen Sie RpcException ab und prüfen Sie den Statuscode, um das Ablaufen der Deadline von anderen Fehlern zu unterscheiden.

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 auf dem Server berücksichtigen

Der Server sollte context.CancellationToken während lang andauernder Arbeiten prüfen. Wenn die Deadline abläuft, wird dieses Token automatisch abgebrochen.

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 weitergeben

Geben Sie das Abbruchtoken des Servers immer durch die gesamte Kette asynchroner Aufrufe weiter. Wenn Sie es ignorieren, verbrauchen abgebrochene Aufrufe weiterhin unnötig Ressourcen.

// 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-Interceptor: Konzept

Interceptor sind das gRPC-Gegenstück zur ASP.NET Core-Middleware – sie werden vor und nach RPC-Aufrufen ausgeführt und können Anfragen, Antworten und Ausnahmen untersuchen oder ändern. Sie eignen sich ideal für Protokollierung, Authentifizierung und Wiederholungslogik.

Einen serverseitigen Interceptor erstellen

Leiten Sie von Interceptor ab und überschreiben Sie den Methodentyp, den Sie abfangen möchten. Rufen Sie continuation auf, um mit dem eigentlichen Handler fortzufahren.

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

Serverseitige Interceptor registrieren

Registrieren Sie Interceptor global (für alle Dienste) oder dienstbezogen in Program.cs. Der DI-Container löst Konstruktorabhängigkeiten auf.

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

Clientseitige Interceptor

Clientseitige Interceptor umschließen ausgehende Aufrufe – nützlich, um Authentifizierungs-Header, Wiederholungslogik oder Korrelations-IDs hinzuzufügen, ohne jede Aufrufstelle zu ändern.

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

Exception-Interceptor

Ein serverseitiger Exception-Interceptor wandelt nicht behandelte Ausnahmen in RpcExceptions um und verhindert so, dass interne Details an Clients weitergegeben werden.

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

Kurze Prüfung

Was geschieht, wenn ein gRPC-Aufruf seine Deadline überschreitet?

Zusammenfassung: Deadlines, Abbruch und Interceptor

Wichtige Erkenntnisse:

Setzen Sie bei Clientaufrufen immer Deadlines, um unbegrenzt lange Wartezeiten zu verhindern
Prüfen Sie context.CancellationToken auf dem Server und übergeben Sie es an alle asynchronen Aufrufe
Interceptor behandeln querschnittliche Belange (Protokollierung, Authentifizierung, Fehlerzuordnung), ohne den Servicecode zu überladen
Serverseitige Interceptor: Überschreiben Sie Unary-/Stream-Handler-Methoden und rufen Sie continuation auf
Clientseitige Interceptor: Binden Sie sie in die Channel-Invoker-Kette ein

Häufig gestellte Fragen

Ist die Lektion „Deadlines, Abbruch und Interceptors“ kostenlos?

Ja — der vollständige Text von „Deadlines, Abbruch und Interceptors“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Deadlines, Abbruch und Interceptors“?

Wenden Sie mit Deadlines Zeitüberschreitungen an, propagieren Sie CancellationToken und ergänzen Sie querschnittliche Funktionen über gRPC-Interceptoren. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Deadlines, Abbruch und Interceptors“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C# Academy