Using SignalR with gRPC Services

In this lesson, you will learn how to bridge the gap between high-performance backend gRPC communication and real-time client-side updates by orchestrating data flow between your services and your SignalR Hubs.

The Architectural Bridge

In complex microservice architectures, your services often communicate via gRPC due to its efficiency and strict contract definitions. However, gRPC is inherently request-response (or streaming) and doesn't natively push notifications to a browser. SignalR, conversely, is built for the browser. The "gRPC-to-SignalR" pattern uses your backend services as the data engine and the SignalR Hub as the broadcasting gateway.

Instead of having your frontend call a gRPC service directly (which often requires a proxy like grpc-web), your web client maintains a SignalR connection. When an internal event occurs, a backend gRPC service processes the heavy lifting, then invokes a method on the IHubContext to push the result to the connected clients.

Implementation Pattern

To integrate these, inject IHubContext<T> directly into your gRPC service implementation. When a gRPC method receives data, it acts as a bridge:

public class OrderService : OrderProto.OrderProtoBase
{
    private readonly IHubContext<OrderHub> _hubContext;

    public OrderService(IHubContext<OrderHub> hubContext)
    {
        _hubContext = hubContext;
    }

    public override async Task<OrderResponse> CreateOrder(OrderRequest request, ServerCallContext context)
    {
        // 1. Process the order via gRPC logic
        var result = await _db.SaveOrder(request);

        // 2. Push real-time update to SignalR clients
        await _hubContext.Clients.All.SendAsync("OrderUpdated", result.Id);

        return new OrderResponse { Status = "Success" };
    }
}

By decoupling the data processing (gRPC) from the notification delivery (SignalR), you maintain clean service boundaries. The gRPC service focuses on domain logic and state, while the SignalR Hub acts purely as an infrastructure layer for real-time delivery. This pattern ensures that your frontend never needs to know about the internal gRPC complexity—it simply listens for events broadcast from the Hub.

Key Takeaway: Use gRPC for backend inter-service communication and inject IHubContext into your gRPC services to trigger real-time notifications to frontend clients as a side effect of service execution.