Sandeep Kumar

Posted on Sep 2, 2022 • Edited on Dec 2, 2024

.NET 8.0 - gRPC Server and Client implementation

#grpc #csharp #dotnet #programming

In this article, we will learn about the basics of gRPC and its usage and, finally, implement the Server and Client using .NET Core 8.0.

gRPC explained:

gRPC (Google Remote Procedure Calls) was initially created by Google, which has used a single general-purpose RPC infrastructure called Stubby to connect the large number of microservices running within and across its data centers for over a decade.
In March 2015, Google decided to build the next version of Stubby and make it open source and the result was gRPC.

gRPC is a modern open-source high-performance Remote Procedure Call (RPC) framework.
It implements APIs using HTTP/2 which can run in any environment.
gRPC has two parts
- gRPC Protocol - As mentioned above it uses HTTP/2 which provides a lot of advantages over traditional HTTP1.x
- Data Serialization - by default gRPC uses Protobuf for the serialization and as an intermediator between client and server.
gRPC clients and servers intercommunicate using a variety of environments and machines.
It supports many languages like Java, C#, Go, Ruby, and Python, check the full list here.
It supports pluggable auth, tracing, load balancing, and health checking.

Different scenarios in which we use gRPC

When we use microservice architecture, and we use that for internal communication from one or more servers.
gRPC is handy when performance is on high priority with low latency.
It is useful when we require duplex communication between services with different types of data.
gRPC is useful in the last mile of distributed computing to connect devices, mobile applications, and browsers to backend services.

gRPC vs REST:

REST has been one of the highly used API frameworks and with gRPC grabbing the limelight, let's see the comparison on various parameters.

	REST	gRPC
Protocol	HTTP/1.1	HTTP/2.0
Request-Response Model	Only supports Request Response as based on HTTP/1.1	Supports All Types Of Streaming as based on HTTP/2
Serialization	JSON/XML	protobuf
Payload Format	Serialization like JSON/XML	Strong Typing
Browser Support	Yes	No

Pros and Cons of gRPC:

Pros

With duplex communication, it supports bi-directional streaming with HTTP/2-based transport.
Performance is one of the talking points of gRPC and it is faster than REST and SOAP.
gRPC services are highly efficient on wire and with a simple service definition framework.
gRPC messages are lightweight compared to other types such as JSON.
Client libraries supporting the 11 languages.

Cons

Browser support is very limited.
Since it uses binary data which is not easily readable compared to JSON or XML.

gRPC Implementation

Prerequisites

Visual Studio 2022
.NET 8.0

Set Up gRPC Service:

Open Visual Studio 2022 and create a new gRPC project with the name GrpcCoreService and select .NET 8.0 under the Framework option.
Review the default project folder structure.
- Protos: contains all the gRPC server asset files, such as greet.proto
- Services: Contains the implementation of the gRPC services.
- Root Folder: appSettings.json contains the service configuration and Program.cs contains code configuring app behavior.
Right-click on the greet.proto and click on Properties, and verify that gRPC Stub Classes is set to Server only.

Set Up Client Application:

Add a Console App Project with the name GrpcClientApp and select the required configurations.
Add the required packages to the client app project.

  Install-Package Grpc.Net.Client
  Install-Package Google.Protobuf
  Install-Package Grpc.Tools

Create a Protos folder and copy the Protos\greet.proto file from the GrpcCoreService under this folder.
Update the namespace inside the greet.proto file to the project's namespace:

  option csharp_namespace = "GrpcClientApp";

After that right-click on greet.proto and click on Properties, and set the gRPC Stub Classes to Client only.
Finally, edit the GrpcClientApp.csproj project file:

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

Once this is completed update the Program.cs file to call the greeter service.

Make sure to use the port number mentioned in the launchSettings.json files of the GrpcCoreService project.

Run and Test:

Set Up StartUp Project: Configure both projects as startup projects in the proper order.
Run the project and review the output of both the gRPC service and the client in the Console window.
gRPC Service Window:
gRPC Client Window:

Setup new service and client:

So far we have tested the default greeter service and client.

Now let's move ahead and set up a new service and client that consumes this new service.

Setup employee service:

To start with add the employee.proto file under the Protos folder and add the following code.

Under the Services folder add the EmployeeService.cs and implement it as shown below.

Inject this new service under the Program.cs.

  app.MapGrpcService<EmployeeService>();

Update the client app to consume the employee service:

Copy the employee.proto file from the GrpcCoreService and update the namespace:

  option csharp_namespace = "GrpcClientApp";

After that right-click on the employee.proto and click on Properties and set the gRPC Stub Classes to Client only
And make sure the proto file is added in the GrpcClientApp.csproj project file:

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

Finally, update the Program.cs file to call the employee service.

Once you are done with changes, you can verify the folders and files under Solution Explorer.

Run and Test the new service:

Run the project and search for the employee by passing the Employee ID in the Console Window

NOTE:

Check the source code here.

sandeepkumar17 / GrpcCoreService

.NET 8.0 - gRPC implementation

.NET8.0 - gRPC Service and Client implementation

Read the blog here

Introduction

gRPC (Google Remote Procedure Calls) 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 the last mile of distributed computing to connect devices, mobile applications, and browsers to backend services.

Solution and Project setup:

Set Up gRPC Service:

Open Visual Studio 2022 and create a new gRPC project, and name it to GrpcCoreService and select .NET 8.0 under the Framework option.
Review the project structure.
Right-click on greet.proto and click on Properties and verify that gRPC Stub Classes is set to Server only.