DEV Community

Cover image for .NET 8.0 - gRPC Server and Client implementation
Sandeep Kumar
Sandeep Kumar

Posted on • Edited on

.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. Core Service Setup Core Service Setup

  • 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. Folder Structure

  • Right-click on the greet.proto and click on Properties, and verify that gRPC Stub Classes is set to Server only.

    Proto_Prop

Set Up Client Application:

  • Add a Console App Project with the name GrpcClientApp and select the required configurations. Client Setup Client Setup
  • 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:
Enter fullscreen mode Exit fullscreen mode

option csharp_namespace = "GrpcClientApp";

- After that right-click on `greet.proto` and click on **Properties**, and set the gRPC Stub Classes to **Client only**.
![Proto_Client_Prop](https://raw.githubusercontent.com/sandeepkumar17/td-dev.to/master/blog-posts/grpc-server-and-client-implementation/assets/gprc_09.png 'Proto Client Properties')

- Finally, edit the **GrpcClientApp.csproj** project file:
Enter fullscreen mode Exit fullscreen mode 
- 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.
Set Up StartUp Project

    • 

  • Run the project and review the output of both the gRPC service and the client in the Console window.
    • 

  • gRPC Service Window:
Service Output

    • 

  • gRPC Client Window:
Client Output

    • 




  
  
  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.
    •
Enter fullscreen mode Exit fullscreen mode

app.MapGrpcService();


#### Update the client app to consume the employee service:
- Copy the `employee.proto` file from the **GrpcCoreService** and update the namespace:
Enter fullscreen mode Exit fullscreen mode

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:
Enter fullscreen mode Exit fullscreen mode 
- 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.
Project Structure

    • 




  
  
  Run and Test the new service:




    

  • Run the project and search for the employee by passing the Employee ID in the Console Window
Employee Output 01
Employee Output 02

    • 




  
  
  NOTE:




Check the source code here.




  

    

      GitHub logo
      
        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.

    

    • 






Set Up Client Application:







    


  • 


    Add a Console App Project with the name GrpcClientApp and select the required configuration


    



    • 


  • 


    Add the required packages…
    



    • 





  



  
View on GitHub







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

Top comments (0)

Read next

extinctsion profile image

Comprehensive Testing in .NET 8: Using Moq and In-Memory Databases

Aditya Sharma -

juarezasjunior profile image

C# Tip: Prefer String Interpolation over Concatenation

Juarez Júnior -

probir-sarkar profile image

Node.js v23.0.0 Released: End of Support for 32-bit Windows

Probir Sarkar -

kiolk profile image

String Parsing with Kotlinx Serialization

Kiolk -