Problema: Ora, ho alcuni eventi che avverranno quando il client invia una richiesta al server. Questi eventi si verificheranno sul server e verranno sottoscritti dai servizi stessi (i servizi sul server interagiscono tra loro non attraverso un canale ma come oggetti semplici, ovvero istanziazione di una classe) che faranno del lavoro e restituiranno il risultato a client se necessario.
In the event aggregator pattern the subscribers and publishers are unaware of each other.
Ora stavo osservando le opzioni che ho per implementare questo problema e gli aggregatori di eventi hanno attirato la mia attenzione. Inoltre, voglio avere un modo per notificare più servizi quando si verifica un evento senza chiamarli esplicitamente.
Modifica
Esempio: Nella mia attuale configurazione dico che ho tre servizi X (editore), Y (sottoscrittore) e Z (sottoscrittore). Ho una richiesta in arrivo per il servizio Y prima di X. Dato che era un abbonato registrato (mi sono iscritto all'evento in ctor) viene istanziato e quindi è un abbonato live. Ora arriva una richiesta per X e viene istanziata e pubblica l'evento. Y è vivo per ascoltare e gestire l'evento. Ma , anche se Z era anche un abbonato ma non aveva alcuna istanza viva quando X ha pubblicato l'evento la chiamata non viene ascoltata. Per questo di seguito ho dato una possibile soluzione ma non so se è valida. Questo sta succedendo sul server.
Modifica 2:
// Service X and Service Y and Service Z are not linked through a channel
// All services are WCF services and client call them through a channel
public class ServiceX{
publi void DoSomeWork(){
MyEventAggregator<MyEvent>.Instance.Publish(Payload); //Some event is triggered and the subscribers will be notified
//if event aggregator is not used normal call would go like
ServiceY obj=new SerivceY(); // no channel creation
obj.CallSomeMethod(Payload);
}
}
public class ServiceY(){
public ServiceY(){
//subscribers register for event
MyEventAggregator<MyEvent>.Instance.Subscribe(MyHandler,true); //true is a flag that keeps subscriber ref alive
}
MyHandler(dynamic obj){
//Do work
}
}
public class ServiceZ{
public ServiceZ(){
//subscribers register for event
MyEventAggregator<MyEvent>.Instance.Subscribe(MyHandlerZ,true); //true is a flag that keeps subscriber ref alive
}
MyHandlerZ(dynamic obj){
//Do work
}
}
public class MyEvent:PubSubEvents<dynamic>{
//from prism library
//My Event
}
public class MyEventAggregator{
//implements singleton that returns the event aggregator instance.
}
//By using event aggregators the there can be multiple subscribers to an event without them knowing about each other
Soluzione possibile: Potrei usare gli Aggregator di eventi di Prism per pubblicare e sottoscrivere gli eventi ma questo di per sé darà luogo a un problema, ad esempio se avrò i miei iscritti registrati funzioneranno solo se vengono istanziati prima che l'evento venga attivato (pubblicato).
So now I will have to make sure that my subscribers are alive when the event is published which could be handled with an infrastructure module together with the unity application block(don't know if it will be required though) that deals with subscriptions though instantiating a ton of objects will have its overhead
Ora quello che volevo sapere è che sto pensando nella giusta direzione perché non ho visto molte persone che usano gli aggregatori di eventi Prism e WCF insieme (il prisma è per lo più considerato come un framework lato client per quanto ne so) .
Modifica 3:
Codice soluzione (per istanziare il sottoscrittore prima del publisher): Potrei usare l'unità per risolvere questa dipendenza dire nel metodo application_start del file global.asax.cs potrei fare qualcosa di simile:
IUnityContainer uContainer = new UnityContainer()
.RegisterType<ISubscriber, ServiceY>("Abc")
.RegisterType<ISubscriber, ServiceZ>("Xyz");
ISubscriber myInstance = uContainer.Resolve<ISubscriber>("Abc");
ISubscriber myInstance = uContainer.Resolve<ISubscriber>("Xyz");
dove tutti gli abbonati si estenderanno e l'interfaccia ISubscriber come:
ServiceY:ISubscriber{}
Ciò assicurerebbe che l'istanza dell'abbonato sia attiva quando viene pubblicato un evento.
Come andresti a gestire gli eventi in WCF?
Ci sono altre opzioni che ho ??