gRPC pour C# (.NET) : bibliothèques, configuration et exemples de code

gRPC pour C# (.NET) : bibliothèques et exemples

gRPC est un framework moderne et haute performance pour l'appel de procédure à distance (RPC), développé par Google. Il utilise HTTP/2 pour le transport et Protocol Buffers (protobuf) pour la sérialisation des données. Dans l'écosystème .NET, gRPC est devenu l'outil principal pour construire une architecture de microservices, offrant un typage strict, un streaming bidirectionnel et une faible latence. Dans cet article, nous examinerons les bibliothèques clés pour travailler avec gRPC en C# et fournirons des exemples pratiques.

Bibliothèques principales pour gRPC dans .NET

Pour travailler avec gRPC dans .NET, les packages NuGet suivants sont utilisés :

• Grpc.Net.Client — bibliothèque cliente pour créer des clients gRPC. Elle fonctionne sur HttpClient et prend en charge tous les types d'appels : unary, server streaming, client streaming et bidirectional streaming.
• Grpc.AspNetCore.Server — bibliothèque serveur pour intégrer gRPC dans ASP.NET Core. Elle permet d'héberger des services gRPC aux côtés des API REST classiques.
• Google.Protobuf — bibliothèque pour travailler avec Protocol Buffers, générer et désérialiser des messages.
• Grpc.Tools — ensemble d'outils pour la génération automatique de code C# à partir de fichiers .proto lors de la compilation du projet.

Le processus de développement comprend trois étapes : la description du service dans un fichier .proto, la génération de code et l'implémentation du serveur/client.

Exemple 1 : Service unary simple (requête-réponse)

Créons un service simple pour obtenir des informations sur un utilisateur. Pour cela, définissons le fichier user.proto :

syntax = "proto3";

package user;

service UserService {  rpc GetUser (UserRequest) returns (UserResponse);}

message UserRequest {  int32 id = 1;}

message UserResponse {  string name = 1;  string email = 2;  int32 age = 3;}

Ajoutez les références aux packages et au fichier .proto dans le projet. Après la compilation, les classes UserRequest, UserResponse et la classe de base UserServiceBase seront générées.

Implémentation du serveur

using Grpc.Core;using User;

public class UserServiceImpl : UserService.UserServiceBase{    public override Task<UserResponse> GetUser(UserRequest request, ServerCallContext context)    {        var user = new UserResponse        {            Name = "Ivan Petrov",            Email = "ivan@example.com",            Age = 30        };        return Task.FromResult(user);    }}

Lancement du serveur dans ASP.NET Core :

var builder = WebApplication.CreateBuilder(args);builder.Services.AddGrpc();var app = builder.Build();app.MapGrpcService<UserServiceImpl>();app.Run();

Implémentation du client

using Grpc.Net.Client;using User;

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

var response = await client.GetUserAsync(new UserRequest { Id = 1 });Console.WriteLine($"Utilisateur : {response.Name}, Email : {response.Email}");

Exemple 2 : Streaming côté serveur (Server Streaming)

Le streaming côté serveur est utile lorsqu'il faut envoyer plusieurs données au client, par exemple une liste d'événements ou des logs. Complétons notre fichier .proto :

service UserService {  rpc GetUser (UserRequest) returns (UserResponse);  rpc ListUsers (Empty) returns (stream UserResponse);}

message Empty {}

Implémentation du serveur :

public override async Task ListUsers(Empty request, IServerStreamWriter<UserResponse> responseStream, ServerCallContext context){    var users = new List<UserResponse>    {        new UserResponse { Name = "Anna", Email = "anna@test.com" },        new UserResponse { Name = "Boris", Email = "boris@test.com" }    };