How do you implement private messaging between two users in a SignalR chat application?

Ravi Vishwakarma 690 22 May 2025

Ravi Vishwakarma

IT-Hardware & Networking

Ravi Vishwakarma is a dedicated Software Developer with a passion for crafting efficient and innovative solutions. With a keen eye for detail and years of experience, he excels in developing robust software systems that meet client needs. His expertise spans across multiple programming languages and technologies, making him a valuable asset in any software development project.

1 Answers

Ravi Vishwakarma 22 May 2025

Identify users uniquely.
Map each connected user to a SignalR connection.
Send a message to a specific user’s connection instead of broadcasting to all clients.

Here’s a step-by-step guide:

1. Setup SignalR Hub

public class ChatHub : Hub
{
    // Static dictionary to keep track of userId and connectionId
    private static readonly Dictionary<string, string> _userConnections = new();

    // Called when a client connects
    public override Task OnConnectedAsync()
    {
        var userId = Context.UserIdentifier; // Must be set by authentication middleware
        if (!string.IsNullOrEmpty(userId))
        {
            lock (_userConnections)
            {
                _userConnections[userId] = Context.ConnectionId;
            }
        }

        return base.OnConnectedAsync();
    }

    // Called when a client disconnects
    public override Task OnDisconnectedAsync(Exception exception)
    {
        var userId = Context.UserIdentifier;
        if (!string.IsNullOrEmpty(userId))
        {
            lock (_userConnections)
            {
                _userConnections.Remove(userId);
            }
        }

        return base.OnDisconnectedAsync(exception);
    }

    // Private messaging method
    public async Task SendPrivateMessage(string recipientUserId, string message)
    {
        if (_userConnections.TryGetValue(recipientUserId, out string connectionId))
        {
            await Clients.Client(connectionId).SendAsync("ReceivePrivateMessage", Context.UserIdentifier, message);
        }
    }
}

2. Configure Authentication Middleware

Ensure that UserIdentifier is set — typically the username or user ID from your authentication system.

In Startup.cs (for .NET Core):

services.AddSignalR();

services.AddAuthentication(...);
services.AddAuthorization();

app.UseAuthentication();
app.UseAuthorization();

app.UseEndpoints(endpoints =>
{
    endpoints.MapHub<ChatHub>("/chatHub");
});

If you're not using full authentication, override UserIdentifier manually:

public class CustomUserIdProvider : IUserIdProvider
{
    public string GetUserId(HubConnectionContext connection)
    {
        // Use connection.User.Identity.Name or a query string, etc.
        return connection.User?.Identity?.Name;
    }
}

services.AddSingleton<IUserIdProvider, CustomUserIdProvider>();

3. Client-Side JavaScript Example

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

connection.on("ReceivePrivateMessage", (senderUserId, message) => {
    console.log(`Message from ${senderUserId}: ${message}`);
});

connection.start().then(() => {
    // Example: send a private message
    const recipientUserId = "user456";
    connection.invoke("SendPrivateMessage", recipientUserId, "Hello in private!");
});

Tips

Use a persistent store instead of an in-memory dictionary (_userConnections) for scalability.
For multiple connections per user (multiple browser tabs), use ConcurrentDictionary<string, HashSet<string>>.
For group chat, use Groups.AddToGroupAsync(connectionId, groupName).

interview