SignalR Programming in Microsoft ASP.NET

public class VisitorsCountConnection: PersistentConnection
{
    private static int connections = 0;
    protected override Task OnConnected(IRequest request, string connectionId)
    {
        Interlocked.Increment(ref connections);
        return base.OnConnected(request, connectionId);


        // Or notify all connected clients using Broadcast()
        // return this.Connection.Broadcast('New connection: ' + connectionId);

        // Or only notify the connecting client using Send()
        // return this.Connection.Send(connectionId, 'Welcome');
    }

    // Use async and await on any of the PersistentConnection methods if you need to 
    // to handle a long running task
    protected override async Task OnReceived(IRequest request, string connectionId, string clientData)
    {
        // Convert clientData string into a type
        var message = JsonConvert.DeserializeObject<ClientMessage>(clientData);

        await this.Connection.Send(connectionId, "Process starting");
    }

    protected override Task OnDisconnected(IRequest request, string connectionId)
    {
        Interlocked.Decrement(ref connections);
        return base.OnDisconnected(request, connectionId);
    }


    // Other methods can be found on this link such as the 2 in comment
    // https://msdn.microsoft.com/en-us/library/microsoft.aspnet.signalr.persistentconnection_methods(v=vs.118).aspx
    // protected override Task OnReconnected
    // protected override Task OnRejoiningGroups
}

public class StartUp
{
    public void Configuration(IAppBuilder app)
    {
        // Use GlobalHost for SignalR configuration
        // https://msdn.microsoft.com/en-us/library/microsoft.aspnet.signalr.globalhost(v=vs.118).aspx
        Microsoft.AspNet.SignalR.GlobalHost
                .Configuration.DisconnectTimeout = TimeSpan.FromSeconds(30);


        // where MyConnection inherits from PersistentConnection
        app.MapSignalR<MyConnection>("/my/path");

        // For older browsers with no JSON support, enable JSONP
        // var config = new ConnectionConfiguration(){EnableJSONP = true};
        // app.MapSignalR<MyConnection>("/my/path", config);

        /*
            // Enabling CORS
            // Microsoft.Owin.Cors must be referenced in the project 
            // and namespaced in the Startup.cs file 
            app.Map("/my/path",
                map =>
                {
                    map.UseCors(CorsOptions.AllowAll);
                    map.RunSignalR<MyConnection>();  // same as MapSignalR(...)
                }
            );
        /*
    }
}

protected override Task OnReceived(IRequest request, string connectionId, string data)
{
    // data argument structure will vary by implementation
    var args = data.Split(new[] {" "}, StringSplitOptions.RemoveEmptyEntries);
    if(args.Length == 2 && args[0].ToLower()=="GROUPKEY")
    {
        return this.Groups.Add(connectionId, args[1]);
    }
}

var connection = $.connection('/my/path');

// Enable console logging
connection.logging = true;

// start() is asynchronous
connection.start()
    .done(function () { })
    .fail(function () { });

// Sending data to the SignalR Server
$('#someButton').click(function () {
    // This will be submitted to OnReceived method
    connection.send({ key: "value" });
});

// Receiving data from the SignalR Server
connection.received(function (msg) {
    // This will be called after a
    // SignalR Server Broadcast() or Send()
    $('body').append(msg + '<br />');
});

// Other client events
// https://docs.microsoft.com/en-us/aspnet/signalr/overview/guide-to-the-api/hubs-api-guide-javascript-client#connectionlifetime

// Use this attribute to override the class name of the hub
[HubName("HubNameOverride")]
public class MyHub : Hub
{
   // Use this attribute to change the method name
   // the client will use
   [HubMethodName("method1")]
   public void MyMethod(string name)
   {
       // Hub through HubBase has a Context property that will
       // give you access to properties related to the clients request
       string connectingUser = Context.User.Identity.Name;

       // Hub object has a Clients property you can use to
       // reference clients connecting to the SignalR server.
       // Note that Clients is dynamic type where myArbitraryMethod
       // is the client function to invoke      
       Clients.All.myArbitraryMethod(name, "Welcome " + connectingUser);
   }

   // Type-checking between client and server is done for you by the library.
   // Overloads are acceptable but note that methods with different signatures
   // will cause ambiguity because the library only uses the number of
   // method arguments when mapping the client request.
   public void MyMethod(string name, int args2)
   {
       // Example of passing state from the client
       // Client.js: hub.state.EmployeeName = 'John Doe'
       Clients.Caller.handleResponse(string.Format("Hello {0}", Clients.Caller.EmployeeName));
   }

   // Async-await is supported
   public async Task<int> Foo()
   {
       return await Something();
   }

   private Task<int> Something()
   {
       throw new NotImplementedException();
   }
}

public class Startup
{
    public void Configuration(IAppBuilder app)
    {
        // You can mix persistent connections with hubs
        // app.MapSignalR<MyPersistentConnection>('/myconnection');

        // Map Hub Connection

        // This maps your hub to the /signalr path by default
        app.MapSignalR();

        // Use the overload constructor if you want to use a different path
        // app.MapSignalR("/mypath", new HubConfiguration(){
              // Specifies whether you want an automated generation of the
              // client javascript proxy to the hub
              // EnableJavaScriptProxies = true; // default
        // });
    }
}

// Note that the client uses camel-casing while the server uses Pascal

// To enable console logging in the client
$.connection.hub.logging = true;

// reference your hub name from the `connection` object
var myHub = $.connection.hubNameOverride;

// Establish your connection
$.connection.hub.start()
   .done(function () {
       // You can invoke any SignalR server method
       // through the `server` object
       document.getElementById("test").click = function () {
           myHub.server.myMethod("John Doe");
       };
   })
   .fail(function (e) { console.log(e); });


// This is the client script that gets executed after the method
// MyHub.MyMethod() function is called on the SignalR Hub
myHub.client.myArbitraryMethod = function (message) {
   console.log(message);
}

var connection = $.hubConnection();

connection.logging = true;

var myHub = connection.createHubProxy('hubNameOverride');

$.connection.start()
   .done(function () {
       document.getElementById('test').click = function () {
           // client calling a server method
           myHub.invoke('myMethod', 'John Doe');
       };
   })
   .fail(function (e) { console.log(e); });

// server will call this client method
myHub.on('myArbitraryMethod', function (message) {
   console.log(message);
});