Why is the hub context connection ID inaccessible at runtime in my VERY simple method?

Question

Let me start by saying this all works perfectly at the moment except for one thing - the notification update for the progress bar goes to all clients (as you would expect given that the code example I used sends to ...Clients.All).

All I want to do is send the notification back to the client that initiated the current call to the hub. That's it, nothing else. There is no concept of "logging in" on this website so there's no user identity stuff to work with.

My method is:

public void NotifyUpdates(decimal val)
{
    var hubContext = GlobalHost.ConnectionManager.GetHubContext<EventsForceHub>();

    if (hubContext != null)
    {
        //"updateProgress" is javascript event trigger name
        await hubContext.Clients.All.updateProgress(val); 
    }
}

So back in my view I subscribe to "updateProgress" and it works fine - the progress bar updates as desired. But if another client happens to be connected to the hub, when one runs the async task and causes the NotifyUpdates method to run, then ALL connected clients see the taskbar update, which is a bit confusing for them!

In debug, if I inspect hubContext at runtime I can see a Clients property and that has a Connection property which has an Identity property with a unique GUID. Perfect! Just what I want to use. But... I cannot access it! If I try:

var currentConnection = hubContext.Clients.Connection;

...then I simply get a

"does not contain a definition for 'Connection'"

error, which I simply don't understand.

I've tried accessing Context.ConnectionId from the method too, but Context is null at that point so I'm a bit confused. The server method that uses NotifyUpdates to send information back to the client is called via a normal asp.net button, not via AJAX.

Clarification on structure

I think there is a degree of confusion here. It's a very simply webpage with an asp.net button control on it. The eventhandler for that button invokes an async method to return data from the server via a service call/repository.

Inside the async method, it has to process each returned data line and make three or four remote web api calls. On each loop I make a call back to the NotifyUpdates SignalR method shown above with a percentage complete number so this can update back to the client via an eventhandler for the method name specified (updateProgress as shown above). There could be dozens of data lines and each data line requires several Web API calls to a remote server to add data. This can take several seconds per iteration, hence me sending back the "update progress" to the client via that updateProgress method call.

Answer 1

NEW ANSWER

Based on your comments I made the following little test:

It will allow clients to connect to the hub with a clientName, and every client is listening to updates send to them. We will have a group defined for them to be able to notify them from the server side.

I made a dummy progress simulator class to throw some update values to the users.

The code:

Hub class:

public class EventsForceHub : Hub {
    public static IHubContext hubContext = GlobalHost.ConnectionManager.GetHubContext<EventsForceHub>();

    // allow users to join to hub and get s dedicated group/channel for them, so we can update them
    public async Task JoinGroup(string clientName) {
        string clientID = Context.ConnectionId;
        ClientInfo.clients.Add(clientID, new MyAppClient(clientID, clientName));
        await Groups.Add(clientID, clientName);

        // this is just mockup to simulate progress events (this uis not needed in real application)
        MockupProgressGenerator.DoJob(clientName, 0);
    }

    public static void NotifyUpdates(decimal val, string clientName) {
        // update the given client on his group/channel
        hubContext.Clients.Group(clientName).updateProgress(val);
    }
}

Some little helper classes:

// client "storage"
public static class ClientInfo  {
    public static Dictionary<string, MyAppClient> clients = new Dictionary<string, MyAppClient>();
    // .. further data and methods
}

// client type
public class MyAppClient {
    public string Id { get; set; }
    public string Name { get; set; }
    // .. further prooerties and methods

    public MyAppClient(string id, string name) {
        Id = id;
        Name = name;
    }
}

// this a completely made up and dumb class to simulate slow process and give some simple progress events
public static class MockupProgressGenerator {
    public static void DoJob(string clientName, int status) {
        if (status < 100) {
            Task.Delay(1000).ContinueWith(a =>
            {
                EventsForceHub.NotifyUpdates(status += 20, clientName);
                DoJob(clientName, status);
            });
        }
    }
}

Let's see two simple clients in JS:

    $(function () {
        var eventsForceHub = $.connection.eventsForceHub;

        $.connection.hub.start().done(function () {
            $('body').append("Joining with Name: Jerry");
            eventsForceHub.server.joinGroup("Jerry");
        });

        eventsForceHub.client.updateProgress = function (val) {
            // message received
            $('body').append('<br>').append("New Progress message: " + val);
        };
    });

For simplicity, same code, with different params, I even put this in two different html pages and stated execution in slightly different timing.

    $(function () {
        var eventsForceHub = $.connection.eventsForceHub;

        $.connection.hub.start().done(function () {
            $('body').append("Joining with Name: Tom");
            eventsForceHub.server.joinGroup("Tom");
        });

        eventsForceHub.client.updateProgress = function (val) {
            // message received
            $('body').append('<br>').append("New Progress message: " + val);
        };
    });

See it in action:

---

FIRST ANSWER

I made a small web application to verify your claim. You may create the following to be able to isolate the issue from other possible problems.

I created an empty Web Application and included SignalR.

This is the hub class:

public class EventsForceHub : Hub {
    public void NotifyUpdates(decimal val) {
        var hubContext = GlobalHost.ConnectionManager.GetHubContext<EventsForceHub>();

        if (Context != null) {
            string clientID = Context.ConnectionId;         // <-- on debug: Ok has conn id.
            object caller = Clients.Caller;                 // <-- on debug: Ok, not null
            object caller2 = Clients.Client(clientID);      // <-- on debug: Ok, not null
            Clients.Caller.updateProgress(val);             // Message sent
            Clients.Client(clientID).updateProgress(val);   // Message sent
        }

        if (hubContext != null) {
            //"updateProgress" is javascript event trigger name
            hubContext.Clients.All.updateProgress(val);     // Message sent
        }
    }
}

This is the web page:

<script src="Scripts/jquery-1.10.2.min.js"></script>
<script src="Scripts/jquery.signalR-2.2.2.min.js"></script>
<script src="signalr/hubs"></script>
<script type="text/javascript">
    $(function () {
        var eventsForceHub = $.connection.eventsForceHub;

        $.connection.hub.start().done(function () {
            // send mock message on start
            console.log("Sending mock message: " + 42);
            eventsForceHub.server.notifyUpdates(42);
        });

        eventsForceHub.client.updateProgress = function (val) {
            // message received
            console.log("New Progress message: " + val);
        };
    });
</script>

Try to build an application as little as this to isolate the issue. I have not had any of the issues you mentioned.

For the sake of simplicity and using the debugger I took away the await and async.

Actually, SignalR will take care of that for you. You will get a new instance of your Hub class at every request, no need to force asynchrony into the methods.

Also, GlobalHost is defined as static which should be shared between instances of your Hub class. Using in an instance method does not seem like a very good idea. I think you want to use the Context and the Clients objects instead. However, while debugging we can verify that using GlobalHost also works.

Some debugger screenshots showing runtime values of callerId, Clients.Caller and Clients.Client(clientID):

Understanding SignalR better will help you a lot in achieving your goal.

Happy debugging!

Answer 2

If you want to send the notification back to the client you should not call

hubContext.Clients.All.updateProgress(val);

instead try

accessing the current user's ConnectionId and use Clients.Client

hubContext.Clients.Client(Context.ConnectionId);