<PackageReference Include="System.Reactive" Version="6.0.0" />

Observable

public static class Observable
Provides a set of static methods for writing in-memory queries over observable sequences.
public static IObservable<TAccumulate> Aggregate<TSource, TAccumulate>(this IObservable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator)

Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value. For aggregation behavior with incremental intermediate results, see Scan<T, U>.

public static IObservable<TResult> Aggregate<TSource, TAccumulate, TResult>(this IObservable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator, Func<TAccumulate, TResult> resultSelector)

Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value, and the specified result selector function is used to select the result value.

public static IObservable<TSource> Aggregate<TSource>(this IObservable<TSource> source, Func<TSource, TSource, TSource> accumulator)

Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. For aggregation behavior with incremental intermediate results, see Scan<T>.

public static IObservable<bool> All<TSource>(this IObservable<TSource> source, Func<TSource, bool> predicate)

Determines whether all elements of an observable sequence satisfy a condition.

public static IObservable<TSource> Amb<TSource>(this IObservable<TSource> first, IObservable<TSource> second)

Propagates the observable sequence that reacts first.

public static IObservable<TSource> Amb<TSource>(IObservable<TSource>[] sources)

Propagates the observable sequence that reacts first.

public static IObservable<TSource> Amb<TSource>(this IEnumerable<IObservable<TSource>> sources)

Propagates the observable sequence that reacts first.

public static Pattern<TLeft, TRight> And<TLeft, TRight>(this IObservable<TLeft> left, IObservable<TRight> right)

Creates a pattern that matches when both observable sequences have an available element.

public static IObservable<bool> Any<TSource>(this IObservable<TSource> source)

Determines whether an observable sequence contains any elements.

public static IObservable<bool> Any<TSource>(this IObservable<TSource> source, Func<TSource, bool> predicate)

Determines whether any element of an observable sequence satisfies a condition.

public static IObservable<TSource> Append<TSource>(this IObservable<TSource> source, TSource value)

Append a value to an observable sequence.

public static IObservable<TSource> Append<TSource>(this IObservable<TSource> source, TSource value, IScheduler scheduler)

Append a value to an observable sequence.

public static IObservable<TSource> AsObservable<TSource>(this IObservable<TSource> source)

Hides the identity of an observable sequence.

public static IObservable<TSource> AutoConnect<TSource>(this IConnectableObservable<TSource> source, int minObservers = 1, Action<IDisposable> onConnect = null)

Automatically connect the upstream IConnectableObservable at most once when the specified number of IObservers have subscribed to this IObservable.

public static IObservable<double> Average(this IObservable<double> source)

Computes the average of an observable sequence of Double values.

public static IObservable<float> Average(this IObservable<float> source)

Computes the average of an observable sequence of Single values.

public static IObservable<decimal> Average(this IObservable<decimal> source)

Computes the average of an observable sequence of Decimal values.

public static IObservable<double> Average(this IObservable<int> source)

Computes the average of an observable sequence of Int32 values.

public static IObservable<double> Average(this IObservable<long> source)

Computes the average of an observable sequence of Int64 values.

public static IObservable<double?> Average(this IObservable<double?> source)

Computes the average of an observable sequence of nullable Double values.

public static IObservable<float?> Average(this IObservable<float?> source)

Computes the average of an observable sequence of nullable Single values.

public static IObservable<decimal?> Average(this IObservable<decimal?> source)

Computes the average of an observable sequence of nullable Decimal values.

public static IObservable<double?> Average(this IObservable<int?> source)

Computes the average of an observable sequence of nullable Int32 values.

public static IObservable<double?> Average(this IObservable<long?> source)

Computes the average of an observable sequence of nullable Int64 values.

public static IObservable<decimal> Average<TSource>(this IObservable<TSource> source, Func<TSource, decimal> selector)

Computes the average of an observable sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.

public static IObservable<double> Average<TSource>(this IObservable<TSource> source, Func<TSource, double> selector)

Computes the average of an observable sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.

public static IObservable<float> Average<TSource>(this IObservable<TSource> source, Func<TSource, float> selector)

Computes the average of an observable sequence of Single values that are obtained by invoking a transform function on each element of the input sequence.

public static IObservable<double> Average<TSource>(this IObservable<TSource> source, Func<TSource, int> selector)

Computes the average of an observable sequence of Int32 values that are obtained by invoking a transform function on each element of the input sequence.

public static IObservable<double> Average<TSource>(this IObservable<TSource> source, Func<TSource, long> selector)

Computes the average of an observable sequence of Int64 values that are obtained by invoking a transform function on each element of the input sequence.

public static IObservable<decimal?> Average<TSource>(this IObservable<TSource> source, Func<TSource, decimal?> selector)

Computes the average of an observable sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.

public static IObservable<double?> Average<TSource>(this IObservable<TSource> source, Func<TSource, double?> selector)

Computes the average of an observable sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.

public static IObservable<float?> Average<TSource>(this IObservable<TSource> source, Func<TSource, float?> selector)

Computes the average of an observable sequence of nullable Single values that are obtained by invoking a transform function on each element of the input sequence.

public static IObservable<double?> Average<TSource>(this IObservable<TSource> source, Func<TSource, int?> selector)

Computes the average of an observable sequence of nullable Int32 values that are obtained by invoking a transform function on each element of the input sequence.

public static IObservable<double?> Average<TSource>(this IObservable<TSource> source, Func<TSource, long?> selector)

Computes the average of an observable sequence of nullable Int64 values that are obtained by invoking a transform function on each element of the input sequence.

public static IObservable<IList<TSource>> Buffer<TSource, TBufferClosing>(this IObservable<TSource> source, Func<IObservable<TBufferClosing>> bufferClosingSelector)

Projects each element of an observable sequence into consecutive non-overlapping buffers.

public static IObservable<IList<TSource>> Buffer<TSource, TBufferOpening, TBufferClosing>(this IObservable<TSource> source, IObservable<TBufferOpening> bufferOpenings, Func<TBufferOpening, IObservable<TBufferClosing>> bufferClosingSelector)

Projects each element of an observable sequence into zero or more buffers.

public static IObservable<IList<TSource>> Buffer<TSource, TBufferBoundary>(this IObservable<TSource> source, IObservable<TBufferBoundary> bufferBoundaries)

Projects each element of an observable sequence into consecutive non-overlapping buffers.

public static IObservable<IList<TSource>> Buffer<TSource>(this IObservable<TSource> source, int count)

Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on element count information.

public static IObservable<IList<TSource>> Buffer<TSource>(this IObservable<TSource> source, int count, int skip)

Projects each element of an observable sequence into zero or more buffers which are produced based on element count information.

public static IObservable<IList<TSource>> Buffer<TSource>(this IObservable<TSource> source, TimeSpan timeSpan)

Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on timing information.

public static IObservable<IList<TSource>> Buffer<TSource>(this IObservable<TSource> source, TimeSpan timeSpan, IScheduler scheduler)

Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on timing information, using the specified scheduler to run timers.

public static IObservable<IList<TSource>> Buffer<TSource>(this IObservable<TSource> source, TimeSpan timeSpan, TimeSpan timeShift)

Projects each element of an observable sequence into zero or more buffers which are produced based on timing information.

public static IObservable<IList<TSource>> Buffer<TSource>(this IObservable<TSource> source, TimeSpan timeSpan, TimeSpan timeShift, IScheduler scheduler)

Projects each element of an observable sequence into zero or more buffers which are produced based on timing information, using the specified scheduler to run timers.

public static IObservable<IList<TSource>> Buffer<TSource>(this IObservable<TSource> source, TimeSpan timeSpan, int count)

Projects each element of an observable sequence into a buffer that's sent out when either it's full or a given amount of time has elapsed. A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first.

public static IObservable<IList<TSource>> Buffer<TSource>(this IObservable<TSource> source, TimeSpan timeSpan, int count, IScheduler scheduler)

Projects each element of an observable sequence into a buffer that's sent out when either it's full or a given amount of time has elapsed, using the specified scheduler to run timers. A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first.

public static IObservable<TResult> Case<TValue, TResult>(Func<TValue> selector, IDictionary<TValue, IObservable<TResult>> sources, IObservable<TResult> defaultSource)

Uses selector to determine which source in sources to return, choosing defaultSource if no match is found.

public static IObservable<TResult> Case<TValue, TResult>(Func<TValue> selector, IDictionary<TValue, IObservable<TResult>> sources, IScheduler scheduler)

Uses selector to determine which source in sources to return, choosing an empty sequence on the specified scheduler if no match is found.

public static IObservable<TResult> Case<TValue, TResult>(Func<TValue> selector, IDictionary<TValue, IObservable<TResult>> sources)

Uses selector to determine which source in sources to return, choosing an empty sequence if no match is found.

public static IObservable<TResult> Cast<TResult>(this IObservable<object> source)

Converts the elements of an observable sequence to the specified type.

public static IObservable<TSource> Catch<TSource, TException>(this IObservable<TSource> source, Func<TException, IObservable<TSource>> handler) where TException : Exception

Continues an observable sequence that is terminated by an exception of the specified type with the observable sequence produced by the handler.

public static IObservable<TSource> Catch<TSource>(this IObservable<TSource> first, IObservable<TSource> second)

Continues an observable sequence that is terminated by an exception with the next observable sequence.

public static IObservable<TSource> Catch<TSource>(IObservable<TSource>[] sources)

Continues an observable sequence that is terminated by an exception with the next observable sequence.

public static IObservable<TSource> Catch<TSource>(this IEnumerable<IObservable<TSource>> sources)

Continues an observable sequence that is terminated by an exception with the next observable sequence.

public static IEnumerable<IList<TSource>> Chunkify<TSource>(this IObservable<TSource> source)

Produces an enumerable sequence of consecutive (possibly empty) chunks of the source sequence.

public static IEnumerable<TResult> Collect<TSource, TResult>(this IObservable<TSource> source, Func<TResult> newCollector, Func<TResult, TSource, TResult> merge)

Produces an enumerable sequence that returns elements collected/aggregated from the source sequence between consecutive iterations.

public static IEnumerable<TResult> Collect<TSource, TResult>(this IObservable<TSource> source, Func<TResult> getInitialCollector, Func<TResult, TSource, TResult> merge, Func<TResult, TResult> getNewCollector)

Produces an enumerable sequence that returns elements collected/aggregated from the source sequence between consecutive iterations.

public static IObservable<TResult> CombineLatest<TSource1, TSource2, TSource3, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, Func<TSource1, TSource2, TSource3, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.

public static IObservable<TResult> CombineLatest<TSource1, TSource2, TSource3, TSource4, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, Func<TSource1, TSource2, TSource3, TSource4, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.

public static IObservable<TResult> CombineLatest<TSource1, TSource2, TSource3, TSource4, TSource5, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.

public static IObservable<TResult> CombineLatest<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, IObservable<TSource6> source6, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.

public static IObservable<TResult> CombineLatest<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, IObservable<TSource6> source6, IObservable<TSource7> source7, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.

public static IObservable<TResult> CombineLatest<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, IObservable<TSource6> source6, IObservable<TSource7> source7, IObservable<TSource8> source8, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.

public static IObservable<TResult> CombineLatest<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, IObservable<TSource6> source6, IObservable<TSource7> source7, IObservable<TSource8> source8, IObservable<TSource9> source9, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.

public static IObservable<TResult> CombineLatest<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, IObservable<TSource6> source6, IObservable<TSource7> source7, IObservable<TSource8> source8, IObservable<TSource9> source9, IObservable<TSource10> source10, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.

public static IObservable<TResult> CombineLatest<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, IObservable<TSource6> source6, IObservable<TSource7> source7, IObservable<TSource8> source8, IObservable<TSource9> source9, IObservable<TSource10> source10, IObservable<TSource11> source11, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.

public static IObservable<TResult> CombineLatest<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TSource12, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, IObservable<TSource6> source6, IObservable<TSource7> source7, IObservable<TSource8> source8, IObservable<TSource9> source9, IObservable<TSource10> source10, IObservable<TSource11> source11, IObservable<TSource12> source12, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TSource12, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.

public static IObservable<TResult> CombineLatest<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TSource12, TSource13, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, IObservable<TSource6> source6, IObservable<TSource7> source7, IObservable<TSource8> source8, IObservable<TSource9> source9, IObservable<TSource10> source10, IObservable<TSource11> source11, IObservable<TSource12> source12, IObservable<TSource13> source13, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TSource12, TSource13, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.

public static IObservable<TResult> CombineLatest<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TSource12, TSource13, TSource14, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, IObservable<TSource6> source6, IObservable<TSource7> source7, IObservable<TSource8> source8, IObservable<TSource9> source9, IObservable<TSource10> source10, IObservable<TSource11> source11, IObservable<TSource12> source12, IObservable<TSource13> source13, IObservable<TSource14> source14, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TSource12, TSource13, TSource14, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.

public static IObservable<TResult> CombineLatest<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TSource12, TSource13, TSource14, TSource15, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, IObservable<TSource6> source6, IObservable<TSource7> source7, IObservable<TSource8> source8, IObservable<TSource9> source9, IObservable<TSource10> source10, IObservable<TSource11> source11, IObservable<TSource12> source12, IObservable<TSource13> source13, IObservable<TSource14> source14, IObservable<TSource15> source15, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TSource12, TSource13, TSource14, TSource15, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.

public static IObservable<TResult> CombineLatest<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TSource12, TSource13, TSource14, TSource15, TSource16, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, IObservable<TSource6> source6, IObservable<TSource7> source7, IObservable<TSource8> source8, IObservable<TSource9> source9, IObservable<TSource10> source10, IObservable<TSource11> source11, IObservable<TSource12> source12, IObservable<TSource13> source13, IObservable<TSource14> source14, IObservable<TSource15> source15, IObservable<TSource16> source16, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TSource12, TSource13, TSource14, TSource15, TSource16, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.

public static IObservable<TResult> CombineLatest<TSource1, TSource2, TResult>(this IObservable<TSource1> first, IObservable<TSource2> second, Func<TSource1, TSource2, TResult> resultSelector)

Merges two observable sequences into one observable sequence by using the selector function whenever one of the observable sequences produces an element.

public static IObservable<TResult> CombineLatest<TSource, TResult>(this IEnumerable<IObservable<TSource>> sources, Func<IList<TSource>, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.

public static IObservable<IList<TSource>> CombineLatest<TSource>(this IEnumerable<IObservable<TSource>> sources)

Merges the specified observable sequences into one observable sequence by emitting a list with the latest source elements whenever any of the observable sequences produces an element.

public static IObservable<IList<TSource>> CombineLatest<TSource>(IObservable<TSource>[] sources)

Merges the specified observable sequences into one observable sequence by emitting a list with the latest source elements whenever any of the observable sequences produces an element.

public static IObservable<TSource> Concat<TSource>(this IObservable<TSource> first, IObservable<TSource> second)

Concatenates the second observable sequence to the first observable sequence upon successful termination of the first.

public static IObservable<TSource> Concat<TSource>(IObservable<TSource>[] sources)

Concatenates all of the specified observable sequences, as long as the previous observable sequence terminated successfully.

public static IObservable<TSource> Concat<TSource>(this IEnumerable<IObservable<TSource>> sources)

Concatenates all observable sequences in the given enumerable sequence, as long as the previous observable sequence terminated successfully.

public static IObservable<TSource> Concat<TSource>(this IObservable<IObservable<TSource>> sources)

Concatenates all inner observable sequences, as long as the previous observable sequence terminated successfully.

public static IObservable<TSource> Concat<TSource>(this IObservable<Task<TSource>> sources)

Concatenates all task results, as long as the previous task terminated successfully.

public static IObservable<bool> Contains<TSource>(this IObservable<TSource> source, TSource value)

Determines whether an observable sequence contains a specified element by using the default equality comparer.

public static IObservable<bool> Contains<TSource>(this IObservable<TSource> source, TSource value, IEqualityComparer<TSource> comparer)

Determines whether an observable sequence contains a specified element by using a specified System.Collections.Generic.IEqualityComparer{T}.

public static IObservable<int> Count<TSource>(this IObservable<TSource> source)

Returns an observable sequence containing an Int32 that represents the total number of elements in an observable sequence.

public static IObservable<int> Count<TSource>(this IObservable<TSource> source, Func<TSource, bool> predicate)

Returns an observable sequence containing an Int32 that represents how many elements in the specified observable sequence satisfy a condition.

public static IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, IDisposable> subscribe)

Creates an observable sequence from a specified Subscribe method implementation.

public static IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, Action> subscribe)

Creates an observable sequence from a specified Subscribe method implementation.

public static IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, CancellationToken, Task> subscribeAsync)

Creates an observable sequence from a specified cancellable asynchronous Subscribe method. The CancellationToken passed to the asynchronous Subscribe method is tied to the returned disposable subscription, allowing best-effort cancellation.

public static IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, Task> subscribeAsync)

Creates an observable sequence from a specified asynchronous Subscribe method.

public static IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, CancellationToken, Task<IDisposable>> subscribeAsync)

Creates an observable sequence from a specified cancellable asynchronous Subscribe method. The CancellationToken passed to the asynchronous Subscribe method is tied to the returned disposable subscription, allowing best-effort cancellation.

public static IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, Task<IDisposable>> subscribeAsync)

Creates an observable sequence from a specified asynchronous Subscribe method.

public static IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, CancellationToken, Task<Action>> subscribeAsync)

Creates an observable sequence from a specified cancellable asynchronous Subscribe method. The CancellationToken passed to the asynchronous Subscribe method is tied to the returned disposable subscription, allowing best-effort cancellation.

public static IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, Task<Action>> subscribeAsync)

Creates an observable sequence from a specified asynchronous Subscribe method.

public static IObservable<TSource> DefaultIfEmpty<TSource>(this IObservable<TSource> source)

Returns the elements of the specified sequence or the type parameter's default value in a singleton sequence if the sequence is empty.

public static IObservable<TSource> DefaultIfEmpty<TSource>(this IObservable<TSource> source, TSource defaultValue)

Returns the elements of the specified sequence or the specified value in a singleton sequence if the sequence is empty.

public static IObservable<TResult> Defer<TResult>(Func<IObservable<TResult>> observableFactory)

Returns an observable sequence that invokes the specified factory function whenever a new observer subscribes.

public static IObservable<TResult> Defer<TResult>(Func<Task<IObservable<TResult>>> observableFactoryAsync)

Returns an observable sequence that starts the specified asynchronous factory function whenever a new observer subscribes.

public static IObservable<TResult> Defer<TResult>(Func<Task<IObservable<TResult>>> observableFactoryAsync, bool ignoreExceptionsAfterUnsubscribe)

Returns an observable sequence that starts the specified asynchronous factory function whenever a new observer subscribes.

public static IObservable<TResult> DeferAsync<TResult>(Func<CancellationToken, Task<IObservable<TResult>>> observableFactoryAsync)

Returns an observable sequence that starts the specified cancellable asynchronous factory function whenever a new observer subscribes. The CancellationToken passed to the asynchronous factory function is tied to the returned disposable subscription, allowing best-effort cancellation.

public static IObservable<TResult> DeferAsync<TResult>(Func<CancellationToken, Task<IObservable<TResult>>> observableFactoryAsync, bool ignoreExceptionsAfterUnsubscribe)

Returns an observable sequence that starts the specified cancellable asynchronous factory function whenever a new observer subscribes. The CancellationToken passed to the asynchronous factory function is tied to the returned disposable subscription, allowing best-effort cancellation.

public static IObservable<TSource> Delay<TSource>(this IObservable<TSource> source, TimeSpan dueTime)

Time shifts the observable sequence by the specified relative time duration. The relative time intervals between the values are preserved.

public static IObservable<TSource> Delay<TSource>(this IObservable<TSource> source, TimeSpan dueTime, IScheduler scheduler)

Time shifts the observable sequence by the specified relative time duration, using the specified scheduler to run timers. The relative time intervals between the values are preserved.

public static IObservable<TSource> Delay<TSource>(this IObservable<TSource> source, DateTimeOffset dueTime)

Time shifts the observable sequence to start propagating notifications at the specified absolute time. The relative time intervals between the values are preserved.

public static IObservable<TSource> Delay<TSource>(this IObservable<TSource> source, DateTimeOffset dueTime, IScheduler scheduler)

Time shifts the observable sequence to start propagating notifications at the specified absolute time, using the specified scheduler to run timers. The relative time intervals between the values are preserved.

public static IObservable<TSource> Delay<TSource, TDelay>(this IObservable<TSource> source, Func<TSource, IObservable<TDelay>> delayDurationSelector)

Time shifts the observable sequence based on a delay selector function for each element.

public static IObservable<TSource> Delay<TSource, TDelay>(this IObservable<TSource> source, IObservable<TDelay> subscriptionDelay, Func<TSource, IObservable<TDelay>> delayDurationSelector)

Time shifts the observable sequence based on a subscription delay and a delay selector function for each element.

public static IObservable<TSource> DelaySubscription<TSource>(this IObservable<TSource> source, TimeSpan dueTime)

Time shifts the observable sequence by delaying the subscription with the specified relative time duration.

public static IObservable<TSource> DelaySubscription<TSource>(this IObservable<TSource> source, TimeSpan dueTime, IScheduler scheduler)

Time shifts the observable sequence by delaying the subscription with the specified relative time duration, using the specified scheduler to run timers.

public static IObservable<TSource> DelaySubscription<TSource>(this IObservable<TSource> source, DateTimeOffset dueTime)

Time shifts the observable sequence by delaying the subscription to the specified absolute time.

public static IObservable<TSource> DelaySubscription<TSource>(this IObservable<TSource> source, DateTimeOffset dueTime, IScheduler scheduler)

Time shifts the observable sequence by delaying the subscription to the specified absolute time, using the specified scheduler to run timers.

public static IObservable<TSource> Dematerialize<TSource>(this IObservable<Notification<TSource>> source)

Dematerializes the explicit notification values of an observable sequence as implicit notifications.

public static IObservable<TSource> Distinct<TSource>(this IObservable<TSource> source)

Returns an observable sequence that contains only distinct elements.

public static IObservable<TSource> Distinct<TSource>(this IObservable<TSource> source, IEqualityComparer<TSource> comparer)

Returns an observable sequence that contains only distinct elements according to the comparer.

public static IObservable<TSource> Distinct<TSource, TKey>(this IObservable<TSource> source, Func<TSource, TKey> keySelector)

Returns an observable sequence that contains only distinct elements according to the keySelector.

public static IObservable<TSource> Distinct<TSource, TKey>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)

Returns an observable sequence that contains only distinct elements according to the keySelector and the comparer.

public static IObservable<TSource> DistinctUntilChanged<TSource>(this IObservable<TSource> source)

Returns an observable sequence that contains only distinct contiguous elements.

public static IObservable<TSource> DistinctUntilChanged<TSource>(this IObservable<TSource> source, IEqualityComparer<TSource> comparer)

Returns an observable sequence that contains only distinct contiguous elements according to the comparer.

public static IObservable<TSource> DistinctUntilChanged<TSource, TKey>(this IObservable<TSource> source, Func<TSource, TKey> keySelector)

Returns an observable sequence that contains only distinct contiguous elements according to the keySelector.

public static IObservable<TSource> DistinctUntilChanged<TSource, TKey>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)

Returns an observable sequence that contains only distinct contiguous elements according to the keySelector and the comparer.

public static IObservable<TSource> Do<TSource>(this IObservable<TSource> source, Action<TSource> onNext)

Invokes an action for each element in the observable sequence, and propagates all observer messages through the result sequence. This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.

public static IObservable<TSource> Do<TSource>(this IObservable<TSource> source, Action<TSource> onNext, Action onCompleted)

Invokes an action for each element in the observable sequence and invokes an action upon graceful termination of the observable sequence. This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.

public static IObservable<TSource> Do<TSource>(this IObservable<TSource> source, Action<TSource> onNext, Action<Exception> onError)

Invokes an action for each element in the observable sequence and invokes an action upon exceptional termination of the observable sequence. This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.

public static IObservable<TSource> Do<TSource>(this IObservable<TSource> source, Action<TSource> onNext, Action<Exception> onError, Action onCompleted)

Invokes an action for each element in the observable sequence and invokes an action upon graceful or exceptional termination of the observable sequence. This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.

public static IObservable<TSource> Do<TSource>(this IObservable<TSource> source, IObserver<TSource> observer)

Invokes the observer's methods for each message in the source sequence. This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.

public static IObservable<TSource> DoWhile<TSource>(this IObservable<TSource> source, Func<bool> condition)

Repeats the given source as long as the specified condition holds, where the condition is evaluated after each repeated source completed.

public static IObservable<TSource> ElementAt<TSource>(this IObservable<TSource> source, int index)

Returns the element at a specified index in a sequence.

public static IObservable<TSource> ElementAtOrDefault<TSource>(this IObservable<TSource> source, int index)

Returns the element at a specified index in a sequence or a default value if the index is out of range.

public static IObservable<TResult> Empty<TResult>()

Returns an empty observable sequence.

public static IObservable<TResult> Empty<TResult>(TResult witness)

Returns an empty observable sequence.

public static IObservable<TResult> Empty<TResult>(IScheduler scheduler)

Returns an empty observable sequence, using the specified scheduler to send out the single OnCompleted message.

public static IObservable<TResult> Empty<TResult>(IScheduler scheduler, TResult witness)

Returns an empty observable sequence, using the specified scheduler to send out the single OnCompleted message.

public static IObservable<TSource> Finally<TSource>(this IObservable<TSource> source, Action finallyAction)

Invokes a specified action after the source observable sequence terminates gracefully or exceptionally.

public static TSource First<TSource>(this IObservable<TSource> source)

Returns the first element of an observable sequence.

public static TSource First<TSource>(this IObservable<TSource> source, Func<TSource, bool> predicate)

Returns the first element of an observable sequence that satisfies the condition in the predicate.

public static IObservable<TSource> FirstAsync<TSource>(this IObservable<TSource> source)

Returns the first element of an observable sequence.

public static IObservable<TSource> FirstAsync<TSource>(this IObservable<TSource> source, Func<TSource, bool> predicate)

Returns the first element of an observable sequence that satisfies the condition in the predicate.

public static TSource FirstOrDefault<TSource>(this IObservable<TSource> source)

Returns the first element of an observable sequence, or a default value if no such element exists.

public static TSource FirstOrDefault<TSource>(this IObservable<TSource> source, Func<TSource, bool> predicate)

Returns the first element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.

public static IObservable<TSource> FirstOrDefaultAsync<TSource>(this IObservable<TSource> source)

Returns the first element of an observable sequence, or a default value if no such element exists.

public static IObservable<TSource> FirstOrDefaultAsync<TSource>(this IObservable<TSource> source, Func<TSource, bool> predicate)

Returns the first element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.

public static IObservable<TResult> For<TSource, TResult>(IEnumerable<TSource> source, Func<TSource, IObservable<TResult>> resultSelector)

Concatenates the observable sequences obtained by running the resultSelector for each element in the given enumerable source.

public static void ForEach<TSource>(this IObservable<TSource> source, Action<TSource> onNext)

Invokes an action for each element in the observable sequence, and blocks until the sequence is terminated.

public static void ForEach<TSource>(this IObservable<TSource> source, Action<TSource, int> onNext)

Invokes an action for each element in the observable sequence, incorporating the element's index, and blocks until the sequence is terminated.

public static Task ForEachAsync<TSource>(this IObservable<TSource> source, Action<TSource> onNext)

Invokes an action for each element in the observable sequence, and returns a Task object that will get signaled when the sequence terminates.

public static Task ForEachAsync<TSource>(this IObservable<TSource> source, Action<TSource> onNext, CancellationToken cancellationToken)

Invokes an action for each element in the observable sequence, and returns a Task object that will get signaled when the sequence terminates. The loop can be quit prematurely by setting the specified cancellation token.

public static Task ForEachAsync<TSource>(this IObservable<TSource> source, Action<TSource, int> onNext)

Invokes an action for each element in the observable sequence, incorporating the element's index, and returns a Task object that will get signaled when the sequence terminates.

public static Task ForEachAsync<TSource>(this IObservable<TSource> source, Action<TSource, int> onNext, CancellationToken cancellationToken)

Invokes an action for each element in the observable sequence, incorporating the element's index, and returns a Task object that will get signaled when the sequence terminates. The loop can be quit prematurely by setting the specified cancellation token.

public static IObservable<TResult> FromAsync<TResult>(Func<Task<TResult>> functionAsync)

Converts an asynchronous function into an observable sequence. Each subscription to the resulting sequence causes the function to be started.

public static IObservable<TResult> FromAsync<TResult>(Func<Task<TResult>> functionAsync, IScheduler scheduler)

Converts an asynchronous function into an observable sequence. Each subscription to the resulting sequence causes the function to be started.

public static IObservable<TResult> FromAsync<TResult>(Func<Task<TResult>> functionAsync, TaskObservationOptions options)

Converts an asynchronous function into an observable sequence. Each subscription to the resulting sequence causes the function to be started.

public static IObservable<TResult> FromAsync<TResult>(Func<CancellationToken, Task<TResult>> functionAsync)

Converts an asynchronous function into an observable sequence. Each subscription to the resulting sequence causes the function to be started. The CancellationToken passed to the asynchronous function is tied to the observable sequence's subscription that triggered the function's invocation and can be used for best-effort cancellation.

public static IObservable<TResult> FromAsync<TResult>(Func<CancellationToken, Task<TResult>> functionAsync, IScheduler scheduler)

Converts an asynchronous function into an observable sequence. Each subscription to the resulting sequence causes the function to be started. The CancellationToken passed to the asynchronous function is tied to the observable sequence's subscription that triggered the function's invocation and can be used for best-effort cancellation.

public static IObservable<TResult> FromAsync<TResult>(Func<CancellationToken, Task<TResult>> functionAsync, TaskObservationOptions options)

Converts an asynchronous function into an observable sequence. Each subscription to the resulting sequence causes the function to be started. The CancellationToken passed to the asynchronous function is tied to the observable sequence's subscription that triggered the function's invocation and can be used for best-effort cancellation.

public static IObservable<Unit> FromAsync(Func<Task> actionAsync)

Converts an asynchronous action into an observable sequence. Each subscription to the resulting sequence causes the action to be started.

public static IObservable<Unit> FromAsync(Func<Task> actionAsync, IScheduler scheduler)

Converts an asynchronous action into an observable sequence. Each subscription to the resulting sequence causes the action to be started.

public static IObservable<Unit> FromAsync(Func<Task> actionAsync, TaskObservationOptions options)

Converts an asynchronous action into an observable sequence. Each subscription to the resulting sequence causes the action to be started.

public static IObservable<Unit> FromAsync(Func<CancellationToken, Task> actionAsync)

Converts an asynchronous action into an observable sequence. Each subscription to the resulting sequence causes the action to be started. The CancellationToken passed to the asynchronous action is tied to the observable sequence's subscription that triggered the action's invocation and can be used for best-effort cancellation.

public static IObservable<Unit> FromAsync(Func<CancellationToken, Task> actionAsync, IScheduler scheduler)

Converts an asynchronous action into an observable sequence. Each subscription to the resulting sequence causes the action to be started. The CancellationToken passed to the asynchronous action is tied to the observable sequence's subscription that triggered the action's invocation and can be used for best-effort cancellation.

public static IObservable<Unit> FromAsync(Func<CancellationToken, Task> actionAsync, TaskObservationOptions options)

Converts an asynchronous action into an observable sequence. Each subscription to the resulting sequence causes the action to be started. The CancellationToken passed to the asynchronous action is tied to the observable sequence's subscription that triggered the action's invocation and can be used for best-effort cancellation.

public static Func<IObservable<TResult>> FromAsyncPattern<TResult>(Func<AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, IObservable<TResult>> FromAsyncPattern<TArg1, TResult>(Func<TArg1, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, IObservable<TResult>> FromAsyncPattern<TArg1, TArg2, TResult>(Func<TArg1, TArg2, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, IObservable<TResult>> FromAsyncPattern<TArg1, TArg2, TArg3, TResult>(Func<TArg1, TArg2, TArg3, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, IObservable<TResult>> FromAsyncPattern<TArg1, TArg2, TArg3, TArg4, TResult>(Func<TArg1, TArg2, TArg3, TArg4, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, IObservable<TResult>> FromAsyncPattern<TArg1, TArg2, TArg3, TArg4, TArg5, TResult>(Func<TArg1, TArg2, TArg3, TArg4, TArg5, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, IObservable<TResult>> FromAsyncPattern<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TResult>(Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, IObservable<TResult>> FromAsyncPattern<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TResult>(Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, IObservable<TResult>> FromAsyncPattern<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TResult>(Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, IObservable<TResult>> FromAsyncPattern<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TResult>(Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, IObservable<TResult>> FromAsyncPattern<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TResult>(Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, IObservable<TResult>> FromAsyncPattern<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TResult>(Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, IObservable<TResult>> FromAsyncPattern<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TResult>(Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, IObservable<TResult>> FromAsyncPattern<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TResult>(Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, IObservable<TResult>> FromAsyncPattern<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TResult>(Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<IObservable<Unit>> FromAsyncPattern(Func<AsyncCallback, object, IAsyncResult> begin, Action<IAsyncResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, IObservable<Unit>> FromAsyncPattern<TArg1>(Func<TArg1, AsyncCallback, object, IAsyncResult> begin, Action<IAsyncResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, IObservable<Unit>> FromAsyncPattern<TArg1, TArg2>(Func<TArg1, TArg2, AsyncCallback, object, IAsyncResult> begin, Action<IAsyncResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, IObservable<Unit>> FromAsyncPattern<TArg1, TArg2, TArg3>(Func<TArg1, TArg2, TArg3, AsyncCallback, object, IAsyncResult> begin, Action<IAsyncResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, IObservable<Unit>> FromAsyncPattern<TArg1, TArg2, TArg3, TArg4>(Func<TArg1, TArg2, TArg3, TArg4, AsyncCallback, object, IAsyncResult> begin, Action<IAsyncResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, IObservable<Unit>> FromAsyncPattern<TArg1, TArg2, TArg3, TArg4, TArg5>(Func<TArg1, TArg2, TArg3, TArg4, TArg5, AsyncCallback, object, IAsyncResult> begin, Action<IAsyncResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, IObservable<Unit>> FromAsyncPattern<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6>(Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, AsyncCallback, object, IAsyncResult> begin, Action<IAsyncResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, IObservable<Unit>> FromAsyncPattern<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7>(Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, AsyncCallback, object, IAsyncResult> begin, Action<IAsyncResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, IObservable<Unit>> FromAsyncPattern<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8>(Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, AsyncCallback, object, IAsyncResult> begin, Action<IAsyncResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, IObservable<Unit>> FromAsyncPattern<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9>(Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, AsyncCallback, object, IAsyncResult> begin, Action<IAsyncResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, IObservable<Unit>> FromAsyncPattern<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10>(Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, AsyncCallback, object, IAsyncResult> begin, Action<IAsyncResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, IObservable<Unit>> FromAsyncPattern<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11>(Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, AsyncCallback, object, IAsyncResult> begin, Action<IAsyncResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, IObservable<Unit>> FromAsyncPattern<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12>(Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, AsyncCallback, object, IAsyncResult> begin, Action<IAsyncResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, IObservable<Unit>> FromAsyncPattern<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13>(Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, AsyncCallback, object, IAsyncResult> begin, Action<IAsyncResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, IObservable<Unit>> FromAsyncPattern<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14>(Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, AsyncCallback, object, IAsyncResult> begin, Action<IAsyncResult> end)

Converts a Begin/End invoke function pair into an asynchronous function.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

public static IObservable<EventPattern<object>> FromEventPattern(Action<EventHandler> addHandler, Action<EventHandler> removeHandler)

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.

public static IObservable<EventPattern<object>> FromEventPattern(Action<EventHandler> addHandler, Action<EventHandler> removeHandler, IScheduler scheduler)

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.

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

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.

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

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.

public static IObservable<EventPattern<TEventArgs>> FromEventPattern<TDelegate, TEventArgs>(Func<EventHandler<TEventArgs>, TDelegate> conversion, Action<TDelegate> addHandler, Action<TDelegate> removeHandler)

Converts a .NET event, conforming to the standard .NET event pattern based on EventHandler<T>, 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.

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

Converts a .NET event, conforming to the standard .NET event pattern based on EventHandler<T>, 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.

public static IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TDelegate, TSender, TEventArgs>(Action<TDelegate> addHandler, Action<TDelegate> removeHandler)

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.

public static IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TDelegate, TSender, TEventArgs>(Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler)

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.

public static IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(Action<EventHandler<TEventArgs>> addHandler, Action<EventHandler<TEventArgs>> removeHandler)

Converts a .NET event, conforming to the standard .NET event pattern based on EventHandler<T>, 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.

public static IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(Action<EventHandler<TEventArgs>> addHandler, Action<EventHandler<TEventArgs>> removeHandler, IScheduler scheduler)

Converts a .NET event, conforming to the standard .NET event pattern based on EventHandler<T>, 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.

public static IObservable<EventPattern<object>> FromEventPattern(object target, string eventName)

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.

public static IObservable<EventPattern<object>> FromEventPattern(object target, string eventName, IScheduler scheduler)

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.

public static IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(object target, string eventName)

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.

public static IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(object target, string eventName, IScheduler scheduler)

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.

public static IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TSender, TEventArgs>(object target, string eventName)

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.

public static IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TSender, TEventArgs>(object target, string eventName, IScheduler scheduler)

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.

public static IObservable<EventPattern<object>> FromEventPattern(Type type, string eventName)

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.

public static IObservable<EventPattern<object>> FromEventPattern(Type type, string eventName, IScheduler scheduler)

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.

public static IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(Type type, string eventName)

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.

public static IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(Type type, string eventName, IScheduler scheduler)

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.

public static IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TSender, TEventArgs>(Type type, string eventName)

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.

public static IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TSender, TEventArgs>(Type type, string eventName, IScheduler scheduler)

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.

public static IObservable<TResult> Generate<TState, TResult>(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterate, Func<TState, TResult> resultSelector)

Generates an observable sequence by running a state-driven loop producing the sequence's elements.

public static IObservable<TResult> Generate<TState, TResult>(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterate, Func<TState, TResult> resultSelector, IScheduler scheduler)

Generates an observable sequence by running a state-driven loop producing the sequence's elements, using the specified scheduler to send out observer messages.

public static IObservable<TResult> Generate<TState, TResult>(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterate, Func<TState, TResult> resultSelector, Func<TState, TimeSpan> timeSelector)

Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements.

public static IObservable<TResult> Generate<TState, TResult>(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterate, Func<TState, TResult> resultSelector, Func<TState, TimeSpan> timeSelector, IScheduler scheduler)

Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements, using the specified scheduler to run timers and to send out observer messages.

public static IObservable<TResult> Generate<TState, TResult>(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterate, Func<TState, TResult> resultSelector, Func<TState, DateTimeOffset> timeSelector)

Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements.

public static IObservable<TResult> Generate<TState, TResult>(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterate, Func<TState, TResult> resultSelector, Func<TState, DateTimeOffset> timeSelector, IScheduler scheduler)

Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements, using the specified scheduler to run timers and to send out observer messages.

public static AsyncSubject<TSource> GetAwaiter<TSource>(this IObservable<TSource> source)

Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. This operation subscribes to the observable sequence, making it hot.

public static AsyncSubject<TSource> GetAwaiter<TSource>(this IConnectableObservable<TSource> source)

Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. This operation subscribes and connects to the observable sequence, making it hot.

public static IEnumerator<TSource> GetEnumerator<TSource>(this IObservable<TSource> source)

Returns an enumerator that enumerates all values of the observable sequence.

public static IObservable<IGroupedObservable<TKey, TSource>> GroupBy<TSource, TKey>(this IObservable<TSource> source, Func<TSource, TKey> keySelector)

Groups the elements of an observable sequence according to a specified key selector function.

public static IObservable<IGroupedObservable<TKey, TSource>> GroupBy<TSource, TKey>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)

Groups the elements of an observable sequence according to a specified key selector function and comparer.

public static IObservable<IGroupedObservable<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)

Groups the elements of an observable sequence and selects the resulting elements by using a specified function.

public static IObservable<IGroupedObservable<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)

Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function.

public static IObservable<IGroupedObservable<TKey, TSource>> GroupBy<TSource, TKey>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, int capacity)

Groups the elements of an observable sequence with the specified initial capacity according to a specified key selector function.

public static IObservable<IGroupedObservable<TKey, TSource>> GroupBy<TSource, TKey>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, int capacity, IEqualityComparer<TKey> comparer)

Groups the elements of an observable sequence with the specified initial capacity according to a specified key selector function and comparer.

public static IObservable<IGroupedObservable<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, int capacity)

Groups the elements of an observable sequence with the specified initial capacity and selects the resulting elements by using a specified function.

public static IObservable<IGroupedObservable<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, int capacity, IEqualityComparer<TKey> comparer)

Groups the elements of an observable sequence with the specified initial capacity according to a specified key selector function and comparer and selects the resulting elements by using a specified function.

public static IObservable<IGroupedObservable<TKey, TElement>> GroupByUntil<TSource, TKey, TElement, TDuration>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>> durationSelector, IEqualityComparer<TKey> comparer)

Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function. A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same key value as a reclaimed group occurs, the group will be reborn with a new lifetime request.

public static IObservable<IGroupedObservable<TKey, TElement>> GroupByUntil<TSource, TKey, TElement, TDuration>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>> durationSelector)

Groups the elements of an observable sequence according to a specified key selector function and selects the resulting elements by using a specified function. A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same key value as a reclaimed group occurs, the group will be reborn with a new lifetime request.

public static IObservable<IGroupedObservable<TKey, TSource>> GroupByUntil<TSource, TKey, TDuration>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<IGroupedObservable<TKey, TSource>, IObservable<TDuration>> durationSelector, IEqualityComparer<TKey> comparer)

Groups the elements of an observable sequence according to a specified key selector function and comparer. A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same key value as a reclaimed group occurs, the group will be reborn with a new lifetime request.

public static IObservable<IGroupedObservable<TKey, TSource>> GroupByUntil<TSource, TKey, TDuration>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<IGroupedObservable<TKey, TSource>, IObservable<TDuration>> durationSelector)

Groups the elements of an observable sequence according to a specified key selector function. A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same key value as a reclaimed group occurs, the group will be reborn with a new lifetime request.

public static IObservable<IGroupedObservable<TKey, TElement>> GroupByUntil<TSource, TKey, TElement, TDuration>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>> durationSelector, int capacity, IEqualityComparer<TKey> comparer)

Groups the elements of an observable sequence with the specified initial capacity according to a specified key selector function and comparer and selects the resulting elements by using a specified function. A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same key value as a reclaimed group occurs, the group will be reborn with a new lifetime request.

public static IObservable<IGroupedObservable<TKey, TElement>> GroupByUntil<TSource, TKey, TElement, TDuration>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>> durationSelector, int capacity)

Groups the elements of an observable sequence with the specified initial capacity according to a specified key selector function and selects the resulting elements by using a specified function. A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same key value as a reclaimed group occurs, the group will be reborn with a new lifetime request.

public static IObservable<IGroupedObservable<TKey, TSource>> GroupByUntil<TSource, TKey, TDuration>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<IGroupedObservable<TKey, TSource>, IObservable<TDuration>> durationSelector, int capacity, IEqualityComparer<TKey> comparer)

Groups the elements of an observable sequence with the specified initial capacity according to a specified key selector function and comparer. A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same key value as a reclaimed group occurs, the group will be reborn with a new lifetime request.

public static IObservable<IGroupedObservable<TKey, TSource>> GroupByUntil<TSource, TKey, TDuration>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<IGroupedObservable<TKey, TSource>, IObservable<TDuration>> durationSelector, int capacity)

Groups the elements of an observable sequence with the specified initial capacity according to a specified key selector function. A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same key value as a reclaimed group occurs, the group will be reborn with a new lifetime request.

public static IObservable<TResult> GroupJoin<TLeft, TRight, TLeftDuration, TRightDuration, TResult>(this IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, IObservable<TLeftDuration>> leftDurationSelector, Func<TRight, IObservable<TRightDuration>> rightDurationSelector, Func<TLeft, IObservable<TRight>, TResult> resultSelector)

Correlates the elements of two sequences based on overlapping durations, and groups the results.

public static IObservable<TResult> If<TResult>(Func<bool> condition, IObservable<TResult> thenSource, IObservable<TResult> elseSource)

If the specified condition evaluates true, select the thenSource sequence. Otherwise, select the elseSource sequence.

public static IObservable<TResult> If<TResult>(Func<bool> condition, IObservable<TResult> thenSource)

If the specified condition evaluates true, select the thenSource sequence. Otherwise, return an empty sequence.

public static IObservable<TResult> If<TResult>(Func<bool> condition, IObservable<TResult> thenSource, IScheduler scheduler)

If the specified condition evaluates true, select the thenSource sequence. Otherwise, return an empty sequence generated on the specified scheduler.

public static IObservable<TSource> IgnoreElements<TSource>(this IObservable<TSource> source)

Ignores all elements in an observable sequence leaving only the termination messages.

public static IObservable<long> Interval(TimeSpan period)

Returns an observable sequence that produces a value after each period.

public static IObservable<long> Interval(TimeSpan period, IScheduler scheduler)

Returns an observable sequence that produces a value after each period, using the specified scheduler to run timers and to send out observer messages.

public static IObservable<bool> IsEmpty<TSource>(this IObservable<TSource> source)

Determines whether an observable sequence is empty.

public static IObservable<TResult> Join<TLeft, TRight, TLeftDuration, TRightDuration, TResult>(this IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, IObservable<TLeftDuration>> leftDurationSelector, Func<TRight, IObservable<TRightDuration>> rightDurationSelector, Func<TLeft, TRight, TResult> resultSelector)

Correlates the elements of two sequences based on overlapping durations.

public static TSource Last<TSource>(this IObservable<TSource> source)

Returns the last element of an observable sequence.

public static TSource Last<TSource>(this IObservable<TSource> source, Func<TSource, bool> predicate)

Returns the last element of an observable sequence that satisfies the condition in the predicate.

public static IObservable<TSource> LastAsync<TSource>(this IObservable<TSource> source)

Returns the last element of an observable sequence.

public static IObservable<TSource> LastAsync<TSource>(this IObservable<TSource> source, Func<TSource, bool> predicate)

Returns the last element of an observable sequence that satisfies the condition in the predicate.

public static TSource LastOrDefault<TSource>(this IObservable<TSource> source)

Returns the last element of an observable sequence, or a default value if no such element exists.

public static TSource LastOrDefault<TSource>(this IObservable<TSource> source, Func<TSource, bool> predicate)

Returns the last element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.

public static IObservable<TSource> LastOrDefaultAsync<TSource>(this IObservable<TSource> source)

Returns the last element of an observable sequence, or a default value if no such element exists.

public static IObservable<TSource> LastOrDefaultAsync<TSource>(this IObservable<TSource> source, Func<TSource, bool> predicate)

Returns the last element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.

public static IEnumerable<TSource> Latest<TSource>(this IObservable<TSource> source)

Returns an enumerable sequence whose enumeration returns the latest observed element in the source observable sequence. Enumerators on the resulting sequence will never produce the same element repeatedly, and will block until the next element becomes available.

public static IObservable<long> LongCount<TSource>(this IObservable<TSource> source)

Returns an observable sequence containing an Int64 that represents the total number of elements in an observable sequence.

public static IObservable<long> LongCount<TSource>(this IObservable<TSource> source, Func<TSource, bool> predicate)

Returns an observable sequence containing an Int64 that represents how many elements in the specified observable sequence satisfy a condition.

public static IObservable<Notification<TSource>> Materialize<TSource>(this IObservable<TSource> source)

Materializes the implicit notifications of an observable sequence as explicit notification values.

public static IObservable<TSource> Max<TSource>(this IObservable<TSource> source)

Returns the maximum element in an observable sequence.

public static IObservable<TSource> Max<TSource>(this IObservable<TSource> source, IComparer<TSource> comparer)

Returns the maximum value in an observable sequence according to the specified comparer.

public static IObservable<double> Max(this IObservable<double> source)

Returns the maximum value in an observable sequence of Double values.

public static IObservable<float> Max(this IObservable<float> source)

Returns the maximum value in an observable sequence of Single values.

public static IObservable<decimal> Max(this IObservable<decimal> source)

Returns the maximum value in an observable sequence of Decimal values.

public static IObservable<int> Max(this IObservable<int> source)

Returns the maximum value in an observable sequence of Int32 values.

public static IObservable<long> Max(this IObservable<long> source)

Returns the maximum value in an observable sequence of Int64 values.

public static IObservable<double?> Max(this IObservable<double?> source)

Returns the maximum value in an observable sequence of nullable Double values.

public static IObservable<float?> Max(this IObservable<float?> source)

Returns the maximum value in an observable sequence of nullable Single values.

public static IObservable<decimal?> Max(this IObservable<decimal?> source)

Returns the maximum value in an observable sequence of nullable Decimal values.

public static IObservable<int?> Max(this IObservable<int?> source)

Returns the maximum value in an observable sequence of nullable Int32 values.

public static IObservable<long?> Max(this IObservable<long?> source)

Returns the maximum value in an observable sequence of nullable Int64 values.

public static IObservable<TResult> Max<TSource, TResult>(this IObservable<TSource> source, Func<TSource, TResult> selector)

Invokes a transform function on each element of a sequence and returns the maximum value.

public static IObservable<TResult> Max<TSource, TResult>(this IObservable<TSource> source, Func<TSource, TResult> selector, IComparer<TResult> comparer)

Invokes a transform function on each element of a sequence and returns the maximum value according to the specified comparer.

public static IObservable<double> Max<TSource>(this IObservable<TSource> source, Func<TSource, double> selector)

Invokes a transform function on each element of a sequence and returns the maximum Double value.

public static IObservable<float> Max<TSource>(this IObservable<TSource> source, Func<TSource, float> selector)

Invokes a transform function on each element of a sequence and returns the maximum Single value.

public static IObservable<decimal> Max<TSource>(this IObservable<TSource> source, Func<TSource, decimal> selector)

Invokes a transform function on each element of a sequence and returns the maximum Decimal value.

public static IObservable<int> Max<TSource>(this IObservable<TSource> source, Func<TSource, int> selector)

Invokes a transform function on each element of a sequence and returns the maximum Int32 value.

public static IObservable<long> Max<TSource>(this IObservable<TSource> source, Func<TSource, long> selector)

Invokes a transform function on each element of a sequence and returns the maximum Int64 value.

public static IObservable<double?> Max<TSource>(this IObservable<TSource> source, Func<TSource, double?> selector)

Invokes a transform function on each element of a sequence and returns the maximum nullable Double value.

public static IObservable<float?> Max<TSource>(this IObservable<TSource> source, Func<TSource, float?> selector)

Invokes a transform function on each element of a sequence and returns the maximum nullable Single value.

public static IObservable<decimal?> Max<TSource>(this IObservable<TSource> source, Func<TSource, decimal?> selector)

Invokes a transform function on each element of a sequence and returns the maximum nullable Decimal value.

public static IObservable<int?> Max<TSource>(this IObservable<TSource> source, Func<TSource, int?> selector)

Invokes a transform function on each element of a sequence and returns the maximum nullable Int32 value.

public static IObservable<long?> Max<TSource>(this IObservable<TSource> source, Func<TSource, long?> selector)

Invokes a transform function on each element of a sequence and returns the maximum nullable Int64 value.

public static IObservable<IList<TSource>> MaxBy<TSource, TKey>(this IObservable<TSource> source, Func<TSource, TKey> keySelector)

Returns the elements in an observable sequence with the maximum key value.

public static IObservable<IList<TSource>> MaxBy<TSource, TKey>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)

Returns the elements in an observable sequence with the maximum key value according to the specified comparer.

public static IObservable<TSource> Merge<TSource>(this IObservable<IObservable<TSource>> sources)

Merges elements from all inner observable sequences into a single observable sequence.

public static IObservable<TSource> Merge<TSource>(this IObservable<Task<TSource>> sources)

Merges results from all source tasks into a single observable sequence.

public static IObservable<TSource> Merge<TSource>(this IObservable<IObservable<TSource>> sources, int maxConcurrent)

Merges elements from all inner observable sequences into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences.

public static IObservable<TSource> Merge<TSource>(this IEnumerable<IObservable<TSource>> sources, int maxConcurrent)

Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences.

public static IObservable<TSource> Merge<TSource>(this IEnumerable<IObservable<TSource>> sources, int maxConcurrent, IScheduler scheduler)

Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences, and using the specified scheduler for enumeration of and subscription to the sources.

public static IObservable<TSource> Merge<TSource>(this IObservable<TSource> first, IObservable<TSource> second)

Merges elements from two observable sequences into a single observable sequence.

public static IObservable<TSource> Merge<TSource>(this IObservable<TSource> first, IObservable<TSource> second, IScheduler scheduler)

Merges elements from two observable sequences into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources.

public static IObservable<TSource> Merge<TSource>(IObservable<TSource>[] sources)

Merges elements from all of the specified observable sequences into a single observable sequence.

public static IObservable<TSource> Merge<TSource>(IScheduler scheduler, IObservable<TSource>[] sources)

Merges elements from all of the specified observable sequences into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources.

public static IObservable<TSource> Merge<TSource>(this IEnumerable<IObservable<TSource>> sources)

Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence.

public static IObservable<TSource> Merge<TSource>(this IEnumerable<IObservable<TSource>> sources, IScheduler scheduler)

Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources.

public static IObservable<TSource> Min<TSource>(this IObservable<TSource> source)

Returns the minimum element in an observable sequence.

public static IObservable<TSource> Min<TSource>(this IObservable<TSource> source, IComparer<TSource> comparer)

Returns the minimum element in an observable sequence according to the specified comparer.

public static IObservable<double> Min(this IObservable<double> source)

Returns the minimum value in an observable sequence of Double values.

public static IObservable<float> Min(this IObservable<float> source)

Returns the minimum value in an observable sequence of Single values.

public static IObservable<decimal> Min(this IObservable<decimal> source)

Returns the minimum value in an observable sequence of Decimal values.

public static IObservable<int> Min(this IObservable<int> source)

Returns the minimum value in an observable sequence of Int32 values.

public static IObservable<long> Min(this IObservable<long> source)

Returns the minimum value in an observable sequence of Int64 values.

public static IObservable<double?> Min(this IObservable<double?> source)

Returns the minimum value in an observable sequence of nullable Double values.

public static IObservable<float?> Min(this IObservable<float?> source)

Returns the minimum value in an observable sequence of nullable Single values.

public static IObservable<decimal?> Min(this IObservable<decimal?> source)

Returns the minimum value in an observable sequence of nullable Decimal values.

public static IObservable<int?> Min(this IObservable<int?> source)

Returns the minimum value in an observable sequence of nullable Int32 values.

public static IObservable<long?> Min(this IObservable<long?> source)

Returns the minimum value in an observable sequence of nullable Int64 values.

public static IObservable<TResult> Min<TSource, TResult>(this IObservable<TSource> source, Func<TSource, TResult> selector)

Invokes a transform function on each element of a sequence and returns the minimum value.

public static IObservable<TResult> Min<TSource, TResult>(this IObservable<TSource> source, Func<TSource, TResult> selector, IComparer<TResult> comparer)

Invokes a transform function on each element of a sequence and returns the minimum value according to the specified comparer.

public static IObservable<double> Min<TSource>(this IObservable<TSource> source, Func<TSource, double> selector)

Invokes a transform function on each element of a sequence and returns the minimum Double value.

public static IObservable<float> Min<TSource>(this IObservable<TSource> source, Func<TSource, float> selector)

Invokes a transform function on each element of a sequence and returns the minimum Single value.

public static IObservable<decimal> Min<TSource>(this IObservable<TSource> source, Func<TSource, decimal> selector)

Invokes a transform function on each element of a sequence and returns the minimum Decimal value.

public static IObservable<int> Min<TSource>(this IObservable<TSource> source, Func<TSource, int> selector)

Invokes a transform function on each element of a sequence and returns the minimum Int32 value.

public static IObservable<long> Min<TSource>(this IObservable<TSource> source, Func<TSource, long> selector)

Invokes a transform function on each element of a sequence and returns the minimum Int64 value.

public static IObservable<double?> Min<TSource>(this IObservable<TSource> source, Func<TSource, double?> selector)

Invokes a transform function on each element of a sequence and returns the minimum nullable Double value.

public static IObservable<float?> Min<TSource>(this IObservable<TSource> source, Func<TSource, float?> selector)

Invokes a transform function on each element of a sequence and returns the minimum nullable Single value.

public static IObservable<decimal?> Min<TSource>(this IObservable<TSource> source, Func<TSource, decimal?> selector)

Invokes a transform function on each element of a sequence and returns the minimum nullable Decimal value.

public static IObservable<int?> Min<TSource>(this IObservable<TSource> source, Func<TSource, int?> selector)

Invokes a transform function on each element of a sequence and returns the minimum nullable Int32 value.

public static IObservable<long?> Min<TSource>(this IObservable<TSource> source, Func<TSource, long?> selector)

Invokes a transform function on each element of a sequence and returns the minimum nullable Int64 value.

public static IObservable<IList<TSource>> MinBy<TSource, TKey>(this IObservable<TSource> source, Func<TSource, TKey> keySelector)

Returns the elements in an observable sequence with the minimum key value.

public static IObservable<IList<TSource>> MinBy<TSource, TKey>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)

Returns the elements in an observable sequence with the minimum key value according to the specified comparer.

public static IEnumerable<TSource> MostRecent<TSource>(this IObservable<TSource> source, TSource initialValue)

Returns an enumerable sequence whose enumeration returns the most recently observed element in the source observable sequence, using the specified initial value in case no element has been sampled yet. Enumerators on the resulting sequence never block and can produce the same element repeatedly.

public static IConnectableObservable<TResult> Multicast<TSource, TResult>(this IObservable<TSource> source, ISubject<TSource, TResult> subject)

Multicasts the source sequence notifications through the specified subject to the resulting connectable observable. Upon connection of the connectable observable, the subject is subscribed to the source exactly one, and messages are forwarded to the observers registered with the connectable observable. For specializations with fixed subject types, see Publish, PublishLast, and Replay.

public static IObservable<TResult> Multicast<TSource, TIntermediate, TResult>(this IObservable<TSource> source, Func<ISubject<TSource, TIntermediate>> subjectSelector, Func<IObservable<TIntermediate>, IObservable<TResult>> selector)

Multicasts the source sequence notifications through an instantiated subject into all uses of the sequence within a selector function. Each subscription to the resulting sequence causes a separate multicast invocation, exposing the sequence resulting from the selector function's invocation. For specializations with fixed subject types, see Publish, PublishLast, and Replay.

public static IObservable<TResult> Never<TResult>()

Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g. when using reactive joins).

public static IObservable<TResult> Never<TResult>(TResult witness)

Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g. when using reactive joins).

public static IEnumerable<TSource> Next<TSource>(this IObservable<TSource> source)

Returns an enumerable sequence whose enumeration blocks until the next element in the source observable sequence becomes available. Enumerators on the resulting sequence will block until the next element becomes available.

public static IObservable<TSource> ObserveOn<TSource>(this IObservable<TSource> source, IScheduler scheduler)

Wraps the source sequence in order to run its observer callbacks on the specified scheduler.

public static IObservable<TSource> ObserveOn<TSource>(this IObservable<TSource> source, SynchronizationContext context)

Wraps the source sequence in order to run its observer callbacks on the specified synchronization context.

public static IObservable<TResult> OfType<TResult>(this IObservable<object> source)

Filters the elements of an observable sequence based on the specified type.

public static IObservable<TSource> OnErrorResumeNext<TSource>(this IObservable<TSource> first, IObservable<TSource> second)

Concatenates the second observable sequence to the first observable sequence upon successful or exceptional termination of the first.

public static IObservable<TSource> OnErrorResumeNext<TSource>(IObservable<TSource>[] sources)

Concatenates all of the specified observable sequences, even if the previous observable sequence terminated exceptionally.

public static IObservable<TSource> OnErrorResumeNext<TSource>(this IEnumerable<IObservable<TSource>> sources)

Concatenates all observable sequences in the given enumerable sequence, even if the previous observable sequence terminated exceptionally.

public static IObservable<TSource> Prepend<TSource>(this IObservable<TSource> source, TSource value)

Prepend a value to an observable sequence.

public static IObservable<TSource> Prepend<TSource>(this IObservable<TSource> source, TSource value, IScheduler scheduler)

Prepend a value to an observable sequence.

public static IConnectableObservable<TSource> Publish<TSource>(this IObservable<TSource> source)

Returns a connectable observable sequence that shares a single subscription to the underlying sequence. This operator is a specialization of Multicast using a regular Subject<T>.

public static IObservable<TResult> Publish<TSource, TResult>(this IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector)

Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence. This operator is a specialization of Multicast using a regular Subject<T>.

public static IConnectableObservable<TSource> Publish<TSource>(this IObservable<TSource> source, TSource initialValue)

Returns a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue. This operator is a specialization of Multicast using a BehaviorSubject<T>.

public static IObservable<TResult> Publish<TSource, TResult>(this IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, TSource initialValue)

Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue. This operator is a specialization of Multicast using a BehaviorSubject<T>.

public static IConnectableObservable<TSource> PublishLast<TSource>(this IObservable<TSource> source)

Returns a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification. This operator is a specialization of Multicast using a AsyncSubject<T>.

public static IObservable<TResult> PublishLast<TSource, TResult>(this IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector)

Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification. This operator is a specialization of Multicast using a AsyncSubject<T>.

public static IObservable<int> Range(int start, int count)

Generates an observable sequence of integral numbers within a specified range.

public static IObservable<int> Range(int start, int count, IScheduler scheduler)

Generates an observable sequence of integral numbers within a specified range, using the specified scheduler to send out observer messages.

public static IObservable<TSource> RefCount<TSource>(this IConnectableObservable<TSource> source)

Returns an observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence.

public static IObservable<TSource> RefCount<TSource>(this IConnectableObservable<TSource> source, TimeSpan disconnectDelay)

Returns an observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence.

public static IObservable<TSource> RefCount<TSource>(this IConnectableObservable<TSource> source, TimeSpan disconnectDelay, IScheduler scheduler)

Returns an observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence.

public static IObservable<TSource> RefCount<TSource>(this IConnectableObservable<TSource> source, int minObservers)

Returns an observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence.

public static IObservable<TSource> RefCount<TSource>(this IConnectableObservable<TSource> source, int minObservers, TimeSpan disconnectDelay)

Returns an observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence.

public static IObservable<TSource> RefCount<TSource>(this IConnectableObservable<TSource> source, int minObservers, TimeSpan disconnectDelay, IScheduler scheduler)

Returns an observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence.

public static IObservable<TResult> Repeat<TResult>(TResult value)

Generates an observable sequence that repeats the given element infinitely.

public static IObservable<TResult> Repeat<TResult>(TResult value, IScheduler scheduler)

Generates an observable sequence that repeats the given element infinitely, using the specified scheduler to send out observer messages.

public static IObservable<TResult> Repeat<TResult>(TResult value, int repeatCount)

Generates an observable sequence that repeats the given element the specified number of times.

public static IObservable<TResult> Repeat<TResult>(TResult value, int repeatCount, IScheduler scheduler)

Generates an observable sequence that repeats the given element the specified number of times, using the specified scheduler to send out observer messages.

public static IObservable<TSource> Repeat<TSource>(this IObservable<TSource> source)

Repeats the observable sequence indefinitely.

public static IObservable<TSource> Repeat<TSource>(this IObservable<TSource> source, int repeatCount)

Repeats the observable sequence a specified number of times.

public static IObservable<TSource> RepeatWhen<TSource, TSignal>(this IObservable<TSource> source, Func<IObservable<object>, IObservable<TSignal>> handler)

Repeatedly resubscribes to the source observable after a normal completion and when the observable returned by a handler produces an arbitrary item.

public static IConnectableObservable<TSource> Replay<TSource>(this IObservable<TSource> source)

Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. This operator is a specialization of Multicast using a ReplaySubject<T>.

public static IConnectableObservable<TSource> Replay<TSource>(this IObservable<TSource> source, IScheduler scheduler)

Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. This operator is a specialization of Multicast using a ReplaySubject<T>.

public static IObservable<TResult> Replay<TSource, TResult>(this IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector)

Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. This operator is a specialization of Multicast using a ReplaySubject<T>.

public static IObservable<TResult> Replay<TSource, TResult>(this IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, IScheduler scheduler)

Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. This operator is a specialization of Multicast using a ReplaySubject<T>.

public static IConnectableObservable<TSource> Replay<TSource>(this IObservable<TSource> source, TimeSpan window)

Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. This operator is a specialization of Multicast using a ReplaySubject<T>.

public static IObservable<TResult> Replay<TSource, TResult>(this IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, TimeSpan window)

Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. This operator is a specialization of Multicast using a ReplaySubject<T>.

public static IConnectableObservable<TSource> Replay<TSource>(this IObservable<TSource> source, TimeSpan window, IScheduler scheduler)

Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. This operator is a specialization of Multicast using a ReplaySubject<T>.

public static IObservable<TResult> Replay<TSource, TResult>(this IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, TimeSpan window, IScheduler scheduler)

Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. This operator is a specialization of Multicast using a ReplaySubject<T>.

public static IConnectableObservable<TSource> Replay<TSource>(this IObservable<TSource> source, int bufferSize, IScheduler scheduler)

Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying bufferSize notifications. This operator is a specialization of Multicast using a ReplaySubject<T>.

public static IObservable<TResult> Replay<TSource, TResult>(this IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, int bufferSize, IScheduler scheduler)

Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. This operator is a specialization of Multicast using a ReplaySubject<T>.

public static IConnectableObservable<TSource> Replay<TSource>(this IObservable<TSource> source, int bufferSize)

Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. This operator is a specialization of Multicast using a ReplaySubject<T>.

public static IObservable<TResult> Replay<TSource, TResult>(this IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, int bufferSize)

Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. This operator is a specialization of Multicast using a ReplaySubject<T>.

public static IConnectableObservable<TSource> Replay<TSource>(this IObservable<TSource> source, int bufferSize, TimeSpan window)

Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. This operator is a specialization of Multicast using a ReplaySubject<T>.

public static IObservable<TResult> Replay<TSource, TResult>(this IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, int bufferSize, TimeSpan window)

Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. This operator is a specialization of Multicast using a ReplaySubject<T>.

public static IConnectableObservable<TSource> Replay<TSource>(this IObservable<TSource> source, int bufferSize, TimeSpan window, IScheduler scheduler)

Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. This operator is a specialization of Multicast using a ReplaySubject<T>.

public static IObservable<TResult> Replay<TSource, TResult>(this IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, int bufferSize, TimeSpan window, IScheduler scheduler)

Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. This operator is a specialization of Multicast using a ReplaySubject<T>.

public static IObservable<TSource> Retry<TSource>(this IObservable<TSource> source)

Repeats the source observable sequence until it successfully terminates.

public static IObservable<TSource> Retry<TSource>(this IObservable<TSource> source, int retryCount)

Repeats the source observable sequence the specified number of times or until it successfully terminates.

public static IObservable<TSource> RetryWhen<TSource, TSignal>(this IObservable<TSource> source, Func<IObservable<Exception>, IObservable<TSignal>> handler)

Retries (resubscribes to) the source observable after a failure and when the observable returned by a handler produces an arbitrary item.

public static IObservable<TResult> Return<TResult>(TResult value)

Returns an observable sequence that contains a single element.

public static IObservable<TResult> Return<TResult>(TResult value, IScheduler scheduler)

Returns an observable sequence that contains a single element, using the specified scheduler to send out observer messages.

public static AsyncSubject<TSource> RunAsync<TSource>(this IObservable<TSource> source, CancellationToken cancellationToken)

Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. This operation subscribes to the observable sequence, making it hot. The supplied CancellationToken can be used to cancel the subscription.

public static AsyncSubject<TSource> RunAsync<TSource>(this IConnectableObservable<TSource> source, CancellationToken cancellationToken)

Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. This operation subscribes and connects to the observable sequence, making it hot. The supplied CancellationToken can be used to cancel the subscription and connection.

public static IObservable<TSource> Sample<TSource>(this IObservable<TSource> source, TimeSpan interval)

Samples the observable sequence at each interval. Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence.

public static IObservable<TSource> Sample<TSource>(this IObservable<TSource> source, TimeSpan interval, IScheduler scheduler)

Samples the observable sequence at each interval, using the specified scheduler to run sampling timers. Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence.

public static IObservable<TSource> Sample<TSource, TSample>(this IObservable<TSource> source, IObservable<TSample> sampler)

Samples the source observable sequence using a sampler observable sequence producing sampling ticks. Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence.

public static IObservable<TAccumulate> Scan<TSource, TAccumulate>(this IObservable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator)

Applies an accumulator function over an observable sequence and returns each intermediate result. The specified seed value is used as the initial accumulator value. For aggregation behavior with no intermediate results, see Aggregate<T, U>.

public static IObservable<TSource> Scan<TSource>(this IObservable<TSource> source, Func<TSource, TSource, TSource> accumulator)

Applies an accumulator function over an observable sequence and returns each intermediate result. For aggregation behavior with no intermediate results, see Aggregate<T>.

public static IObservable<TResult> Select<TSource, TResult>(this IObservable<TSource> source, Func<TSource, TResult> selector)

Projects each element of an observable sequence into a new form.

public static IObservable<TResult> Select<TSource, TResult>(this IObservable<TSource> source, Func<TSource, int, TResult> selector)

Projects each element of an observable sequence into a new form by incorporating the element's index.

public static IObservable<TOther> SelectMany<TSource, TOther>(this IObservable<TSource> source, IObservable<TOther> other)

Projects each element of the source observable sequence to the other observable sequence and merges the resulting observable sequences into one observable sequence.

public static IObservable<TResult> SelectMany<TSource, TResult>(this IObservable<TSource> source, Func<TSource, IObservable<TResult>> selector)

Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.

public static IObservable<TResult> SelectMany<TSource, TResult>(this IObservable<TSource> source, Func<TSource, int, IObservable<TResult>> selector)

Projects each element of an observable sequence to an observable sequence by incorporating the element's index and merges the resulting observable sequences into one observable sequence.

public static IObservable<TResult> SelectMany<TSource, TResult>(this IObservable<TSource> source, Func<TSource, Task<TResult>> selector)

Projects each element of an observable sequence to a task and merges all of the task results into one observable sequence.

public static IObservable<TResult> SelectMany<TSource, TResult>(this IObservable<TSource> source, Func<TSource, int, Task<TResult>> selector)

Projects each element of an observable sequence to a task by incorporating the element's index and merges all of the task results into one observable sequence.

public static IObservable<TResult> SelectMany<TSource, TResult>(this IObservable<TSource> source, Func<TSource, CancellationToken, Task<TResult>> selector)

Projects each element of an observable sequence to a task with cancellation support and merges all of the task results into one observable sequence.

public static IObservable<TResult> SelectMany<TSource, TResult>(this IObservable<TSource> source, Func<TSource, int, CancellationToken, Task<TResult>> selector)

Projects each element of an observable sequence to a task by incorporating the element's index with cancellation support and merges all of the task results into one observable sequence.

public static IObservable<TResult> SelectMany<TSource, TCollection, TResult>(this IObservable<TSource> source, Func<TSource, IObservable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)

Projects each element of an observable sequence to an observable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence.

public static IObservable<TResult> SelectMany<TSource, TCollection, TResult>(this IObservable<TSource> source, Func<TSource, int, IObservable<TCollection>> collectionSelector, Func<TSource, int, TCollection, int, TResult> resultSelector)

Projects each element of an observable sequence to an observable sequence by incorporating the element's index, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence.

public static IObservable<TResult> SelectMany<TSource, TTaskResult, TResult>(this IObservable<TSource> source, Func<TSource, Task<TTaskResult>> taskSelector, Func<TSource, TTaskResult, TResult> resultSelector)

Projects each element of an observable sequence to a task, invokes the result selector for the source element and the task result, and merges the results into one observable sequence.

public static IObservable<TResult> SelectMany<TSource, TTaskResult, TResult>(this IObservable<TSource> source, Func<TSource, int, Task<TTaskResult>> taskSelector, Func<TSource, int, TTaskResult, TResult> resultSelector)

Projects each element of an observable sequence to a task by incorporating the element's index, invokes the result selector for the source element and the task result, and merges the results into one observable sequence.

public static IObservable<TResult> SelectMany<TSource, TTaskResult, TResult>(this IObservable<TSource> source, Func<TSource, CancellationToken, Task<TTaskResult>> taskSelector, Func<TSource, TTaskResult, TResult> resultSelector)

Projects each element of an observable sequence to a task with cancellation support, invokes the result selector for the source element and the task result, and merges the results into one observable sequence.

public static IObservable<TResult> SelectMany<TSource, TTaskResult, TResult>(this IObservable<TSource> source, Func<TSource, int, CancellationToken, Task<TTaskResult>> taskSelector, Func<TSource, int, TTaskResult, TResult> resultSelector)

Projects each element of an observable sequence to a task by incorporating the element's index with cancellation support, invokes the result selector for the source element and the task result, and merges the results into one observable sequence.

public static IObservable<TResult> SelectMany<TSource, TResult>(this IObservable<TSource> source, Func<TSource, IObservable<TResult>> onNext, Func<Exception, IObservable<TResult>> onError, Func<IObservable<TResult>> onCompleted)

Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.

public static IObservable<TResult> SelectMany<TSource, TResult>(this IObservable<TSource> source, Func<TSource, int, IObservable<TResult>> onNext, Func<Exception, IObservable<TResult>> onError, Func<IObservable<TResult>> onCompleted)

Projects each notification of an observable sequence to an observable sequence by incorporating the element's index and merges the resulting observable sequences into one observable sequence.

public static IObservable<TResult> SelectMany<TSource, TResult>(this IObservable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)

Projects each element of an observable sequence to an enumerable sequence and concatenates the resulting enumerable sequences into one observable sequence.

public static IObservable<TResult> SelectMany<TSource, TResult>(this IObservable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector)

Projects each element of an observable sequence to an enumerable sequence by incorporating the element's index and concatenates the resulting enumerable sequences into one observable sequence.

public static IObservable<TResult> SelectMany<TSource, TCollection, TResult>(this IObservable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)

Projects each element of an observable sequence to an enumerable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence.

public static IObservable<TResult> SelectMany<TSource, TCollection, TResult>(this IObservable<TSource> source, Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, int, TCollection, int, TResult> resultSelector)

Projects each element of an observable sequence to an enumerable sequence by incorporating the element's index, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence.

public static IObservable<bool> SequenceEqual<TSource>(this IObservable<TSource> first, IObservable<TSource> second)

Determines whether two sequences are equal by comparing the elements pairwise.

public static IObservable<bool> SequenceEqual<TSource>(this IObservable<TSource> first, IObservable<TSource> second, IEqualityComparer<TSource> comparer)

Determines whether two sequences are equal by comparing the elements pairwise using a specified equality comparer.

public static IObservable<bool> SequenceEqual<TSource>(this IObservable<TSource> first, IEnumerable<TSource> second)

Determines whether an observable and enumerable sequence are equal by comparing the elements pairwise.

public static IObservable<bool> SequenceEqual<TSource>(this IObservable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)

Determines whether an observable and enumerable sequence are equal by comparing the elements pairwise using a specified equality comparer.

public static TSource Single<TSource>(this IObservable<TSource> source)

Returns the only element of an observable sequence, and throws an exception if there is not exactly one element in the observable sequence.

public static TSource Single<TSource>(this IObservable<TSource> source, Func<TSource, bool> predicate)

Returns the only element of an observable sequence that satisfies the condition in the predicate, and throws an exception if there is not exactly one element matching the predicate in the observable sequence.

public static IObservable<TSource> SingleAsync<TSource>(this IObservable<TSource> source)

Returns the only element of an observable sequence, and reports an exception if there is not exactly one element in the observable sequence.

public static IObservable<TSource> SingleAsync<TSource>(this IObservable<TSource> source, Func<TSource, bool> predicate)

Returns the only element of an observable sequence that satisfies the condition in the predicate, and reports an exception if there is not exactly one element in the observable sequence.

public static TSource SingleOrDefault<TSource>(this IObservable<TSource> source)

Returns the only element of an observable sequence, or a default value if the observable sequence is empty; this method throws an exception if there is more than one element in the observable sequence.

public static TSource SingleOrDefault<TSource>(this IObservable<TSource> source, Func<TSource, bool> predicate)

Returns the only element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists; this method throws an exception if there is more than one element matching the predicate in the observable sequence.

public static IObservable<TSource> SingleOrDefaultAsync<TSource>(this IObservable<TSource> source)

Returns the only element of an observable sequence, or a default value if the observable sequence is empty; this method reports an exception if there is more than one element in the observable sequence.

public static IObservable<TSource> SingleOrDefaultAsync<TSource>(this IObservable<TSource> source, Func<TSource, bool> predicate)

Returns the only element of an observable sequence that matches the predicate, or a default value if no such element exists; this method reports an exception if there is more than one element in the observable sequence.

public static IObservable<TSource> Skip<TSource>(this IObservable<TSource> source, int count)

Bypasses a specified number of elements in an observable sequence and then returns the remaining elements.

public static IObservable<TSource> Skip<TSource>(this IObservable<TSource> source, TimeSpan duration)

Skips elements for the specified duration from the start of the observable source sequence.

public static IObservable<TSource> Skip<TSource>(this IObservable<TSource> source, TimeSpan duration, IScheduler scheduler)

Skips elements for the specified duration from the start of the observable source sequence, using the specified scheduler to run timers.

public static IObservable<TSource> SkipLast<TSource>(this IObservable<TSource> source, int count)

Bypasses a specified number of elements at the end of an observable sequence.

public static IObservable<TSource> SkipLast<TSource>(this IObservable<TSource> source, TimeSpan duration)

Skips elements for the specified duration from the end of the observable source sequence.

public static IObservable<TSource> SkipLast<TSource>(this IObservable<TSource> source, TimeSpan duration, IScheduler scheduler)

Skips elements for the specified duration from the end of the observable source sequence, using the specified scheduler to run timers.

public static IObservable<TSource> SkipUntil<TSource, TOther>(this IObservable<TSource> source, IObservable<TOther> other)

Returns the elements from the source observable sequence only after the other observable sequence produces an element. Starting from Rx.NET 4.0, this will subscribe to other before subscribing to source so in case other emits an element right away, elements from source are not missed.

public static IObservable<TSource> SkipUntil<TSource>(this IObservable<TSource> source, DateTimeOffset startTime)

Skips elements from the observable source sequence until the specified start time.

public static IObservable<TSource> SkipUntil<TSource>(this IObservable<TSource> source, DateTimeOffset startTime, IScheduler scheduler)

Skips elements from the observable source sequence until the specified start time, using the specified scheduler to run timers.

public static IObservable<TSource> SkipWhile<TSource>(this IObservable<TSource> source, Func<TSource, bool> predicate)

Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements.

public static IObservable<TSource> SkipWhile<TSource>(this IObservable<TSource> source, Func<TSource, int, bool> predicate)

Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements. The element's index is used in the logic of the predicate function.

public static IObservable<TResult> Start<TResult>(Func<TResult> function)

Invokes the specified function asynchronously, surfacing the result through an observable sequence.

public static IObservable<TResult> Start<TResult>(Func<TResult> function, IScheduler scheduler)

Invokes the specified function asynchronously on the specified scheduler, surfacing the result through an observable sequence

public static IObservable<Unit> Start(Action action)

Invokes the action asynchronously, surfacing the result through an observable sequence.

public static IObservable<Unit> Start(Action action, IScheduler scheduler)

Invokes the action asynchronously on the specified scheduler, surfacing the result through an observable sequence.

public static IObservable<TResult> StartAsync<TResult>(Func<Task<TResult>> functionAsync)

Invokes the asynchronous function, surfacing the result through an observable sequence.

public static IObservable<TResult> StartAsync<TResult>(Func<Task<TResult>> functionAsync, IScheduler scheduler)

Invokes the asynchronous function, surfacing the result through an observable sequence.

public static IObservable<TResult> StartAsync<TResult>(Func<Task<TResult>> functionAsync, TaskObservationOptions options)

Invokes the asynchronous function, surfacing the result through an observable sequence.

public static IObservable<TResult> StartAsync<TResult>(Func<CancellationToken, Task<TResult>> functionAsync)

Invokes the asynchronous function, surfacing the result through an observable sequence. The CancellationToken is shared by all subscriptions on the resulting observable sequence. See the remarks section for more information.

public static IObservable<TResult> StartAsync<TResult>(Func<CancellationToken, Task<TResult>> functionAsync, IScheduler scheduler)

Invokes the asynchronous function, surfacing the result through an observable sequence. The CancellationToken is shared by all subscriptions on the resulting observable sequence. See the remarks section for more information.

public static IObservable<TResult> StartAsync<TResult>(Func<CancellationToken, Task<TResult>> functionAsync, TaskObservationOptions options)

Invokes the asynchronous function, surfacing the result through an observable sequence. The CancellationToken is shared by all subscriptions on the resulting observable sequence. See the remarks section for more information.

public static IObservable<Unit> StartAsync(Func<Task> actionAsync)

Invokes the asynchronous action, surfacing the result through an observable sequence.

public static IObservable<Unit> StartAsync(Func<Task> actionAsync, IScheduler scheduler)

Invokes the asynchronous action, surfacing the result through an observable sequence.

public static IObservable<Unit> StartAsync(Func<Task> actionAsync, TaskObservationOptions options)

Invokes the asynchronous action, surfacing the result through an observable sequence.

public static IObservable<Unit> StartAsync(Func<CancellationToken, Task> actionAsync)

Invokes the asynchronous action, surfacing the result through an observable sequence. The CancellationToken is shared by all subscriptions on the resulting observable sequence. See the remarks section for more information.

public static IObservable<Unit> StartAsync(Func<CancellationToken, Task> actionAsync, IScheduler scheduler)

Invokes the asynchronous action, surfacing the result through an observable sequence. The CancellationToken is shared by all subscriptions on the resulting observable sequence. See the remarks section for more information.

public static IObservable<Unit> StartAsync(Func<CancellationToken, Task> actionAsync, TaskObservationOptions options)

Invokes the asynchronous action, surfacing the result through an observable sequence. The CancellationToken is shared by all subscriptions on the resulting observable sequence. See the remarks section for more information.

public static IObservable<TSource> StartWith<TSource>(this IObservable<TSource> source, TSource[] values)

Prepends a sequence of values to an observable sequence.

public static IObservable<TSource> StartWith<TSource>(this IObservable<TSource> source, IEnumerable<TSource> values)

Prepends a sequence of values to an observable sequence.

public static IObservable<TSource> StartWith<TSource>(this IObservable<TSource> source, IScheduler scheduler, TSource[] values)

Prepends a sequence of values to an observable sequence.

public static IObservable<TSource> StartWith<TSource>(this IObservable<TSource> source, IScheduler scheduler, IEnumerable<TSource> values)

Prepends a sequence of values to an observable sequence.

public static IDisposable Subscribe<TSource>(this IEnumerable<TSource> source, IObserver<TSource> observer)

Subscribes an observer to an enumerable sequence.

public static IDisposable Subscribe<TSource>(this IEnumerable<TSource> source, IObserver<TSource> observer, IScheduler scheduler)

Subscribes an observer to an enumerable sequence, using the specified scheduler to run the enumeration loop.

public static IObservable<TSource> SubscribeOn<TSource>(this IObservable<TSource> source, IScheduler scheduler)

Wraps the source sequence in order to run its subscription and unsubscription logic on the specified scheduler. This operation is not commonly used; see the remarks section for more information on the distinction between SubscribeOn and ObserveOn.

public static IObservable<TSource> SubscribeOn<TSource>(this IObservable<TSource> source, SynchronizationContext context)

Wraps the source sequence in order to run its subscription and unsubscription logic on the specified synchronization context. This operation is not commonly used; see the remarks section for more information on the distinction between SubscribeOn and ObserveOn.

public static IObservable<double> Sum(this IObservable<double> source)

Computes the sum of a sequence of Double values.

public static IObservable<float> Sum(this IObservable<float> source)

Computes the sum of a sequence of Single values.

public static IObservable<decimal> Sum(this IObservable<decimal> source)

Computes the sum of a sequence of Decimal values.

public static IObservable<int> Sum(this IObservable<int> source)

Computes the sum of a sequence of Int32 values.

public static IObservable<long> Sum(this IObservable<long> source)

Computes the sum of a sequence of Int64 values.

public static IObservable<double?> Sum(this IObservable<double?> source)

Computes the sum of a sequence of nullable Double values.

public static IObservable<float?> Sum(this IObservable<float?> source)

Computes the sum of a sequence of nullable Single values.

public static IObservable<decimal?> Sum(this IObservable<decimal?> source)

Computes the sum of a sequence of nullable Decimal values.

public static IObservable<int?> Sum(this IObservable<int?> source)

Computes the sum of a sequence of nullable Int32 values.

public static IObservable<long?> Sum(this IObservable<long?> source)

Computes the sum of a sequence of nullable Int64 values.

public static IObservable<double> Sum<TSource>(this IObservable<TSource> source, Func<TSource, double> selector)

Computes the sum of a sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.

public static IObservable<float> Sum<TSource>(this IObservable<TSource> source, Func<TSource, float> selector)

Computes the sum of a sequence of Single values that are obtained by invoking a transform function on each element of the input sequence.

public static IObservable<decimal> Sum<TSource>(this IObservable<TSource> source, Func<TSource, decimal> selector)

Computes the sum of a sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.

public static IObservable<int> Sum<TSource>(this IObservable<TSource> source, Func<TSource, int> selector)

Computes the sum of a sequence of Int32 values that are obtained by invoking a transform function on each element of the input sequence.

public static IObservable<long> Sum<TSource>(this IObservable<TSource> source, Func<TSource, long> selector)

Computes the sum of a sequence of Int64 values that are obtained by invoking a transform function on each element of the input sequence.

public static IObservable<double?> Sum<TSource>(this IObservable<TSource> source, Func<TSource, double?> selector)

Computes the sum of a sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.

public static IObservable<float?> Sum<TSource>(this IObservable<TSource> source, Func<TSource, float?> selector)

Computes the sum of a sequence of nullable Single values that are obtained by invoking a transform function on each element of the input sequence.

public static IObservable<decimal?> Sum<TSource>(this IObservable<TSource> source, Func<TSource, decimal?> selector)

Computes the sum of a sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.

public static IObservable<int?> Sum<TSource>(this IObservable<TSource> source, Func<TSource, int?> selector)

Computes the sum of a sequence of nullable Int32 values that are obtained by invoking a transform function on each element of the input sequence.

public static IObservable<long?> Sum<TSource>(this IObservable<TSource> source, Func<TSource, long?> selector)

Computes the sum of a sequence of nullable Int64 values that are obtained by invoking a transform function on each element of the input sequence.

public static IObservable<TSource> Switch<TSource>(this IObservable<IObservable<TSource>> sources)

Transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence. Each time a new inner observable sequence is received, unsubscribe from the previous inner observable sequence.

public static IObservable<TSource> Switch<TSource>(this IObservable<Task<TSource>> sources)

Transforms an observable sequence of tasks into an observable sequence producing values only from the most recent observable sequence. Each time a new task is received, the previous task's result is ignored.

public static IObservable<TSource> Synchronize<TSource>(this IObservable<TSource> source)

Synchronizes the observable sequence such that observer notifications cannot be delivered concurrently. This overload is useful to "fix" an observable sequence that exhibits concurrent callbacks on individual observers, which is invalid behavior for the query processor.

public static IObservable<TSource> Synchronize<TSource>(this IObservable<TSource> source, object gate)

Synchronizes the observable sequence such that observer notifications cannot be delivered concurrently, using the specified gate object. This overload is useful when writing n-ary query operators, in order to prevent concurrent callbacks from different sources by synchronizing on a common gate object.

public static IObservable<TSource> Take<TSource>(this IObservable<TSource> source, int count)

Returns a specified number of contiguous elements from the start of an observable sequence.

public static IObservable<TSource> Take<TSource>(this IObservable<TSource> source, int count, IScheduler scheduler)

Returns a specified number of contiguous elements from the start of an observable sequence, using the specified scheduler for the edge case of Take(0).

public static IObservable<TSource> Take<TSource>(this IObservable<TSource> source, TimeSpan duration)

Takes elements for the specified duration from the start of the observable source sequence.

public static IObservable<TSource> Take<TSource>(this IObservable<TSource> source, TimeSpan duration, IScheduler scheduler)

Takes elements for the specified duration from the start of the observable source sequence, using the specified scheduler to run timers.

public static IObservable<TSource> TakeLast<TSource>(this IObservable<TSource> source, int count)

Returns a specified number of contiguous elements from the end of an observable sequence.

public static IObservable<TSource> TakeLast<TSource>(this IObservable<TSource> source, int count, IScheduler scheduler)

Returns a specified number of contiguous elements from the end of an observable sequence, using the specified scheduler to drain the queue.

public static IObservable<TSource> TakeLast<TSource>(this IObservable<TSource> source, TimeSpan duration)

Returns elements within the specified duration from the end of the observable source sequence.

public static IObservable<TSource> TakeLast<TSource>(this IObservable<TSource> source, TimeSpan duration, IScheduler scheduler)

Returns elements within the specified duration from the end of the observable source sequence, using the specified scheduler to run timers.

public static IObservable<TSource> TakeLast<TSource>(this IObservable<TSource> source, TimeSpan duration, IScheduler timerScheduler, IScheduler loopScheduler)

Returns elements within the specified duration from the end of the observable source sequence, using the specified schedulers to run timers and to drain the collected elements.

public static IObservable<IList<TSource>> TakeLastBuffer<TSource>(this IObservable<TSource> source, int count)

Returns a list with the specified number of contiguous elements from the end of an observable sequence.

public static IObservable<IList<TSource>> TakeLastBuffer<TSource>(this IObservable<TSource> source, TimeSpan duration)

Returns a list with the elements within the specified duration from the end of the observable source sequence.

public static IObservable<IList<TSource>> TakeLastBuffer<TSource>(this IObservable<TSource> source, TimeSpan duration, IScheduler scheduler)

Returns a list with the elements within the specified duration from the end of the observable source sequence, using the specified scheduler to run timers.

public static IObservable<TSource> TakeUntil<TSource, TOther>(this IObservable<TSource> source, IObservable<TOther> other)

Returns the elements from the source observable sequence until the other observable sequence produces an element.

public static IObservable<TSource> TakeUntil<TSource>(this IObservable<TSource> source, Func<TSource, bool> stopPredicate)

Relays elements from the source observable sequence and calls the predicate after an emission to check if the sequence should stop after that specific item.

public static IObservable<TSource> TakeUntil<TSource>(this IObservable<TSource> source, DateTimeOffset endTime)

Takes elements for the specified duration until the specified end time.

public static IObservable<TSource> TakeUntil<TSource>(this IObservable<TSource> source, DateTimeOffset endTime, IScheduler scheduler)

Takes elements for the specified duration until the specified end time, using the specified scheduler to run timers.

public static IObservable<TSource> TakeWhile<TSource>(this IObservable<TSource> source, Func<TSource, bool> predicate)

Returns elements from an observable sequence as long as a specified condition is true.

public static IObservable<TSource> TakeWhile<TSource>(this IObservable<TSource> source, Func<TSource, int, bool> predicate)

Returns elements from an observable sequence as long as a specified condition is true. The element's index is used in the logic of the predicate function.

public static Plan<TResult> Then<TSource, TResult>(this IObservable<TSource> source, Func<TSource, TResult> selector)

Matches when the observable sequence has an available element and projects the element by invoking the selector function.

public static IObservable<TSource> Throttle<TSource>(this IObservable<TSource> source, TimeSpan dueTime)

Ignores elements from an observable sequence which are followed by another element within a specified relative time duration.

public static IObservable<TSource> Throttle<TSource>(this IObservable<TSource> source, TimeSpan dueTime, IScheduler scheduler)

Ignores elements from an observable sequence which are followed by another element within a specified relative time duration, using the specified scheduler to run throttling timers.

public static IObservable<TSource> Throttle<TSource, TThrottle>(this IObservable<TSource> source, Func<TSource, IObservable<TThrottle>> throttleDurationSelector)

Ignores elements from an observable sequence which are followed by another value within a computed throttle duration.

public static IObservable<TResult> Throw<TResult>(Exception exception)

Returns an observable sequence that terminates with an exception.

public static IObservable<TResult> Throw<TResult>(Exception exception, TResult witness)

Returns an observable sequence that terminates with an exception.

public static IObservable<TResult> Throw<TResult>(Exception exception, IScheduler scheduler)

Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single OnError message.

public static IObservable<TResult> Throw<TResult>(Exception exception, IScheduler scheduler, TResult witness)

Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single OnError message.

public static IObservable<TimeInterval<TSource>> TimeInterval<TSource>(this IObservable<TSource> source)

Records the time interval between consecutive elements in an observable sequence.

public static IObservable<TimeInterval<TSource>> TimeInterval<TSource>(this IObservable<TSource> source, IScheduler scheduler)

Records the time interval between consecutive elements in an observable sequence, using the specified scheduler to compute time intervals.

public static IObservable<TSource> Timeout<TSource>(this IObservable<TSource> source, TimeSpan dueTime)

Applies a timeout policy for each element in the observable sequence. If the next element isn't received within the specified timeout duration starting from its predecessor, a TimeoutException is propagated to the observer.

public static IObservable<TSource> Timeout<TSource>(this IObservable<TSource> source, TimeSpan dueTime, IScheduler scheduler)

Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers. If the next element isn't received within the specified timeout duration starting from its predecessor, a TimeoutException is propagated to the observer.

public static IObservable<TSource> Timeout<TSource>(this IObservable<TSource> source, TimeSpan dueTime, IObservable<TSource> other)

Applies a timeout policy for each element in the observable sequence. If the next element isn't received within the specified timeout duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on.

public static IObservable<TSource> Timeout<TSource>(this IObservable<TSource> source, TimeSpan dueTime, IObservable<TSource> other, IScheduler scheduler)

Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers. If the next element isn't received within the specified timeout duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on.

public static IObservable<TSource> Timeout<TSource>(this IObservable<TSource> source, DateTimeOffset dueTime)

Applies a timeout policy to the observable sequence based on an absolute time. If the sequence doesn't terminate before the specified absolute due time, a TimeoutException is propagated to the observer.

public static IObservable<TSource> Timeout<TSource>(this IObservable<TSource> source, DateTimeOffset dueTime, IScheduler scheduler)

Applies a timeout policy to the observable sequence based on an absolute time, using the specified scheduler to run timeout timers. If the sequence doesn't terminate before the specified absolute due time, a TimeoutException is propagated to the observer.

public static IObservable<TSource> Timeout<TSource>(this IObservable<TSource> source, DateTimeOffset dueTime, IObservable<TSource> other)

Applies a timeout policy to the observable sequence based on an absolute time. If the sequence doesn't terminate before the specified absolute due time, the other observable sequence is used to produce future messages from that point on.

public static IObservable<TSource> Timeout<TSource>(this IObservable<TSource> source, DateTimeOffset dueTime, IObservable<TSource> other, IScheduler scheduler)

Applies a timeout policy to the observable sequence based on an absolute time, using the specified scheduler to run timeout timers. If the sequence doesn't terminate before the specified absolute due time, the other observable sequence is used to produce future messages from that point on.

public static IObservable<TSource> Timeout<TSource, TTimeout>(this IObservable<TSource> source, Func<TSource, IObservable<TTimeout>> timeoutDurationSelector)

Applies a timeout policy to the observable sequence based on a timeout duration computed for each element. If the next element isn't received within the computed duration starting from its predecessor, a TimeoutException is propagated to the observer.

public static IObservable<TSource> Timeout<TSource, TTimeout>(this IObservable<TSource> source, Func<TSource, IObservable<TTimeout>> timeoutDurationSelector, IObservable<TSource> other)

Applies a timeout policy to the observable sequence based on a timeout duration computed for each element. If the next element isn't received within the computed duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on.

public static IObservable<TSource> Timeout<TSource, TTimeout>(this IObservable<TSource> source, IObservable<TTimeout> firstTimeout, Func<TSource, IObservable<TTimeout>> timeoutDurationSelector)

Applies a timeout policy to the observable sequence based on an initial timeout duration for the first element, and a timeout duration computed for each subsequent element. If the next element isn't received within the computed duration starting from its predecessor, a TimeoutException is propagated to the observer.

public static IObservable<TSource> Timeout<TSource, TTimeout>(this IObservable<TSource> source, IObservable<TTimeout> firstTimeout, Func<TSource, IObservable<TTimeout>> timeoutDurationSelector, IObservable<TSource> other)

Applies a timeout policy to the observable sequence based on an initial timeout duration for the first element, and a timeout duration computed for each subsequent element. If the next element isn't received within the computed duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on.

public static IObservable<long> Timer(TimeSpan dueTime)

Returns an observable sequence that produces a single value after the specified relative due time has elapsed.

public static IObservable<long> Timer(DateTimeOffset dueTime)

Returns an observable sequence that produces a single value at the specified absolute due time.

public static IObservable<long> Timer(TimeSpan dueTime, TimeSpan period)

Returns an observable sequence that periodically produces a value after the specified initial relative due time has elapsed.

public static IObservable<long> Timer(DateTimeOffset dueTime, TimeSpan period)

Returns an observable sequence that periodically produces a value starting at the specified initial absolute due time.

public static IObservable<long> Timer(TimeSpan dueTime, IScheduler scheduler)

Returns an observable sequence that produces a single value after the specified relative due time has elapsed, using the specified scheduler to run the timer.

public static IObservable<long> Timer(DateTimeOffset dueTime, IScheduler scheduler)

Returns an observable sequence that produces a single value at the specified absolute due time, using the specified scheduler to run the timer.

public static IObservable<long> Timer(TimeSpan dueTime, TimeSpan period, IScheduler scheduler)

Returns an observable sequence that periodically produces a value after the specified initial relative due time has elapsed, using the specified scheduler to run timers.

public static IObservable<long> Timer(DateTimeOffset dueTime, TimeSpan period, IScheduler scheduler)

Returns an observable sequence that periodically produces a value starting at the specified initial absolute due time, using the specified scheduler to run timers.

public static IObservable<Timestamped<TSource>> Timestamp<TSource>(this IObservable<TSource> source)

Timestamps each element in an observable sequence using the local system clock.

public static IObservable<Timestamped<TSource>> Timestamp<TSource>(this IObservable<TSource> source, IScheduler scheduler)

Timestamp each element in an observable sequence using the clock of the specified scheduler.

public static IObservable<TSource[]> ToArray<TSource>(this IObservable<TSource> source)

Creates an array from an observable sequence.

public static Func<IObservable<TResult>> ToAsync<TResult>(this Func<TResult> function)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function.

public static Func<IObservable<TResult>> ToAsync<TResult>(this Func<TResult> function, IScheduler scheduler)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler.

public static Func<TArg1, IObservable<TResult>> ToAsync<TArg1, TResult>(this Func<TArg1, TResult> function)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function.

public static Func<TArg1, IObservable<TResult>> ToAsync<TArg1, TResult>(this Func<TArg1, TResult> function, IScheduler scheduler)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler.

public static Func<TArg1, TArg2, IObservable<TResult>> ToAsync<TArg1, TArg2, TResult>(this Func<TArg1, TArg2, TResult> function)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function.

public static Func<TArg1, TArg2, IObservable<TResult>> ToAsync<TArg1, TArg2, TResult>(this Func<TArg1, TArg2, TResult> function, IScheduler scheduler)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TResult>(this Func<TArg1, TArg2, TArg3, TResult> function)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function.

public static Func<TArg1, TArg2, TArg3, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TResult>(this Func<TArg1, TArg2, TArg3, TResult> function, IScheduler scheduler)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TResult> function)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TResult> function, IScheduler scheduler)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TResult> function)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TResult> function, IScheduler scheduler)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TResult> function)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TResult> function, IScheduler scheduler)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TResult> function)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TResult> function, IScheduler scheduler)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TResult> function)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TResult> function, IScheduler scheduler)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TResult> function)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TResult> function, IScheduler scheduler)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TResult> function)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TResult> function, IScheduler scheduler)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TResult> function)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TResult> function, IScheduler scheduler)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TResult> function)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TResult> function, IScheduler scheduler)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TResult> function)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TResult> function, IScheduler scheduler)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TResult> function)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TResult> function, IScheduler scheduler)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15, TResult> function)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15, TResult> function, IScheduler scheduler)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15, TArg16, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15, TArg16, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15, TArg16, TResult> function)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15, TArg16, IObservable<TResult>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15, TArg16, TResult>(this Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15, TArg16, TResult> function, IScheduler scheduler)

Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler.

public static Func<IObservable<Unit>> ToAsync(this Action action)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler.

public static Func<IObservable<Unit>> ToAsync(this Action action, IScheduler scheduler)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler.

public static Func<TArg1, IObservable<Unit>> ToAsync<TArg1>(this Action<TArg1> action)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler.

public static Func<TArg1, IObservable<Unit>> ToAsync<TArg1>(this Action<TArg1> action, IScheduler scheduler)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler.

public static Func<TArg1, TArg2, IObservable<Unit>> ToAsync<TArg1, TArg2>(this Action<TArg1, TArg2> action)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler.

public static Func<TArg1, TArg2, IObservable<Unit>> ToAsync<TArg1, TArg2>(this Action<TArg1, TArg2> action, IScheduler scheduler)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3>(this Action<TArg1, TArg2, TArg3> action)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler.

public static Func<TArg1, TArg2, TArg3, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3>(this Action<TArg1, TArg2, TArg3> action, IScheduler scheduler)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4>(this Action<TArg1, TArg2, TArg3, TArg4> action)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4>(this Action<TArg1, TArg2, TArg3, TArg4> action, IScheduler scheduler)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5> action)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5> action, IScheduler scheduler)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6> action)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6> action, IScheduler scheduler)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7> action)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7> action, IScheduler scheduler)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8> action)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8> action, IScheduler scheduler)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9> action)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9> action, IScheduler scheduler)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10> action)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10> action, IScheduler scheduler)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11> action)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11> action, IScheduler scheduler)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12> action)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12> action, IScheduler scheduler)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13> action)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13> action, IScheduler scheduler)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14> action)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14> action, IScheduler scheduler)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15> action)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15> action, IScheduler scheduler)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15, TArg16, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15, TArg16>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15, TArg16> action)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler.

public static Func<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15, TArg16, IObservable<Unit>> ToAsync<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15, TArg16>(this Action<TArg1, TArg2, TArg3, TArg4, TArg5, TArg6, TArg7, TArg8, TArg9, TArg10, TArg11, TArg12, TArg13, TArg14, TArg15, TArg16> action, IScheduler scheduler)

Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler.

public static IObservable<IDictionary<TKey, TSource>> ToDictionary<TSource, TKey>(this IObservable<TSource> source, Func<TSource, TKey> keySelector)

Creates a dictionary from an observable sequence according to a specified key selector function.

public static IObservable<IDictionary<TKey, TSource>> ToDictionary<TSource, TKey>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)

Creates a dictionary from an observable sequence according to a specified key selector function, and a comparer.

public static IObservable<IDictionary<TKey, TElement>> ToDictionary<TSource, TKey, TElement>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)

Creates a dictionary from an observable sequence according to a specified key selector function, and an element selector function.

public static IObservable<IDictionary<TKey, TElement>> ToDictionary<TSource, TKey, TElement>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)

Creates a dictionary from an observable sequence according to a specified key selector function, a comparer, and an element selector function.

public static IEnumerable<TSource> ToEnumerable<TSource>(this IObservable<TSource> source)

Converts an observable sequence to an enumerable sequence.

public static IEventSource<Unit> ToEvent(this IObservable<Unit> source)

Exposes an observable sequence as an object with an Action-based .NET event.

public static IEventSource<TSource> ToEvent<TSource>(this IObservable<TSource> source)

Exposes an observable sequence as an object with an Action<T>-based .NET event.

public static IEventPatternSource<TEventArgs> ToEventPattern<TEventArgs>(this IObservable<EventPattern<TEventArgs>> source)

Exposes an observable sequence as an object with a .NET event, conforming to the standard .NET event pattern.

public static IObservable<IList<TSource>> ToList<TSource>(this IObservable<TSource> source)

Creates a list from an observable sequence.

public static IObservable<ILookup<TKey, TSource>> ToLookup<TSource, TKey>(this IObservable<TSource> source, Func<TSource, TKey> keySelector)

Creates a lookup from an observable sequence according to a specified key selector function.

public static IObservable<ILookup<TKey, TSource>> ToLookup<TSource, TKey>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)

Creates a lookup from an observable sequence according to a specified key selector function, and a comparer.

public static IObservable<ILookup<TKey, TElement>> ToLookup<TSource, TKey, TElement>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)

Creates a lookup from an observable sequence according to a specified key selector function, and an element selector function.

public static IObservable<ILookup<TKey, TElement>> ToLookup<TSource, TKey, TElement>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)

Creates a lookup from an observable sequence according to a specified key selector function, a comparer, and an element selector function.

public static IObservable<TSource> ToObservable<TSource>(this IEnumerable<TSource> source)

Converts an enumerable sequence to an observable sequence.

public static IObservable<TSource> ToObservable<TSource>(this IEnumerable<TSource> source, IScheduler scheduler)

Converts an enumerable sequence to an observable sequence, using the specified scheduler to run the enumeration loop.

public static IObservable<TResult> Using<TResult, TResource>(Func<TResource> resourceFactory, Func<TResource, IObservable<TResult>> observableFactory) where TResource : IDisposable

Constructs an observable sequence that depends on a resource object, whose lifetime is tied to the resulting observable sequence's lifetime.

public static IObservable<TResult> Using<TResult, TResource>(Func<CancellationToken, Task<TResource>> resourceFactoryAsync, Func<TResource, CancellationToken, Task<IObservable<TResult>>> observableFactoryAsync) where TResource : IDisposable

Constructs an observable sequence that depends on a resource object, whose lifetime is tied to the resulting observable sequence's lifetime. The resource is obtained and used through asynchronous methods. The CancellationToken passed to the asynchronous methods is tied to the returned disposable subscription, allowing best-effort cancellation at any stage of the resource acquisition or usage.

public static TSource Wait<TSource>(this IObservable<TSource> source)

Waits for the observable sequence to complete and returns the last element of the sequence. If the sequence terminates with an OnError notification, the exception is thrown.

public static IObservable<TResult> When<TResult>(Plan<TResult>[] plans)

Joins together the results from several patterns.

public static IObservable<TResult> When<TResult>(this IEnumerable<Plan<TResult>> plans)

Joins together the results from several patterns.

public static IObservable<TSource> Where<TSource>(this IObservable<TSource> source, Func<TSource, bool> predicate)

Filters the elements of an observable sequence based on a predicate.

public static IObservable<TSource> Where<TSource>(this IObservable<TSource> source, Func<TSource, int, bool> predicate)

Filters the elements of an observable sequence based on a predicate by incorporating the element's index.

public static IObservable<TSource> While<TSource>(Func<bool> condition, IObservable<TSource> source)

Repeats the given source as long as the specified condition holds, where the condition is evaluated before each repeated source is subscribed to.

public static IObservable<IObservable<TSource>> Window<TSource, TWindowClosing>(this IObservable<TSource> source, Func<IObservable<TWindowClosing>> windowClosingSelector)

Projects each element of an observable sequence into consecutive non-overlapping windows.

public static IObservable<IObservable<TSource>> Window<TSource, TWindowOpening, TWindowClosing>(this IObservable<TSource> source, IObservable<TWindowOpening> windowOpenings, Func<TWindowOpening, IObservable<TWindowClosing>> windowClosingSelector)

Projects each element of an observable sequence into zero or more windows.

public static IObservable<IObservable<TSource>> Window<TSource, TWindowBoundary>(this IObservable<TSource> source, IObservable<TWindowBoundary> windowBoundaries)

Projects each element of an observable sequence into consecutive non-overlapping windows.

public static IObservable<IObservable<TSource>> Window<TSource>(this IObservable<TSource> source, int count)

Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on element count information.

public static IObservable<IObservable<TSource>> Window<TSource>(this IObservable<TSource> source, int count, int skip)

Projects each element of an observable sequence into zero or more windows which are produced based on element count information.

public static IObservable<IObservable<TSource>> Window<TSource>(this IObservable<TSource> source, TimeSpan timeSpan)

Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on timing information.

public static IObservable<IObservable<TSource>> Window<TSource>(this IObservable<TSource> source, TimeSpan timeSpan, IScheduler scheduler)

Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on timing information, using the specified scheduler to run timers.

public static IObservable<IObservable<TSource>> Window<TSource>(this IObservable<TSource> source, TimeSpan timeSpan, TimeSpan timeShift)

Projects each element of an observable sequence into zero or more windows which are produced based on timing information.

public static IObservable<IObservable<TSource>> Window<TSource>(this IObservable<TSource> source, TimeSpan timeSpan, TimeSpan timeShift, IScheduler scheduler)

Projects each element of an observable sequence into zero or more windows which are produced based on timing information, using the specified scheduler to run timers.

public static IObservable<IObservable<TSource>> Window<TSource>(this IObservable<TSource> source, TimeSpan timeSpan, int count)

Projects each element of an observable sequence into a window that is completed when either it's full or a given amount of time has elapsed. A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first.

public static IObservable<IObservable<TSource>> Window<TSource>(this IObservable<TSource> source, TimeSpan timeSpan, int count, IScheduler scheduler)

Projects each element of an observable sequence into a window that is completed when either it's full or a given amount of time has elapsed, using the specified scheduler to run timers. A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first.

public static IObservable<TResult> WithLatestFrom<TFirst, TSecond, TResult>(this IObservable<TFirst> first, IObservable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)

Merges two observable sequences into one observable sequence by combining each element from the first source with the latest element from the second source, if any. Starting from Rx.NET 4.0, this will subscribe to second before subscribing to first to have a latest element readily available in case first emits an element right away.

public static IObservable<TResult> Zip<TSource1, TSource2, TResult>(this IObservable<TSource1> first, IObservable<TSource2> second, Func<TSource1, TSource2, TResult> resultSelector)

Merges two observable sequences into one observable sequence by combining their elements in a pairwise fashion.

public static IObservable<TResult> Zip<TSource, TResult>(this IEnumerable<IObservable<TSource>> sources, Func<IList<TSource>, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.

public static IObservable<IList<TSource>> Zip<TSource>(this IEnumerable<IObservable<TSource>> sources)

Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexes.

public static IObservable<IList<TSource>> Zip<TSource>(IObservable<TSource>[] sources)

Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexes.

public static IObservable<TResult> Zip<TSource1, TSource2, TResult>(this IObservable<TSource1> first, IEnumerable<TSource2> second, Func<TSource1, TSource2, TResult> resultSelector)

Merges an observable sequence and an enumerable sequence into one observable sequence by using the selector function.

public static IObservable<TResult> Zip<TSource1, TSource2, TSource3, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, Func<TSource1, TSource2, TSource3, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.

public static IObservable<TResult> Zip<TSource1, TSource2, TSource3, TSource4, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, Func<TSource1, TSource2, TSource3, TSource4, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.

public static IObservable<TResult> Zip<TSource1, TSource2, TSource3, TSource4, TSource5, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.

public static IObservable<TResult> Zip<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, IObservable<TSource6> source6, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.

public static IObservable<TResult> Zip<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, IObservable<TSource6> source6, IObservable<TSource7> source7, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.

public static IObservable<TResult> Zip<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, IObservable<TSource6> source6, IObservable<TSource7> source7, IObservable<TSource8> source8, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.

public static IObservable<TResult> Zip<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, IObservable<TSource6> source6, IObservable<TSource7> source7, IObservable<TSource8> source8, IObservable<TSource9> source9, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.

public static IObservable<TResult> Zip<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, IObservable<TSource6> source6, IObservable<TSource7> source7, IObservable<TSource8> source8, IObservable<TSource9> source9, IObservable<TSource10> source10, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.

public static IObservable<TResult> Zip<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, IObservable<TSource6> source6, IObservable<TSource7> source7, IObservable<TSource8> source8, IObservable<TSource9> source9, IObservable<TSource10> source10, IObservable<TSource11> source11, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.

public static IObservable<TResult> Zip<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TSource12, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, IObservable<TSource6> source6, IObservable<TSource7> source7, IObservable<TSource8> source8, IObservable<TSource9> source9, IObservable<TSource10> source10, IObservable<TSource11> source11, IObservable<TSource12> source12, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TSource12, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.

public static IObservable<TResult> Zip<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TSource12, TSource13, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, IObservable<TSource6> source6, IObservable<TSource7> source7, IObservable<TSource8> source8, IObservable<TSource9> source9, IObservable<TSource10> source10, IObservable<TSource11> source11, IObservable<TSource12> source12, IObservable<TSource13> source13, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TSource12, TSource13, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.

public static IObservable<TResult> Zip<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TSource12, TSource13, TSource14, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, IObservable<TSource6> source6, IObservable<TSource7> source7, IObservable<TSource8> source8, IObservable<TSource9> source9, IObservable<TSource10> source10, IObservable<TSource11> source11, IObservable<TSource12> source12, IObservable<TSource13> source13, IObservable<TSource14> source14, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TSource12, TSource13, TSource14, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.

public static IObservable<TResult> Zip<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TSource12, TSource13, TSource14, TSource15, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, IObservable<TSource6> source6, IObservable<TSource7> source7, IObservable<TSource8> source8, IObservable<TSource9> source9, IObservable<TSource10> source10, IObservable<TSource11> source11, IObservable<TSource12> source12, IObservable<TSource13> source13, IObservable<TSource14> source14, IObservable<TSource15> source15, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TSource12, TSource13, TSource14, TSource15, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.

public static IObservable<TResult> Zip<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TSource12, TSource13, TSource14, TSource15, TSource16, TResult>(this IObservable<TSource1> source1, IObservable<TSource2> source2, IObservable<TSource3> source3, IObservable<TSource4> source4, IObservable<TSource5> source5, IObservable<TSource6> source6, IObservable<TSource7> source7, IObservable<TSource8> source8, IObservable<TSource9> source9, IObservable<TSource10> source10, IObservable<TSource11> source11, IObservable<TSource12> source12, IObservable<TSource13> source13, IObservable<TSource14> source14, IObservable<TSource15> source15, IObservable<TSource16> source16, Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TSource12, TSource13, TSource14, TSource15, TSource16, TResult> resultSelector)

Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.