Real-time features with SignalR

Hubs, groups and reconnection, and the scaling decision that has to be made before the first user connects, not after.

Hubs and clients

public sealed class OrderHub : Hub<IOrderClient>
{
    private readonly ILogger<OrderHub> _log;
    public OrderHub(ILogger<OrderHub> log) => _log = log;

    public override async Task OnConnectedAsync()
    {
        var tenant = Context.User?.FindFirst("tenant")?.Value;
        if (tenant is null)
        {
            Context.Abort();              // never serve a connection without a tenant
            return;
        }

        // A group per tenant, so broadcasts never cross a boundary
        await Groups.AddToGroupAsync(Context.ConnectionId, "tenant:" + tenant);
        await base.OnConnectedAsync();
    }

    public override Task OnDisconnectedAsync(Exception? exception)
    {
        if (exception is not null)
            _log.LogWarning(exception, "hub connection {ConnectionId} failed",
                            Context.ConnectionId);
        return base.OnDisconnectedAsync(exception);
    }

    // Called by a client
    public Task SubscribeToOrder(int orderId) =>
        Groups.AddToGroupAsync(Context.ConnectionId, "order:" + orderId);

    // Called from server code elsewhere in the application
    public static Task NotifyAsync(IHubContext<OrderHub, IOrderClient> hub,
                                   string tenant, int orderId, string status,
                                   CancellationToken ct = default) =>
        hub.Clients.Group("tenant:" + tenant)
           .OrderChanged(orderId, status);

    // Always take a cancellation token on a long-running hub method
    public async Task<IReadOnlyList<Order>> LoadRecentAsync(CancellationToken ct)
    {
        await Task.Delay(50, ct);           // stand-in for a repository call
        return Array.Empty<Order>();
    }
}

// A typed client interface keeps the method names in one place
public interface IOrderClient
{
    Task OrderChanged(int orderId, string status);
    Task Notification(string message);
}

• Use a strongly typed hub. A typo in a client method name is otherwise a silent no-op at runtime.
• Every method that may run long needs a CancellationToken: the framework passes one that fires when the connection drops.
• Authorise inside the hub method as well as at the connection. A connection being authenticated says nothing about which orders it may subscribe to.
• Messaging a group is cheap; iterating Clients.All from application code is a pattern that does not scale.

Connections, reconnection and scale-out

// A browser client with automatic reconnect and a visible state
const connection = new signalR.HubConnectionBuilder()
  .withUrl("/hubs/orders")
  .withAutomaticReconnect([0, 2000, 5000, 10000, 30000])
  .configureLogging(signalR.LogLevel.Warning)
  .build();

connection.on("OrderChanged", (orderId, status) => {
  renderUpdate(orderId, status);
});

connection.onreconnecting(() => setStatus("reconnecting"));
connection.onreconnected(() => {
  setStatus("connected");
  resync();                 // the client missed messages while disconnected
});
connection.onclose(() => setStatus("offline"));

await connection.start();

// Scale out: without a backplane, messages only reach clients on one instance
builder.Services.AddSignalR()
    .AddStackExchangeRedis(builder.Configuration.GetConnectionString("Redis"), o =>
    {
        o.Configuration.ChannelPrefix = RedisChannel.Literal("orders");
    });

// Also raise the per-message limit when clients send large payloads
builder.Services.AddSignalR(o => o.MaximumReceiveMessageSize = 64 * 1024);

app.MapHub<OrderHub>("/hubs/orders").RequireAuthorization();

FAQ

Related

Interactive UI with Blazor Static files, uploads and streaming responses

Last refreshed 2026-09-18.