1. IronPDF
2. IronPDF Blog
3. .NET Help
4. Signalr C#

Published November 15, 2023

Signalr C# (How it Works For Developers)

The modern web thrives on interactivity and real-time feedback. When building responsive applications, real-time web functionality is a must. This is where SignalR shines. ASP.NET Core SignalR is a library that makes adding real-time web functionality to your applications simpler than you might think.

In this tutorial, we'll embark on a journey through the basics and nuances of SignalR. Let’s dive in!

Introduction to SignalR in ASP.NET Core

ASP.NET Core SignalR provides an API for creating real-time web functionality using WebSockets and other technologies, like server-sent events. It's not just limited to ASP.NET Core. You can use SignalR with various clients, like a browser or a mobile app, ensuring connected clients are updated instantly.

Setting Up Your Development Environment

To get started, you’ll need:

• ASP.NET Core SDK
• Visual Studio

Building the SignalR Hub

At its core, SignalR revolves around a SignalR hub, a central point for both the client and the server to interact.

Create a new ASP.NET Core project. Now, add a new class and name it ChatHub. This will act as our SignalR hub.

using Microsoft.AspNetCore.SignalR;

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

using Microsoft.AspNetCore.SignalR;

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

Imports Microsoft.AspNetCore.SignalR

Public Class ChatHub
	Inherits Hub

	Public Async Function SendMessage(ByVal user As String, ByVal message As String) As Task
		Await Clients.All.SendAsync("ReceiveMessage", user, message)
	End Function
End Class

In the public class Startup, let's integrate our hub.

public void ConfigureServices(IServiceCollection services)
{
    services.AddSignalR();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapHub<ChatHub>("/chatHub");
    });
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddSignalR();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapHub<ChatHub>("/chatHub");
    });
}

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	services.AddSignalR()
End Sub

Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
	app.UseEndpoints(Sub(endpoints)
		endpoints.MapHub(Of ChatHub)("/chatHub")
	End Sub)
End Sub

Client Side Implementation

SignalR is versatile. While this tutorial focuses on the ASP.NET Core and the JavaScript client library, SignalR supports various clients, from .NET to Java.

Using the SignalR Client Library

The SignalR client library lets your client-side code connect and communicate directly with the server side. For our example, let's use JavaScript.

First, add the SignalR JavaScript client library:

<script src="https://cdn.jsdelivr.net/npm/@microsoft/signalr@3.1.8/dist/browser/signalr.js"></script>

<script src="https://cdn.jsdelivr.net/npm/@microsoft/signalr@3.1.8/dist/browser/signalr.js"></script>

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'<script src="https://cdn.jsdelivr.net/npm/@microsoft/signalr@3.1.8/dist/browser/signalr.js"></script>

Now, you can connect to the hub:

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

connection.start();

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

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

connection.start();

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

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

connection.start()

connection.on("ReceiveMessage", Sub(user, message)
	console.log(`${user} says:= ${message}`)
End Sub)

This simple client-side code connects to the hub and listens for any messages broadcast.

Real-Time Functionality in Action

Sending Messages

Using our earlier client-side and server-side code snippets, sending messages is straightforward. Both the server and the client can initiate communication.

From server-side:

await Clients.All.SendAsync("ReceiveMessage", "Server", "Hello from server!");

await Clients.All.SendAsync("ReceiveMessage", "Server", "Hello from server!");

Await Clients.All.SendAsync("ReceiveMessage", "Server", "Hello from server!")

And from client:

connection.send("SendMessage", "Client", "Hello from client!");

connection.send("SendMessage", "Client", "Hello from client!");

connection.send("SendMessage", "Client", "Hello from client!")

Advanced Real-Time Communication

ASP.NET Core SignalR offers advanced real-time communication features:

1. Grouping Connections: Segment connected clients into groups, broadcasting messages to specific segments.
2. Handling Disconnections: Automatically manage client connections and disconnections.
3. Binary Protocol: While SignalR uses a text-based protocol by default, it supports a binary protocol as well.

SignalR with Azure SignalR Service

For scalable real-time functionality, integrate Azure SignalR Service. This fully managed service supports massive numbers of simultaneous connections, making it ideal for high-demand apps.

Integrating Azure SignalR Service:

1. Install the Azure SignalR SDK.
2. Use Azure Service Bus for backplane support.
3. Adjust the public class Startup to use Azure SignalR.

public void ConfigureServices(IServiceCollection services)
{
    services.AddSignalR().AddAzureSignalR();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseAzureSignalR(routes =>
    {
        routes.MapHub<ChatHub>("/chatHub");
    });
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddSignalR().AddAzureSignalR();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseAzureSignalR(routes =>
    {
        routes.MapHub<ChatHub>("/chatHub");
    });
}

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	services.AddSignalR().AddAzureSignalR()
End Sub

Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
	app.UseAzureSignalR(Sub(routes)
		routes.MapHub(Of ChatHub)("/chatHub")
	End Sub)
End Sub

Iron Suite Enhancing SignalR with Premium .NET Tools

While ASP.NET Core SignalR provides an outstanding foundation for real-time web functionality, developers often look for tools to enhance the overall experience and functionality. That's where Iron Suite enters the picture.

Iron Suite is a suite of premium .NET libraries, designed to supercharge your ASP.NET Core applications, including those utilizing SignalR. Each product in this suite offers unique capabilities, ensuring a richer application experience. Let's delve into the offerings:

IronPDF

IronPDF lets you generate, edit, and read PDF files within your .NET applications. Imagine integrating SignalR in a scenario where a team collaborates on a document in real-time. As changes are made, the document can be converted to a PDF on the fly, with updates pushed to all connected clients seamlessly. The real-time functionality of SignalR paired with IronPDF's capabilities could revolutionize collaborative tools.

IronXL

When it comes to working with Excel spreadsheets, IronXL is a champion. In a business setting, spreadsheets play a vital role. Incorporating SignalR alongside IronXL means that financial teams could work on budget sheets in real-time, witnessing changes as they happen. Imagine a scenario where data entries from various departments flow into a centralized Excel sheet, with real-time updates for all stakeholders. The fusion of real-time communication and dynamic spreadsheet management becomes a reality with this combination.

IronOCR

Optical Character Recognition (OCR) has become a staple in modern applications. IronOCR empowers .NET developers to extract text from images and documents. Pairing this with SignalR's real-time functionality can be game-changing. Consider a platform where users upload images containing textual data. SignalR could be used to notify users in real-time once IronOCR processes the images, making data extraction interactive and instantaneous.

IronBarcode

Barcoding is integral in inventory management, ticketing systems, and more. IronBarcode simplifies the creation and reading of barcodes. Now, think of integrating this with SignalR in a warehouse management system. As items are scanned, the inventory gets updated in real-time, notifying connected clients of stock levels, and ensuring a smooth logistical operation.

Conclusion

The fusion of ASP.NET Core SignalR with Iron Suite's powerful tools promises an elevated experience for both developers and end-users. Real-time web functionality becomes not just about communication but a transformative tool that, when paired with the right resources like Iron Suite, can redefine interactive applications.

It's worth noting the value proposition offered by Iron Suite. Each product license starts from $749, providing developers with a premium set of features. However, if you're unsure about the immediate commitment, each product generously offers a free trial. This allows you to test-drive the capabilities before making a decision.

And, if you're considering integrating multiple tools, there's fantastic news: you can purchase the entire Iron Suite for the price of just two products! This not only ensures you get the best bang for your buck but also equips you with a comprehensive toolkit to revolutionize your ASP.NET Core SignalR applications.