gRPC (A high performance, open source universal RPC framework)

gRPC is a modern open source high performance Remote Procedure Call (RPC) framework that can run in any environment. It can efficiently connect services in and across data centers with pluggable support for load balancing, tracing, health checking and authentication. It is also applicable in last mile of distributed computing to connect devices, mobile applications and browsers to backend services.

gRPC is based around the idea of defining a service, specifying the methods that can be called remotely with their parameters and return types. By default, gRPC uses protocol buffers as the Interface Definition Language (IDL) for describing both the service interface and the structure of the payload messages. It is possible to use other alternatives if desired.

The main benefits of gRPC are:

• Modern, high-performance, lightweight RPC framework.
• Contract-first API development, using Protocol Buffers by default, allowing for language agnostic implementations.
• Tooling available for many languages to generate strongly-typed servers and clients.
• Supports client, server, and bi-directional streaming calls.
• Reduced network usage with Protobuf binary serialization.

These benefits make gRPC ideal for:

• Lightweight microservices where efficiency is critical.
• Polyglot systems where multiple languages are required for development.
• Point-to-point real-time services that need to handle streaming requests or responses.

gRPC uses a contract-first approach to API development. Services and messages are defined in .proto files:

syntax = "proto3";

service Greeter {

  rpc SayHello (HelloRequest) returns (HelloReply);

}

message HelloRequest {

  string name = 1;

}

message HelloReply {

  string message = 1;

}

gRPC services can be hosted on ASP.NET Core. Services have full integration with ASP.NET Core features such as logging, dependency injection (DI), authentication, and authorization.

Add gRPC services to an ASP.NET Core app

gRPC requires the Grpc.AspNetCore package. 

In Program.cs:

• gRPC is enabled with the AddGrpc method.
• Each gRPC service is added to the routing pipeline through the MapGrpcService method.

using GrpcGreeter.Services;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddGrpc();

var app = builder.Build();

app.MapGrpcService<GreeterService>();

app.MapGet("/", () => "Communication with gRPC endpoints must be made through a gRPC client. To learn how to create a client, visit: https://go.microsoft.com/fwlink/?linkid=2086909");

app.Run();

Service Code

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)

    {

        return Task.FromResult(new HelloReply

        {

            Message = "Hello " + request.Name

        });

    }

}

Client Code

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