Capire HubConnection di SignalR da una prospettiva SignalNet .Net Client

Se posso sottolineare che non ho un problema con il codice né il requisito per la revisione del codice, quindi la pubblicazione qui.

In generale, sto cercando una migliore comprensione su come progettare veramente un progetto SignalR .Net Client per impedire la creazione di più HubConnections .

I / Abbiamo un prototipo in un ambiente di staging, che trasferisce con successo le informazioni di stampa dai centri di distribuzione remoti alla nostra app.

Ciò che veramente mi confonde è che sto creando un'istanza di HubConnection ogni volta che ho bisogno di inviare un messaggio a cui si accede direttamente sull'Hub, non su un endpoint di API.

Per favore, permettimi di dimostrare un codice, quindi il nostro sistema parla con un API bloccato, che poi parla con un hub ospitato altrove dove.

    [IdentityBasicAuthentication]
    [Authorize]
    [RoutePrefix("api/v1")]
    public class PrinterStatusV1Controller : ApiController
    {
        //logic removed
        private HubConnection _hubConnection;

        public PrinterStatusV1Controller()
        {   
            //logic removed
        }

        [HttpPost]
        [Route("dummy")]
        public async Task<IHttpActionResult> AddPrinterStatusAsync([FromBody]PrinterStatus printerStatus)
        {
            try
            {
                var identity = User.Identity as ClaimsIdentity;

                var identityInstance = new IdentityInstance(identity);
                if (identityInstance == null)
                    return StatusCode(HttpStatusCode.Forbidden);

                if (printerStatus == null)
                    return NotFound();

                IHubProxy aProxy = Create(dummy);

                if(printerProxy != null)
                    await printerProxy.Invoke("dummy", dummy);

                await _printerStatusRepo.Dummy(dummy);
                return Ok();
            }
            catch (System.Exception ex)
            {
                return InternalServerError();
            }
        }
        private IHubProxy Create(string dummy)
        {
            try
            {
                /logic removed
                _hubConnection = new HubConnection("dummy", dictionary);
                var hubProxy = _hubConnection.CreateHubProxy("dummy");
                _hubConnection.Start().Wait();

                _hubConnection.Closed += () => {
                    var connected = false;
                    while (!connected)
                    {
                        System.Threading.Thread.Sleep(2000);
                        _hubConnection = new HubConnection("dummy", dictionary);
                        hubProxy = _hubConnection.CreateHubProxy("dummy");
                        _hubConnection.Start().Wait();
                        connected = true;
                    }
                };

                return hubProxy;
            }
            catch
            {
                return null;
            }
        }
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (_hubConnection != null)
                {
                    _hubConnection.Stop();
                    _hubConnection.Dispose();
                }

                //logic removed
            }
            base.Dispose(disposing);
        }
    }
}

Dovrei arrivare al punto, qual è generalmente il miglior modello / architettura per evitare di creare un HubConnection , ogni volta che chiamo un endpoint? ogni suggerimento è molto apprezzato. Posso mettere in atto molte astrazioni, ma in teoria sto creando un'istanza di un nuovo HubConnection ogni volta.