How to send a realtime notification to specific user in blazor wasm client from asp.net core background service using SignalR in .NET 8

[fingers10]

I'm new to SignalR and learning it and practicing it for the first time. I'm trying to send real time notification to specific User in my Blazor WASM app from a BackgroundService in ASP.NET Core Web API using SignalR in .NET 8 as per the following code.

Client Side:

private HubConnection? _hubConnection;
private readonly List<string> _notifications = new();

[Inject] IAccessTokenProvider TokenProvider { get; set; }

[Inject] IConfiguration Configuration { get; set; }

[CascadingParameter] private Task<AuthenticationState> authenticationStateTask { get; set; }

protected override async Task OnInitializedAsync()
{
    var authState = await authenticationStateTask;
    var user = authState.User;

    if (user.Identity.IsAuthenticated)
    {
        _hubConnection = new HubConnectionBuilder()
                        .WithUrl($"{Configuration.GetValue<string>("ApiBaseAddress")}notifications",
                        options =>
                        {
                            options.AccessTokenProvider = async () =>
                            {
                                var accessTokenResult = await TokenProvider.RequestAccessToken();
                                accessTokenResult.TryGetToken(out var token);
                                return token.Value;
                            };
                        })
                        .Build();

        _hubConnection.On<string>("ReceiveNotification", notification =>
        {
            _notifications.Add(notification);

            InvokeAsync(StateHasChanged);
        });

        await _hubConnection.StartAsync();
    }
}

I'm sending the auth token along with the connection.

Server Side:

Hub:

[Authorize]
public class NotificationsHub : Hub<INotificationClient>
{
}

public interface INotificationClient
{
    Task ReceiveNotification(string message);
}

Program.cs:

...
builder.Services.AddSignalR();
...
app.MapHub<NotificationsHub>("notifications");

BackgroundService:

public class InventoryNotifier(
    IHubContext<NotificationsHub, INotificationClient> hubContext,
    ILogger<InventoryNotifier> logger) : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        using var timer = new PeriodicTimer(TimeSpan.FromSeconds(5));

        while (!stoppingToken.IsCancellationRequested && await timer.WaitForNextTickAsync(stoppingToken))
        {
            await hubContext.Clients
                .All
                .ReceiveNotification($"InventoryNotifier is starting... {DateTime.Now}");
        }

        stoppingToken.Register(() => logger.LogWarning($"{nameof(InventoryNotifier)} is stopping due to host shut down."));
    }
}

The above setup works fine and I receive notifications in my blazor wasm client app. However i'm sending messages to Clients.All from background service.

await hubContext.Clients
                .All // <--- This sends for All Client.
                .ReceiveNotification($"InventoryNotifier is starting... {DateTime.Now}");

When i tried to send to specific User, I noticed that Clients.User() exists and that needs an userId.

How can i get the user id inside background service? After some research I noticed that I can use IUserIdProvider and call GetUserId() method from that as shown below.

namespace Microsoft.AspNetCore.SignalR;

/// <summary>
/// A provider abstraction for configuring the "User ID" for a connection.
/// </summary>
/// <remarks><see cref="IUserIdProvider"/> is used by <see cref="IHubClients{T}.User(string)"/> to invoke connections associated with a user.</remarks>
public interface IUserIdProvider
{
    /// <summary>
    /// Gets the user ID for the specified connection.
    /// </summary>
    /// <param name="connection">The connection to get the user ID for.</param>
    /// <returns>The user ID for the specified connection.</returns>
    string? GetUserId(HubConnectionContext connection);
}

But again this requires HubConnectionContext. And now I'm not sure how to get HubConnectionContext inside BackgroundService.

The final idea i had in my mind is to have something like the one below.

public class InventoryNotifier(
    IHubContext<NotificationsHub, INotificationClient> hubContext,
    IUserIdProvider userIdProvider,
    ILogger<InventoryNotifier> logger) : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        using var timer = new PeriodicTimer(TimeSpan.FromSeconds(5));
        
        while (!stoppingToken.IsCancellationRequested && await timer.WaitForNextTickAsync(stoppingToken))
        {
            await hubContext.Clients
                .User(userIdProvider.GetUserId()) // <---- Not sure how to get HubConnectionContext here
                //.All
                .ReceiveNotification($"InventoryNotifier is starting... {DateTime.Now}");
        }

        stoppingToken.Register(() => logger.LogWarning($"{nameof(InventoryNotifier)} is stopping due to host shut down."));
    }
}

Please can anyone assist me on this? Is this the right way? or Am I complicating it?

[davidfowl]

How can i get the user id inside background service? After some research I noticed that I can use IUserIdProvider and call GetUserId() method from that as shown below.

This is the question. How does the background service running on a webserver handling many users know which user it should send updates to? Is there any operation it can query with the associated user context?

[fingers10]

@davidfowl Many thanks for your time and response. Here are the options that come to my mind.

1. Using the DefaultUserIdProvider? Is this possible? if so this needs access to HubConnectionContext and this comes back to my question on how to get HubConnectionContext inside BackgroundService?

using System.Security.Claims;

namespace Microsoft.AspNetCore.SignalR;

/// <summary>
/// The default provider for getting the user ID from a connection.
/// This provider gets the user ID from the connection's <see cref="HubConnectionContext.User"/> name identifier claim.
/// </summary>
public class DefaultUserIdProvider : IUserIdProvider
{
    /// <inheritdoc />
    public virtual string? GetUserId(HubConnectionContext connection)
    {
        return connection.User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
    }
}

2. Any configuration needs to be done in OnConnectedAsync?

[Authorize]
public class NotificationsHub : Hub<INotificationClient>
{
    public override Task OnConnectedAsync()
    {
        // any logic goes here? as this has access to Context.User.Identity ?

        return base.OnConnectedAsync();
    }
}

3. Sending the userid as message or input from my client?
4. Any other options ?

[davidfowl]

The question is more fundamental. Do you have a list of all users in your application somewhere? If not, doing this from a background service is never going to work as you need to query all users and send then messages based on their user id.

[fingers10]

@davidfowl Thank you for your time and support. Thank you for your patience. Here is my implementation.

Client Side:

private HubConnection? _hubConnection;
private readonly List<string> _notifications = new();

[Inject] IAccessTokenProvider TokenProvider { get; set; }

[Inject] IConfiguration Configuration { get; set; }

[CascadingParameter] private Task<AuthenticationState> authenticationStateTask { get; set; }

protected override async Task OnInitializedAsync()
{
    var authState = await authenticationStateTask;
    var user = authState.User;

    if (user.Identity.IsAuthenticated)
    {
        _hubConnection = new HubConnectionBuilder()
                        .WithUrl($"{Configuration.GetValue<string>("ApiBaseAddress")}notifications",
                        options =>
                        {
                            options.AccessTokenProvider = async () =>
                            {
                                var accessTokenResult = await TokenProvider.RequestAccessToken();
                                accessTokenResult.TryGetToken(out var token);
                                return token.Value;
                            };
                        })
                        .Build();

        _hubConnection.On<string>("ReceiveNotification", notification =>
        {
            _notifications.Add(notification);

            InvokeAsync(StateHasChanged);
        });

        await _hubConnection.StartAsync();
    }
}

I'm sending the auth token along with the connection.

Server Side:

Hub:

public class NotificationsHub(ConnectedUsers connectedUsers,
    ILogger<NotificationsHub> logger) : Hub<INotificationClient>
{
    public override async Task OnConnectedAsync()
    {
        //await Clients.Client(Context.ConnectionId).ReceiveNotification($"Connected {Context.User?.Identity?.Name}");

        var userToNotify = new
        {
            UserId = Guid.Parse(Context.User!.FindFirst("sub")!.Value),
            BranchId = Guid.Parse(Context.User!.FindFirst("branchId")!.Value)
        };

        await Groups.AddToGroupAsync(Context.ConnectionId, userToNotify.BranchId.ToString());

        connectedUsers.AddUser(userToNotify.UserId, userToNotify.BranchId);

        logger.LogInformation($"User {userToNotify.UserId} connected to branch {userToNotify.BranchId}");

        await base.OnConnectedAsync();
    }

    public override Task OnDisconnectedAsync(Exception? exception)
    {
        var userToNotify = new
        {
            UserId = Guid.Parse(Context.User!.FindFirst("sub")!.Value),
            BranchId = Guid.Parse(Context.User!.FindFirst("branchId")!.Value)
        };

        logger.LogInformation($"User {userToNotify.UserId} disconnected from branch {userToNotify.BranchId}");

        connectedUsers.RemoveUser(userToNotify.UserId);

        if (exception is not null) 
        {
            logger.LogError(exception, "An error occurred during disconnection.");
        }

        return base.OnDisconnectedAsync(exception);
    }
}

public interface INotificationClient
{
    Task ReceiveNotification(string message);
}

public class ConnectedUsers 
{
    public Dictionary<Guid,Guid> Users { get; private set; } = [];

    public void AddUser(Guid userId, Guid branchId)
    {
        Users.TryAdd(userId, branchId);
    }

    public void RemoveUser(Guid userId)
    {
        Users.Remove(userId);
    }
}

Program.cs:

...
builder.Services.AddSignalR();
builder.Services.AddHostedService<InventoryNotifierService>();
builder.Services.AddSingleton<ConnectedUsers>();
...
app.MapHub<NotificationsHub>("notifications");

BackgroundService:

public class InventoryNotifierService(
    IHubContext<NotificationsHub, INotificationClient> hubContext,
    IServiceProvider serviceProvider,
    ConnectedUsers connectedUsers,
    ILogger<InventoryNotifierService> logger) : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        try
        {
            using var timer = new PeriodicTimer(TimeSpan.FromSeconds(30));
            using var scope = serviceProvider.CreateScope();
            var isolatedReadContext = scope.ServiceProvider.GetRequiredService<AnyBillsBaseIsolatedReadContext>();

            while (!stoppingToken.IsCancellationRequested && await timer.WaitForNextTickAsync(stoppingToken))
            {
                var branches = connectedUsers.Users.Values.Distinct().ToList();

                var items = await isolatedReadContext
                        .Items
                        .Where(i => branches.Contains(i.BranchId) && i.Product && i.Quantity < 5)
                        .GroupBy(i => i.BranchId)
                        .ToListAsync();

                foreach (var branchItems in items)
                {
                    foreach (var item in branchItems)
                    {
                        await hubContext.Clients
                            .Group(branchItems.Key.ToString())
                            .ReceiveNotification($"You have {item.Name} {item.Quantity} in your inventory.");
                    }
                }
            }
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "Error while reading branch items for sending notifications.");
        }

        stoppingToken.Register(() => logger.LogWarning($"{nameof(InventoryNotifierService)} is stopping due to host shut down."));
    }
}

[fingers10]

Ah,

ConcurrentDictionary - lemme update and test again. Thanks for spotting this.

ConcurrentDictionary - How to increment and Decrement users? I suppose we should use override OnConnectedAsync to increment and override OnDisconnectedAsync to decrement ? Even in this case I noticed that whenever the user logs out OnDisconnectedAsync is not getting fired. Whats your thoughts on this? I'm calling Dispose inside my razor component as shown below.

public async ValueTask DisposeAsync()
{
    if (_hubConnection is not null)
    {
        await _hubConnection.DisposeAsync();
    }
}

In your InventoryNotifierService you're using a single DbContext for the entire background thread. That should be in the loop instead right? - its single DbContext.. I'm using shared DB for multi tenancy. So this is fine.

[davidfowl]

public class NotificationsHub(ActiveBranches branches,
    ILogger<NotificationsHub> logger) : Hub<INotificationClient>
{
    public override async Task OnConnectedAsync()
    {
        //await Clients.Client(Context.ConnectionId).ReceiveNotification($"Connected {Context.User?.Identity?.Name}");

        var userToNotify = new
        {
            UserId = Guid.Parse(Context.User!.FindFirst("sub")!.Value),
            BranchId = Guid.Parse(Context.User!.FindFirst("branchId")!.Value)
        };

        await Groups.AddToGroupAsync(Context.ConnectionId, userToNotify.BranchId.ToString());

        branches.Increment(userToNotify.BranchId);

        logger.LogInformation($"User {userToNotify.UserId} connected to branch {userToNotify.BranchId}");

        await base.OnConnectedAsync();
    }

    public override Task OnDisconnectedAsync(Exception? exception)
    {
        var userToNotify = new
        {
            UserId = Guid.Parse(Context.User!.FindFirst("sub")!.Value),
            BranchId = Guid.Parse(Context.User!.FindFirst("branchId")!.Value)
        };

        logger.LogInformation($"User {userToNotify.UserId} disconnected from branch {userToNotify.BranchId}");

        branches.Decrement(userToNotify.BranchId);

        if (exception is not null) 
        {
            logger.LogError(exception, "An error occurred during disconnection.");
        }

        return base.OnDisconnectedAsync(exception);
    }
}

[fingers10]

Many thanks for the support @davidfowl. I would like to be part of your network to learn and collaborate more. I need your help and approval in accepting my LinkedIn invite. It's pending for a long time. Please can you add me to your network? Again many thanks for the support and time.

[fingers10]

@davidfowl the following .Where(i => branches.IsActive(i.BranchId) && i.Product && i.Quantity < 5) filter will fail in LINQ translation as EF Core cannot do this.

So changing IsActive() to

public List<Guid> IsActive() =>
    BranchUserMappings.Where(x => x.Value > 0).Select(x => x.Key).ToList();

and then

var branches = connectedUsers.IsActive();

var items = await isolatedReadContext
        .Items
        .Where(i => branches.Contains(i.BranchId) && i.Product && i.Quantity < 5)
        .GroupBy(i => i.BranchId)
        .ToListAsync();

should do the trick

[fingers10]

@davidfowl I'm curious and love to be part of your network to learn more. I'm awaiting your acceptance of my invite in linkedin for a long time. Please can you add me to your network? This could help me a whole lot of opportunities to learn with you.