When to use Observable.FromEventPattern and not Observable.FromEvent?

Question

We have a client who calls the TIBCO EMS queue and connects to the following events:

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); 

When I call response.Subscribe(...) , I get a System.ArgumentException "Target Method Error."

I can get it to work with Observable.FromEventPattern<EMSMessageEventArgs>(msgConsumer, "MessageHandler") , but then it received the event as a string and is simply not so clean.

Also I have IObservable<EventPattern<EMSMessageEventArgs>> , and not IObservable<EMSMessageEventArgs>

What I would like to understand: when should I use FromEvent over FromEventPattern ? This seems to be a bit of trial and error.

Answer 1

"Using FromEvent for events is structurally unlike a .NET event template (that is, not based on sender, args events) and using FromEventPattern for templates." - Bart De Smith (Rx Team)

Answer 2

To dwell on this in more detail, you can determine when to select one of FromEvent vs FromEventPattern according to the type of event used in the class that you are trying to observe. Use FromEventPattern when your event is of type EventHandler or generic EventHandler<T> . Use FromEvent when you use a custom, non-generic type of event handler. The following examples are taken directly from the Rx wiki , in which there are many good examples - 101 of them to be exact.

FromEventPattern (with a common EventHandler) :

 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

The new syntax seems to have changed a bit. The current syntax is as follows:

 // 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();