Skip to content

SignalR

Overview

SignalR is a real-time communication framework for .NET that enables bi-directional, persistent, and low-latency messaging between servers and clients (web, desktop, mobile).

In simple terms:

SignalR allows your C# application to push updates to connected clients instantly — without the client constantly polling the server.

It abstracts away complex transport mechanisms (WebSockets, Server-Sent Events, Long Polling) and exposes a clean API for real-time messaging.

What Problem Does SignalR Solve?

Traditional HTTP is request/response and client-driven, meaning:

  • The server can't initiate communication.
  • The client must poll regularly to check for updates (wasteful, slow).

SignalR solves this by enabling real-time server push.

When Would You Use SignalR?

Use SignalR when you need live updates shared among multiple clients. SignalR is perfect for scenarios such as:

  • Live dashboards - Example: KPI dashboards, trading platforms, monitoring screens.
  • Chat applications - Real-time messaging between users.
  • Collaborative apps - Live document editing, shared whiteboards, multi-user interaction.
  • Notifications pushed from the server - Alerts, toasts, “your report is ready”, job completion messages.
  • Real-time games / interactive systems - Multiplayer games, logistics tracking, GPS/telemetry updates.
  • Presence updates - Who is online, typing indicators, availability data.

How SignalR Works Internally

SignalR tries to use WebSockets by default because it's the fastest transport.

If WebSockets isn't supported, it falls back to:

  1. Server-Sent Events (for browsers)
  2. Long Polling (fallback-of-last-resort)

This automatic fallback removes the complexity of handling different real-time transports manually.

How to Use SignalR in a C# Application

Below is the minimum setup to make a working real-time hub.

1. Create a Hub

using Microsoft.AspNetCore.SignalR;

public class ChatHub : Hub
{
    public async Task SendMessage(string user, string message)
    {
        await Clients.All.SendAsync("ReceiveMessage", user, message);
    }
}

A Hub is a high-level abstraction that handles real-time messaging.

2. Register SignalR in Program.cs

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddSignalR();

var app = builder.Build();

app.MapHub<ChatHub>("/chatHub");

app.Run();

3. Call the Hub from the Client

JavaScript client example

const connection = new signalR.HubConnectionBuilder()
    .withUrl("/chatHub")
    .build();

connection.on("ReceiveMessage", (user, message) => {
    console.log(`${user}: ${message}`);
});

await connection.start();

await connection.invoke("SendMessage", "Stuart", "Hello world!");

C# client (e.g., console app or Blazor Server)

var connection = new HubConnectionBuilder()
    .WithUrl("https://localhost:5001/chatHub")
    .Build();

connection.On<string, string>("ReceiveMessage", (user, msg) =>
{
    Console.WriteLine($"{user}: {msg}");
});

await connection.StartAsync();
await connection.InvokeAsync("SendMessage", "Stuart", "Hello from console!");

Advantages of SignalR

  1. Real-Time, Bi-Directional Communication - Server → Client and Client → Server instantly.
  2. WebSockets First - Uses the most efficient transport automatically.
  3. Minimal Boilerplate - The Hub abstraction is extremely easy to use.
  4. Works with Many Client Types -
    • JavaScript browsers
    • C# clients
    • Xamarin/MAUI
    • Unity
    • Java (via 3rd party libs)
  5. 5. Built Into .NET - Deeply integrated with ASP.NET Core.
  6. 6. Scales with Azure SignalR Service - Huge throughput using distributed backplanes.

Disadvantages of SignalR

  1. State Management Can Get Tricky - Connection IDs change, online/offline detection can be painful.
  2. Requires Persistent Connections - Not ideal for highly intermittent or mobile networks.
  3. Not Great for Very Large Pub/Sub Systems - For thousands of topics & millions of clients, you'd use a message broker.
  4. Horizontal Scaling Requires a Backplane - Options:
    • Redis backplane
    • Azure SignalR Service
    • SQL Server backplane (not recommended now)
  5. Not a Replacement for Async Messaging - It’s real-time messaging, not durable messaging.

Alternatives to SignalR

Alternative Description When to Use
Azure Web PubSub Fully managed WebSocket service Large scale web apps
gRPC (with streaming) High-performance RPC with bidirectional streaming Enterprise microservices; service-to-service comms
Kafka / RabbitMQ Durable, reliable message brokers Event-driven systems
Server-Sent Events (SSE) One-way server-to-client Simple notifications
WebSockets directly Manual real-time comms More control, less abstraction
Firebase Realtime DB / Firestore Real-time DB push Mobile/web real-time apps

Summary

SignalR is a real-time communication framework in .NET that provides instant bi-directional messaging between clients and servers, using WebSockets when available.

You use SignalR when you need real-time updates — chat apps, dashboards, notifications, and collaborative tools.

It’s easy to use but requires careful scaling and isn’t suited for durable messaging.

Alternatives include gRPC streaming, Azure PubSub, or message brokers like Kafka or RabbitMQ depending on your needs.