Building Real-Time Applications with SignalR and ASP.NET Core

Introduction

Modern applications increasingly rely on real-time communication to deliver instant updates and interactive experiences. Whether it's a chat application, live dashboard, stock market tracker, multiplayer game, or notification system, users expect data to update immediately without refreshing the page.

Traditionally, web applications relied on polling techniques where clients repeatedly asked the server for updates. This approach increases server load and introduces delays.

SignalR solves this problem by enabling real-time communication between clients and servers.

In this article, you'll learn what SignalR is, how it works, and how to build real-time applications using SignalR and ASP.NET Core.

What Is SignalR?

SignalR is a real-time communication library for ASP.NET Core that allows servers to push updates to connected clients instantly.

Instead of clients constantly requesting updates, the server can send information whenever data changes.

SignalR supports:

Real-time messaging
Live notifications
Collaborative applications
Dashboard updates
Multiplayer experiences

It simplifies the process of adding real-time functionality to web applications.

Why Use SignalR?

SignalR offers several advantages over traditional communication methods.

Instant Updates

Clients receive updates immediately when data changes.

Reduced Server Requests

No need for continuous polling.

Better User Experience

Applications feel more responsive and interactive.

Cross-Platform Support

SignalR works with:

ASP.NET Core
JavaScript
Blazor
Mobile applications

Automatic Connection Management

SignalR handles connection establishment and reconnection automatically.

How SignalR Works

SignalR creates a persistent connection between clients and the server.

Typical workflow:

Client
   ↕
SignalR Hub
   ↕
Server

When the server sends data, connected clients receive it instantly.

This communication is bidirectional, meaning both the server and clients can exchange messages.

SignalR Transport Methods

SignalR automatically chooses the best available communication method.

Supported transports include:

WebSockets

Preferred option for maximum performance.

Client ↔ Server

Server-Sent Events (SSE)

Used when WebSockets are unavailable.

Long Polling

Fallback option for older environments.

SignalR automatically selects the most appropriate transport.

Common Real-Time Use Cases

SignalR is commonly used for:

Chat applications
Live dashboards
Notifications
Online gaming
Collaborative editing
Financial applications
Monitoring systems

Any application requiring immediate updates can benefit from SignalR.

Creating an ASP.NET Core Project

Create a new ASP.NET Core project.

dotnet new webapp -n SignalRDemo

Navigate to the project folder.

cd SignalRDemo

Run the application.

dotnet run

The project is now ready for SignalR integration.

Adding SignalR

Install the SignalR package.

dotnet add package Microsoft.AspNetCore.SignalR

This package provides all required SignalR functionality.

Creating a SignalR Hub

A Hub acts as the communication center between clients and the server.

Create a new file named:

ChatHub.cs

Add the following code.

using Microsoft.AspNetCore.SignalR;

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

The hub receives messages and broadcasts them to all connected clients.

Registering SignalR Services

Open Program.cs.

Add SignalR services.

builder.Services.AddSignalR();

Map the hub endpoint.

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

SignalR is now configured and ready to accept connections.

Creating a Client Connection

Add the SignalR JavaScript library.

<script src="
https://cdnjs.cloudflare.com/ajax/libs/microsoft-signalr/8.0.0/signalr.min.js">
</script>

Create a connection.

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

This establishes communication with the server.

Starting the Connection

Start the connection after building it.

connection.start()
    .then(() => {
        console.log(
            "Connected"
        );
    });

The client is now connected to the SignalR hub.

Receiving Messages

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

Whenever the server sends a message, the client receives it immediately.

Sending Messages from the Client

Invoke a hub method.

connection.invoke(
    "SendMessage",
    "John",
    "Hello SignalR"
);

The server receives the message and broadcasts it to all connected users.

Building a Simple Chat Application

A chat application is one of the most common SignalR examples.

Workflow:

User A
   ↓
SignalR Hub
   ↓
User B

Messages appear instantly for all connected users.

This eliminates the need for manual page refreshes.

Sending Notifications

SignalR is ideal for notification systems.

Example:

await Clients.User(userId)
    .SendAsync(
        "Notification",
        "Order Approved"
    );

Users receive notifications immediately when events occur.

Common examples include:

Order updates
Payment confirmations
Security alerts
System messages

Using Groups

Groups allow messages to be sent to specific users.

Example:

await Groups.AddToGroupAsync(
    Context.ConnectionId,
    "Developers"
);

Send a message to the group.

await Clients.Group("Developers")
    .SendAsync(
        "ReceiveMessage",
        "Welcome Developers"
    );

Groups are useful for:

Team chats
Project channels
Department communication

Managing User Connections

SignalR provides connection lifecycle events.

User connected:

public override async Task OnConnectedAsync()
{
    await base.OnConnectedAsync();
}

User disconnected:

public override async Task OnDisconnectedAsync(
    Exception exception)
{
    await base.OnDisconnectedAsync(
        exception
    );
}

These methods help track active users.

Real-Time Dashboards

SignalR is widely used for live dashboards.

Example metrics:

Website traffic
Sales data
System performance
Application health

Architecture:

Data Source
      ↓
ASP.NET Core
      ↓
SignalR
      ↓
Dashboard

Users see updates as soon as data changes.

SignalR with Blazor

SignalR powers many real-time features in Blazor applications.

Examples:

Live data updates
Collaborative editing
Interactive dashboards

Blazor and SignalR work together seamlessly within the ASP.NET ecosystem.

Scaling SignalR Applications

As applications grow, multiple servers may be required.

Example:

Load Balancer
     ↓
Server 1
Server 2
Server 3

To synchronize messages across servers, organizations often use:

Redis Backplane
Azure SignalR Service

These solutions ensure all users receive updates regardless of which server they connect to.

Using Azure SignalR Service

Azure SignalR Service simplifies scaling.

Benefits include:

Managed infrastructure
Automatic scaling
Reduced server load
Global availability

Large applications often use Azure SignalR for production deployments.

Security Considerations

Real-time applications must be secured properly.

Recommended practices:

Use HTTPS
Implement authentication
Authorize hub methods
Validate user input
Restrict group access

Example:

[Authorize]
public class ChatHub : Hub
{
}

This ensures only authenticated users can connect.

Best Practices

When building SignalR applications:

Keep messages small.
Use groups where appropriate.
Handle reconnection scenarios.
Secure hub endpoints.
Monitor connection counts.
Scale using Azure SignalR or Redis.
Validate incoming data.

Following these practices improves reliability and performance.

Common Mistakes to Avoid

Developers often encounter these issues:

Broadcasting unnecessary data
Ignoring connection failures
Skipping authentication
Sending large payloads
Not handling reconnections
Poor group management

Avoiding these mistakes leads to more stable real-time applications.

Real-World Applications

SignalR is commonly used for:

Chat Platforms

Real-time messaging between users.

Live Dashboards

Instant metric updates.

Financial Applications

Stock prices and trading updates.

Collaboration Tools

Shared editing experiences.

Monitoring Systems

Real-time infrastructure monitoring.

Its flexibility makes it suitable for many modern applications.

Conclusion

SignalR makes it easy to add real-time functionality to ASP.NET Core applications. By maintaining persistent connections between clients and servers, it enables instant communication without the overhead of continuous polling.

Whether you're building chat systems, notification platforms, dashboards, collaborative tools, or monitoring applications, SignalR provides a reliable and scalable solution for real-time communication.

Combined with ASP.NET Core's performance and flexibility, SignalR allows developers to create highly interactive applications that deliver a modern user experience.