,--0},System.Action{--0},System.Action{--0})} ,--0},System.Action{--0},System.Action{--0},System.Reactive.Concurrency.IScheduler)} ,System.Action{--0})} ,System.Action{--0},System.Reactive.Concurrency.IScheduler)} },System.Action{System.Action{--0}})} },System.Action{System.Action{--0}},System.Reactive.Concurrency.IScheduler)} ,System.Action{System.Action})} ,System.Action{System.Action},System.Reactive.Concurrency.IScheduler)}

Observable.FromEvent(Func, TDelegate>, Action, Action) method¶

Overloads¶

• 1. public static IObservable<TEventArgs> FromEvent<TDelegate, TEventArgs>(Func<Action<TEventArgs>, TDelegate> conversion, Action<TDelegate> addHandler, Action<TDelegate> removeHandler)
• 2. public static IObservable<TEventArgs> FromEvent<TDelegate, TEventArgs>(Func<Action<TEventArgs>, TDelegate> conversion, Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler)
• 3. public static IObservable<TEventArgs> FromEvent<TDelegate, TEventArgs>(Action<TDelegate> addHandler, Action<TDelegate> removeHandler)
• 4. public static IObservable<TEventArgs> FromEvent<TDelegate, TEventArgs>(Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler)
• 5. public static IObservable<TEventArgs> FromEvent<TEventArgs>(Action<Action<TEventArgs>> addHandler, Action<Action<TEventArgs>> removeHandler)
• 6. public static IObservable<TEventArgs> FromEvent<TEventArgs>(Action<Action<TEventArgs>> addHandler, Action<Action<TEventArgs>> removeHandler, IScheduler scheduler)
• 7. public static IObservable<Unit> FromEvent(Action<Action> addHandler, Action<Action> removeHandler)
• 8. public static IObservable<Unit> FromEvent(Action<Action> addHandler, Action<Action> removeHandler, IScheduler scheduler)

1. Overload¶

public static IObservable<TEventArgs> FromEvent<TDelegate, TEventArgs>(Func<Action<TEventArgs>, TDelegate> conversion, Action<TDelegate> addHandler, Action<TDelegate> removeHandler)

Summary: Converts a .NET event to an observable sequence, using a conversion function to obtain the event delegate. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead.

Type parameters

Parameters

Returns: IObservable -- The observable sequence that contains the event argument objects passed to the 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 FromEvent, 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 FromEvent, add and remove handler invocations are made synchronously on the thread making the Subscribe or Dispose call, respectively.

It's recommended to lift FromEvent 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.ToEvent(System.IObservable{System.Reactive.Unit})

2. Overload¶

public static IObservable<TEventArgs> FromEvent<TDelegate, TEventArgs>(Func<Action<TEventArgs>, TDelegate> conversion, Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler)

Summary: Converts a .NET event to an observable sequence, using a conversion function to obtain the event delegate. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead.

Type parameters

Parameters

Returns: IObservable -- The observable sequence that contains the event argument objects passed to the 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 FromEvent 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 FromEvent that omit the IScheduler parameter. For more information, see the remarks section on those overloads.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEvent(System.IObservable{System.Reactive.Unit})

3. Overload¶

public static IObservable<TEventArgs> FromEvent<TDelegate, TEventArgs>(Action<TDelegate> addHandler, Action<TDelegate> removeHandler)

Summary: Converts a .NET event to an observable sequence, using a supplied event delegate type. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead.

Type parameters

Parameters

Returns: IObservable -- The observable sequence that contains the event argument objects passed to the 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 FromEvent, 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 FromEvent, add and remove handler invocations are made synchronously on the thread making the Subscribe or Dispose call, respectively.

It's recommended to lift FromEvent 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.ToEvent(System.IObservable{System.Reactive.Unit})

4. Overload¶

public static IObservable<TEventArgs> FromEvent<TDelegate, TEventArgs>(Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler)

Summary: Converts a .NET event to an observable sequence, using a supplied event delegate type. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead.

Type parameters

Parameters

Returns: IObservable -- The observable sequence that contains the event argument objects passed to the 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 FromEvent 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 FromEvent that omit the IScheduler parameter. For more information, see the remarks section on those overloads.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEvent(System.IObservable{System.Reactive.Unit})

5. Overload¶

public static IObservable<TEventArgs> FromEvent<TEventArgs>(Action<Action<TEventArgs>> addHandler, Action<Action<TEventArgs>> removeHandler)

Summary: Converts a generic Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead.

Type parameters

Parameters

Returns: IObservable -- The observable sequence that contains the event argument objects passed to the 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 FromEvent, 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 FromEvent, add and remove handler invocations are made synchronously on the thread making the Subscribe or Dispose call, respectively.

It's recommended to lift FromEvent 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.ToEvent(System.IObservable{System.Reactive.Unit})

6. Overload¶

public static IObservable<TEventArgs> FromEvent<TEventArgs>(Action<Action<TEventArgs>> addHandler, Action<Action<TEventArgs>> removeHandler, IScheduler scheduler)

Summary: Converts a generic Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead.

Type parameters

Parameters

Returns: IObservable -- The observable sequence that contains the event argument objects passed to the 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 FromEvent 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 FromEvent that omit the IScheduler parameter. For more information, see the remarks section on those overloads.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEvent(System.IObservable{System.Reactive.Unit})

7. Overload¶

public static IObservable<Unit> FromEvent(Action<Action> addHandler, Action<Action> removeHandler)

Summary: Converts an Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead.

Parameters

Returns: IObservable -- The observable sequence that contains the event argument objects passed to the 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 FromEvent, 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 FromEvent, add and remove handler invocations are made synchronously on the thread making the Subscribe or Dispose call, respectively.

It's recommended to lift FromEvent 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.ToEvent(System.IObservable{System.Reactive.Unit})

8. Overload¶

public static IObservable<Unit> FromEvent(Action<Action> addHandler, Action<Action> removeHandler, IScheduler scheduler)

Summary: Converts an Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead.

Parameters

Returns: IObservable -- The observable sequence that contains the event argument objects passed to the 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 FromEvent 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 FromEvent that omit the IScheduler parameter. For more information, see the remarks section on those overloads.

Exceptions

See also

• System.Reactive.Linq.Observable.ToEvent(System.IObservable{System.Reactive.Unit})