First of all, let's understand SignalR.
🚀 SignalR is an open-source library built for .NET, designed to facilitate real-time communication in applications. Unlike the traditional request-response model, where the client sends a request and waits for a server response, SignalR enables two-way communication via a persistent connection.
🔄 Think of WhatsApp! 💬 Whenever someone sends you a message, it instantly appears on your screen (server pushing data to the client). Similarly, when you send a message, it reaches the recipient immediately (client sending data to the server).
📖 Further Reading:
Now, let’s implement SignalR in .NET Core by building a simple backend for a chat application. 💻
🛠️ Installing the SignalR NuGet Package
Install the latest SignalR package from NuGet using the following command:
dotnet add package Microsoft.AspNetCore.SignalR
📌 Alternatively, you can install it via the NuGet Package Manager UI.
📝 Creating a SignalR Hub
🔗 The Hub is the central component of SignalR that enables real-time communication. It allows clients and servers to call each other’s methods. Let's create a basic ChatHub:
using Microsoft.AspNetCore.SignalR;
namespace MySignalRProject.Hubs
{
// Create a hub class by inheriting SignalR Hub
public class ChatHub : Hub
{
// A server event triggered by the client
public async Task SendMessage(string message)
{
// Broadcast the message to all connected clients
await Clients.All.SendAsync("ReceiveMessage", message);
}
}
}
🔍 How does it work?
- Clients call
SendMessage(message), sending a message to the server. - The server then triggers
ReceiveMessage(message), sending it to all connected clients.
❓ Problem: Sending a message to everyone isn't always ideal.
✅ Solution: We can use Groups to restrict message delivery.
👥 Implementing Groups in SignalR
🔹 Groups allow clients to join specific chat rooms.
🔹 Only users in a group will receive messages sent to that group.
Here’s how to implement it:
using Microsoft.AspNetCore.SignalR;
namespace MySignalRProject.Hubs
{
public class ChatHub : Hub
{
// Join a specific group
public async Task Connect(string groupId)
{
await Groups.AddToGroupAsync(Context.ConnectionId, groupId);
}
// Leave a group
public async Task Disconnect(string groupId)
{
await Groups.RemoveFromGroupAsync(Context.ConnectionId, groupId);
}
// Send a message to a specific group
public async Task SendMessage(string groupId, string message)
{
await Clients.Group(groupId).SendAsync("ReceiveMessage", message);
}
}
}
✅ Now, only members of a specific group will receive messages sent to that group.
🌍 Exposing the Hub via API
🛠️ Register SignalR services in Startup.cs or Program.cs:
services.AddSignalR();
🔗 Expose ChatHub publicly at /chathub:
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
endpoints.MapHealthChecks("/health");
endpoints.MapHub<ChatHub>("/chatHub"); // Exposing SignalR Hub
});
🎉 Once your API starts, the real-time chat hub will be accessible at /chathub!
⚡ Making SignalR Type-Safe
🛑 Potential Issue:
await Clients.Group(groupId).SendAsync("ReceiveMessage", message);
If a developer mistypes "ReceiveMessage" as "ReceivedMessage" or "receiveMessage", debugging the issue can be time-consuming.
✅ Solution: Use Strongly Typed Hubs to enforce correct method names.
1️⃣ Define Client Events in an Interface
namespace MySignalRProject.Hubs.Interfaces
{
public interface IClientChatHub
{
Task ReceiveMessage(string message);
Task ReceiveReaction(int userId, string reaction);
}
}
2️⃣ Implement a Strongly Typed Hub
using Microsoft.AspNetCore.SignalR;
using MySignalRProject.Hubs.Interfaces;
namespace MySignalRProject.Hubs
{
public class ChatHub : Hub<IClientChatHub>
{
public async Task Connect(string groupId)
{
await Groups.AddToGroupAsync(Context.ConnectionId, groupId);
}
public async Task Disconnect(string groupId)
{
await Groups.RemoveFromGroupAsync(Context.ConnectionId, groupId);
}
public async Task SendMessage(string groupId, string message)
{
// No more typos! Method calls are now type-checked.
await Clients.Group(groupId).ReceiveMessage(message);
}
}
}
🔎 Comparison: Strongly Typed vs. Traditional Approach
❌ Group.SendAsync("EventName")
|
✅ Group.EventName
|
|---|---|
| Typos can break functionality ⚠️ | No typo worries 🚀 |
| No restrictions on event calls | Strict event control ✅ |
| No parameter validation | Parameter types are enforced 🛠️ |
✅ Using strongly typed hubs reduces runtime errors and improves code maintainability.
📢 Injecting HubContext in Services
🤔 Can we trigger SignalR events outside the Hub class?
💡 Yes! By injecting IHubContext, we can send messages from any service.
Example: Sending Messages from a Service Class
using Microsoft.AspNetCore.SignalR;
using MySignalRProject.Hubs;
using MySignalRProject.Hubs.Interfaces;
namespace MySignalRProject.Services
{
public class MyService
{
private readonly IHubContext<ChatHub, IClientChatHub> _hubContext;
public MyService(IHubContext<ChatHub, IClientChatHub> hubContext)
{
_hubContext = hubContext;
}
public async Task PerformSomeWork()
{
// Perform some logic...
var result = "Task completed ✅";
// Notify clients in 'myGroup'
await _hubContext.Clients.Group("myGroup").ReceiveMessage(result);
}
}
}
📌 What is IHubContext<ChatHub, IClientChatHub>?
-
ChatHub: The SignalR Hub class. -
IClientChatHub: The strongly-typed client event interface
✅ This approach allows you to send real-time updates from anywhere in your backend!
🎯 Conclusion
🎉 Now you have a working real-time chat backend using SignalR in .NET Core!
🛠️ Key Takeaways:
✅ SignalR enables real-time two-way communication
✅ Using Groups ensures messages go to the right audience
✅ Strongly typed hubs prevent typos & enforce method safety
✅ HubContext allows triggering real-time updates from services
🚀 What’s Next?
🔹 Implement authentication & authorization for enhanced security 🔐
🔹 Add message persistence using a database 📦
🔹 Scale SignalR using Redis for distributed applications 🌍
Happy coding! 💻✨
Top comments (0)