Übersicht für gRPC auf .NET

Von James Newton-King

gRPC ist ein sprachunabhängiges RPC-Framework mit hoher Leistung (Remote Procedure Call, Remoteprozeduraufruf).

Im Folgenden sind die Hauptvorteile von gRPC aufgelistet:

• Ein modernes, hochleistungsfähiges und reduziertes Framework für Remoteprozeduraufrufe
• Contract First-API-Entwicklung mit standardmäßiger Verwendung von Protokollpuffern, wodurch sprachunabhängige Implementierungen möglich sind
• Für viele Sprachen verfügbare Tools zur Generierung stark typisierter Server und Clients
• Unterstützung von Clients, Servern und bidirektionalen Streamingaufrufen
• Reduzierte Netzwerkauslastung mit binärer Protobuf-Serialisierung

gRPC ist für die folgenden Komponenten besonders geeignet:

• Einfache Microservices, bei denen Effizienz essentiell ist
• Mehrsprachige Systeme, bei denen mehrere Sprachen für die Entwicklung erforderlich sind
• Point-to-Point-Dienste, die in Echtzeit Streaminganforderungen oder -antworten verarbeiten müssen

C#-Toolunterstützung für .proto-Dateien

gRPC verwendet einen Vertrag zuerst-Ansatz für die API-Entwicklung. Dienste und Nachrichten werden in .proto-Dateien definiert:

syntax = "proto3";

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

.NET-Typen für Dienste, Clients und Nachrichten werden automatisch generiert, indem .proto-Dateien in ein Projekt aufgenommen werden:

• Fügen Sie dem Grpc.Tools-Paket einen Paketverweis hinzu.
• Fügen Sie .proto-Dateien der Elementgruppe <Protobuf> hinzu.

<ItemGroup>
  <Protobuf Include="Protos\greet.proto" />
</ItemGroup>

Weitere Informationen zur Unterstützung von gRPC-Tools finden Sie unter gRPC-Dienste mit C#.

gRPC-Dienste in ASP.NET Core

gRPC-Dienste können in ASP.NET Core gehostet werden. Dienste verfügen über eine vollständige Integration mit ASP.NET Core-Features wie der Protokollierung, Dependency Injection (DI), der Authentifizierung und der Autorisierung.

Hinzufügen von gRPC-Diensten zu einer ASP.NET Core-App

gRPC erfordert das Paket Grpc.AspNetCore. Informationen zum Konfigurieren von gRPC in einer .NET-App finden Sie unter Konfigurieren von gRPC.

gRPC-Dienstprojektvorlage

Die Projektvorlage für gRPC-Dienste in ASP.NET Core stellt einen Startdienst bereit:

public class GreeterService : Greeter.GreeterBase
{
    private readonly ILogger<GreeterService> _logger;

    public GreeterService(ILogger<GreeterService> logger)
    {
        _logger = logger;
    }

    public override Task<HelloReply> SayHello(HelloRequest request,
        ServerCallContext context)
    {
        _logger.LogInformation("Saying hello to {Name}", request.Name);
        return Task.FromResult(new HelloReply 
        {
            Message = "Hello " + request.Name
        });
    }
}

GreeterService erbt vom Typ GreeterBase, der aus dem Greeter-Dienst in der .proto-Datei generiert wird. Der Dienst wird für Clients in Program.cs verfügbar gemacht:

app.MapGrpcService<GreeterService>();

Weitere Informationen zu gRPC-Diensten in ASP.NET Core finden Sie unter gRPC-Dienste mit ASP.NET Core.

Aufrufen von gRPC-Diensten mithilfe eines .NET-Clients

gRPC-Clients sind konkrete Clienttypen, die aus .proto-Dateien generiert werden. Der konkrete gRPC-Client verfügt über Methoden, die in den gRPC-Dienst in der .proto-Datei übersetzt werden.

var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new Greeter.GreeterClient(channel);

var response = await client.SayHelloAsync(
    new HelloRequest { Name = "World" });

Console.WriteLine(response.Message);

Ein gRPC-Client wird mithilfe eines Kanals erstellt, der eine langlebige Verbindung mit einem gRPC-Dienst darstellt. Ein Kanal kann mithilfe von GrpcChannel.ForAddress erstellt werden.

Weitere Informationen zum Erstellen von Clients und zum Aufrufen verschiedener Dienstmethoden finden Sie unter Aufrufen von gRPC-Diensten mit dem .NET-Client.

Zusätzliche Ressourcen

• gRPC-Dienste mit C#
• gRPC-Dienste mit ASP.NET Core
• Aufrufen von gRPC-Diensten mithilfe eines .NET-Clients
• gRPC-Clientfactoryintegration in .NET
• Erstellen eines .NET Core-gRPC-Clients und -Servers in ASP.NET Core