gRPC-Integration von Clientfactory in .NET CoregRPC client factory integration in .NET Core

Die gRPC-Integration mit HttpClientFactory bietet eine zentralisierte Möglichkeit, gRPC-Clients zu erstellen.gRPC integration with HttpClientFactory offers a centralized way to create gRPC clients. Diese Möglichkeit kann als Alternative zum Konfigurieren eigenständiger gRPC-Clientinstanzen verwendet werden.It can be used as an alternative to configuring stand-alone gRPC client instances. Die Factoryintegration ist im NuGet-Paket Grpc.Net.ClientFactory verfügbar.Factory integration is available in the Grpc.Net.ClientFactory NuGet package.

Die Factory bietet die folgenden Vorteile:The factory offers the following benefits:

  • Ein zentraler Ort für das Konfigurieren logischer gRPC-ClientinstanzenProvides a central location for configuring logical gRPC client instances
  • Optionen für die Verwaltung der Lebensdauer des zugrunde liegenden HttpClientMessageHandlerManages the lifetime of the underlying HttpClientMessageHandler
  • Automatische Weitergabe von Stichtagen und Absagen in einem ASP.NET Core-gRPC-DienstAutomatic propagation of deadline and cancellation in an ASP.NET Core gRPC service

Registrierung von gRPC-ClientsRegister gRPC clients

Zum Registrieren eines gRPC-Clients kann die generische Erweiterungsmethode AddGrpcClient innerhalb von Startup.ConfigureServices verwendet werden, die die typisierte Klasse des gRPC-Clients und die Dienstadresse angibt:To register a gRPC client, the generic AddGrpcClient extension method can be used within Startup.ConfigureServices, specifying the gRPC typed client class and service address:

services.AddGrpcClient<Greeter.GreeterClient>(o =>
{
    o.Address = new Uri("https://localhost:5001");
});

Der gRPC-Clienttyp wird als vorübergehender Typ mit einer Abhängigkeitsinjektion (Dependency Injection, DI) registriert.The gRPC client type is registered as transient with dependency injection (DI). Der Client kann nun injiziert und direkt in von der DI erstellten Typen genutzt werden.The client can now be injected and consumed directly in types created by DI. Bei ASP.NET Core-MVC-Controllern, SignalR-Hubs und gRPC-Diensten handelt es sich um Orte, an denen gRPC-Clients direkt injiziert werden können:ASP.NET Core MVC controllers, SignalR hubs and gRPC services are places where gRPC clients can automatically be injected:

public class AggregatorService : Aggregator.AggregatorBase
{
    private readonly Greeter.GreeterClient _client;

    public AggregatorService(Greeter.GreeterClient client)
    {
        _client = client;
    }

    public override async Task SayHellos(HelloRequest request,
        IServerStreamWriter<HelloReply> responseStream, ServerCallContext context)
    {
        // Forward the call on to the greeter service
        using (var call = _client.SayHellos(request))
        {
            await foreach (var response in call.ResponseStream.ReadAllAsync())
            {
                await responseStream.WriteAsync(response);
            }
        }
    }
}

Konfigurieren von HttpClientConfigure HttpClient

HttpClientFactory erstellt die HttpClient-Klasse, die vom gRPC-Client verwendet wird.HttpClientFactory creates the HttpClient used by the gRPC client. HttpClientFactory-Standardmethoden können verwendet werden ,um Middleware für ausgehende Anforderungen hinzuzufügen oder den zugrunde liegenden HttpClientHandler der HttpClient-Klasse zu konfigurieren:Standard HttpClientFactory methods can be used to add outgoing request middleware or to configure the underlying HttpClientHandler of the HttpClient:

services
    .AddGrpcClient<Greeter.GreeterClient>(o =>
    {
        o.Address = new Uri("https://localhost:5001");
    })
    .ConfigurePrimaryHttpMessageHandler(() =>
    {
        var handler = new HttpClientHandler();
        handler.ClientCertificates.Add(LoadCertificate());
        return handler;
    });

Weitere Informationen erhalten Sie unter Stellen von HTTP-Anforderungen mithilfe von IHttpClientFactory in ASP.NET Core.For more information, see Make HTTP requests using IHttpClientFactory.

Konfigurieren von Kanal und InterceptorenConfigure Channel and Interceptors

Für Folgendes sind gRPC-spezifische Methoden verfügbar:gRPC-specific methods are available to:

  • Konfigurieren des einem gRPC-Client zugrunde liegenden KanalsConfigure a gRPC client's underlying channel.
  • Hinzufügen von Interceptor-Instanzen, die der Client für gRPC-Aufrufe verwendetAdd Interceptor instances that the client will use when making gRPC calls.
services
    .AddGrpcClient<Greeter.GreeterClient>(o =>
    {
        o.Address = new Uri("https://localhost:5001");
    })
    .AddInterceptor(() => new LoggingInterceptor())
    .ConfigureChannel(o =>
    {
        o.Credentials = new CustomCredentials();
    });

Weitergabe von Stichtagen und AbsagenDeadline and cancellation propagation

gRPC-Clients, die von der Factory in einem gRPC-Dienst erstellt wurden, können mit EnableCallContextPropagation() so konfiguriert werden, dass sie die Tokens für Stichtage und Absagen automatisch an untergeordnete Aufrufe weitergeben.gRPC clients created by the factory in a gRPC service can be configured with EnableCallContextPropagation() to automatically propagate the deadline and cancellation token to child calls. Die Erweiterungsmethode EnableCallContextPropagation() ist im NuGet-Paket Grpc.AspNetCore.Server.ClientFactory verfügbar.The EnableCallContextPropagation() extension method is available in the Grpc.AspNetCore.Server.ClientFactory NuGet package.

Die Weitergabe von Aufrufkontext funktioniert, in dem die Tokens für Stichtage und Absagen aus dem aktuellen gRPC-Anforderungskontext gelesen und automatisch an ausgehende Aufrufe weitergegeben werden, die vom gRPC-Client ausgeführt werden.Call context propagation works by reading the deadline and cancellation token from the current gRPC request context and automatically propagating them to outgoing calls made by the gRPC client. Die Weitergabe von Aufrufkontext ist eine sehr gute Möglichkeit, sicherzustellen, dass komplexe und verschachtelte gRPC-Szenarios immer den Stichtag und die Absage weitergeben.Call context propagation is an excellent way of ensuring that complex, nested gRPC scenarios always propagate the deadline and cancellation.

services
    .AddGrpcClient<Greeter.GreeterClient>(o =>
    {
        o.Address = new Uri("https://localhost:5001");
    })
    .EnableCallContextPropagation();

EnableCallContextPropagation löst standardmäßig einen Fehler aus, wenn der Client außerhalb von gRPC-Aufrufen verwendet wird.By default, EnableCallContextPropagation raises an error if the client is used outside the context of a gRPC call. Der Fehler ist dazu konzipiert, Sie darüber zu informieren, dass kein Aufrufkontext zum Übertragen vorhanden ist.The error is designed to alert you that there isn't a call context to propagate. Wenn Sie den Client außerhalb eines Aufrufkontexts verwenden möchten, unterdrücken Sie den Fehler, wenn der Client mit SuppressContextNotFoundErrors konfiguriert ist:If you want to use the client outside of a call context, suppress the error when the client is configured with SuppressContextNotFoundErrors:

services
    .AddGrpcClient<Greeter.GreeterClient>(o =>
    {
        o.Address = new Uri("https://localhost:5001");
    })
    .EnableCallContextPropagation(o => o.SuppressContextNotFoundErrors = true);

Weitere Informationen zu Stichtagen und der RPC-Absage finden Sie unter RPC-Lebenszyklus.For more information about deadlines and RPC cancellation, see RPC life cycle.

Zusätzliche RessourcenAdditional resources