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, checkthe 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.

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 nameGrpcCoreService and select.NET 8.0 under the Framework option.

• Review the default project folder structure.

  • Protos: contains all the gRPC server asset files, such asgreet.proto
  • Services: Contains the implementation of the gRPC services.
  • Root Folder:appSettings.json contains the service configuration andProgram.cs contains code configuring app behavior.

• Right-click on thegreet.proto and click on Properties, and verify that gRPC Stub Classes is set toServer only.
  

Set Up Client Application:

• Add a Console App Project with the nameGrpcClientApp 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 aProtos folder and copy theProtos\greet.proto file from theGrpcCoreService under this folder.
• Update the namespace inside thegreet.proto file to the project's namespace:

  option csharp_namespace = "GrpcClientApp";

• After that right-click ongreet.proto and click onProperties, and set the gRPC Stub Classes toClient only.
  

• Finally, edit theGrpcClientApp.csproj project file:
  

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

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

Make sure to use the port number mentioned in thelaunchSettings.json files of theGrpcCoreService 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 theemployee.proto file under theProtos folder and add the following code.

• Under theServices folder add theEmployeeService.cs and implement it as shown below.

• Inject this new service under theProgram.cs.

  app.MapGrpcService<EmployeeService>();

Update the client app to consume the employee service:

• Copy theemployee.proto file from theGrpcCoreService and update the namespace:

  option csharp_namespace = "GrpcClientApp";

• After that right-click on theemployee.proto and click onProperties and set the gRPC Stub Classes toClient only
• And make sure the proto file is added in theGrpcClientApp.csproj project file:

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

• Finally, update theProgram.cs file to call theemployee service.

• Once you are done with changes, you can verify the folders and files underSolution 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.

If you have any comments or suggestions, please leave them behind in the comments section below.