Panoramica di gRPC in .NET

Di James Newton-King

gRPC è un framework RPC indipendente dal linguaggio a elevate prestazioni.

I principali vantaggi di gRPC sono:

• Framework RPC leggero e moderno ad alte prestazioni.
• Sviluppo di API con priorità al contratto usando i buffer del protocollo per impostazione predefinita e implementazioni indipendenti dal linguaggio.
• Strumenti disponibili per molte linguaggi consentono di generare client e server fortemente tipizzati.
• Supporto per chiamate client, server e di streaming bidirezionale.
• Utilizzo di rete ridotto grazie alla serializzazione binaria Protobuf.

Questi vantaggi rendono gRPC ideale per:

• Microservizi leggeri in cui l'efficienza è fondamentale.
• Sistemi poliglotti che richiedono l'uso di più linguaggi per lo sviluppo.
• Servizi in tempo reale da punto a punto che devono gestire richieste o risposte di streaming.

Supporto degli strumenti C# per i file .proto

gRPC usa un approccio con priorità al contratto ("contract-first") per lo sviluppo di API. I servizi e i messaggi sono definiti nei file .proto:

syntax = "proto3";

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

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

I tipi .NET per servizi, client e messaggi vengono generati automaticamente includendo i file .proto in un progetto:

• Aggiungere un riferimento al pacchetto Grpc.Tools.
• Aggiungere i file .proto al gruppo di elementi <Protobuf>.

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

Per altre informazioni sul supporto degli strumenti gRPC, vedere Servizi gRPC con C#.

Servizi gRPC in ASP.NET Core

I servizi gRPC possono essere ospitati in ASP.NET Core. I servizi offrono l'integrazione completa con funzionalità di ASP.NET Core, ad esempio la registrazione, l'inserimento delle dipendenze, l'autenticazione e l'autorizzazione.

Aggiungere servizi gRPC a un'app ASP.NET Core

gRPC richiede il pacchetto Grpc.AspNetCore. Per informazioni sulla configurazione di gRPC in un'app .NET, vedere Configurare gRPC.

Modello di progetto del servizio gRPC

Il modello di progetto del servizio gRPC ASP.NET Core fornisce un servizio di avvio:

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 eredita dal tipo GreeterBase, generato dal servizio Greeter nel file .proto. Il servizio è reso accessibile ai client in Program.cs:

app.MapGrpcService<GreeterService>();

Per altre informazioni sui servizi gRPC in ASP.NET Core, vedere Servizi gRPC con ASP.NET Core.

Chiamare servizi gRPC con un client .NET

I client gRPC sono tipi client concreti generati da file .proto. Il client gRPC concreto include metodi che si traducono nel servizio gRPC nel file .proto.

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

Un client gRPC viene creato usando un canale, che rappresenta una connessione di lunga durata a un servizio gRPC. È possibile creare un canale usando GrpcChannel.ForAddress.

Per altre informazioni sulla creazione di client e sulla chiamata di diversi metodi di servizio, vedere Chiamare i servizi gRPC con il client .NET.

Risorse aggiuntive

• Servizi gRPC con C#
• Servizi gRPC con ASP.NET Core
• Chiamare i servizi gRPC con il client .NET
• Integrazione della factory client gRPC in .NET
• Creare un client e un server gRPC di .NET Core in ASP.NET Core