},System.Linq.Expressions.Expression{System.Action{System.EventHandler}})} },System.Linq.Expressions.Expression{System.Action{System.EventHandler}},System.Reactive.Concurrency.IScheduler)} },System.Linq.Expressions.Expression{System.Action{--0}})} },System.Linq.Expressions.Expression{System.Action{--0}},System.Reactive.Concurrency.IScheduler)} ,--0}},System.Linq.Expressions.Expression{System.Action{--0}},System.Linq.Expressions.Expression{System.Action{--0}})} ,--0}},System.Linq.Expressions.Expression{System.Action{--0}},System.Linq.Expressions.Expression{System.Action{--0}},System.Reactive.Concurrency.IScheduler)} },System.Linq.Expressions.Expression{System.Action{--0}})} },System.Linq.Expressions.Expression{System.Action{--0}},System.Reactive.Concurrency.IScheduler)} }},System.Linq.Expressions.Expression{System.Action{System.EventHandler{--0}}})} }},System.Linq.Expressions.Expression{System.Action{System.EventHandler{--0}}},System.Reactive.Concurrency.IScheduler)}

Qbservable.FromEventPattern(IQbservableProvider, Expression>, Expression>) method¶

Overloads¶

• 1. public static IQbservable<EventPattern<object>> FromEventPattern(this IQbservableProvider provider, Expression<Action<EventHandler>> addHandler, Expression<Action<EventHandler>> removeHandler)
• 2. public static IQbservable<EventPattern<object>> FromEventPattern(this IQbservableProvider provider, Expression<Action<EventHandler>> addHandler, Expression<Action<EventHandler>> removeHandler, IScheduler scheduler)
• 3. public static IQbservable<EventPattern<object>> FromEventPattern(this IQbservableProvider provider, object target, string eventName)
• 4. public static IQbservable<EventPattern<object>> FromEventPattern(this IQbservableProvider provider, object target, string eventName, IScheduler scheduler)
• 5. public static IQbservable<EventPattern<object>> FromEventPattern(this IQbservableProvider provider, Type type, string eventName)
• 6. public static IQbservable<EventPattern<object>> FromEventPattern(this IQbservableProvider provider, Type type, string eventName, IScheduler scheduler)
• 7. public static IQbservable<EventPattern<TEventArgs>> FromEventPattern<TDelegate, TEventArgs>(this IQbservableProvider provider, Expression<Action<TDelegate>> addHandler, Expression<Action<TDelegate>> removeHandler)
• 8. public static IQbservable<EventPattern<TEventArgs>> FromEventPattern<TDelegate, TEventArgs>(this IQbservableProvider provider, Expression<Action<TDelegate>> addHandler, Expression<Action<TDelegate>> removeHandler, IScheduler scheduler)
• 9. public static IQbservable<EventPattern<TEventArgs>> FromEventPattern<TDelegate, TEventArgs>(this IQbservableProvider provider, Expression<Func<EventHandler<TEventArgs>, TDelegate>> conversion, Expression<Action<TDelegate>> addHandler, Expression<Action<TDelegate>> removeHandler)
• 10. public static IQbservable<EventPattern<TEventArgs>> FromEventPattern<TDelegate, TEventArgs>(this IQbservableProvider provider, Expression<Func<EventHandler<TEventArgs>, TDelegate>> conversion, Expression<Action<TDelegate>> addHandler, Expression<Action<TDelegate>> removeHandler, IScheduler scheduler)
• 11. public static IQbservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TDelegate, TSender, TEventArgs>(this IQbservableProvider provider, Expression<Action<TDelegate>> addHandler, Expression<Action<TDelegate>> removeHandler)
• 12. public static IQbservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TDelegate, TSender, TEventArgs>(this IQbservableProvider provider, Expression<Action<TDelegate>> addHandler, Expression<Action<TDelegate>> removeHandler, IScheduler scheduler)
• 13. public static IQbservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(this IQbservableProvider provider, Expression<Action<EventHandler<TEventArgs>>> addHandler, Expression<Action<EventHandler<TEventArgs>>> removeHandler)
• 14. public static IQbservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(this IQbservableProvider provider, Expression<Action<EventHandler<TEventArgs>>> addHandler, Expression<Action<EventHandler<TEventArgs>>> removeHandler, IScheduler scheduler)
• 15. public static IQbservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(this IQbservableProvider provider, object target, string eventName)
• 16. public static IQbservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(this IQbservableProvider provider, object target, string eventName, IScheduler scheduler)
• 17. public static IQbservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(this IQbservableProvider provider, Type type, string eventName)
• 18. public static IQbservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(this IQbservableProvider provider, Type type, string eventName, IScheduler scheduler)
• 19. public static IQbservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TSender, TEventArgs>(this IQbservableProvider provider, object target, string eventName)
• 20. public static IQbservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TSender, TEventArgs>(this IQbservableProvider provider, object target, string eventName, IScheduler scheduler)
• 21. public static IQbservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TSender, TEventArgs>(this IQbservableProvider provider, Type type, string eventName)
• 22. public static IQbservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TSender, TEventArgs>(this IQbservableProvider provider, Type type, string eventName, IScheduler scheduler)

1. Overload¶

public static IQbservable<EventPattern<object>> FromEventPattern(this IQbservableProvider provider, Expression<Action<EventHandler>> addHandler, Expression<Action<EventHandler>> removeHandler)

Summary: Converts a .NET event, conforming to the standard .NET event pattern based on EventHandler, to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.

Parameters

Returns: IQbservable> -- The observable sequence that contains data representations of invocations of the underlying .NET event.

Remarks

Add and remove handler invocations are made whenever the number of observers grows beyond zero. As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.

The current SynchronizationContext is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.

If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread making the Subscribe or Dispose call, respectively.

It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions more concise and easier to understand.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEventPattern1(System.IObservable{System.Reactive.EventPattern{0}})

2. Overload¶

public static IQbservable<EventPattern<object>> FromEventPattern(this IQbservableProvider provider, Expression<Action<EventHandler>> addHandler, Expression<Action<EventHandler>> removeHandler, IScheduler scheduler)

Summary: Converts a .NET event, conforming to the standard .NET event pattern based on EventHandler, to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.

Parameters

Returns: IQbservable> -- The observable sequence that contains data representations of invocations of the underlying .NET event.

Remarks

Add and remove handler invocations are made whenever the number of observers grows beyond zero. As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.

Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be accessed from the same context, as required by some UI frameworks.

It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler parameter. For more information, see the remarks section on those overloads.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEventPattern1(System.IObservable{System.Reactive.EventPattern{0}})

3. Overload¶

public static IQbservable<EventPattern<object>> FromEventPattern(this IQbservableProvider provider, object target, string eventName)

Summary: Converts an instance .NET event, conforming to the standard .NET event pattern with an EventArgs parameter, to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. Reflection is used to discover the event based on the target object type and the specified event name. For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.

Parameters

Returns: IQbservable> -- The observable sequence that contains data representations of invocations of the underlying .NET event.

Remarks

Add and remove handler invocations are made whenever the number of observers grows beyond zero. As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.

The current SynchronizationContext is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.

If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread making the Subscribe or Dispose call, respectively.

It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions more concise and easier to understand.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEventPattern1(System.IObservable{System.Reactive.EventPattern{0}})

4. Overload¶

public static IQbservable<EventPattern<object>> FromEventPattern(this IQbservableProvider provider, object target, string eventName, IScheduler scheduler)

Summary: Converts an instance .NET event, conforming to the standard .NET event pattern with an EventArgs parameter, to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. Reflection is used to discover the event based on the target object type and the specified event name. For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.

Parameters

Returns: IQbservable> -- The observable sequence that contains data representations of invocations of the underlying .NET event.

Remarks

Add and remove handler invocations are made whenever the number of observers grows beyond zero. As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.

Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be accessed from the same context, as required by some UI frameworks.

It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler parameter. For more information, see the remarks section on those overloads.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEventPattern1(System.IObservable{System.Reactive.EventPattern{0}})

5. Overload¶

public static IQbservable<EventPattern<object>> FromEventPattern(this IQbservableProvider provider, Type type, string eventName)

Summary: Converts a static .NET event, conforming to the standard .NET event pattern with an EventArgs parameter, to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. Reflection is used to discover the event based on the specified type and the specified event name. For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.

Parameters

Returns: IQbservable> -- The observable sequence that contains data representations of invocations of the underlying .NET event.

Remarks

Add and remove handler invocations are made whenever the number of observers grows beyond zero. As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.

The current SynchronizationContext is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.

If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread making the Subscribe or Dispose call, respectively.

It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions more concise and easier to understand.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEventPattern1(System.IObservable{System.Reactive.EventPattern{0}})

6. Overload¶

public static IQbservable<EventPattern<object>> FromEventPattern(this IQbservableProvider provider, Type type, string eventName, IScheduler scheduler)

Summary: Converts a static .NET event, conforming to the standard .NET event pattern with an EventArgs parameter, to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. Reflection is used to discover the event based on the specified type and the specified event name. For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.

Parameters

Returns: IQbservable> -- The observable sequence that contains data representations of invocations of the underlying .NET event.

Remarks

Add and remove handler invocations are made whenever the number of observers grows beyond zero. As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.

Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be accessed from the same context, as required by some UI frameworks.

It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler parameter. For more information, see the remarks section on those overloads.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEventPattern1(System.IObservable{System.Reactive.EventPattern{0}})

7. Overload¶

public static IQbservable<EventPattern<TEventArgs>> FromEventPattern<TDelegate, TEventArgs>(this IQbservableProvider provider, Expression<Action<TDelegate>> addHandler, Expression<Action<TDelegate>> removeHandler)

Summary: Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type, to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.

Type parameters

Parameters

Returns: IQbservable> -- The observable sequence that contains data representations of invocations of the underlying .NET event.

Remarks

Add and remove handler invocations are made whenever the number of observers grows beyond zero. As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.

The current SynchronizationContext is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.

If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread making the Subscribe or Dispose call, respectively.

It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions more concise and easier to understand.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEventPattern1(System.IObservable{System.Reactive.EventPattern{0}})

8. Overload¶

public static IQbservable<EventPattern<TEventArgs>> FromEventPattern<TDelegate, TEventArgs>(this IQbservableProvider provider, Expression<Action<TDelegate>> addHandler, Expression<Action<TDelegate>> removeHandler, IScheduler scheduler)

Summary: Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type, to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.

Type parameters

Parameters

Returns: IQbservable> -- The observable sequence that contains data representations of invocations of the underlying .NET event.

Remarks

Add and remove handler invocations are made whenever the number of observers grows beyond zero. As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.

Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be accessed from the same context, as required by some UI frameworks.

It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler parameter. For more information, see the remarks section on those overloads.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEventPattern1(System.IObservable{System.Reactive.EventPattern{0}})

9. Overload¶

public static IQbservable<EventPattern<TEventArgs>> FromEventPattern<TDelegate, TEventArgs>(this IQbservableProvider provider, Expression<Func<EventHandler<TEventArgs>, TDelegate>> conversion, Expression<Action<TDelegate>> addHandler, Expression<Action<TDelegate>> removeHandler)

Summary: Converts a .NET event, conforming to the standard .NET event pattern based on EventHandler, to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.

Type parameters

Parameters

Returns: IQbservable> -- The observable sequence that contains data representations of invocations of the underlying .NET event.

Remarks

Add and remove handler invocations are made whenever the number of observers grows beyond zero. As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.

The current SynchronizationContext is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.

If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread making the Subscribe or Dispose call, respectively.

It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions more concise and easier to understand.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEventPattern1(System.IObservable{System.Reactive.EventPattern{0}})

10. Overload¶

public static IQbservable<EventPattern<TEventArgs>> FromEventPattern<TDelegate, TEventArgs>(this IQbservableProvider provider, Expression<Func<EventHandler<TEventArgs>, TDelegate>> conversion, Expression<Action<TDelegate>> addHandler, Expression<Action<TDelegate>> removeHandler, IScheduler scheduler)

Summary: Converts a .NET event, conforming to the standard .NET event pattern based on EventHandler, to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.

Type parameters

Parameters

Returns: IQbservable> -- The observable sequence that contains data representations of invocations of the underlying .NET event.

Remarks

Add and remove handler invocations are made whenever the number of observers grows beyond zero. As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.

Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be accessed from the same context, as required by some UI frameworks.

It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler parameter. For more information, see the remarks section on those overloads.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEventPattern1(System.IObservable{System.Reactive.EventPattern{0}})

11. Overload¶

public static IQbservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TDelegate, TSender, TEventArgs>(this IQbservableProvider provider, Expression<Action<TDelegate>> addHandler, Expression<Action<TDelegate>> removeHandler)

Summary: Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type with a strongly typed sender parameter, to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.

Type parameters

Parameters

Returns: IQbservable> -- The observable sequence that contains data representations of invocations of the underlying .NET event.

Remarks

Add and remove handler invocations are made whenever the number of observers grows beyond zero. As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.

The current SynchronizationContext is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.

If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread making the Subscribe or Dispose call, respectively.

It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions more concise and easier to understand.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEventPattern1(System.IObservable{System.Reactive.EventPattern{0}})

12. Overload¶

public static IQbservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TDelegate, TSender, TEventArgs>(this IQbservableProvider provider, Expression<Action<TDelegate>> addHandler, Expression<Action<TDelegate>> removeHandler, IScheduler scheduler)

Summary: Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type with a strongly typed sender parameter, to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.

Type parameters

Parameters

Returns: IQbservable> -- The observable sequence that contains data representations of invocations of the underlying .NET event.

Remarks

Add and remove handler invocations are made whenever the number of observers grows beyond zero. As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.

Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be accessed from the same context, as required by some UI frameworks.

It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler parameter. For more information, see the remarks section on those overloads.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEventPattern1(System.IObservable{System.Reactive.EventPattern{0}})

13. Overload¶

public static IQbservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(this IQbservableProvider provider, Expression<Action<EventHandler<TEventArgs>>> addHandler, Expression<Action<EventHandler<TEventArgs>>> removeHandler)

Summary: Converts a .NET event, conforming to the standard .NET event pattern based on EventHandler, to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.

Type parameters

Parameters

Returns: IQbservable> -- The observable sequence that contains data representations of invocations of the underlying .NET event.

Remarks

Add and remove handler invocations are made whenever the number of observers grows beyond zero. As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.

The current SynchronizationContext is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.

If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread making the Subscribe or Dispose call, respectively.

It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions more concise and easier to understand.

See also

• System.Reactive.Linq.Observable.ToEventPattern1(System.IObservable{System.Reactive.EventPattern{0}})

14. Overload¶

public static IQbservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(this IQbservableProvider provider, Expression<Action<EventHandler<TEventArgs>>> addHandler, Expression<Action<EventHandler<TEventArgs>>> removeHandler, IScheduler scheduler)

Summary: Converts a .NET event, conforming to the standard .NET event pattern based on EventHandler, to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.

Type parameters

Parameters

Returns: IQbservable> -- The observable sequence that contains data representations of invocations of the underlying .NET event.

Remarks

Add and remove handler invocations are made whenever the number of observers grows beyond zero. As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.

Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be accessed from the same context, as required by some UI frameworks.

It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler parameter. For more information, see the remarks section on those overloads.

See also

• System.Reactive.Linq.Observable.ToEventPattern1(System.IObservable{System.Reactive.EventPattern{0}})

15. Overload¶

public static IQbservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(this IQbservableProvider provider, object target, string eventName)

Summary: Converts an instance .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. Reflection is used to discover the event based on the target object type and the specified event name. For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.

Type parameters

Parameters

Returns: IQbservable> -- The observable sequence that contains data representations of invocations of the underlying .NET event.

Remarks

Add and remove handler invocations are made whenever the number of observers grows beyond zero. As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.

The current SynchronizationContext is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.

If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread making the Subscribe or Dispose call, respectively.

It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions more concise and easier to understand.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEventPattern1(System.IObservable{System.Reactive.EventPattern{0}})

16. Overload¶

public static IQbservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(this IQbservableProvider provider, object target, string eventName, IScheduler scheduler)

Summary: Converts an instance .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. Reflection is used to discover the event based on the target object type and the specified event name. For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.

Type parameters

Parameters

Returns: IQbservable> -- The observable sequence that contains data representations of invocations of the underlying .NET event.

Remarks

Add and remove handler invocations are made whenever the number of observers grows beyond zero. As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.

Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be accessed from the same context, as required by some UI frameworks.

It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler parameter. For more information, see the remarks section on those overloads.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEventPattern1(System.IObservable{System.Reactive.EventPattern{0}})

17. Overload¶

public static IQbservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(this IQbservableProvider provider, Type type, string eventName)

Summary: Converts a static .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. Reflection is used to discover the event based on the specified type and the specified event name. For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.

Type parameters

Parameters

Returns: IQbservable> -- The observable sequence that contains data representations of invocations of the underlying .NET event.

Remarks

Add and remove handler invocations are made whenever the number of observers grows beyond zero. As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.

The current SynchronizationContext is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.

If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread making the Subscribe or Dispose call, respectively.

It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions more concise and easier to understand.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEventPattern1(System.IObservable{System.Reactive.EventPattern{0}})

18. Overload¶

public static IQbservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(this IQbservableProvider provider, Type type, string eventName, IScheduler scheduler)

Summary: Converts a static .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. Reflection is used to discover the event based on the specified type and the specified event name. For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.

Type parameters

Parameters

Returns: IQbservable> -- The observable sequence that contains data representations of invocations of the underlying .NET event.

Remarks

Add and remove handler invocations are made whenever the number of observers grows beyond zero. As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.

Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be accessed from the same context, as required by some UI frameworks.

It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler parameter. For more information, see the remarks section on those overloads.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEventPattern1(System.IObservable{System.Reactive.EventPattern{0}})

19. Overload¶

public static IQbservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TSender, TEventArgs>(this IQbservableProvider provider, object target, string eventName)

Summary: Converts an instance .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. Reflection is used to discover the event based on the target object type and the specified event name. For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.

Type parameters

Parameters

Returns: IQbservable> -- The observable sequence that contains data representations of invocations of the underlying .NET event.

Remarks

Add and remove handler invocations are made whenever the number of observers grows beyond zero. As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.

The current SynchronizationContext is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.

If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread making the Subscribe or Dispose call, respectively.

It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions more concise and easier to understand.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEventPattern1(System.IObservable{System.Reactive.EventPattern{0}})

20. Overload¶

public static IQbservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TSender, TEventArgs>(this IQbservableProvider provider, object target, string eventName, IScheduler scheduler)

Summary: Converts an instance .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. Reflection is used to discover the event based on the target object type and the specified event name. For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.

Type parameters

Parameters

Returns: IQbservable> -- The observable sequence that contains data representations of invocations of the underlying .NET event.

Remarks

Add and remove handler invocations are made whenever the number of observers grows beyond zero. As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.

Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be accessed from the same context, as required by some UI frameworks.

It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler parameter. For more information, see the remarks section on those overloads.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEventPattern1(System.IObservable{System.Reactive.EventPattern{0}})

21. Overload¶

public static IQbservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TSender, TEventArgs>(this IQbservableProvider provider, Type type, string eventName)

Summary: Converts a static .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. Reflection is used to discover the event based on the specified type and the specified event name. For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.

Type parameters

Parameters

Returns: IQbservable> -- The observable sequence that contains data representations of invocations of the underlying .NET event.

Remarks

Add and remove handler invocations are made whenever the number of observers grows beyond zero. As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.

The current SynchronizationContext is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.

If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread making the Subscribe or Dispose call, respectively.

It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions more concise and easier to understand.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEventPattern1(System.IObservable{System.Reactive.EventPattern{0}})

22. Overload¶

public static IQbservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TSender, TEventArgs>(this IQbservableProvider provider, Type type, string eventName, IScheduler scheduler)

Summary: Converts a static .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. Reflection is used to discover the event based on the specified type and the specified event name. For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.

Type parameters

Parameters

Returns: IQbservable> -- The observable sequence that contains data representations of invocations of the underlying .NET event.

Remarks

Add and remove handler invocations are made whenever the number of observers grows beyond zero. As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.

Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be accessed from the same context, as required by some UI frameworks.

It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler parameter. For more information, see the remarks section on those overloads.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEventPattern1(System.IObservable{System.Reactive.EventPattern{0}})