[Issue] Benchmarking - Concurrent client messages about signalr

[BrennanConroy]

Yeah, I have a different workaround for you:

public class MyHub : Hub
{
    private readonly IHubContext<MyHub> _context;
    public MyHub(IHubContext<MyHub> context)
    {
        // capture an IHubContext<> that isn't tied to the Hub lifetime
        _context = context;
    }

    public Task SendMessage(string message)
    {
        // Capture the connectionId of the client so we can use Clients.Caller from outside the Hub
        var connectionId = Context.ConnectionId;
        Task.Run(async () =>
        {
            await Task.Delay(5000);
            // The IHubContext<THub> doesn't have Clients.Caller because it isn't associated with a connection
            // So we use Clients.Client(connectionId) to do the exact same thing
            await _context.Clients.Client(connectionId).SendAsync("Send", "testing");
        });

        return Task.CompletedTask;
    }

[saibaskaran57]

Hi @BrennanConroy ,

Thanks for your assistance.

I have tried the workaround and it's working great.

Hopefully, it will get considered to have it supported on SignalR instead.

[muratg]

This is by design in current release.

We'll consider https://github.com/aspnet/SignalR/issues/3133 in 3.0.

[muratg]

@BrennanConroy could you add the workaround here?

[BrennanConroy]

You can achieve long running tasks by using the IHubContext<Hub> class. See https://docs.microsoft.com/en-us/aspnet/core/signalr/hubcontext?view=aspnetcore-2.2 for some reference on the usage.

[saibaskaran57]

Thanks for the confirmation.

As mentioned by @BrennanConroy, the workaround is to send via Middleware, Controllers. Our clients would be expected to use SignalR Hub to stream down their messages.

I have a thought in mind as below:

Assume the long-running task which is a service call(can be in milliseconds/seconds) and can be concurrent messages sent in.

Does the below workaround recommended to be applied since Websocket is Full-duplex?

Server-side code :

public Task SendMessage(string message)
{
      this.HandleMessageAsync(message).ConfigureAwait(false);

      return Task.CompletedTask;
}

private async Task HandleMessageAsync(string message)
{
     await Task.Delay(5000); // to simulate long running tasks(e.g. service/database calls/processing)
     await Clients.Caller.SendAsync("ReceiveMessage", message);
}

The above does not block each message and can be sent concurrently.

Please give a shout-out, if this is a terrible idea.

[BrennanConroy]

Client-side code :

I'm assuming that is still server side code, and you just meant it is the code that communicates with the client.

That approach would most likely fail because you are possibly using properties of the Hub class after the Hub method has exited and the Hub will be disposed of after each method call.

[saibaskaran57]

@BrennanConroy

Yes, you are right. That is still the server side code. Corrected the comment.

The current design seems to be a show-stopper for our use case. Are there any other workaround on this?

[saibaskaran57]

Thanks for your quick response & workaround. I'll give it a try and let you know how that went.

[samcov]

Very good information guys... Thanks!