C# Academy · Oppitunti

Määräajat, peruutus ja interceptors

Soveltakaa aikakatkaisuja määräajoilla, välittäkää CancellationToken eteenpäin ja lisätkää poikkileikkaavia toimintoja gRPC-interceptoreilla.

Oppitunti 4/412 vaihetta

Määräajat, peruutus ja interceptors on ilmainen C# Academy-oppitunti CoddyKitissä. Tämä on oppitunti 4/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu C# Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. C# Academy-kurssilla on yhteensä 4 oppituntia.

gRPC:n luotettavuus: määräajat ja peruutus

Tuotantokäyttöön tarkoitetuissa gRPC-palveluissa on käsiteltävä kaksi keskeistä luotettavuuteen liittyvää asiaa: määräajat (kuinka kauan asiakas odottaa) ja peruutus (työn lopettaminen ennenaikaisesti). Yhdessä ne estävät resurssien ehtymisen ja ketjuuntuvat toimintahäiriöt.

Määräajan asettaminen kutsulle

Määräaika on absoluuttinen ajankohta, johon mennessä kutsun on valmistuttava. Asettakaa se CallOptions-olion avulla. Jos määräaika ylittyy, palvelin vastaanottaa peruutuksen ja asiakas saa arvon 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-arvon käsittely asiakkaalla

Ottakaa RpcException kiinni ja tarkistakaa tilakoodi erottaaksenne määräajan umpeutumisen muista virheistä.

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

Määräaikojen noudattaminen palvelimella

Palvelimen tulee tarkistaa context.CancellationToken pitkän käsittelyn aikana. Kun määräaika umpeutuu, tämä token peruutetaan automaattisesti.

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

CancellationTokenin välittäminen

Välittäkää aina palvelimen CancellationToken jokaisen asynkronisen kutsuketjun läpi. Jos jätätte sen huomiotta, peruutetut kutsut kuluttavat edelleen tarpeettomasti resursseja.

// 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-interceptorit: periaate

Interceptorit ovat gRPC:n vastine ASP.NET Coren middlewarelle — ne suoritetaan ennen RPC-kutsuja ja niiden jälkeen, ja ne voivat tarkastella tai muokata pyyntöjä, vastauksia ja poikkeuksia. Ne sopivat ihanteellisesti lokitukseen, todennukseen ja uudelleenyrityslogiikkaan.

Palvelinpuolen interceptorin luominen

Perikää Interceptor-luokka ja ylikirjoittakaa haluamanne menetelmätyyppi. Kutsukaa continuation-kutsua jatkaaksenne varsinaiseen käsittelijään.

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

Palvelinpuolen interceptorien rekisteröinti

Rekisteröikää interceptorit maailmanlaajuisesti (kaikki palvelut) tai palvelukohtaisesti tiedostossa Program.cs. DI-säilö selvittää konstruktorin riippuvuudet.

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

Asiakaspuolen interceptorit

Asiakaspuolen interceptorit käsittelevät lähtevät kutsut — ne ovat hyödyllisiä todennusotsakkeiden, uudelleenyrityslogiikan tai korrelaatiotunnusten lisäämiseen ilman muutoksia jokaiseen kutsukohtaan.

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

Poikkeusinterceptori

Palvelinpuolen poikkeusinterceptori muuntaa käsittelemättömät poikkeukset RpcException-poikkeuksiksi, mikä estää sisäisten tietojen vuotamisen asiakkaille.

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

Pikatarkistus

Mitä tapahtuu, kun gRPC-kutsu ylittää määräaikansa?

Vastaa interaktiivisessa oppitunnissa

Kertaus: määräajat, peruutus ja interceptorit

Keskeiset opit:

Asettakaa aina määräajat asiakaskutsuille rajoittamattoman odotuksen estämiseksi
Tarkistakaa palvelimella context.CancellationToken ja välittäkää se kaikille asynkronisille kutsuille
Interceptorit käsittelevät poikkileikkaavat huolenaiheet (lokitus, todennus, virheiden muunnos) ilman palvelukoodin sotkemista
Palvelinpuolen interceptorit: ylikirjoittakaa Unary/Stream-käsittelijämetodit ja kutsukaa continuation-kutsua
Asiakaspuolen interceptorit: liittäkää ne kanavan kutsuketjuun

Aloita maksutta

Opi C# tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 93
Oppitunnit: 346

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Määräajat, peruutus ja interceptors” ilmainen?

Kyllä – oppitunnin ”Määräajat, peruutus ja interceptors” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko C# Academy-kurssin, päivitä CoddyKit PROhon. C# Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Määräajat, peruutus ja interceptors”?

Soveltakaa aikakatkaisuja määräajoilla, välittäkää CancellationToken eteenpäin ja lisätkää poikkileikkaavia toimintoja gRPC-interceptoreilla. Harjoittelet C# Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni C# Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin C# Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 4/4.

Kuinka kauan ”Määräajat, peruutus ja interceptors”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä C# Academy-oppitunnilla?

Kyllä. Jokainen C# Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

gRPC:n ja Protobufin perusteet
Unary- ja palvelimen suoratoisto-RPC:t
Asiakkaan suoratoisto ja kaksisuuntainen suoratoisto
Määräajat, peruutus ja interceptors

← Takaisin: C# Academy