IQbservable<TSource> Interface

Provides functionality to evaluate queries against a specific data source wherein the type of the data is known.

Namespace:  System.Reactive.Linq
Assembly:  System.Reactive.Providers (in System.Reactive.Providers.dll)

Syntax

'Declaration
Public Interface IQbservable(Of Out TSource) _
    Inherits IQbservable, IObservable(Of TSource)

'Usage
Dim instance As IQbservable(Of Out TSource)

public interface IQbservable<out TSource> : IQbservable, 
    IObservable<TSource>

generic<typename TSource>
public interface class IQbservable : IQbservable, 
    IObservable<TSource>

type IQbservable<'TSource> =  
    interface
        interface IQbservable
        interface IObservable<'TSource>
    end

JScript does not support generic types and methods.

Type Parameters

• outTSource
  The type of the elements of source.

  This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see .

The IQbservable<TSource> type exposes the following members.

Properties

	Name	Description
	ElementType	Gets the type of the element(s) that are returned when the expression tree associated with this instance of IQbservable is executed. (Inherited from IQbservable.)
	Expression	Gets the expression tree that is associated with the instance of IQbservable. (Inherited from IQbservable.)
	Provider	Gets the query provider that is associated with this data source. (Inherited from IQbservable.)

Top

Methods

	Name	Description
	Subscribe	(Inherited from IObservable<TSource>.)

Top

Extension Methods

	Name	Description
	Aggregate<TSource>(Func<TSource, TSource, TSource>)	Overloaded. Applies an accumulator function over an observable sequence. (Defined by Observable.)
	Aggregate<TSource>(Expression<Func<TSource, TSource, TSource>>)	Overloaded. Applies an accumulator function over a queryable observable sequence. (Defined by Qbservable.)
	Aggregate<TSource, TAccumulate>(TAccumulate, Func<TAccumulate, TSource, TAccumulate>)	Overloaded. Applies an accumulator function over an observable sequence with the specified seed value. (Defined by Observable.)
	Aggregate<TSource, TAccumulate>(TAccumulate, Expression<Func<TAccumulate, TSource, TAccumulate>>)	Overloaded. Applies an accumulator function over a queryable observable sequence. (Defined by Qbservable.)
	All<TSource>(Func<TSource, Boolean>)	Overloaded. Determines whether all elements of an observable sequence satisfies a condition. (Defined by Observable.)
	All<TSource>(Expression<Func<TSource, Boolean>>)	Overloaded. Determines whether all elements of a queryable observable sequence satisfies a condition. (Defined by Qbservable.)
	Amb<TSource>(IObservable<TSource>)	Overloaded. Propagates the observable sequence that reacts first with the specified first and second sequence. (Defined by Observable.)
	Amb<TSource>(IObservable<TSource>)	Overloaded. Propagates the queryable observable sequence that reacts first with the specified first and second sequence. (Defined by Qbservable.)
	And<TSource, TRight>(IObservable<TRight>)	Overloaded. Matches when both observable sequences have an available value. (Defined by Observable.)
	And<TLeft, TRight>(IObservable<TRight>)	Overloaded. Matches when both queryable observable sequences have an available value. (Defined by Qbservable.)
	Any<TSource>()	Overloaded. Determines whether an observable sequence contains any elements. (Defined by Observable.)
	Any<TSource>()	Overloaded. Determines whether a queryable observable sequence contains any elements. (Defined by Qbservable.)
	Any<TSource>(Func<TSource, Boolean>)	Overloaded. Determines whether all elements of an observable sequence satisfies a condition. (Defined by Observable.)
	Any<TSource>(Expression<Func<TSource, Boolean>>)	Overloaded. Determines whether all elements of a queryable observable sequence satisfies a condition. (Defined by Qbservable.)
	AsObservable<TSource>()	Overloaded. Hides the identity of an observable sequence. (Defined by Observable.)
	AsObservable<TSource>()	Overloaded. Hides the identity of an observable sequence. (Defined by Qbservable.)
	AsQbservable<TSource>	Converts an observable sequence into a queryable observable sequence. (Defined by Qbservable.)
	AssertEqual<TSource>	(Defined by Extensions.)
	Baz<T, R>	(Defined by MyExt.)
	Buffer<TSource>(Int32)	Overloaded. Indicates each element of an observable sequence into consecutive non-overlapping buffers which are produced based on element count information. (Defined by Observable.)
	Buffer<TSource>(TimeSpan)	Overloaded. Indicates each element of an observable sequence into consecutive non-overlapping buffers which are produced based on timing information. (Defined by Observable.)
	Buffer<TSource>(TimeSpan)	Overloaded. Indicates each element of a queryable observable sequence into consecutive non-overlapping buffers which are produced based on timing information. (Defined by Qbservable.)
	Buffer<TSource>(Int32)	Overloaded. Indicates each element of a queryable observable sequence into consecutive non-overlapping buffers which are produced based on element count information. (Defined by Qbservable.)
	Buffer<TSource>(Int32, Int32)	Overloaded. Indicates each element of an observable sequence into zero or more buffers which are produced based on element count information. (Defined by Observable.)
	Buffer<TSource>(TimeSpan, IScheduler)	Overloaded. Indicates each element of an observable sequence into consecutive non-overlapping buffers which are produced based on timing information. (Defined by Observable.)
	Buffer<TSource>(TimeSpan, TimeSpan)	Overloaded. Indicates each element of an observable sequence into zero or more buffers which are produced based on timing information. (Defined by Observable.)
	Buffer<TSource>(TimeSpan, Int32)	Overloaded. Indicates 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. (Defined by Observable.)
	Buffer<TSource>(TimeSpan, IScheduler)	Overloaded. Indicates each element of a queryable observable sequence into consecutive non-overlapping buffers which are produced based on timing information. (Defined by Qbservable.)
	Buffer<TSource>(TimeSpan, TimeSpan)	Overloaded. Indicates each element of a queryable observable sequence into zero or more buffers which are produced based on timing information. (Defined by Qbservable.)
	Buffer<TSource>(TimeSpan, Int32)	Overloaded. Indicates each element of a queryable observable sequence into a buffer that’s sent out when either it’s full or a given amount of time has elapsed. (Defined by Qbservable.)
	Buffer<TSource>(Int32, Int32)	Overloaded. Indicates each element of a queryable observable sequence into zero or more buffers which are produced based on element count information. (Defined by Qbservable.)
	Buffer<TSource>(TimeSpan, TimeSpan, IScheduler)	Overloaded. Indicates each element of an observable sequence into zero or more buffers which are produced based on timing information. (Defined by Observable.)
	Buffer<TSource>(TimeSpan, Int32, IScheduler)	Overloaded. Indicates 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. (Defined by Observable.)
	Buffer<TSource>(TimeSpan, TimeSpan, IScheduler)	Overloaded. Indicates each element of a queryable observable sequence into zero or more buffers which are produced based on timing information. (Defined by Qbservable.)
	Buffer<TSource>(TimeSpan, Int32, IScheduler)	Overloaded. Indicates each element of a queryable observable sequence into a buffer that’s sent out when either it’s full or a given amount of time has elapsed. (Defined by Qbservable.)
	Buffer<TSource, TBufferClosing>(Func<IObservable<TBufferClosing>>)	Overloaded. Indicates each element of an observable sequence into consecutive non-overlapping buffers. (Defined by Observable.)
	Buffer<TSource, TBufferClosing>(Expression<Func<IObservable<TBufferClosing>>>)	Overloaded. Indicates each element of a queryable observable sequence into consecutive non-overlapping buffers. (Defined by Qbservable.)
	Buffer<TSource, TBufferOpening, TBufferClosing>(IObservable<TBufferOpening>, Func<TBufferOpening, IObservable<TBufferClosing>>)	Overloaded. Indicates each element of a queryable observable sequence into consecutive non-overlapping buffers. (Defined by Observable.)
	Buffer<TSource, TBufferOpening, TBufferClosing>(IObservable<TBufferOpening>, Expression<Func<TBufferOpening, IObservable<TBufferClosing>>>)	Overloaded. Indicates each element of a queryable observable sequence into consecutive non-overlapping buffers. (Defined by Qbservable.)
	Catch<TSource>(IObservable<TSource>)	Overloaded. Continues an observable sequence that is terminated by an exception with the next observable sequence. (Defined by Observable.)
	Catch<TSource>(IObservable<TSource>)	Overloaded. Continues a queryable observable sequence that is terminated by an exception with the next queryable observable sequence. (Defined by Qbservable.)
	Catch<TSource, TException>(Func<TException, IObservable<TSource>>)	Overloaded. Continues an observable sequence that is terminated by an exception of the specified type with the observable sequence produced by the handler. (Defined by Observable.)
	Catch<TSource, TException>(Expression<Func<TException, IObservable<TSource>>>)	Overloaded. Continues a queryable observable sequence that is terminated by an exception of the specified type with the queryable observable sequence produced by the handler. (Defined by Qbservable.)
	CombineLatest<TSource, TSecond, TResult>(IObservable<TSecond>, Func<TSource, TSecond, TResult>)	Overloaded. Merges two observable sequences into one observable sequence by using the selector function whenever one of the observable sequences produces an element. (Defined by Observable.)
	CombineLatest<TFirst, TSecond, TResult>(IObservable<TSecond>, Expression<Func<TFirst, TSecond, TResult>>)	Overloaded. Merges two queryable observable sequences into one queryable observable sequence by using the selector function whenever one of the queryable observable sequences produces an element. (Defined by Qbservable.)
	Concat<TSource>(IObservable<TSource>)	Overloaded. Concatenates two observable sequences. (Defined by Observable.)
	Concat<TSource>(IObservable<TSource>)	Overloaded. Concatenates two observable sequences. (Defined by Qbservable.)
	Contains<TSource>(TSource)	Overloaded. Determines whether an observable sequence contains a specified element by using the default equality comparer. (Defined by Observable.)
	Contains<TSource>(TSource)	Overloaded. Determines whether a queryable observable sequence contains a specified element by using the default equality comparer. (Defined by Qbservable.)
	Contains<TSource>(TSource, IEqualityComparer<TSource>)	Overloaded. Determines whether an observable sequence contains a specified element by using a specified System.Collections.Generic.IEqualityComparer&lt;T&gt;. (Defined by Observable.)
	Contains<TSource>(TSource, IEqualityComparer<TSource>)	Overloaded. Determines whether an observable sequence contains a specified element by using a specified source type, source, value and comparer. (Defined by Qbservable.)
	Count<TSource>()	Overloaded. Returns a Int32 that represents the total number of elements in an observable sequence. (Defined by Observable.)
	Count<TSource>()	Overloaded. Returns a [System.Int32] that represents the total number of elements in a queryable observable sequence. (Defined by Qbservable.)
	DefaultIfEmpty<TSource>()	Overloaded. Returns the elements of the specified sequence or the type parameter's default value in a singleton sequence if the sequence is empty. (Defined by Observable.)
	DefaultIfEmpty<TSource>()	Overloaded. Returns the elements of the specified sequence or the type parameter's default value in a singleton sequence if the sequence is empty. (Defined by Qbservable.)
	DefaultIfEmpty<TSource>(TSource)	Overloaded. Returns the elements of the specified sequence or the type parameter's default value in a singleton sequence if the sequence is empty. (Defined by Observable.)
	DefaultIfEmpty<TSource>(TSource)	Overloaded. Returns the elements of the specified sequence or the type parameter's default value in a singleton sequence if the sequence is empty. (Defined by Qbservable.)
	Delay<TSource>(TimeSpan)	Overloaded. Indicates the observable sequence by due time with the specified source and dueTime. (Defined by Observable.)
	Delay<TSource>(DateTimeOffset)	Overloaded. Indicates the observable sequence by due time with the specified source and dueTime. (Defined by Observable.)
	Delay<TSource>(TimeSpan)	Overloaded. Indicates the queryable observable sequence by due time with the specified source and dueTime. (Defined by Qbservable.)
	Delay<TSource>(DateTimeOffset)	Overloaded. Indicates the queryable observable sequence by due time with the specified source and dueTime. (Defined by Qbservable.)
	Delay<TSource>(TimeSpan, IScheduler)	Overloaded. Indicates the observable sequence by due time with the specified source, dueTime and scheduler. (Defined by Observable.)
	Delay<TSource>(DateTimeOffset, IScheduler)	Overloaded. Indicates the observable sequence by due time with the specified source, dueTime and scheduler. (Defined by Observable.)
	Delay<TSource>(TimeSpan, IScheduler)	Overloaded. Indicates the queryable observable sequence by due time with the specified source, dueTime and scheduler. (Defined by Qbservable.)
	Delay<TSource>(DateTimeOffset, IScheduler)	Overloaded. Indicates the queryable observable sequence by due time with the specified source, dueTime and scheduler. (Defined by Qbservable.)
	Distinct<TSource>()	Overloaded. Returns an observable sequence that contains only distinct elements with a specified source. (Defined by Observable.)
	Distinct<TSource>()	Overloaded. Returns a queryable observable sequence that contains only distinct elements with a specified source. (Defined by Qbservable.)
	Distinct<TSource>(IEqualityComparer<TSource>)	Overloaded. Returns an observable sequence that contains only distinct elements according to the comparer. (Defined by Observable.)
	Distinct<TSource>(IEqualityComparer<TSource>)	Overloaded. Returns a queryable observable sequence that contains only distinct elements according to the comparer. (Defined by Qbservable.)
	Distinct<TSource, TKey>(Func<TSource, TKey>)	Overloaded. Returns an observable sequence that contains only distinct elements according to the keySelector. (Defined by Observable.)
	Distinct<TSource, TKey>(Expression<Func<TSource, TKey>>)	Overloaded. Returns a queryable observable sequence that contains only distinct elements according to the keySelector. (Defined by Qbservable.)
	Distinct<TSource, TKey>(Func<TSource, TKey>, IEqualityComparer<TKey>)	Overloaded. Returns an observable sequence that contains only distinct elements according to the keySelector. (Defined by Observable.)
	Distinct<TSource, TKey>(Expression<Func<TSource, TKey>>, IEqualityComparer<TKey>)	Overloaded. Returns a queryable observable sequence that contains only distinct elements according to the keySelector and comparer. (Defined by Qbservable.)
	DistinctUntilChanged<TSource>()	Overloaded. Returns an observable sequence that contains only distinct contiguous elements with a specified source. (Defined by Observable.)
	DistinctUntilChanged<TSource>()	Overloaded. Returns a queryable observable sequence that contains only distinct contiguous elements with a specified source. (Defined by Qbservable.)
	DistinctUntilChanged<TSource>(IEqualityComparer<TSource>)	Overloaded. Returns an observable sequence that contains only distinct contiguous elements according to the comparer. (Defined by Observable.)
	DistinctUntilChanged<TSource>(IEqualityComparer<TSource>)	Overloaded. Returns a queryable observable sequence that contains only distinct contiguous elements according to the comparer. (Defined by Qbservable.)
	DistinctUntilChanged<TSource, TKey>(Func<TSource, TKey>)	Overloaded. Returns an observable sequence that contains only distinct contiguous elements according to the keySelector. (Defined by Observable.)
	DistinctUntilChanged<TSource, TKey>(Expression<Func<TSource, TKey>>)	Overloaded. Returns a queryable observable sequence that contains only distinct contiguous elements according to the keySelector. (Defined by Qbservable.)
	DistinctUntilChanged<TSource, TKey>(Func<TSource, TKey>, IEqualityComparer<TKey>)	Overloaded. Returns an observable sequence that contains only distinct contiguous elements according to the keySelector and the comparer. (Defined by Observable.)
	DistinctUntilChanged<TSource, TKey>(Expression<Func<TSource, TKey>>, IEqualityComparer<TKey>)	Overloaded. Returns a queryable observable sequence that contains only distinct contiguous elements according to the keySelector and the comparer. (Defined by Qbservable.)
	Do<TSource>(Action<TSource>)	Overloaded. Invokes an action for each element in the observable sequence. (Defined by Observable.)
	Do<TSource>(IObserver<TSource>)	Overloaded. Invokes an action for each element in the observable sequence and invokes an action upon exceptional termination of the observable sequence. (Defined by Observable.)
	Do<TSource>(Expression<Action<TSource>>)	Overloaded. Invokes an action for each element in the queryable observable sequence and invokes an action upon graceful termination of the queryable observable sequence. (Defined by Qbservable.)
	Do<TSource>(IObserver<TSource>)	Overloaded. Invokes an action for each element in the queryable observable sequence. (Defined by Qbservable.)
	Do<TSource>(Action<TSource>, Action)	Overloaded. Invokes an action for each element in the observable sequence and invokes an action upon graceful termination of the observable sequence. (Defined by Observable.)
	Do<TSource>(Action<TSource>, Action<Exception>)	Overloaded. Invokes an action for each element in the observable sequence and invokes an action upon exceptional termination of the observable sequence. (Defined by Observable.)
	Do<TSource>(Expression<Action<TSource>>, Expression<Action>)	Overloaded. Invokes an action for each element in the queryable observable sequence, and invokes an action upon graceful or exceptional termination of the queryable observable sequence. (Defined by Qbservable.)
	Do<TSource>(Expression<Action<TSource>>, Expression<Action<Exception>>)	Overloaded. Invokes an action for each element in the queryable observable sequence and invokes an action upon exceptional termination of the queryable observable sequence. (Defined by Qbservable.)
	Do<TSource>(Action<TSource>, Action<Exception>, Action)	Overloaded. Invokes an action for each element in the observable sequence, and invokes an action upon graceful or exceptional termination of the observable sequence. (Defined by Observable.)
	Do<TSource>(Expression<Action<TSource>>, Expression<Action<Exception>>, Expression<Action>)	Overloaded. Invokes an action for each element in the queryable observable sequence, and invokes an action upon graceful or exceptional termination of the queryable observable sequence. (Defined by Qbservable.)
	ElementAt<TSource>(Int32)	Overloaded. Returns the element at a specified index in a sequence. (Defined by Observable.)
	ElementAt<TSource>(Int32)	Overloaded. Returns the element at a specified index in a sequence. (Defined by Qbservable.)
	ElementAtOrDefault<TSource>(Int32)	Overloaded. Returns the element at a specified index in a sequence or a default value if the index is out of range. (Defined by Observable.)
	ElementAtOrDefault<TSource>(Int32)	Overloaded. Returns the element at a specified index in a sequence or a default value if the index is out of range. (Defined by Qbservable.)
	Finally<TSource>(Action)	Overloaded. Invokes a specified action after source observable sequence terminates normally or by an exception. (Defined by Observable.)
	Finally<TSource>(Expression<Action>)	Overloaded. Invokes a specified action after source observable sequence terminates normally or by an exception. (Defined by Qbservable.)
	First<TSource>()	Overloaded. Returns the first element of an observable sequence with a specified source. (Defined by Observable.)
	First<TSource>(Func<TSource, Boolean>)	Overloaded. Returns the first element of an observable sequence that matches the predicate. (Defined by Observable.)
	FirstOrDefault<TSource>()	Overloaded. Returns the first element of an observable sequence, or a default value if no value is found. (Defined by Observable.)
	FirstOrDefault<TSource>(Func<TSource, Boolean>)	Overloaded. Returns the first element of an observable sequence that matches the predicate, or a default value if no value is found. (Defined by Observable.)
	Foo<TSource, R>(Func<TSource, R>)	Overloaded. (Defined by MyExt.)
	Foo<T, R>(Expression<Func<T, R>>)	Overloaded. (Defined by MyExt.)
	ForEach<TSource>	Invokes an action for each element in the observable sequence, and blocks until the sequence is terminated. (Defined by Observable.)
	GetEnumerator<TSource>	Returns an enumerator that enumerates all values of the observable sequence. (Defined by Observable.)
	GroupBy<TSource, TKey>(Func<TSource, TKey>)	Overloaded. Groups the elements of an observable sequence according to a specified key selector function. (Defined by Observable.)
	GroupBy<TSource, TKey>(Expression<Func<TSource, TKey>>)	Overloaded. Groups the elements of a queryable observable sequence according to a specified key selector function. (Defined by Qbservable.)
	GroupBy<TSource, TKey>(Func<TSource, TKey>, IEqualityComparer<TKey>)	Overloaded. Groups the elements of an observable sequence according to a specified key selector function and comparer. (Defined by Observable.)
	GroupBy<TSource, TKey>(Expression<Func<TSource, TKey>>, IEqualityComparer<TKey>)	Overloaded. Groups the elements of a queryable observable sequence according to a specified key selector function and comparer. (Defined by Qbservable.)
	GroupBy<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>)	Overloaded. Groups the elements of an observable sequence and selects the resulting elements by using a specified function. (Defined by Observable.)
	GroupBy<TSource, TKey, TElement>(Expression<Func<TSource, TKey>>, Expression<Func<TSource, TElement>>)	Overloaded. Groups the elements of a queryable observable sequence and selects the resulting elements by using a specified function. (Defined by Qbservable.)
	GroupBy<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>, IEqualityComparer<TKey>)	Overloaded. 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. (Defined by Observable.)
	GroupBy<TSource, TKey, TElement>(Expression<Func<TSource, TKey>>, Expression<Func<TSource, TElement>>, IEqualityComparer<TKey>)	Overloaded. Groups the elements of a queryable observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function. (Defined by Qbservable.)
	GroupByUntil<TSource, TKey, TDuration>(Func<TSource, TKey>, Func<IGroupedObservable<TKey, TSource>, IObservable<TDuration>>)	Overloaded. Groups the elements of an observable sequence according to a specified key selector function. (Defined by Observable.)
	GroupByUntil<TSource, TKey, TDuration>(Expression<Func<TSource, TKey>>, Expression<Func<IGroupedObservable<TKey, TSource>, IObservable<TDuration>>>)	Overloaded. Groups the elements of a queryable observable sequence according to a specified key selector function. (Defined by Qbservable.)
	GroupByUntil<TSource, TKey, TDuration>(Func<TSource, TKey>, Func<IGroupedObservable<TKey, TSource>, IObservable<TDuration>>, IEqualityComparer<TKey>)	Overloaded. Groups the elements of an observable sequence according to a specified key selector function and comparer. (Defined by Observable.)
	GroupByUntil<TSource, TKey, TDuration>(Expression<Func<TSource, TKey>>, Expression<Func<IGroupedObservable<TKey, TSource>, IObservable<TDuration>>>, IEqualityComparer<TKey>)	Overloaded. Groups the elements of a queryable observable sequence according to a specified key selector function and comparer. (Defined by Qbservable.)
	GroupByUntil<TSource, TKey, TElement, TDuration>(Func<TSource, TKey>, Func<TSource, TElement>, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>)	Overloaded. Groups the elements of an observable sequence according to a specified key selector function and selects the resulting elements by using a specified function. (Defined by Observable.)
	GroupByUntil<TSource, TKey, TElement, TDuration>(Expression<Func<TSource, TKey>>, Expression<Func<TSource, TElement>>, Expression<Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>>)	Overloaded. Groups the elements of a queryable observable sequence according to a specified key selector function and selects the resulting elements by using a specified function. (Defined by Qbservable.)
	GroupByUntil<TSource, TKey, TElement, TDuration>(Func<TSource, TKey>, Func<TSource, TElement>, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>, IEqualityComparer<TKey>)	Overloaded. 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. (Defined by Observable.)
	GroupByUntil<TSource, TKey, TElement, TDuration>(Expression<Func<TSource, TKey>>, Expression<Func<TSource, TElement>>, Expression<Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>>, IEqualityComparer<TKey>)	Overloaded. Groups the elements of a queryable observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function. (Defined by Qbservable.)
	GroupJoin<TSource, TRight, TLeftDuration, TRightDuration, TResult>(IObservable<TRight>, Func<TSource, IObservable<TLeftDuration>>, Func<TRight, IObservable<TRightDuration>>, Func<TSource, IObservable<TRight>, TResult>)	Overloaded. Correlates the elements of two sequences based on overlapping durations, and groups the results. (Defined by Observable.)
	GroupJoin<TLeft, TRight, TLeftDuration, TRightDuration, TResult>(IObservable<TRight>, Expression<Func<TLeft, IObservable<TLeftDuration>>>, Expression<Func<TRight, IObservable<TRightDuration>>>, Expression<Func<TLeft, IObservable<TRight>, TResult>>)	Overloaded. Correlates the elements of two sequences based on overlapping durations, and groups the results. (Defined by Qbservable.)
	IgnoreElements<TSource>()	Overloaded. Ignores all values in an observable sequence leaving only the termination messages. (Defined by Observable.)
	IgnoreElements<TSource>()	Overloaded. Ignores all values in a queryable observable sequence leaving only the termination messages. (Defined by Qbservable.)
	Join<TSource, TRight, TLeftDuration, TRightDuration, TResult>(IObservable<TRight>, Func<TSource, IObservable<TLeftDuration>>, Func<TRight, IObservable<TRightDuration>>, Func<TSource, TRight, TResult>)	Overloaded. Correlates the elements of two sequences based on overlapping durations. (Defined by Observable.)
	Join<TLeft, TRight, TLeftDuration, TRightDuration, TResult>(IObservable<TRight>, Expression<Func<TLeft, IObservable<TLeftDuration>>>, Expression<Func<TRight, IObservable<TRightDuration>>>, Expression<Func<TLeft, TRight, TResult>>)	Overloaded. Correlates the elements of two sequences based on overlapping durations. (Defined by Qbservable.)
	Last<TSource>()	Overloaded. Returns the last element of an observable sequence with a specified source. (Defined by Observable.)
	Last<TSource>(Func<TSource, Boolean>)	Overloaded. Returns the last element of an observable sequence that matches the predicate. (Defined by Observable.)
	LastOrDefault<TSource>()	Overloaded. Returns last element in the observable sequence, or a default value if no value is found. (Defined by Observable.)
	LastOrDefault<TSource>(Func<TSource, Boolean>)	Overloaded. Returns the last element of an observable sequence that matches the predicate, or a default value if no value is found. (Defined by Observable.)
	Latest<TSource>()	Overloaded. Samples the most recent value in an observable sequence. (Defined by Observable.)
	Latest<TSource>()	Overloaded. Samples the most recent value in a queryable observable sequence. (Defined by Qbservable.)
	LongCount<TSource>()	Overloaded. Returns a Int64 that represents the total number of elements in an observable sequence. (Defined by Observable.)
	LongCount<TSource>()	Overloaded. Returns a [System.Int64] that represents the total number of elements in a queryable observable sequence. (Defined by Qbservable.)
	Materialize<TSource>()	Overloaded. Materializes the implicit notifications of an observable sequence as explicit notification values. (Defined by Observable.)
	Materialize<TSource>()	Overloaded. Materializes the implicit notifications of a queryable observable sequence as explicit notification values. (Defined by Qbservable.)
	Max<TSource>()	Overloaded. Returns the maximum element in an observable sequence. (Defined by Observable.)
	Max<TSource>()	Overloaded. Returns the maximum element in a queryable observable sequence. (Defined by Qbservable.)
	Max<TSource>(IComparer<TSource>)	Overloaded. Returns the maximum value in an observable sequence according to the specified comparer. (Defined by Observable.)
	Max<TSource>(IComparer<TSource>)	Overloaded. Returns the maximum value in a queryable observable sequence according to the specified comparer. (Defined by Qbservable.)
	MaxBy<TSource, TKey>(Func<TSource, TKey>)	Overloaded. Returns the elements in an observable sequence with the maximum key value. (Defined by Observable.)
	MaxBy<TSource, TKey>(Expression<Func<TSource, TKey>>)	Overloaded. Returns the elements in a queryable observable sequence with the maximum key value. (Defined by Qbservable.)
	MaxBy<TSource, TKey>(Func<TSource, TKey>, IComparer<TKey>)	Overloaded. Returns the elements in an observable sequence with the maximum key value. (Defined by Observable.)
	MaxBy<TSource, TKey>(Expression<Func<TSource, TKey>>, IComparer<TKey>)	Overloaded. Returns the elements in a queryable observable sequence with the maximum key value. (Defined by Qbservable.)
	Merge<TSource>(IObservable<TSource>)	Overloaded. Merges an observable sequence of observable sequences into an observable sequence. (Defined by Observable.)
	Merge<TSource>(IObservable<TSource>)	Overloaded. Merges an enumerable sequence of queryable observable sequences into a single observable sequence. (Defined by Qbservable.)
	Merge<TSource>(IObservable<TSource>, IScheduler)	Overloaded. Merges two observable sequences into a single observable sequence. (Defined by Observable.)
	Merge<TSource>(IObservable<TSource>, IScheduler)	Overloaded. Merges two queryable observable sequences into a single queryable observable sequence. (Defined by Qbservable.)
	Min<TSource>()	Overloaded. Returns the minimum element in an observable sequence. (Defined by Observable.)
	Min<TSource>()	Overloaded. Returns the minimum element in a queryable observable sequence. (Defined by Qbservable.)
	Min<TSource>(IComparer<TSource>)	Overloaded. Returns the minimum value in an observable sequence according to the specified comparer. (Defined by Observable.)
	Min<TSource>(IComparer<TSource>)	Overloaded. Returns the minimum value in a queryable observable sequence according to the specified comparer. (Defined by Qbservable.)
	MinBy<TSource, TKey>(Func<TSource, TKey>)	Overloaded. Returns the elements in an observable sequence with the minimum key value. (Defined by Observable.)
	MinBy<TSource, TKey>(Expression<Func<TSource, TKey>>)	Overloaded. Returns the elements in a queryable observable sequence with the minimum key value. (Defined by Qbservable.)
	MinBy<TSource, TKey>(Func<TSource, TKey>, IComparer<TKey>)	Overloaded. Returns the elements in an observable sequence with the minimum key value according to the specified comparer. (Defined by Observable.)
	MinBy<TSource, TKey>(Expression<Func<TSource, TKey>>, IComparer<TKey>)	Overloaded. Returns the elements in a queryable observable sequence with the minimum key value according to the specified comparer. (Defined by Qbservable.)
	MostRecent<TSource>(TSource)	Overloaded. Samples the most recent value in an observable sequence. (Defined by Observable.)
	MostRecent<TSource>(TSource)	Overloaded. Samples the most recent value in a queryable observable sequence. (Defined by Qbservable.)
	Multicast<TSource, TResult>(ISubject<TSource, TResult>)	Overloaded. Returns a connectable observable sequence that upon connection causes the source sequence to push results into the specified subject. (Defined by Observable.)
	Multicast<TSource, TIntermediate, TResult>(Func<ISubject<TSource, TIntermediate>>, Func<IObservable<TIntermediate>, IObservable<TResult>>)	Overloaded. Returns an observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. (Defined by Observable.)
	Multicast<TSource, TIntermediate, TResult>(Expression<Func<ISubject<TSource, TIntermediate>>>, Expression<Func<IObservable<TIntermediate>, IObservable<TResult>>>)	Overloaded. Returns a queryable observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. (Defined by Qbservable.)
	Next<TSource>()	Overloaded. Samples the next value (blocking without buffering) from in an observable sequence. (Defined by Observable.)
	Next<TSource>()	Overloaded. Samples the next value (blocking without buffering) from in an queryable observable sequence. (Defined by Qbservable.)
	ObserveOn<TSource>(SynchronizationContext)	Overloaded. Asynchronously notify observers on the specified synchronization context. (Defined by Observable.)
	ObserveOn<TSource>(Control)	Overloaded. (Defined by ControlObservable.)
	ObserveOn<TSource>(Dispatcher)	Overloaded. (Defined by DispatcherObservable.)
	ObserveOn<TSource>(SynchronizationContext)	Overloaded. Asynchronously notify observers on the specified synchronization context. (Defined by Qbservable.)
	ObserveOn<TSource>(DispatcherScheduler)	Overloaded. (Defined by DispatcherObservable.)
	ObserveOn<TSource>(IScheduler)	Overloaded. Asynchronously notify observers on the specified scheduler. (Defined by Observable.)
	ObserveOn<TSource>(IScheduler)	Overloaded. Asynchronously notify observers on the specified synchronization context. (Defined by Qbservable.)
	ObserveOnDispatcher<TSource>	(Defined by DispatcherObservable.)
	OnErrorResumeNext<TSource>(IObservable<TSource>)	Overloaded. Continues an observable sequence that is terminated normally or by an exception with the next observable sequence. (Defined by Observable.)
	OnErrorResumeNext<TSource>(IObservable<TSource>)	Overloaded. Continues a queryable observable sequence that is terminated normally or by an exception with the next queryable observable sequence. (Defined by Qbservable.)
	Publish<TSource>()	Overloaded. Returns a connectable observable sequence that shares a single subscription to the underlying sequence. (Defined by Observable.)
	Publish<TSource>(TSource)	Overloaded. Returns a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue. (Defined by Observable.)
	Publish<TSource, TResult>(Func<IObservable<TSource>, IObservable<TResult>>)	Overloaded. 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. (Defined by Observable.)
	Publish<TSource, TResult>(Expression<Func<IObservable<TSource>, IObservable<TResult>>>)	Overloaded. Returns a queryable observable sequence that is the result of invoking the selector on a connectable queryable observable sequence that shares a single subscription to the underlying sequence. (Defined by Qbservable.)
	Publish<TSource, TResult>(Func<IObservable<TSource>, IObservable<TResult>>, TSource)	Overloaded. Returns a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue. (Defined by Observable.)
	Publish<TSource, TResult>(Expression<Func<IObservable<TSource>, IObservable<TResult>>>, TSource)	Overloaded. Returns a queryable observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence. (Defined by Qbservable.)
	PublishLast<TSource>()	Overloaded. Returns a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification. (Defined by Observable.)
	PublishLast<TSource, TResult>(Func<IObservable<TSource>, IObservable<TResult>>)	Overloaded. 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. (Defined by Observable.)
	PublishLast<TSource, TResult>(Expression<Func<IObservable<TSource>, IObservable<TResult>>>)	Overloaded. Returns a queryable observable sequence that is the result of invoking the selector on a connectable queryable observable sequence that shares a single subscription to the underlying sequence containing only the last notification. (Defined by Qbservable.)
	Repeat<TSource>()	Overloaded. Repeats the observable sequence indefinitely. (Defined by Observable.)
	Repeat<TSource>()	Overloaded. Repeats the queryable observable sequence indefinitely. (Defined by Qbservable.)
	Repeat<TSource>(Int32)	Overloaded. Repeats the observable sequence indefinitely. (Defined by Observable.)
	Repeat<TSource>(Int32)	Overloaded. Repeats the queryable observable sequence indefinitely. (Defined by Qbservable.)
	Replay<TSource>()	Overloaded. Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. (Defined by Observable.)
	Replay<TSource>(TimeSpan)	Overloaded. Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications within window. (Defined by Observable.)
	Replay<TSource>(Int32)	Overloaded. Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying bufferSize notifications. (Defined by Observable.)
	Replay<TSource>(IScheduler)	Overloaded. Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. (Defined by Observable.)
	Replay<TSource>(TimeSpan, IScheduler)	Overloaded. Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications within window. (Defined by Observable.)
	Replay<TSource>(Int32, IScheduler)	Overloaded. Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying bufferSize notifications. (Defined by Observable.)
	Replay<TSource>(Int32, TimeSpan)	Overloaded. Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying bufferSize notifications within window. (Defined by Observable.)
	Replay<TSource>(Int32, TimeSpan, IScheduler)	Overloaded. Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying bufferSize notifications within window. (Defined by Observable.)
	Replay<TSource, TResult>(Func<IObservable<TSource>, IObservable<TResult>>)	Overloaded. 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 initial value. (Defined by Observable.)
	Replay<TSource, TResult>(Expression<Func<IObservable<TSource>, IObservable<TResult>>>)	Overloaded. Returns a queryable 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 initial value. (Defined by Qbservable.)
	Replay<TSource, TResult>(Func<IObservable<TSource>, IObservable<TResult>>, IScheduler)	Overloaded. 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. (Defined by Observable.)
	Replay<TSource, TResult>(Func<IObservable<TSource>, IObservable<TResult>>, TimeSpan)	Overloaded. 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 within window. (Defined by Observable.)
	Replay<TSource, TResult>(Func<IObservable<TSource>, IObservable<TResult>>, Int32)	Overloaded. 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 bufferSize notifications. (Defined by Observable.)
	Replay<TSource, TResult>(Expression<Func<IObservable<TSource>, IObservable<TResult>>>, IScheduler)	Overloaded. Returns a queryable observable sequence that is the result of invoking the selector on a connectable queryable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. (Defined by Qbservable.)
	Replay<TSource, TResult>(Expression<Func<IObservable<TSource>, IObservable<TResult>>>, TimeSpan)	Overloaded. Returns a queryable observable sequence that is the result of invoking the selector on a connectable queryable observable sequence that shares a single subscription to the underlying sequence replaying all notifications within window. (Defined by Qbservable.)
	Replay<TSource, TResult>(Expression<Func<IObservable<TSource>, IObservable<TResult>>>, Int32)	Overloaded. Returns a queryable observable sequence that is the result of invoking the selector on a connectable queryable observable sequence that shares a single subscription to the underlying sequence replaying bufferSize notifications. (Defined by Qbservable.)
	Replay<TSource, TResult>(Func<IObservable<TSource>, IObservable<TResult>>, TimeSpan, IScheduler)	Overloaded. 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 within window. (Defined by Observable.)
	Replay<TSource, TResult>(Func<IObservable<TSource>, IObservable<TResult>>, Int32, IScheduler)	Overloaded. 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 bufferSize notifications. (Defined by Observable.)
	Replay<TSource, TResult>(Func<IObservable<TSource>, IObservable<TResult>>, Int32, TimeSpan)	Overloaded. 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 bufferSize notifications within window. (Defined by Observable.)
	Replay<TSource, TResult>(Expression<Func<IObservable<TSource>, IObservable<TResult>>>, TimeSpan, IScheduler)	Overloaded. Returns a queryable observable sequence that is the result of invoking the selector on a connectable queryable observable sequence that shares a single subscription to the underlying sequence replaying all notifications within window. (Defined by Qbservable.)
	Replay<TSource, TResult>(Expression<Func<IObservable<TSource>, IObservable<TResult>>>, Int32, IScheduler)	Overloaded. Returns a queryable observable sequence that is the result of invoking the selector on a connectable queryable observable sequence that shares a single subscription to the underlying sequence replaying bufferSize notifications. (Defined by Qbservable.)
	Replay<TSource, TResult>(Expression<Func<IObservable<TSource>, IObservable<TResult>>>, Int32, TimeSpan)	Overloaded. Returns a queryable observable sequence that is the result of invoking the selector on a connectable queryable observable sequence that shares a single subscription to the underlying sequence replaying bufferSize notifications within window. (Defined by Qbservable.)
	Replay<TSource, TResult>(Func<IObservable<TSource>, IObservable<TResult>>, Int32, TimeSpan, IScheduler)	Overloaded. 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 bufferSize notifications within window. (Defined by Observable.)
	Replay<TSource, TResult>(Expression<Func<IObservable<TSource>, IObservable<TResult>>>, Int32, TimeSpan, IScheduler)	Overloaded. Returns a queryable observable sequence that is the result of invoking the selector on a connectable queryable observable sequence that shares a single subscription to the underlying sequence replaying bufferSize notifications within window. (Defined by Qbservable.)
	Retry<TSource>()	Overloaded. Repeats the source observable sequence until it successfully terminates. (Defined by Observable.)
	Retry<TSource>()	Overloaded. Repeats the source queryable observable sequence until it successfully terminates. (Defined by Qbservable.)
	Retry<TSource>(Int32)	Overloaded. Repeats the source observable sequence until it successfully terminates. (Defined by Observable.)
	Retry<TSource>(Int32)	Overloaded. Repeats the source queryable observable sequence until it successfully terminates. (Defined by Qbservable.)
	Sample<TSource>(TimeSpan)	Overloaded. Samples the observable sequence at each interval. (Defined by Observable.)
	Sample<TSource>(TimeSpan)	Overloaded. Samples the queryable observable sequence at each interval. (Defined by Qbservable.)
	Sample<TSource>(TimeSpan, IScheduler)	Overloaded. Samples the observable sequence at each interval with the specified source, interval and scheduler. (Defined by Observable.)
	Sample<TSource>(TimeSpan, IScheduler)	Overloaded. Samples the queryable observable sequence at each interval with the specified source, interval and scheduler. (Defined by Qbservable.)
	Sample<TSource, TSample>(IObservable<TSample>)	Overloaded. Samples the observable sequence at sampling ticks with the specified source and sampler. (Defined by Observable.)
	Sample<TSource, TSample>(IObservable<TSample>)	Overloaded. Samples the queryable observable sequence at sampling ticks with the specified source and sampler. (Defined by Qbservable.)
	Scan<TSource>(Func<TSource, TSource, TSource>)	Overloaded. Applies an accumulator function over an observable sequence and returns each intermediate result with the specified source and accumulator. (Defined by Observable.)
	Scan<TSource>(Expression<Func<TSource, TSource, TSource>>)	Overloaded. Applies an accumulator function over a queryable observable sequence and returns each intermediate result with the specified source and accumulator. (Defined by Qbservable.)
	Scan<TSource, TAccumulate>(TAccumulate, Func<TAccumulate, TSource, TAccumulate>)	Overloaded. Applies an accumulator function over an observable sequence and returns each intermediate result with the specified source, seed and accumulator. (Defined by Observable.)
	Scan<TSource, TAccumulate>(TAccumulate, Expression<Func<TAccumulate, TSource, TAccumulate>>)	Overloaded. Applies an accumulator function over a queryable observable sequence and returns each intermediate result with the specified source, seed and accumulator. (Defined by Qbservable.)
	Select<TSource, TResult>(Func<TSource, TResult>)	Overloaded. Projects each element of an observable sequence into a new form with the specified source and selector. (Defined by Observable.)
	Select<TSource, TResult>(Func<TSource, Int32, TResult>)	Overloaded. Projects each element of an observable sequence into a new form by incorporating the element’s index with the specified source and selector. (Defined by Observable.)
	Select<TSource, TResult>(Expression<Func<TSource, TResult>>)	Overloaded. Projects each element of a queryable observable sequence into a new form with the specified source and selector. (Defined by Qbservable.)
	Select<TSource, TResult>(Expression<Func<TSource, Int32, TResult>>)	Overloaded. Projects each element of a queryable observable sequence into a new form by incorporating the element’s index with the specified source and selector. (Defined by Qbservable.)
	SelectMany<TSource, TOther>(IObservable<TOther>)	Overloaded. Projects each element of an observable sequence to an observable sequence and flattens the resulting observable sequences into one observable sequence. (Defined by Observable.)
	SelectMany<TSource, TResult>(Func<TSource, IObservable<TResult>>)	Overloaded. Projects each element of an observable sequence to an observable sequence and flattens the resulting observable sequences into one observable sequence. (Defined by Observable.)
	SelectMany<TSource, TResult>(Func<TSource, IEnumerable<TResult>>)	Overloaded. Projects each element of an observable sequence to an observable sequence and flattens the resulting observable sequences into one observable sequence. (Defined by Observable.)
	SelectMany<TSource, TOther>(IObservable<TOther>)	Overloaded. Projects each element of a queryable observable sequence to a queryable observable sequence and flattens the resulting queryable observable sequences into one queryable observable sequence. (Defined by Qbservable.)
	SelectMany<TSource, TResult>(Expression<Func<TSource, IObservable<TResult>>>)	Overloaded. Projects each element of a queryable observable sequence to a queryable observable sequence and flattens the resulting queryable observable sequences into one queryable observable sequence. (Defined by Qbservable.)
	SelectMany<TSource, TResult>(Expression<Func<TSource, IEnumerable<TResult>>>)	Overloaded. Projects each element of a queryable observable sequence to a queryable observable sequence and flattens the resulting queryable observable sequences into one queryable observable sequence. (Defined by Qbservable.)
	SelectMany<TSource, TResult>(Func<TSource, IObservable<TResult>>, Func<Exception, IObservable<TResult>>, Func<IObservable<TResult>>)	Overloaded. Projects each element of an observable sequence to an observable sequence and flattens the resulting observable sequences into one observable sequence. (Defined by Observable.)
	SelectMany<TSource, TResult>(Expression<Func<TSource, IObservable<TResult>>>, Expression<Func<Exception, IObservable<TResult>>>, Expression<Func<IObservable<TResult>>>)	Overloaded. Projects each element of a queryable observable sequence to a queryable observable sequence and flattens the resulting queryable observable sequences into one queryable observable sequence. (Defined by Qbservable.)
	SelectMany<TSource, TCollection, TResult>(Func<TSource, IEnumerable<TCollection>>, Func<TSource, TCollection, TResult>)	Overloaded. Projects each element of an observable sequence to an observable sequence and flattens the resulting observable sequences into one observable sequence. (Defined by Observable.)
	SelectMany<TSource, TCollection, TResult>(Func<TSource, IObservable<TCollection>>, Func<TSource, TCollection, TResult>)	Overloaded. Projects each element of an observable sequence to an observable sequence and flattens the resulting observable sequences into one observable sequence. (Defined by Observable.)
	SelectMany<TSource, TCollection, TResult>(Expression<Func<TSource, IEnumerable<TCollection>>>, Expression<Func<TSource, TCollection, TResult>>)	Overloaded. Projects each element of a queryable observable sequence to a queryable observable sequence and flattens the resulting queryable observable sequences into one queryable observable sequence. (Defined by Qbservable.)
	SelectMany<TSource, TCollection, TResult>(Expression<Func<TSource, IObservable<TCollection>>>, Expression<Func<TSource, TCollection, TResult>>)	Overloaded. Projects each element of a queryable observable sequence to a queryable observable sequence and flattens the resulting queryable observable sequences into one queryable observable sequence. (Defined by Qbservable.)
	SequenceEqual<TSource>(IObservable<TSource>)	Overloaded. Determines whether two sequences are equal by comparing the elements pairwise. (Defined by Observable.)
	SequenceEqual<TSource>(IObservable<TSource>)	Overloaded. Determines whether two sequences are equal by comparing the elements pairwise. (Defined by Qbservable.)
	SequenceEqual<TSource>(IObservable<TSource>, IEqualityComparer<TSource>)	Overloaded. Determines whether two sequences are equal by comparing the elements pairwise using a specified equality comparer. (Defined by Observable.)
	SequenceEqual<TSource>(IObservable<TSource>, IEqualityComparer<TSource>)	Overloaded. Determines whether two sequences are equal by comparing the elements pairwise using a specified equality comparer. (Defined by Qbservable.)
	Single<TSource>()	Overloaded. Returns the only element of an observable sequence and throws an exception if there is not exactly one element in the observable sequence. (Defined by Observable.)
	Single<TSource>(Func<TSource, Boolean>)	Overloaded. Returns the only element of an observable sequence that matches the predicate and throws an exception if there is not exactly one element in the observable sequence. (Defined by Observable.)
	SingleOrDefault<TSource>()	Overloaded. Returns the only element of an observable sequence, or a default value if the observable sequence is empty. (Defined by Observable.)
	SingleOrDefault<TSource>(Func<TSource, Boolean>)	Overloaded. Returns the only element of an observable sequence that matches the predicate, or a default value if no value is found. (Defined by Observable.)
	Skip<TSource>(Int32)	Overloaded. Bypasses a specified number of values in an observable sequence and then returns the remaining values. (Defined by Observable.)
	Skip<TSource>(Int32)	Overloaded. Bypasses a specified number of values in an observable sequence and then returns the remaining values. (Defined by Qbservable.)
	SkipLast<TSource>(Int32)	Overloaded. Bypasses a specified number of elements at the end of an observable sequence. (Defined by Observable.)
	SkipLast<TSource>(Int32)	Overloaded. Bypasses a specified number of elements at the end of a queryable observable sequence. (Defined by Qbservable.)
	SkipUntil<TSource, TOther>(IObservable<TOther>)	Overloaded. Returns the values from the source observable sequence only after the other observable sequence produces a value. (Defined by Observable.)
	SkipUntil<TSource, TOther>(IObservable<TOther>)	Overloaded. Returns the values from the source queryable observable sequence only after the other queryable observable sequence produces a value. (Defined by Qbservable.)
	SkipWhile<TSource>(Func<TSource, Boolean>)	Overloaded. Bypasses values in an observable sequence as long as a specified condition is true and then returns the remaining values. (Defined by Observable.)
	SkipWhile<TSource>(Func<TSource, Int32, Boolean>)	Overloaded. Bypasses values in an observable sequence as long as a specified condition is true and then returns the remaining values. (Defined by Observable.)
	SkipWhile<TSource>(Expression<Func<TSource, Boolean>>)	Overloaded. Bypasses values in a queryable observable sequence as long as a specified condition is true and then returns the remaining values. (Defined by Qbservable.)
	SkipWhile<TSource>(Expression<Func<TSource, Int32, Boolean>>)	Overloaded. Bypasses values in a queryable observable sequence as long as a specified condition is true and then returns the remaining values. (Defined by Qbservable.)
	StartWith<TSource>TSource[])	Overloaded. Prepends a sequence of values to an observable sequence with the specified source and values. (Defined by Observable.)
	StartWith<TSource>TSource[])	Overloaded. Prepends a sequence of values to a queryable observable sequence with the specified source and values. (Defined by Qbservable.)
	StartWith<TSource>(IScheduler, TSource[])	Overloaded. Prepends a sequence of values to an observable sequence with the specified source, scheduler and values. (Defined by Observable.)
	StartWith<TSource>(IScheduler, TSource[])	Overloaded. Prepends a sequence of values to a queryable observable sequence with the specified source, scheduler and values. (Defined by Qbservable.)
	Subscribe<TSource>()	Overloaded. Evaluates the observable sequence with a specified source. (Defined by ObservableExtensions.)
	Subscribe<TSource>(Action<TSource>)	Overloaded. Subscribes an element handler to an observable sequence. (Defined by ObservableExtensions.)
	Subscribe<TSource>(Action<TSource>, Action<Exception>)	Overloaded. Subscribes an element handler and an exception handler to an observable sequence. (Defined by ObservableExtensions.)
	Subscribe<TSource>(Action<TSource>, Action)	Overloaded. Subscribes an element handler and a completion handler to an observable sequence. (Defined by ObservableExtensions.)
	Subscribe<TSource>(Action<TSource>, Action<Exception>, Action)	Overloaded. Subscribes an element handler, an exception handler, and a completion handler to an observable sequence. (Defined by ObservableExtensions.)
	SubscribeOn<TSource>(SynchronizationContext)	Overloaded. Asynchronously subscribes and unsubscribes observers on the specified synchronization context. (Defined by Observable.)
	SubscribeOn<TSource>(Control)	Overloaded. (Defined by ControlObservable.)
	SubscribeOn<TSource>(Dispatcher)	Overloaded. (Defined by DispatcherObservable.)
	SubscribeOn<TSource>(SynchronizationContext)	Overloaded. Asynchronously subscribes and unsubscribes observers on the specified synchronization context. (Defined by Qbservable.)
	SubscribeOn<TSource>(DispatcherScheduler)	Overloaded. (Defined by DispatcherObservable.)
	SubscribeOn<TSource>(IScheduler)	Overloaded. Asynchronously subscribes and unsubscribes observers on the specified scheduler. (Defined by Observable.)
	SubscribeOn<TSource>(IScheduler)	Overloaded. Asynchronously subscribes and unsubscribes observers on the specified synchronization context. (Defined by Qbservable.)
	SubscribeOnDispatcher<TSource>	(Defined by DispatcherObservable.)
	Synchronize<TSource>()	Overloaded. Synchronizes the observable sequence. (Defined by Observable.)
	Synchronize<TSource>()	Overloaded. Synchronizes the queryable observable sequence. (Defined by Qbservable.)
	Synchronize<TSource>(Object)	Overloaded. Synchronizes the observable sequence. (Defined by Observable.)
	Synchronize<TSource>(Object)	Overloaded. Synchronizes the queryable observable sequence. (Defined by Qbservable.)
	Take<TSource>(Int32)	Overloaded. Returns a specified number of contiguous values from the start of an observable sequence. (Defined by Observable.)
	Take<TSource>(Int32)	Overloaded. Returns a specified number of contiguous values from the start of a queryable observable sequence. (Defined by Qbservable.)
	TakeLast<TSource>(Int32)	Overloaded. Returns a specified number of contiguous elements from the end of an observable sequence. (Defined by Observable.)
	TakeLast<TSource>(Int32)	Overloaded. Returns a specified number of contiguous elements from the end of a queryable observable sequence. (Defined by Qbservable.)
	TakeUntil<TSource, TOther>(IObservable<TOther>)	Overloaded. Returns the values from the source observable sequence until the other observable sequence produces a value. (Defined by Observable.)
	TakeUntil<TSource, TOther>(IObservable<TOther>)	Overloaded. Returns the values from the source queryable observable sequence until the other queryable observable sequence produces a value. (Defined by Qbservable.)
	TakeWhile<TSource>(Func<TSource, Boolean>)	Overloaded. Returns values from an observable sequence as long as a specified condition is true, and then skips the remaining values. (Defined by Observable.)
	TakeWhile<TSource>(Func<TSource, Int32, Boolean>)	Overloaded. Returns values from an observable sequence as long as a specified condition is true, and then skips the remaining values. (Defined by Observable.)
	TakeWhile<TSource>(Expression<Func<TSource, Boolean>>)	Overloaded. Returns values from a queryable observable sequence as long as a specified condition is true, and then skips the remaining values. (Defined by Qbservable.)
	TakeWhile<TSource>(Expression<Func<TSource, Int32, Boolean>>)	Overloaded. Returns values from a queryable observable sequence as long as a specified condition is true, and then skips the remaining values. (Defined by Qbservable.)
	Then<TSource, TResult>(Func<TSource, TResult>)	Overloaded. Matches when the observable sequence has an available value and projects the value. (Defined by Observable.)
	Then<TSource, TResult>(Expression<Func<TSource, TResult>>)	Overloaded. Matches when the queryable observable sequence has an available value and projects the value. (Defined by Qbservable.)
	Throttle<TSource>(TimeSpan)	Overloaded. Ignores the values from an observable sequence which are followed by another value before due time with the specified source and dueTime. (Defined by Observable.)
	Throttle<TSource>(TimeSpan)	Overloaded. Ignores the values from a queryable observable sequence which are followed by another value before due time with the specified source and dueTime. (Defined by Qbservable.)
	Throttle<TSource>(TimeSpan, IScheduler)	Overloaded. Ignores the values from an observable sequence which are followed by another value before due time with the specified source, dueTime and scheduler. (Defined by Observable.)
	Throttle<TSource>(TimeSpan, IScheduler)	Overloaded. Ignores the values from a queryable observable sequence which are followed by another value before due time with the specified source, dueTime and scheduler. (Defined by Qbservable.)
	TimeInterval<TSource>()	Overloaded. Records the time interval between consecutive values in an observable sequence with the specified source. (Defined by Observable.)
	TimeInterval<TSource>()	Overloaded. Records the time interval between consecutive values in a queryable observable sequence with the specified source. (Defined by Qbservable.)
	TimeInterval<TSource>(IScheduler)	Overloaded. Records the time interval between consecutive values in an observable sequence with the specified source and scheduler. (Defined by Observable.)
	TimeInterval<TSource>(IScheduler)	Overloaded. Records the time interval between consecutive values in a queryable observable sequence with the specified source and scheduler. (Defined by Qbservable.)
	Timeout<TSource>(TimeSpan)	Overloaded. Returns either the observable sequence or an TimeoutException if dueTime elapses. (Defined by Observable.)
	Timeout<TSource>(DateTimeOffset)	Overloaded. Returns either the observable sequence or a TimeoutException if dueTime elapses. (Defined by Observable.)
	Timeout<TSource>(TimeSpan)	Overloaded. Returns either the queryable observable sequence or a TimeoutException if dueTime elapses. (Defined by Qbservable.)
	Timeout<TSource>(DateTimeOffset)	Overloaded. Returns either the queryable observable sequence or a TimeoutException if dueTime elapses. (Defined by Qbservable.)
	Timeout<TSource>(TimeSpan, IObservable<TSource>)	Overloaded. Returns the source observable sequence or the other observable sequence if dueTime elapses. (Defined by Observable.)
	Timeout<TSource>(DateTimeOffset, IObservable<TSource>)	Overloaded. Returns either the observable sequence or an TimeoutException if dueTime elapses. (Defined by Observable.)
	Timeout<TSource>(TimeSpan, IScheduler)	Overloaded. Returns either the observable sequence or an TimeoutException if dueTime elapses. (Defined by Observable.)
	Timeout<TSource>(DateTimeOffset, IScheduler)	Overloaded. Returns either the observable sequence or an TimeoutException if dueTime elapses. (Defined by Observable.)
	Timeout<TSource>(TimeSpan, IObservable<TSource>)	Overloaded. Returns the source queryable observable sequence or the other queryable observable sequence if dueTime elapses. (Defined by Qbservable.)
	Timeout<TSource>(DateTimeOffset, IObservable<TSource>)	Overloaded. Returns either the queryable observable sequence or an TimeoutException if dueTime elapses. (Defined by Qbservable.)
	Timeout<TSource>(TimeSpan, IScheduler)	Overloaded. Returns either the queryable observable sequence or a TimeoutException if dueTime elapses. (Defined by Qbservable.)
	Timeout<TSource>(DateTimeOffset, IScheduler)	Overloaded. Returns either the queryable observable sequence or a TimeoutException if dueTime elapses. (Defined by Qbservable.)
	Timeout<TSource>(TimeSpan, IObservable<TSource>, IScheduler)	Overloaded. Returns the source observable sequence or the other observable sequence if dueTime elapses. (Defined by Observable.)
	Timeout<TSource>(DateTimeOffset, IObservable<TSource>, IScheduler)	Overloaded. Returns the source observable sequence or the other observable sequence if dueTime elapses. (Defined by Observable.)
	Timeout<TSource>(TimeSpan, IObservable<TSource>, IScheduler)	Overloaded. Returns the source queryable observable sequence or the other queryable observable sequence if dueTime elapses. (Defined by Qbservable.)
	Timeout<TSource>(DateTimeOffset, IObservable<TSource>, IScheduler)	Overloaded. Returns the source queryable observable sequence or the other queryable observable sequence if dueTime elapses. (Defined by Qbservable.)
	Timestamp<TSource>()	Overloaded. Records the timestamp for each value in an observable sequence with the specified source. (Defined by Observable.)
	Timestamp<TSource>()	Overloaded. Records the timestamp for each value in a queryable observable sequence with the specified source. (Defined by Qbservable.)
	Timestamp<TSource>(IScheduler)	Overloaded. Records the timestamp for each value in an observable sequence with the specified source and scheduler. (Defined by Observable.)
	Timestamp<TSource>(IScheduler)	Overloaded. Records the timestamp for each value in a queryable observable sequence with the specified source and scheduler. (Defined by Qbservable.)
	ToArray<TSource>()	Overloaded. Creates an array from an observable sequence. (Defined by Observable.)
	ToArray<TSource>()	Overloaded. Creates an array from a queryable observable sequence. (Defined by Qbservable.)
	ToDictionary<TSource, TKey>(Func<TSource, TKey>)	Overloaded. Creates a dictionary from an observable sequence according to a specified key selector function. (Defined by Observable.)
	ToDictionary<TSource, TKey>(Expression<Func<TSource, TKey>>)	Overloaded. Creates a dictionary from a queryable observable sequence according to a specified key selector function. (Defined by Qbservable.)
	ToDictionary<TSource, TKey>(Func<TSource, TKey>, IEqualityComparer<TKey>)	Overloaded. Creates a dictionary from an observable sequence according to a specified key selector function, and a comparer. (Defined by Observable.)
	ToDictionary<TSource, TKey>(Expression<Func<TSource, TKey>>, IEqualityComparer<TKey>)	Overloaded. Creates a dictionary from a queryable observable sequence according to a specified key selector function, and a comparer. (Defined by Qbservable.)
	ToDictionary<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>)	Overloaded. Creates a dictionary from an observable sequence according to a specified key selector function, and an element selector function. (Defined by Observable.)
	ToDictionary<TSource, TKey, TElement>(Expression<Func<TSource, TKey>>, Expression<Func<TSource, TElement>>)	Overloaded. Creates a dictionary from a queryable observable sequence according to a specified key selector function, and an element selector function. (Defined by Qbservable.)
	ToDictionary<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>, IEqualityComparer<TKey>)	Overloaded. Creates a dictionary from an observable sequence according to a specified key selector function, a comparer, and an element selector function. (Defined by Observable.)
	ToDictionary<TSource, TKey, TElement>(Expression<Func<TSource, TKey>>, Expression<Func<TSource, TElement>>, IEqualityComparer<TKey>)	Overloaded. Creates a dictionary from a queryable observable sequence according to a specified key selector function, a comparer, and an element selector function. (Defined by Qbservable.)
	ToEnumerable<TSource>	Converts an observable sequence to an enumerable sequence. (Defined by Observable.)
	ToEvent<TSource>	Exposes an observable sequence as an object with a .NET event with a specified source. (Defined by Observable.)
	ToList<TSource>()	Overloaded. Creates a list from an observable sequence. (Defined by Observable.)
	ToList<TSource>()	Overloaded. Creates a list from a queryable observable sequence. (Defined by Qbservable.)
	ToLookup<TSource, TKey>(Func<TSource, TKey>)	Overloaded. Creates a lookup from an observable sequence according to a specified key selector function. (Defined by Observable.)
	ToLookup<TSource, TKey>(Expression<Func<TSource, TKey>>)	Overloaded. Creates a lookup from a queryable observable sequence according to a specified key selector function. (Defined by Qbservable.)
	ToLookup<TSource, TKey>(Func<TSource, TKey>, IEqualityComparer<TKey>)	Overloaded. Creates a lookup from an observable sequence according to a specified key selector function, and a comparer. (Defined by Observable.)
	ToLookup<TSource, TKey>(Expression<Func<TSource, TKey>>, IEqualityComparer<TKey>)	Overloaded. Creates a lookup from a queryable observable sequence according to a specified key selector function, and a comparer. (Defined by Qbservable.)
	ToLookup<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>)	Overloaded. Creates a lookup from an observable sequence according to a specified key selector function, and an element selector function. (Defined by Observable.)
	ToLookup<TSource, TKey, TElement>(Expression<Func<TSource, TKey>>, Expression<Func<TSource, TElement>>)	Overloaded. Creates a lookup from a queryable observable sequence according to a specified key selector function, and an element selector function. (Defined by Qbservable.)
	ToLookup<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>, IEqualityComparer<TKey>)	Overloaded. Creates a lookup from an observable sequence according to a specified key selector function, a comparer, and an element selector function. (Defined by Observable.)
	ToLookup<TSource, TKey, TElement>(Expression<Func<TSource, TKey>>, Expression<Func<TSource, TElement>>, IEqualityComparer<TKey>)	Overloaded. Creates a lookup from a queryable observable sequence according to a specified key selector function, a comparer, and an element selector function. (Defined by Qbservable.)
	ToQueryable<TSource>	Converts an enumerable sequence to a queryable observable sequence with a specified source. (Defined by Qbservable.)
	ToTask<TSource>()	Overloaded. Returns a task that contains the last value of the observable sequence. (Defined by TaskObservableExtensions.)
	ToTask<TSource>(Object)	Overloaded. Returns a task that contains the last value of the observable sequence. (Defined by TaskObservableExtensions.)
	ToTask<TSource>(CancellationToken)	Overloaded. Returns a task that contains the last value of the observable sequence. (Defined by TaskObservableExtensions.)
	ToTask<TSource>(CancellationToken, Object)	Overloaded. Returns a task that contains the last value of the observable sequence. (Defined by TaskObservableExtensions.)
	Where<TSource>(Func<TSource, Boolean>)	Overloaded. Filters the elements of an observable sequence based on a predicate. (Defined by Observable.)
	Where<TSource>(Func<TSource, Int32, Boolean>)	Overloaded. Filters the elements of an observable sequence based on a predicate by incorporating the element's index. (Defined by Observable.)
	Where<TSource>(Expression<Func<TSource, Boolean>>)	Overloaded. Filters the elements of a queryable observable sequence based on a predicate. (Defined by Qbservable.)
	Where<TSource>(Expression<Func<TSource, Int32, Boolean>>)	Overloaded. Filters the elements of a queryable observable sequence based on a predicate by incorporating the element's index. (Defined by Qbservable.)
	Window<TSource>(Int32)	Overloaded. Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on element count information. (Defined by Observable.)
	Window<TSource>(TimeSpan)	Overloaded. Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on timing information. (Defined by Observable.)
	Window<TSource>(TimeSpan)	Overloaded. Projects each element of a queryable observable sequence into consecutive non-overlapping windows which are produced based on timing information. (Defined by Qbservable.)
	Window<TSource>(Int32)	Overloaded. Projects each element of a queryable observable sequence into consecutive non-overlapping windows which are produced based on element count information. (Defined by Qbservable.)
	Window<TSource>(Int32, Int32)	Overloaded. Projects each element of an observable sequence into zero or more windows which are produced based on element count information. (Defined by Observable.)
	Window<TSource>(TimeSpan, IScheduler)	Overloaded. Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on timing information. (Defined by Observable.)
	Window<TSource>(TimeSpan, TimeSpan)	Overloaded. Projects each element of an observable sequence into zero or more windows which are produced based on timing information. (Defined by Observable.)
	Window<TSource>(TimeSpan, Int32)	Overloaded. 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. (Defined by Observable.)
	Window<TSource>(TimeSpan, TimeSpan)	Overloaded. Projects each element of a queryable observable sequence into zero or more windows which are produced based on timing information. (Defined by Qbservable.)
	Window<TSource>(TimeSpan, Int32)	Overloaded. Projects each element of a queryable observable sequence into a window that is completed when either it’s full or a given amount of time has elapsed. (Defined by Qbservable.)
	Window<TSource>(TimeSpan, IScheduler)	Overloaded. Projects each element of a queryable observable sequence into consecutive non-overlapping windows which are produced based on timing information. (Defined by Qbservable.)
	Window<TSource>(Int32, Int32)	Overloaded. Projects each element of a queryable observable sequence into zero or more windows which are produced based on element count information. (Defined by Qbservable.)
	Window<TSource>(TimeSpan, TimeSpan, IScheduler)	Overloaded. Projects each element of an observable sequence into zero or more windows which are produced based on timing information. (Defined by Observable.)
	Window<TSource>(TimeSpan, Int32, IScheduler)	Overloaded. 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. (Defined by Observable.)
	Window<TSource>(TimeSpan, Int32, IScheduler)	Overloaded. Projects each element of a queryable observable sequence into a window that is completed when either it’s full or a given amount of time has elapsed. (Defined by Qbservable.)
	Window<TSource>(TimeSpan, TimeSpan, IScheduler)	Overloaded. Projects each element of a queryable observable sequence into zero or more windows which are produced based on timing information. (Defined by Qbservable.)
	Window<TSource, TWindowClosing>(Func<IObservable<TWindowClosing>>)	Overloaded. Projects each element of an observable sequence into consecutive non-overlapping windows. (Defined by Observable.)
	Window<TSource, TWindowClosing>(Expression<Func<IObservable<TWindowClosing>>>)	Overloaded. Projects each element of a queryable observable sequence into consecutive non-overlapping windows. (Defined by Qbservable.)
	Window<TSource, TWindowOpening, TWindowClosing>(IObservable<TWindowOpening>, Func<TWindowOpening, IObservable<TWindowClosing>>)	Overloaded. Projects each element of an observable sequence into zero or more windows. (Defined by Observable.)
	Window<TSource, TWindowOpening, TWindowClosing>(IObservable<TWindowOpening>, Expression<Func<TWindowOpening, IObservable<TWindowClosing>>>)	Overloaded. Projects each element of a queryable observable sequence into zero or more windows. (Defined by Qbservable.)
	Zip<TSource, TSecond, TResult>(IObservable<TSecond>, Func<TSource, TSecond, TResult>)	Overloaded. Merges two observable sequences into one observable sequence by combining their elements in a pairwise fashion. (Defined by Observable.)
	Zip<TSource, TSecond, TResult>(IEnumerable<TSecond>, Func<TSource, TSecond, TResult>)	Overloaded. Merges an observable sequence and an enumerable sequence into one observable sequence by using the selector function. (Defined by Observable.)
	Zip<TFirst, TSecond, TResult>(IObservable<TSecond>, Expression<Func<TFirst, TSecond, TResult>>)	Overloaded. Merges two queryable observable sequences into one queryable observable sequence by combining their elements in a pairwise fashion. (Defined by Qbservable.)
	Zip<TFirst, TSecond, TResult>(IEnumerable<TSecond>, Expression<Func<TFirst, TSecond, TResult>>)	Overloaded. Merges a queryable observable sequence and an enumerable sequence into one queryable observable sequence by using the selector function. (Defined by Qbservable.)

Top

See Also

Reference

System.Reactive.Linq Namespace