Cuándo utilizar Observable.FromEventPattern en lugar de Observable.FromEvent?

Question

Tenemos un cliente que llama a una cola de TIBCO EMS y están cableando los eventos como este:

var msgConsumer = _session.CreateConsumer(responseQueue); 
var response = Observable.FromEvent<EMSMessageHandler,EMSMessageEventArgs> 
      (h => msgConsumer.MessageHandler += h, h => msgConsumer.MessageHandler -= h) 
      .Where(arg => arg.Message.CorrelationID == message.MessageID); 

Cuando llamo response.Subscribe(...) me sale System.ArgumentException "error de unirse a secuencias diana método."

Puedo hacer que funcione con Observable.FromEventPattern<EMSMessageEventArgs>(msgConsumer, "MessageHandler") pero luego tiene el evento como una cadena y no tan limpio.

También he IObservable<EventPattern<EMSMessageEventArgs>> en lugar de IObservable<EMSMessageEventArgs>

Lo que me gustaría que entender es: ¿cuándo debo usar FromEvent sobre FromEventPattern? Parece un poco de prueba y error.

Answer 1

"Usar FromEvent para eventos estructuralmente no se ve como un patrón de evento .NET (es decir, no se basa en remitente, eventos args), y usa FromEventPattern para los basados ​​en patrones." - Bart De Smet (Rx team)

Answer 2

Para más detalles sobre esto un poco más lejos, normalmente se puede determinar cuándo se debe elegir uno de los FromEvent vs FromEventPattern por el tipo de evento se utiliza en la clase que usted está tratando de observar. Use FromEventPattern cuando su evento sea del tipo EventHandler o el genérico EventHandler<T>. Use FromEvent cuando esté usando un tipo de controlador de eventos personalizado y no genérico. Los siguientes ejemplos se han eliminado directamente del Rx wiki, que tiene muchos buenos ejemplos: 101 of them para ser exactos.

FromEventPattern (con manejador de sucesos genérico) :

class ObserveEvent_Generic 
{ 
    public class SomeEventArgs : EventArgs { } 
    public static event EventHandler<SomeEventArgs> GenericEvent; 

    static void Main() 
    { 
     // To consume GenericEvent as an IObservable: 
     IObservable<EventPattern<SomeEventArgs>> eventAsObservable = Observable.FromEventPattern<SomeEventArgs>(
      ev => GenericEvent += ev, 
      ev => GenericEvent -= ev); 
    } 
} 

FromEvent:

class ObserveEvent_NonGeneric 
{ 
    public class SomeEventArgs : EventArgs { } 
    public delegate void SomeNonGenericEventHandler(object sender, SomeEventArgs e); 
    public static event SomeNonGenericEventHandler NonGenericEvent; 

    static void Main() 
    { 
     // To consume NonGenericEvent as an IObservable, first inspect the type of EventArgs used in the second parameter of the delegate. 
     // In this case, it is SomeEventArgs. Then, use as shown below. 
     IObservable<IEvent<SomeEventArgs>> eventAsObservable = Observable.FromEvent(
      (EventHandler<SomeEventArgs> ev) => new SomeNonGenericEventHandler(ev), 
      ev => NonGenericEvent += ev, 
      ev => NonGenericEvent -= ev); 
    } 
} 

Answer 3

Al parecer, la nueva sintaxis ha cambiado un poco. La sintaxis actual es la siguiente:

// get events as observable 
var events = Observable.FromEvent<MouseButtonEventHandler, MouseEventArgs>(
    handler => MouseUp += handler, handler => MouseUp -= handler); 

// subscribe to events 
var subscription = events.Subscribe(args => OnMouseUp())); 

// always dispose subscriptions! 
subscription.Dispose();