gRPC for .NET

Trigger On

• building backend-to-backend RPC services or clients
• adding protobuf contracts, streaming calls, or interceptors
• deciding between gRPC, HTTP APIs, and SignalR
• optimizing gRPC performance, deadlines, cancellation, or connection reuse
• integrating service-to-service communication in microservices

Workflow

1. Validate the architecture fit before touching code.

- prefer gRPC for backend RPC, strong contracts, low-latency calls, or streaming - prefer REST or minimal APIs for broad browser compatibility and loosely coupled public APIs - prefer SignalR for browser/client realtime fan-out and UI collaboration

1. Treat .proto files as the source of truth.

- keep package names, csharp_namespace, service names, and versioning deliberate - reserve removed field numbers and avoid reusing tags - use wrapper types or explicit messages when optionality matters

1. Choose the RPC shape from the interaction model.

- unary for request/response - server streaming for large or progressive result sets - client streaming for uploads or batches - bidirectional streaming for coordinated two-way flows

1. Wire server and client behavior together.

- register services with AddGrpc - use AddGrpcClient or long-lived GrpcChannel reuse - set deadlines and propagate cancellation - convert domain failures to appropriate RpcException status codes

1. Add observability and resilience where the boundary justifies it.

- logging or exception interceptors - OpenTelemetry traces and status-code metrics - retry policy only for safe idempotent calls

1. Validate with the repo's normal build and tests, plus a focused smoke call when runnable.

flowchart LR
  A["RPC requirement"] --> B["proto contract"]
  B --> C["server implementation"]
  B --> D["client factory or channel"]
  C --> E["deadlines / cancellation / status codes"]
  D --> E
  E --> F["build, tests, smoke call"]

Deliver

• stable protobuf contracts and generated-code ownership
• service and client code that match the RPC shape
• explicit deadline, cancellation, retry, and status-code behavior
• tests or smoke checks for serialization and call behavior
• documentation of browser, transport, or deployment constraints when relevant

Validate

• dotnet build succeeds after contract or generated-code changes
• tests or smoke checks exercise at least one server/client call
• streaming methods respect cancellation and bounded message sizes
• channels are reused through client factory or a long-lived channel
• status-code handling is intentional and observable
• browser constraints are documented if gRPC-Web is involved

Anti-Patterns

• creating a new GrpcChannel per call
• omitting deadlines and relying only on client-side cancellation
• ignoring ServerCallContext.CancellationToken in streaming handlers
• sending large single messages instead of chunking or streaming
• using gRPC as the default public browser API
• swallowing exceptions inside interceptors
• retrying non-idempotent calls without explicit policy

Load References

Related skills