DOTNET: RPC with GRPC and REST and its Performance Impact

Below is a complete, runnable .NET 8 demo where:

• One server exposes:
  • A REST (JSON) endpoint
  • A gRPC (Protobuf) endpoint
• One console client:
  • Sends N requests to REST
  • Sends N requests to gRPC
  • Prints total time, average latency, and payload sizes

You’ll be able to feel the difference.

1. Solution structure

We’ll build this:

RpcPerfDemo/
  RpcPerfDemo.sln
  RpcPerfDemo.Server/     (ASP.NET Core – REST + gRPC)
    Program.cs
    Services/
      PerfServiceImpl.cs
    Models/
      RestPerfResponse.cs
    Protos/
      perf.proto
    RpcPerfDemo.Server.csproj
  RpcPerfDemo.Client/     (Console – benchmark client)
    Program.cs
    RpcPerfDemo.Client.csproj

Target: .NET 8.0 (works with future .NET 10+ too).

2. Step-by-step setup

✅ Step 0 – Prerequisites

• Install .NET 8 SDK dotnet --version Make sure it shows 8.x.x.
• Ensure dev HTTPS cert is trusted (only needed once): dotnet dev-certs https --trust

✅ Step 1 – Create solution + projects

mkdir RpcPerfDemo
cd RpcPerfDemo

# Create solution
dotnet new sln -n RpcPerfDemo

# Create server (web app)
dotnet new web -n RpcPerfDemo.Server

# Create client (console app)
dotnet new console -n RpcPerfDemo.Client

# Add to solution
dotnet sln add RpcPerfDemo.Server/RpcPerfDemo.Server.csproj
dotnet sln add RpcPerfDemo.Client/RpcPerfDemo.Client.csproj
Code language: PHP (php)

✅ Step 2 – Add packages

Server packages

cd RpcPerfDemo.Server
dotnet add package Grpc.AspNetCore
dotnet add package Grpc.Tools
dotnet add package Google.Protobuf
cd ..
Code language: CSS (css)

Client packages

cd RpcPerfDemo.Client
dotnet add package Grpc.Net.Client
dotnet add package Grpc.Tools
dotnet add package Google.Protobuf
cd ..
Code language: CSS (css)

✅ Step 3 – Define the Protobuf contract

Create folder and file:

mkdir -p RpcPerfDemo.Server/Protos

Create RpcPerfDemo.Server/Protos/perf.proto:

syntax = "proto3";

option csharp_namespace = "RpcPerfDemo.Grpc";

package perf;

// Request for performance test
message PerfRequest {
  int32 id = 1;
  string name = 2;
}

// Response from server
message PerfResponse {
  int32 id = 1;
  string name = 2;
  repeated int32 values = 3;
  int64 processedAtTicks = 4;
}

// gRPC service
service PerfService {
  rpc GetData(PerfRequest) returns (PerfResponse);
}
Code language: JavaScript (javascript)

✅ Step 4 – Wire proto into both projects

4.1 Server .csproj

Open RpcPerfDemo.Server/RpcPerfDemo.Server.csproj and make it look like this (keep your PropertyGroup as generated, just ensure these ItemGroups exist):

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Grpc.AspNetCore" Version="*" />
    <PackageReference Include="Grpc.Tools" Version="*">
      <PrivateAssets>All</PrivateAssets>
    </PackageReference>
    <PackageReference Include="Google.Protobuf" Version="*" />
  </ItemGroup>

  <ItemGroup>
    <Protobuf Include="Protos\perf.proto" GrpcServices="Server" />
  </ItemGroup>

</Project>
Code language: HTML, XML (xml)

Version="*" is fine – the real versions were already resolved by dotnet add package.

4.2 Client .csproj

Open RpcPerfDemo.Client/RpcPerfDemo.Client.csproj:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Grpc.Net.Client" Version="*" />
    <PackageReference Include="Grpc.Tools" Version="*">
      <PrivateAssets>All</PrivateAssets>
    </PackageReference>
    <PackageReference Include="Google.Protobuf" Version="*" />
  </ItemGroup>

  <!-- Reuse the same proto for client stubs -->
  <ItemGroup>
    <Protobuf Include="..\RpcPerfDemo.Server\Protos\perf.proto"
              Link="Protos\perf.proto"
              GrpcServices="Client" />
  </ItemGroup>

</Project>
Code language: HTML, XML (xml)

✅ Step 5 – Implement the server (REST + gRPC)

5.1 REST model

Create folder:

mkdir -p RpcPerfDemo.Server/Models

Create RpcPerfDemo.Server/Models/RestPerfResponse.cs:

namespace RpcPerfDemo.Server.Models;

public class RestPerfResponse
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public List<int> Values { get; set; } = new();
    public long ProcessedAtTicks { get; set; }
}
Code language: JavaScript (javascript)

5.2 gRPC service implementation

Create folder:

mkdir -p RpcPerfDemo.Server/Services

Create RpcPerfDemo.Server/Services/PerfServiceImpl.cs:

using Grpc.Core;
using RpcPerfDemo.Grpc;

namespace RpcPerfDemo.Server.Services;

public class PerfServiceImpl : PerfService.PerfServiceBase
{
    public override Task<PerfResponse> GetData(PerfRequest request, ServerCallContext context)
    {
        // Simulate some CPU work
        var values = Enumerable.Range(0, 200).ToList();

        var response = new PerfResponse
        {
            Id = request.Id,
            Name = request.Name,
            ProcessedAtTicks = DateTime.UtcNow.Ticks
        };
        response.Values.AddRange(values);

        return Task.FromResult(response);
    }
}
Code language: HTML, XML (xml)

5.3 Minimal API + gRPC configuration

Replace RpcPerfDemo.Server/Program.cs with:

using RpcPerfDemo.Server.Models;
using RpcPerfDemo.Server.Services;

var builder = WebApplication.CreateBuilder(args);

// Add gRPC services
builder.Services.AddGrpc();

var app = builder.Build();

// Map REST endpoint
app.MapGet("/rest/perf", () =>
{
    // Simulate some work, similar to gRPC
    var values = Enumerable.Range(0, 200).ToList();

    var response = new RestPerfResponse
    {
        Id = 1,
        Name = "REST-JSON",
        Values = values,
        ProcessedAtTicks = DateTime.UtcNow.Ticks
    };

    return Results.Ok(response);
});

// Map gRPC endpoint
app.MapGrpcService<PerfServiceImpl>();

// Optional health check endpoint
app.MapGet("/", () => "RPC Performance Demo Server (REST + gRPC)");

app.Run();
Code language: PHP (php)

ASP.NET Core will host both REST and gRPC on the same app and ports.

✅ Step 6 – Implement the benchmark client

Replace RpcPerfDemo.Client/Program.cs with:

3. Build and run

✅ Step 7 – Build everything

From the solution root (RpcPerfDemo):

dotnet build

You should see Build succeeded.

✅ Step 8 – Run the server

From the solution root:

dotnet run --project RpcPerfDemo.Server
Code language: CSS (css)

You’ll see output similar to:

info: Microsoft.Hosting.Lifetime[14]
      Now listening on: https://localhost:5001
info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://localhost:5000
Code language: JavaScript (javascript)

• Confirm https://localhost:5001 is there.
• If it prints a different HTTPS port, either:
  • Change ServerAddress constant in the client, or
  • Set ASPNETCORE_URLS: set ASPNETCORE_URLS=https://localhost:5001;http://localhost:5000 # Windows export ASPNETCORE_URLS="https://localhost:5001;http://localhost:5000" # Linux/macOS
  and re-run the server.

Leave the server running.

You can quickly test the REST endpoint in a browser:

• Visit: https://localhost:5001/rest/perf
  You should see JSON like:

{
  "id": 1,
  "name": "REST-JSON",
  "values": [...],
  "processedAtTicks": 638000000000000000
}
Code language: JSON / JSON with Comments (json)

✅ Step 9 – Run the client benchmark

In a new terminal, from solution root:

dotnet run --project RpcPerfDemo.Client
Code language: CSS (css)

You should see something like:

=== RPC Performance Demo: REST vs gRPC ===
Server address: https://localhost:5001
Total requests per style: 1000

Warming up REST endpoint...
Sample REST JSON payload size: 2350 bytes
Running REST benchmark...
REST total time: 950.32 ms for 1000 requests
REST avg per request: 0.9503 ms

Warming up gRPC endpoint...
Sample gRPC Protobuf payload size: 640 bytes
Running gRPC benchmark...
gRPC total time: 480.15 ms for 1000 requests
gRPC avg per request: 0.4802 ms

Done.
Code language: JavaScript (javascript)

(Exact numbers will vary by machine.)

4. How to interpret the results

You’ll get two kinds of insights:

1️⃣ Payload size

From log:

• REST JSON payload size – e.g. 2350 bytes
• gRPC Protobuf payload size – e.g. 640 bytes

👉 This shows gRPC messages are much smaller, even for the same data (id, name, 200 ints, timestamp).

Smaller payloads → less bandwidth → better performance, especially over slow networks.

2️⃣ Latency per request

You’ll see:

• REST total time and REST avg per request
• gRPC total time and gRPC avg per request

Typically:

• gRPC average per request will be lower
• Total time for N requests will also be lower

On localhost the difference may be modest, but:

• Add more iterations (Iterations = 10000)
• Or run on separate machines
• Or add more data in values (e.g. Enumerable.Range(0, 2000))

→ you’ll see gRPC scaling better.

5. What you just experienced

• Same server, same business logic size, same data.
• REST vs gRPC differ only in:
  • Data format (JSON vs Protobuf)
  • Protocol (HTTP/1.1 vs HTTP/2)
• Your measurements showed:
  • gRPC = smaller payloads
  • gRPC = lower average latency & total time

This is exactly the impact you care about for:

• High-throughput microservices
• Telemetry, streaming, real-time APIs
• Cloud Run → EKS migration with full gRPC support

Rajesh Kumar

I’m Rajesh Kumar, a DevOps, SRE, DevSecOps, Cloud, and Platform Engineering expert passionate about sharing practical knowledge, real-world experiences, and industry best practices. I have worked at Cotocus and regularly write about technology, travel, investing, health, product reviews, and digital marketing through my various platforms.

I publish technical articles at DevOps School, travel stories at Holiday Landmark, stock market insights at Stocks Mantra, health and fitness guidance at My Medic Plus, product reviews at TrueReviewNow, and SEO and digital marketing strategies at Wizbrand.