Hub Signalr (1.0.0-alpha2) - È possibile aggiungere funzioni client dopo l'avvio della connessione?

Question

Utilizzando Signalr (1.0.0-alpha2), voglio sapere se è possibile aggiungere funzioni client dopo l'avvio di una connessione.

Dire che creo la mia connessione e prendere il proxy. Quindi aggiungo alcune funzioni client Server Fired all'hub per fare alcune cose. Quindi inizio la mia connessione. Quindi desidero aggiungere altre funzioni Server Fired al mio oggetto hub. È possibile?

var myHub= $.connection.myHub; 
myHub.SomeClientFunction = function() { 
    alert("serverside called 'Clients.SomeClientFunction()'"); 
}; 
$.connection.hub.start() 
    .done(function() { 
     myHub.SomeNewClientFunction = function() { 
     alert("serverside called 'Clients.SomeNewClientFunction()'"); 
     } 
    }) 

Questo esempio non è realistico, ma io fondamentalmente voglio inviare il mio variabile 'MyHub' a un oggetto diverso dopo l'hub viene avviato di sottoscrivere nuovi eventi che il codice originale non importava per.

Esempio di vita reale: una dashboard con un numero di eventi hub diversi (nuove visite al sito, messaggio chat, errore del sito). I 'subscribe' dopo l'avvio della connessione e quindi passare il mio proxy hub a tutti i miei diversi componenti dell'interfaccia utente per gestire i loro 'tipi di messaggi' specifici. Dovrei creare hub separati per questi o dovrei essere in grado di aggiungere altre funzioni client di Server Fired al volo?

Answer 1

Sì, è possibile. Usa il metodo .on.

Esempio:

myHub.on('somethingNew', function() { 
    alert("This was called after the connection started!"); 
}); 

Se si desidera rimuovere in un secondo momento utilizzare il metodo .OFF.

Answer 2

Ho la stessa identica situazione. Potresti prendere in considerazione l'aggiunta di un altro layout di astrazione se stai provando a chiamarlo da più posti.

Ecco una versione preliminare di ciò che mi è venuto in mente (dattiloscritto).

Inizierò con l'utilizzo. SignalRManager è la mia classe 'manager' che astrae il mio hub debuggingHub. Ho un metodo client fooChanged attivato sul server.

Da qualche parte nel modulo che utilizza SignalR ho appena chiamato il metodo start, che non è riavviato se già avviato.

// ensure signalR is started 
SignalRManager.start().done(() => 
{ 
    $.connection.debuggingHub.server.init(); 
}); 

tuo 'modulo' registra semplicemente il suo richiamata attraverso la classe dirigente e ogni volta che viene attivato il metodo cliente SignalR vostro gestore è chiamato.

// handler for foo changed 
SignalRManager.onFooChanged((guid: string) => 
{ 
    if (this.currentSession().guid == guid) 
    { 
     alert('changed'); 
    } 
}); 

Questa è una semplice versione di SignalRManager che utilizza jQuery $.Callbacks di trasmettere la richiesta al maggior numero di moduli come si deve. Ovviamente potresti usare qualsiasi meccanismo tu voglia, ma questo sembra essere il più semplice.

module RR 
{ 
    export class SignalRManager 
    { 
     // the original promise returned when calling hub.Start 
     static _start: JQueryPromise<any>; 

     private static _fooChangedCallback = $.Callbacks(); 

     // add callback for 'fooChanged' callback 
     static onfooChanged(callback: (guid: string) => any) 
     { 
      SignalRManager._fooChangedCallback.add(callback); 
     } 

     static start(): JQueryPromise<any> 
     { 
      if (!SignalRManager._start) 
      { 
       // callback for fooChanged 
       $.connection.debuggingHub.client.fooChanged = (guid: string) => 
       { 
        console.log('foo Changed ' + guid); 
        SignalRManager._fooChangedCallback.fire.apply(arguments);      
       }; 

       // start hub and save the promise returned 
       SignalRManager._start = $.connection.hub.start().done(() => 
       { 
        console.log('Signal R initialized'); 
       }); 
      } 

      return SignalRManager._start; 
     } 
    } 
} 

Nota: potrebbe essere necessario un ulteriore lavoro per gestire disconnessioni o connessioni perse.