gRPC Services

syntax = "proto3";

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

Common follow-ups: Why is gRPC generally unsuitable for direct browser consumption without a proxy?;How do you decide between gRPC and REST for a given service boundary?

// greet.proto
service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

// GreeterService.cs -- inherits generated base class
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
app.MapGrpcService<GreeterService>();

Common follow-ups: How do you version a .proto contract without breaking existing clients?;How is the generated code shared between multiple services/repositories?

service DataService {
  rpc GetItem (ItemRequest) returns (Item);  // unary
  rpc StreamUpdates (SubscribeRequest) returns (stream Update);  // server streaming
  rpc UploadItems (stream Item) returns (UploadSummary);  // client streaming
  rpc Chat (stream ChatMessage) returns (stream ChatMessage);  // bidirectional
}

Common follow-ups: How does cancellation work differently across these four streaming patterns?;What are the connection/resource lifetime implications of long-lived streaming calls?

// Program.cs -- enabling gRPC-Web support directly in ASP.NET Core
builder.Services.AddGrpc();
var app = builder.Build();
app.UseGrpcWeb();
app.MapGrpcService<GreeterService>().EnableGrpcWeb();

Common follow-ups: What are the streaming limitations of gRPC-Web compared to full native gRPC?;When would you use a separate Envoy proxy instead of ASP.NET Core's built-in gRPC-Web support?

[Authorize]
public class SecureGreeterService : Greeter.GreeterBase {
    [Authorize(Policy = "AdminOnly")]
    public override Task<HelloReply> SayHello(HelloRequest request, ServerCallContext context) {
        var user = context.GetHttpContext().User;
        return Task.FromResult(new HelloReply { Message = $"Hello {user.Identity.Name}" });
    }
}

// Client attaches the token via call metadata
var headers = new Metadata { { "Authorization", $"Bearer {token}" } };
var reply = await client.SayHelloAsync(request, headers);

Common follow-ups: How does mutual TLS (mTLS) provide an alternative/complementary authentication mechanism for service-to-service gRPC calls?;How do you propagate authentication context through a chain of gRPC calls (service A calling service B calling service C)?

public override Task<Item> GetItem(ItemRequest request, ServerCallContext context) {
    var item = _repository.Find(request.Id);
    if (item is null)
        throw new RpcException(new Status(StatusCode.NotFound, $"Item {request.Id} not found"));
    return Task.FromResult(item);
}

// Client-side handling
try {
    var item = await client.GetItemAsync(request);
} catch (RpcException ex) when (ex.StatusCode == StatusCode.NotFound) {
    // handle not-found case
}

Common follow-ups: How do gRPC status codes map (or fail to map cleanly) to HTTP status codes when using gRPC-Web through a proxy?;How would you implement a gRPC interceptor for centralized error logging?

public class LoggingInterceptor : Interceptor {
    public override async Task<TResponse> UnaryServerHandler<TRequest, TResponse>(
        TRequest request, ServerCallContext context, UnaryServerMethod<TRequest, TResponse> continuation) {
        var start = DateTime.UtcNow;
        try {
            return await continuation(request, context);
        } finally {
            Console.WriteLine($"{context.Method} took {(DateTime.UtcNow - start).TotalMilliseconds}ms");
        }
    }
}

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

Common follow-ups: How do interceptors differ in scope/capability between server-side and client-side registration?;How would you chain multiple interceptors and control their execution order?

// Program.cs -- DI-based typed client registration
builder.Services.AddGrpcClient<Greeter.GreeterClient>(options => {
    options.Address = new Uri("https://localhost:5001");
});

// Injected and used in a service
public class MyService(Greeter.GreeterClient client) {
    public async Task<string> Greet(string name) {
        var reply = await client.SayHelloAsync(new HelloRequest { Name = name });
        return reply.Message;
    }
}

Common follow-ups: How does connection pooling/channel reuse work under the hood with GrpcChannel?;How would you configure retry policies for a gRPC client using the built-in resilience handlers?

// Client sets an explicit deadline
var callOptions = new CallOptions(deadline: DateTime.UtcNow.AddSeconds(5));
var reply = await client.SayHelloAsync(request, callOptions);

// If SayHello internally calls another gRPC service using the ServerCallContext's
// deadline, that downstream call automatically inherits the remaining time budget

Common follow-ups: How do you handle deadline exceeded errors gracefully at each level of the chain?;What's the difference between a deadline and a cancellation token in this context?

// Program.cs
#if DEBUG
builder.Services.AddGrpcReflection();
#endif

var app = builder.Build();
#if DEBUG
app.MapGrpcReflectionService();
#endif

# Using grpcurl with reflection enabled
grpcurl -plaintext localhost:5001 list
grpcurl -plaintext -d '{"name": "World"}' localhost:5001 Greeter/SayHello

Common follow-ups: Why is reflection typically disabled in production, and what's the security concern?;What's the equivalent of Swagger UI for browsing gRPC service documentation?