chrishuffman5/signalr

SignalR (.NET 8-10)

This skill covers ASP.NET Core SignalR, Microsoft's real-time communication library for .NET. Covers .NET 8, 9, and 10 (preview). It has deep knowledge of:

• Hub model: methods, strongly-typed hubs, client targeting, lifecycle
• Transport negotiation: WebSocket > SSE > Long Polling
• Groups, user targeting, and connection management
• Streaming: IAsyncEnumerable<T>, ChannelReader<T> (server and client)
• Authentication: JWT, cookies, custom user ID providers
• Scale-out: Redis backplane, Azure SignalR Service
• Hub protocols: JSON (default), MessagePack (binary)
• Hub filters (IHubFilter) for cross-cutting concerns
• IHubContext<T> for sending messages from outside hubs

How to Approach Tasks

1. Classify the request:

   • Architecture / hub design -- Load references/architecture.md for hub model, transports, protocols, lifecycle, streaming
   • Performance / scaling -- Load references/best-practices.md for Azure SignalR Service, Redis backplane, reconnection, security
   • Troubleshooting -- Load references/diagnostics.md for connection failures, transport issues, auth problems, scaling issues
   • Cross-technology comparison -- Read the overview skill for SignalR vs Socket.IO, WebSocket, SSE

2. Gather context -- .NET version, transport in use, scaling approach (single server vs Azure SignalR Service vs Redis), authentication method

3. Analyze -- Apply SignalR-specific reasoning: hub lifecycle (transient), group persistence, transport fallback behavior, backplane latency.

4. Recommend -- Provide C# code, JavaScript client code, and Azure configuration.

Core Architecture

Hub Model

Hubs are the central abstraction. Server defines methods callable by clients and vice versa. Hubs are transient -- do NOT store state in hub properties.

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSignalR();
var app = builder.Build();
app.MapHub<ChatHub>("/chathub");

Transport Negotiation

Priority: WebSocket (preferred) > SSE > Long Polling. Skip negotiation for performance:

options.SkipNegotiation = true;
options.Transports = HttpTransportType.WebSockets;

Client Targeting

Clients.All, Clients.Caller, Clients.Others, Clients.Client(id), Clients.Group(name), Clients.User(userId), Clients.OthersInGroup(name).

Hub Protocols

JSON (built-in, default) and MessagePack (~30-40% smaller payloads, faster parsing). Add MessagePack: builder.Services.AddSignalR().AddMessagePackProtocol().

IHubContext for External Messages

public class NotificationService(IHubContext<ChatHub> hubContext) : BackgroundService {
    protected override async Task ExecuteAsync(CancellationToken ct) {
        await hubContext.Clients.All.SendAsync("Notification", "Heartbeat", ct);
    }
}

Anti-Patterns

1. Storing state in hub properties -- Hubs are transient. Each method call creates a new instance. Use external state (Redis, database).
2. Not re-joining groups after reconnect -- Groups are cleaned up on disconnect. Persist group membership and re-join in OnConnectedAsync.
3. Calling RemoveFromGroupAsync in OnDisconnectedAsync -- Groups auto-cleanup. No need to remove.
4. Enabling DetailedErrors in production -- Exposes internal error details to clients. Only use in development.
5. Ignoring token expiry on long-lived connections -- WebSocket connections remain authenticated after token expires. Use CloseOnAuthenticationExpiration: true or validate per-message.
6. Not using IHubContext from outside hubs -- Never instantiate a hub directly. Use DI-injected IHubContext<T>.
7. Blocking hub methods -- Hub methods block the connection pipeline. Use async/await and return quickly.
8. Strongly typed hubs with Native AOT -- Hub<T> is not compatible with Native AOT (.NET 9+).

Reference Files

• references/architecture.md -- Hub model, transports, protocols, lifecycle, streaming, groups, strongly-typed hubs, hub filters, client results
• references/best-practices.md -- Authentication (JWT, cookies), Azure SignalR Service, Redis backplane, reconnection, MessagePack, performance, security
• references/diagnostics.md -- Connection failures, transport negotiation issues, auth problems, scaling issues, streaming errors, group management

Cross-References

• overview skill -- SignalR vs Socket.IO, WebSocket, SSE comparisons
• aspnet-core skill (in the backend plugin) -- ASP.NET Core framework context