gRPC Services

// order.proto -- defines the contract
service OrderService {
  rpc GetOrder (GetOrderRequest) returns (OrderResponse);
}
message GetOrderRequest { int32 order_id = 1; }
message OrderResponse { int32 id = 1; string status = 2; }

Common follow-ups: Why is gRPC less suitable for direct browser consumption without gRPC-Web?;How does protobuf's binary format achieve smaller payloads than JSON?

// Greeter.proto
syntax = "proto3";
service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}
message HelloRequest { string name = 1; }
message HelloReply { string message = 1; }

<!-- .csproj -->
<ItemGroup>
  <Protobuf Include="Protos\Greeter.proto" GrpcServices="Server" />
</ItemGroup>

Common follow-ups: What do the numbered fields in a proto message (like 'name = 1') actually mean and why do they matter for compatibility?

service DataService {
  rpc GetItem (ItemRequest) returns (ItemResponse);                    // unary
  rpc StreamUpdates (SubscribeRequest) returns (stream Update);        // server streaming
  rpc UploadChunks (stream ChunkRequest) returns (UploadResult);       // client streaming
  rpc Chat (stream ChatMessage) returns (stream ChatMessage);          // bidirectional
}

Common follow-ups: How does .NET's IAsyncEnumerable<T> map naturally to gRPC streaming methods?;What are the connection and resource lifetime implications of long-lived streaming calls?

public class GreeterService : Greeter.GreeterBase {
    public override Task<HelloReply> SayHello(HelloRequest request, ServerCallContext context) {
        return Task.FromResult(new HelloReply { Message = $"Hello, {request.Name}" });
    }
}

// Program.cs
builder.Services.AddGrpc();
app.MapGrpcService<GreeterService>();

Common follow-ups: Can a single ASP.NET Core app serve both REST and gRPC endpoints simultaneously?;How does dependency injection work within a gRPC service method?

public override Task<OrderResponse> GetOrder(GetOrderRequest request, ServerCallContext context) {
    var order = _repository.Find(request.OrderId);
    if (order == null) {
        throw new RpcException(new Status(StatusCode.NotFound, $"Order {request.OrderId} not found"));
    }
    return Task.FromResult(MapToResponse(order));
}

// Client-side:
try {
    var response = await client.GetOrderAsync(request);
} catch (RpcException ex) when (ex.StatusCode == StatusCode.NotFound) {
    // handle specifically
}

Common follow-ups: How do you attach custom error details (like field-level validation errors) to an RpcException?;How does gRPC status code mapping relate to HTTP status codes when gRPC runs over HTTP/2?

builder.Services.AddGrpc();
var app = builder.Build();

app.UseGrpcWeb();  // enables gRPC-Web support directly, no separate proxy needed
app.MapGrpcService<GreeterService>().EnableGrpcWeb();

Common follow-ups: What specific browser limitations prevent native gRPC from working directly?;How does gRPC-Web's performance compare to native gRPC given the translation overhead?

// A single HTTP/2 connection can carry many concurrent gRPC calls
// without head-of-line blocking, unlike sequential HTTP/1.1 requests:
var tasks = new[] {
    client.GetOrderAsync(request1),
    client.GetOrderAsync(request2),
    client.GetOrderAsync(request3)
};
await Task.WhenAll(tasks);  // all multiplexed over one connection efficiently

Common follow-ups: What is HTTP/1.1 head-of-line blocking specifically, and how does HTTP/2 solve it?;Does gRPC's binary format meaningfully outperform JSON for typical payload sizes?

public override async Task StreamUpdates(SubscribeRequest request, IServerStreamWriter<Update> responseStream, ServerCallContext context) {
    await foreach (var update in _updateSource.GetUpdatesAsync(context.CancellationToken)) {
        await responseStream.WriteAsync(update);
    }
}

Common follow-ups: How does the client consume a server-streaming response using IAsyncEnumerable?;What happens to the stream if the client disconnects mid-stream?

public class LoggingInterceptor : Interceptor {
    public override async Task<TResponse> UnaryServerHandler<TRequest, TResponse>(
        TRequest request, ServerCallContext context, UnaryServerMethod<TRequest, TResponse> continuation) {
        _logger.LogInformation("Calling {Method}", context.Method);
        return await continuation(request, context);
    }
}

builder.Services.AddGrpc(options => options.Interceptors.Add<LoggingInterceptor>());

Common follow-ups: How do interceptors compare conceptually to ASP.NET Core middleware for REST APIs?;How do you chain multiple interceptors and control their execution order?

// Original message (version 1)
message Order { int32 id = 1; string status = 2; }

// SAFE evolution: add new fields with NEW numbers, never reuse 1 or 2
message Order { int32 id = 1; string status = 2; string customer_email = 3; }

// DANGEROUS: never do this -- reusing field number 2 for a different purpose
// message Order { int32 id = 1; int32 status_code = 2; }  // BREAKS compatibility silently

Common follow-ups: How does protobuf's `reserved` keyword help prevent accidental field number reuse?;What's the protobuf convention for marking a field as deprecated without removing it?