Blog post .NET, Technical

gRPC in .Net Core 3.0

Stefan Djokic | Software Developer

16 Jan 2020 |

Introduction

gRPC is nothing but Remote Procedure Call (RPC). But, why is it prefixed with a “g”? Because … Google; it’s made by Google.

“gRPC is a modern open source high performance 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.io

gRPC is a method of web communication between services – it’s kind of like an API. It responds to requests across the web and gives the caller back the requested information. The differences are in how it’s set up and how it transports data.

gRPC relies on a known configuration that is shared between the client and the server. This connection is something like a contract. These contracts are called Protocol Buffers.
gRPC communicates using a binary stream. This is much more efficient than a web server that can use JSON or XML.

There are other differences, but those two are the most important. Let’s build a gRPC server and a client, so we can see the other differences in the context of how they’re used.

Building application

1. Building the server

We’ll create a new project – gRPC Service since this is a .Net Core 3.0 item. We should have only .Net core 3.0 installed.

syntax = "proto3";

option csharp_namespace = "gRPCServer";

package Greet;

// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply);
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings.
message HelloReply {
  string message = 1;
}

syntax = "proto3";

option csharp_namespace = "gRPCServer";

package Greet;

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings.
message HelloReply {
  string message = 1;
}

// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply);
}

public HelloReply SayHello(HelloRequest input)
{
    //Do something
}

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

In the GreeterService.cs file, we focus on one piece of code that is the most important for us. We have a public override SayHello method. That’s because it’s implemented in GreeterBase already, but in GreeterBase, we notice that method throws a new RPC exception if we try to use it. It says, “Hey, I’m not implemented.” And because of that, we need to override each method in our GreeterService from the proto file. When the method SayHello is called, actually this method runs. The result is HelloReply object (HelloReply message in the proto file).

public override Task<HelloReply> SayHello(HelloRequest request, ServerCallContext context)
        {
            return Task.FromResult(new HelloReply
            {
                Message = "Hello " + request.Name
            });
        }

2. Building the client

We’ll build the Console Application. Be aware that anything can be the client: web project, console application, or android application.
First up, we need to add new NuGet Packages. There are three packages we need to add:

Google.Protobuf - Allows us to work with proto files;
Grpc.Net.Client - Allows to talk with gRPC Services;
Grpc.Tools – Allows us to have a visual studio tooling that works with our settings.

The next thing that we need to do is add a proto file. In the newly created Protos folder, we should add the file greet.proto. This is the same file from the server. We can tell those two are shared contract between the server and the client. This way, they can recognize each other. We can copy this file from the server or create a new with the same content.

Here we should set the properties for this file.
We can leave all default except gRPC Stub Classes. We should set up this for the client only. But there is an error when we try to do that. So, this can be done manually by changing GrpcServices value on Client from Protobuf item group in gRPCClient.csproj file.

Another important thing to do is rebuild the client project because it creates a new file that has client settings in the obj folder. So now we have that setup, and we can code.
Next, we should create a channel. We need to set the channel to have an address that is on our server. In this case, that is localhost with port 5001.

var channel = GrpcChannel.ForAddress("https://localhost:5001");

var client = new Greeter.GreeterClient(channel);

This process is a little bit tricky. Here we create an instance of Greeter object which comes from the Server project. But we are using ONLY using statement for this; there is no reference in the Server project. They don’t know each other before connection. It looks like we're instantiating a Greeter object from a proto file from the server, but that’s not the case. We are creating a client that will communicate via channels to the server. And only then will they know that the server exists.

The last thing we will do is get a response from the server and write it in the client console.

var input = new HelloRequest() { Name = "Stefan" };
var reply = client.SayHello(input);
Console.WriteLine(reply.Message);

We’re creating HelloRequest type input with property Name = Stefan. After that, we’re calling SayHello method passing in input, and at the end, we’re writing that response in the client console.

Running the application

Before running the application, we need to start both applications. This is very simple. On right-click, on our solution, we choose “Set up StartUp Projects,” then select Multiple Startup projects and for action on both projects choose “Start.”

When we run the project, we’re getting what we’re expected. The server is started and listening on port 5001. The client connects to the server, calls the method, and gets the right response which, is written in console “Hello Stefan.”

Conclusion

First-class support for gRPC in the latest ASP.NET Core 3.0 release is great news for .NET developers. They will get easier than ever access to a framework that provides efficient, secure, and cross-language/platform Remote Procedure Calls between servers.

While it has a major drawback in the lack of browser support, there is no shortage of scenarios in which it can shine or at least become a worthy addition to your toolset. Building Microservices, native mobile apps, or the Internet of Things (IoT) are just a few of the examples where gRPC would be a good fit.

Blog post .NET, Technical

gRPC in .Net Core 3.0

Introduction

Building application

#Proto file

#Service

2. Building the client

Running the application

Conclusion

Customize Xperience by Kentico UI – Channel specific settings

Launching a website with Xperience by Kentico: First Impressions

Implement C# data access with Dapper (using stored procedures) for MSSQL database