global object that needs to be referenced in a message handler

Question

I have a signalr client that I want to be global.

I think creating the signalr client in the Init() of the endpointconfig would be best.

public class EndpointConfig : IConfigureThisEndpoint, AsA_Server, IWantCustomInitialization
{
    public static HubConnection hubConnection;
    public static IHubProxy hubProxy;

    public void Init()
    {
        Configure.With()
            .DefiningEventsAs(t => t.Namespace != null && t.Namespace.Contains(".Events."))
            .DefiningMessagesAs(t => t.Namespace != null && t.Namespace.Contains(".Messages."))
            .StructureMapBuilder(new Container(new DependencyRegistry()));

        Configure.Serialization.Json();

        hubConnection = new HubConnection("http://localhost:58120"); 
        hubProxy = hubConnection.CreateHubProxy("AmsHub");
        hubProxy.On<string>("receiveServerPush", x => System.Diagnostics.Debug.WriteLine(x));
        hubConnection.Start().Wait();
    }

    public class DependencyRegistry : Registry
    {
        public DependencyRegistry()
        {
            Scan(x =>
            {
                x.AssembliesFromApplicationBaseDirectory();
                x.ExcludeNamespace("StructureMap");
                x.WithDefaultConventions();
            });
        }
    }
}

What I'm confused about, is how am I supposed to reference the hubConnection and hubProxy in a message handler? I seems like I'm jerry rigging NServicebus.

public class TestHandler : IHandleMessages<AMS.Infrastructure.Events.IEvent>
{
    public void Handle(AMS.Infrastructure.Events.IEvent message)
    {
        EndpointConfig.hubProxy.Invoke("ServerFunction", "yodle");
    }
}

PS: the reason I need the connection and proxy to be global is because spawning up a new hubConnection is expensive according to the signalr people. They highly discourage creating and destroying hubconnections over and over again. They found that making the hubconnection global/static(?) ok though.

Answer 1

In this case, your Hub Connection/Proxy really are unrelated to the EndPointConfiguration class. They don't use nor require any data from this type in order to function.

I would recommend placing them in their own lazy initialized singleton, and start them automatically upon first access. This would look like:

public class Hub
{
    private static Lazy<Hub> instance = new Lazy<Hub>(() => new Hub());

    public static Hub Instance { get { return instance.Value; } }

    private Hub()
    {
        this.Connection = new HubConnection("http://localhost:58120"); 
        this.Proxy = Connection.CreateHubProxy("AmsHub");
        this.Proxy.On<string>("receiveServerPush", x => System.Diagnostics.Debug.WriteLine(x));
        this.Connection.Start().Wait(); 
    }

    public HubConnection Connection { get; private set; }
    public IHubProxy Proxy { get; private set; }
}

Your consumers then just use:

public class TestHandler : IHandleMessages<AMS.Infrastructure.Events.IEvent>
{
    public void Handle(AMS.Infrastructure.Events.IEvent message)
    {
        Hub.Instance.Proxy.Invoke("ServerFunction", "yodle");
    }
}

This has the benefit of not creating and starting until first use, and isolates this type into it's own class.

Given that you're also handling the subscription internally, you also could, optionally, encapsulate your methods to simplify usage:

public class Hub
{
    private static Lazy<Hub> instance = new Lazy<Hub>(() => new Hub());

    public static Hub Instance { get { return instance.Value; } }

    private Hub()
    {
        this.Connection = new HubConnection("http://localhost:58120"); 
        this.Proxy = Connection.CreateHubProxy("AmsHub");
        this.Proxy.On<string>("receiveServerPush", x => System.Diagnostics.Debug.WriteLine(x));
        this.Connection.Start().Wait(); 
    }

    private HubConnection Connection { get; set; }
    private IHubProxy Proxy { get; set; }

            public static Task Invoke(string method, params Object[] args)
            {
                 return Instance.Proxy.Invoke(method, args);
            }

            public static Task<T> Invoke<T>(string method, params Object[] args)
            {
                 return Instance.Proxy.Invoke<T>(method, args);
            }
}

With the above, you could just use: Hub.Invoke("ServerFunction", "yodle");