ISubject<T> インターフェイス

  • [アーティクル]

観察可能なシーケンスとオブザーバーの両方であるオブジェクトを表します。

Namespace:System.Reactive.Subjects
アセンブリ： System.Reactive (System.Reactive.dll)

構文

'Declaration
Public Interface ISubject(Of T) _
    Inherits ISubject(Of T, T), IObserver(Of T),  _
    IObservable(Of T)

'Usage
Dim instance As ISubject(Of T)

public interface ISubject<T> : ISubject<T, T>, 
    IObserver<T>, IObservable<T>

generic<typename T>
public interface class ISubject : ISubject<T, T>, 
    IObserver<T>, IObservable<T>

type ISubject<'T> =  
    interface
        interface ISubject<'T, 'T>
        interface IObserver<'T>
        interface IObservable<'T>
    end

JScript does not support generic types and methods.

型パラメーター

  • T
    件名の種類。

ISubject<T> 型は、次のメンバーを公開します。

メソッド

  名前 説明
Public メソッド OnCompleted (IObserver から継承されます)<T>.)
Public メソッド OnError (IObserver から継承されます)<T>.)
Public メソッド Onnext (IObserver から継承されます)<T>.)
Public メソッド サブスクライブ (IObservable から継承されます)<T>.)

上

拡張メソッド

  名前 説明
パブリック拡張メソッド 集計<T>(Func<T, T, T>) オーバーロードされます。 監視可能なシーケンスにアキュムレータ関数を適用します。 ( Observable によって定義されます)。
パブリック拡張メソッド Aggregate<T, TAccumulate>(TAccumulate, Func<TAccumulate, T, TAccumulate>) オーバーロードされます。 指定されたシード値を持つ監視可能なシーケンスにアキュムレータ関数を適用します。 ( Observable によって定義されます)。
パブリック拡張メソッド すべての<T> 監視可能なシーケンスのすべての要素が条件を満たすかどうかを判断します。 ( Observable によって定義されます)。
パブリック拡張メソッド Amb<T> 指定した 1 番目と 2 番目のシーケンスと最初に反応する観測可能なシーケンスを伝達します。 ( Observable によって定義されます)。
パブリック拡張メソッド および<T、TRight> 両方の監視可能なシーケンスに使用可能な値がある場合に一致します。 ( Observable によって定義されます)。
パブリック拡張メソッド Any<T>() オーバーロードされます。 監視可能なシーケンスに要素が含まれているかどうかを判断します。 ( Observable によって定義されます)。
パブリック拡張メソッド Any<T>(Func<T, Boolean>) オーバーロードされます。 監視可能なシーケンスのすべての要素が条件を満たすかどうかを判断します。 ( Observable によって定義されます)。
パブリック拡張メソッド AsObservable<T> 監視可能なシーケンスの ID を非表示にします。 ( Observable によって定義されます)。
パブリック拡張メソッド AsObserver<T> オブザーバーの ID を非表示にします。 ( オブザーバーによって定義されます。
パブリック拡張メソッド AsQbservable<T> 監視可能なシーケンスをクエリ可能な監視可能なシーケンスに変換します。 ( Qbservable によって定義されます。
パブリック拡張メソッド AssertEqual<T> ( 拡張機能によって定義されます。)
パブリック拡張メソッド Buffer<T>(Int32) オーバーロードされます。 監視可能なシーケンスの各要素を、要素数情報に基づいて生成される連続した重複しないバッファーに示します。 ( Observable によって定義されます)。
パブリック拡張メソッド Buffer<T>(TimeSpan) オーバーロードされます。 監視可能なシーケンスの各要素を、タイミング情報に基づいて生成される連続した重複しないバッファーに示します。 ( Observable によって定義されます)。
パブリック拡張メソッド Buffer<T>(Int32, Int32) オーバーロードされます。 監視可能なシーケンスの各要素を、要素数情報に基づいて生成される 0 個以上のバッファーに示します。 ( Observable によって定義されます)。
パブリック拡張メソッド Buffer<T>(TimeSpan, IScheduler) オーバーロードされます。 監視可能なシーケンスの各要素を、タイミング情報に基づいて生成される連続した重複しないバッファーに示します。 ( Observable によって定義されます)。
パブリック拡張メソッド Buffer<T>(TimeSpan, TimeSpan) オーバーロードされます。 監視可能なシーケンスの各要素を、タイミング情報に基づいて生成される 0 個以上のバッファーに示します。 ( Observable によって定義されます。
パブリック拡張メソッド Buffer<T>(TimeSpan, Int32) オーバーロードされます。 監視可能なシーケンスの各要素をバッファーに示します。バッファーが満杯になった場合、または特定の時間が経過したときに送信されます。 ( Observable によって定義されます。
パブリック拡張メソッド Buffer<T>(TimeSpan, TimeSpan, IScheduler) オーバーロードされます。 監視可能なシーケンスの各要素を、タイミング情報に基づいて生成される 0 個以上のバッファーに示します。 ( Observable によって定義されます。
パブリック拡張メソッド Buffer<T>(TimeSpan, Int32, IScheduler) オーバーロードされます。 監視可能なシーケンスの各要素をバッファーに示します。バッファーが満杯になった場合、または特定の時間が経過したときに送信されます。 ( Observable によって定義されます。
パブリック拡張メソッド Buffer<T,TBufferClosing>(Func<IObservable<TBufferClosing>>) オーバーロードされます。 監視可能なシーケンスの各要素を連続する重複しないバッファーに示します。 ( Observable によって定義されます。
パブリック拡張メソッド Buffer<T、TBufferOpening、TBufferClosing>(IObservable<TBufferOpening>、Func<TBufferOpening、IObservable<TBufferClosing>>) オーバーロードされます。 クエリ可能な監視可能なシーケンスの各要素を、重複しない連続するバッファーに示します。 ( Observable によって定義されます。
パブリック拡張メソッド Catch<T>(IObservable<T>) オーバーロードされます。 次の監視可能なシーケンスで例外によって終了される監視可能なシーケンスを続行します。 ( Observable によって定義されます。
パブリック拡張メソッド Catch<T, TException>(Func<TException, IObservable<T>>) オーバーロードされます。 ハンドラーによって生成された監視可能なシーケンスを使用して、指定された型の例外によって終了される監視可能なシーケンスを続行します。 ( Observable によって定義されます。
パブリック拡張メソッド CombineLatest<T、TSecond、TResult> 監視可能なシーケンスの 1 つが要素を生成するたびに、セレクター関数を使用して、2 つの監視可能なシーケンスを 1 つの監視可能なシーケンスにマージします。 ( Observable によって定義されます。
パブリック拡張メソッド Concat<T> 2 つの監視可能なシーケンスを連結します。 ( Observable によって定義されます。
パブリック拡張メソッド T>(T) を<含む オーバーロードされます。 既定の等値比較子を使用して、監視可能なシーケンスに指定された要素が含まれているかどうかを判断します。 ( Observable によって定義されます。
パブリック拡張メソッド <T>(T, IEqualityComparer<T>) が含まれています オーバーロードされます。 指定した System.Collections.Generic.IEqualityComparer&lt を使用して、監視可能なシーケンスに指定された要素が含まれているかどうかを判断します。T&gt;. ( Observable によって定義されます。
パブリック拡張メソッド カウント<T> 観測可能なシーケンス内の要素の合計数を表す Int32 を返します。 ( Observable によって定義されます。
パブリック拡張メソッド DefaultIfEmpty<T>() オーバーロードされます。 シーケンスが空の場合は、指定したシーケンスの要素、またはシングルトン シーケンス内の型パラメーターの既定値を返します。 ( Observable によって定義されます。
パブリック拡張メソッド DefaultIfEmpty<T>(T) オーバーロードされます。 シーケンスが空の場合は、指定したシーケンスの要素、またはシングルトン シーケンス内の型パラメーターの既定値を返します。 ( Observable によって定義されます。
パブリック拡張メソッド Delay<T>(TimeSpan) オーバーロードされます。 指定した source と dueTime を使用して、期限で監視可能なシーケンスを示します。 ( Observable によって定義されます。
パブリック拡張メソッド Delay<T>(DateTimeOffset) オーバーロードされます。 指定した source と dueTime を使用して、期限で監視可能なシーケンスを示します。 ( Observable によって定義されます。
パブリック拡張メソッド Delay<T>(TimeSpan, IScheduler) オーバーロードされます。 指定したソース、dueTime、およびスケジューラを使用して、期限によって監視可能なシーケンスを示します。 ( Observable によって定義されます。
パブリック拡張メソッド Delay<T>(DateTimeOffset, IScheduler) オーバーロードされます。 指定したソース、dueTime、およびスケジューラを使用して、期限によって監視可能なシーケンスを示します。 ( Observable によって定義されます。
パブリック拡張メソッド Distinct<T>() オーバーロードされます。 指定したソースを持つ個別の要素のみを含む監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド Distinct<T>(IEqualityComparer<T>) オーバーロードされます。 比較子に従って個別の要素のみを含む監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド Distinct<T,TKey>(Func<T, TKey>) オーバーロードされます。 keySelector に従って個別の要素のみを含む監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド Distinct<T,TKey>(Func<T, TKey>, IEqualityComparer<TKey>) オーバーロードされます。 keySelector に従って個別の要素のみを含む監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド DistinctUntilChanged<T>() オーバーロードされます。 指定したソースを持つ個別の連続する要素のみを含む監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド DistinctUntilChanged<T>(IEqualityComparer<T>) オーバーロードされます。 比較子に従って個別の連続する要素のみを含む監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド DistinctUntilChanged<T,TKey>(Func<T, TKey>) オーバーロードされます。 keySelector に従って、個別の連続する要素のみを含む監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド DistinctUntilChanged<T,TKey>(Func<T, TKey>, IEqualityComparer<TKey>) オーバーロードされます。 keySelector と比較子に従って、個別の連続する要素のみを含む監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド Do<T>(Action<T>) オーバーロードされます。 監視可能なシーケンス内の各要素に対してアクションを呼び出します。 ( Observable によって定義されます。
パブリック拡張メソッド Do<T>(IObserver<T>) オーバーロードされます。 監視可能シーケンス内の各要素に対してアクションを呼び出し、監視可能シーケンスの例外的な終了時にアクションを呼び出します。 ( Observable によって定義されます。
パブリック拡張メソッド Do<T>(Action<T>, Action) オーバーロードされます。 監視可能なシーケンス内の各要素に対してアクションを呼び出し、監視可能なシーケンスの正常な終了時にアクションを呼び出します。 ( Observable によって定義されます。
パブリック拡張メソッド Do<T>(Action<T>, Action<Exception>) オーバーロードされます。 監視可能シーケンス内の各要素に対してアクションを呼び出し、監視可能シーケンスの例外的な終了時にアクションを呼び出します。 ( Observable によって定義されます。
パブリック拡張メソッド Do<T>(Action<T>, Action<Exception>, Action) オーバーロードされます。 監視可能なシーケンス内の各要素に対してアクションを呼び出し、監視可能なシーケンスの正常または例外的な終了時にアクションを呼び出します。 ( Observable によって定義されます。
パブリック拡張メソッド ElementAt<T> シーケンス内の指定されたインデックス位置にある要素を返します。 ( Observable によって定義されます。
パブリック拡張メソッド ElementAtOrDefault<T> シーケンス内の指定したインデックス位置にある要素を返します。インデックスが範囲外の場合は既定値を返します。 ( Observable によって定義されます。
パブリック拡張メソッド Finally<T> ソース監視可能シーケンスが正常に終了した後、または例外によって、指定されたアクションを呼び出します。 ( Observable によって定義されます。
パブリック拡張メソッド 最初の<T>() オーバーロードされます。 指定したソースを持つ監視可能なシーケンスの最初の要素を返します。 ( Observable によって定義されます。
パブリック拡張メソッド First<T>(Func<T, Boolean>) オーバーロードされます。 述語に一致する監視可能なシーケンスの最初の要素を返します。 ( Observable によって定義されます。
パブリック拡張メソッド FirstOrDefault<T>() オーバーロードされます。 監視可能なシーケンスの最初の要素を返します。値が見つからない場合は既定値を返します。 ( Observable によって定義されます。
パブリック拡張メソッド FirstOrDefault<T>(Func<T, Boolean>) オーバーロードされます。 述語に一致する監視可能なシーケンスの最初の要素を返します。値が見つからない場合は既定値を返します。 ( Observable によって定義されます。
パブリック拡張メソッド Foo<T、R> ( MyExt によって定義されます。)
パブリック拡張メソッド ForEach<T> 監視可能なシーケンス内の各要素に対してアクションを呼び出し、シーケンスが終了するまでブロックします。 ( Observable によって定義されます。
パブリック拡張メソッド GetEnumerator<T> 監視可能なシーケンスのすべての値を列挙する列挙子を返します。 ( Observable によって定義されます。
パブリック拡張メソッド GroupBy<T,TKey>(Func<T, TKey>) オーバーロードされます。 指定したキー セレクター関数に従って、監視可能なシーケンスの要素をグループ化します。 ( Observable によって定義されます)。
パブリック拡張メソッド GroupBy<T,TKey>(Func<T, TKey>, IEqualityComparer<TKey>) オーバーロードされます。 指定したキー セレクター関数と比較子に従って、監視可能なシーケンスの要素をグループ化します。 ( Observable によって定義されます)。
パブリック拡張メソッド GroupBy<T、TKey、TElement>(Func<T、TKey>、Func<T、TElement>) オーバーロードされます。 監視可能なシーケンスの要素をグループ化し、指定した関数を使用して結果の要素を選択します。 ( Observable によって定義されます)。
パブリック拡張メソッド GroupBy<T、TKey、TElement>(Func<T、TKey>、Func<T、TElement>、IEqualityComparer<TKey>) オーバーロードされます。 指定したキー セレクター関数と比較子に従って監視可能なシーケンスの要素をグループ化し、指定した関数を使用して結果の要素を選択します。 ( Observable によって定義されます)。
パブリック拡張メソッド GroupByUntil<T, TKey, TDuration>(Func<T, TKey>, Func<IGroupedObservable<TKey, T>, IObservable<TDuration>>) オーバーロードされます。 指定したキー セレクター関数に従って、監視可能なシーケンスの要素をグループ化します。 ( Observable によって定義されます)。
パブリック拡張メソッド GroupByUntil<T, TKey, TDuration>(Func<T, TKey>, Func<IGroupedObservable<TKey, T>, IObservable<TDuration>>, IEqualityComparer<TKey>) オーバーロードされます。 指定したキー セレクター関数と比較子に従って、監視可能なシーケンスの要素をグループ化します。 ( Observable によって定義されます)。
パブリック拡張メソッド GroupByUntil<T,TKey, TElement, TDuration>(Func<T, TKey>, Func<T, TElement>, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>) オーバーロードされます。 指定したキー セレクター関数に従って監視可能なシーケンスの要素をグループ化し、指定した関数を使用して結果の要素を選択します。 ( Observable によって定義されます)。
パブリック拡張メソッド GroupByUntil<T,TKey, TElement, TDuration>(Func<T, TKey>, Func<T, TElement>, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>, IEqualityComparer<TKey>) オーバーロードされます。 指定したキー セレクター関数と比較子に従って監視可能なシーケンスの要素をグループ化し、指定した関数を使用して結果の要素を選択します。 ( Observable によって定義されます)。
パブリック拡張メソッド GroupJoin<T、TRight、TLeftDuration、TRightDuration、TResult> 重複する期間に基づいて 2 つのシーケンスの要素を関連付け、結果をグループ化します。 ( Observable によって定義されます)。
パブリック拡張メソッド IgnoreElements<T> 終了メッセージのみを残して、監視可能なシーケンス内のすべての値を無視します。 ( Observable によって定義されます)。
パブリック拡張メソッド 結合<T、TRight、TLeftDuration、TRightDuration、TResult> 重複する期間に基づいて、2 つのシーケンスの要素を関連付けます。 ( Observable によって定義されます)。
パブリック拡張メソッド Last<T>() オーバーロードされます。 指定したソースを持つ監視可能なシーケンスの最後の要素を返します。 ( Observable によって定義されます)。
パブリック拡張メソッド Last<T>(Func<T, Boolean>) オーバーロードされます。 述語に一致する監視可能なシーケンスの最後の要素を返します。 ( Observable によって定義されます)。
パブリック拡張メソッド LastOrDefault<T>() オーバーロードされます。 監視可能なシーケンスの最後の要素を返します。値が見つからない場合は既定値を返します。 ( Observable によって定義されます)。
パブリック拡張メソッド LastOrDefault<T>(Func<T, Boolean>) オーバーロードされます。 述語と一致する監視可能なシーケンスの最後の要素を返します。値が見つからない場合は既定値を返します。 ( Observable によって定義されます)。
パブリック拡張メソッド 最新<の T> 監視可能なシーケンスの最新の値をサンプリングします。 ( Observable によって定義されます)。
パブリック拡張メソッド LongCount<T> 監視可能なシーケンス内の要素の合計数を表す Int64 を返します。 ( Observable によって定義されます)。
パブリック拡張メソッド <具体化 T> 監視可能なシーケンスの暗黙的な通知を明示的な通知値として具体化します。 ( Observable によって定義されます)。
パブリック拡張メソッド 最大<T>() オーバーロードされます。 監視可能なシーケンス内の最大要素を返します。 ( Observable によって定義されます)。
パブリック拡張メソッド 最大<T>(IComparer<T>) オーバーロードされます。 指定した比較子に従って、監視可能なシーケンスの最大値を返します。 ( Observable によって定義されます)。
パブリック拡張メソッド MaxBy<T、TKey>(Func<T、TKey>) オーバーロードされます。 最大キー値を持つ監視可能なシーケンス内の要素を返します。 ( Observable によって定義されます)。
パブリック拡張メソッド MaxBy<T、TKey>(Func<T、TKey>、IComparer<TKey>) オーバーロードされます。 最大キー値を持つ監視可能なシーケンス内の要素を返します。 ( Observable によって定義されます)。
パブリック拡張メソッド マージ<T>(IObservable<T>) オーバーロードされます。 監視可能なシーケンスの監視可能なシーケンスを監視可能なシーケンスにマージします。 ( Observable によって定義されます。
パブリック拡張メソッド Merge<T>(IObservable<T>, IScheduler) オーバーロードされます。 2 つの監視可能なシーケンスを 1 つの監視可能なシーケンスにマージします。 ( Observable によって定義されます。
パブリック拡張メソッド Min<T>() オーバーロードされます。 監視可能なシーケンス内の最小要素を返します。 ( Observable によって定義されます。
パブリック拡張メソッド Min<T>(IComparer<T>) オーバーロードされます。 指定した比較子に従って、監視可能なシーケンスの最小値を返します。 ( Observable によって定義されます。
パブリック拡張メソッド MinBy<T、TKey>(Func<T、TKey>) オーバーロードされます。 最小キー値を持つ監視可能なシーケンス内の要素を返します。 ( Observable によって定義されます。
パブリック拡張メソッド MinBy<T、TKey>(Func<T、TKey>、IComparer<TKey>) オーバーロードされます。 指定した比較子に従って、最小キー値を持つ監視可能なシーケンス内の要素を返します。 ( Observable によって定義されます。
パブリック拡張メソッド MostRecent<T> 監視可能なシーケンス内の最新の値をサンプリングします。 ( Observable によって定義されます。
パブリック拡張メソッド Multicast<T, TResult>(ISubject<T, TResult>) オーバーロードされます。 接続時にソース シーケンスが指定したサブジェクトに結果をプッシュする、接続可能な監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド マルチキャスト<T、TIntermediate、TResult>(Func<ISubject<T、TIntermediate>>、Func<IObservable<TIntermediate>、IObservable<TResult>>) オーバーロードされます。 セレクター関数内でソース シーケンスをマルチキャストすることによって生成されるシーケンスの要素を含む監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド 次の<T> 監視可能なシーケンス内の から、次の値 (バッファリングなしでブロック) をサンプリングします。 ( Observable によって定義されます。
パブリック拡張メソッド ObserveOn<T>(SynchronizationContext) オーバーロードされます。 指定した同期コンテキストでオブザーバーに非同期的に通知します。 ( Observable によって定義されます。
パブリック拡張メソッド ObserveOn<T>(Control) オーバーロードされます。 ( ControlObservable によって定義されます。
パブリック拡張メソッド ObserveOn<T>(Dispatcher) オーバーロードされます。 ( DispatcherObservable によって定義されます)。
パブリック拡張メソッド ObserveOn<T>(DispatcherScheduler) オーバーロードされます。 ( DispatcherObservable によって定義されます)。
パブリック拡張メソッド ObserveOn<T>(IScheduler) オーバーロードされます。 指定したスケジューラでオブザーバーに非同期的に通知します。 ( Observable によって定義されます。
パブリック拡張メソッド ObserveOnDispatcher<T> ( DispatcherObservable によって定義されます)。
パブリック拡張メソッド OnErrorResumeNext<T> 正常に終了するか、次の監視可能なシーケンスで例外によって終了される監視可能なシーケンスを続行します。 ( Observable によって定義されます。
パブリック拡張メソッド 発行<T>() オーバーロードされます。 基になるシーケンスに 1 つのサブスクリプションを共有する、接続可能な監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド 発行<T>(T) オーバーロードされます。 基になるシーケンスに 1 つのサブスクリプションを共有し、initialValue で始まる、接続可能な監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド Publish<T, TResult>(Func<IObservable<T>, IObservable<TResult>>) オーバーロードされます。 基になるシーケンスに 1 つのサブスクリプションを共有する接続可能な監視可能なシーケンスでセレクターを呼び出した結果である監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド Publish<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, T) オーバーロードされます。 基になるシーケンスに 1 つのサブスクリプションを共有し、initialValue で始まる、接続可能な監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド PublishLast<T>() オーバーロードされます。 最後の通知のみを含む基になるシーケンスに 1 つのサブスクリプションを共有する、接続可能な監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド PublishLast<T, TResult>(Func<IObservable<T>, IObservable<TResult>>) オーバーロードされます。 最後の通知のみを含む基になるシーケンスに 1 つのサブスクリプションを共有する接続可能な監視可能なシーケンスでセレクターを呼び出した結果である監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド 繰り返し<T>() オーバーロードされます。 監視可能なシーケンスを無期限に繰り返します。 ( Observable によって定義されます。
パブリック拡張メソッド 繰り返し<T>(Int32) オーバーロードされます。 監視可能なシーケンスを無期限に繰り返します。 ( Observable によって定義されます。
パブリック拡張メソッド 再生<T>() オーバーロードされます。 すべての通知を再生する基になるシーケンスに 1 つのサブスクリプションを共有する、接続可能な監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド 再生<T>(TimeSpan) オーバーロードされます。 ウィンドウ内のすべての通知を再生する基になるシーケンスに 1 つのサブスクリプションを共有する、接続可能な監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド 再生<T>(Int32) オーバーロードされます。 bufferSize 通知を再生する基になるシーケンスに 1 つのサブスクリプションを共有する、接続可能な監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド Replay<T>(IScheduler) オーバーロードされます。 すべての通知を再生する基になるシーケンスに 1 つのサブスクリプションを共有する、接続可能な監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド Replay<T>(TimeSpan, IScheduler) オーバーロードされます。 ウィンドウ内のすべての通知を再生する基になるシーケンスに 1 つのサブスクリプションを共有する、接続可能な監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド Replay<T>(Int32, IScheduler) オーバーロードされます。 bufferSize 通知を再生する基になるシーケンスに 1 つのサブスクリプションを共有する、接続可能な監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド 再生<T>(Int32, TimeSpan) オーバーロードされます。 ウィンドウ内の bufferSize 通知を再生する基になるシーケンスに 1 つのサブスクリプションを共有する、接続可能な監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド Replay<T>(Int32, TimeSpan, IScheduler) オーバーロードされます。 ウィンドウ内の bufferSize 通知を再生する基になるシーケンスに 1 つのサブスクリプションを共有する、接続可能な監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>) オーバーロードされます。 基になるシーケンスに 1 つのサブスクリプションを共有し、初期値で始まる、接続可能な監視可能なシーケンスでセレクターを呼び出した結果である監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, IScheduler) オーバーロードされます。 すべての通知を再生する基になるシーケンスに 1 つのサブスクリプションを共有する接続可能な監視可能なシーケンスでセレクターを呼び出した結果である監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, TimeSpan) オーバーロードされます。 ウィンドウ内のすべての通知を再生する基になるシーケンスに 1 つのサブスクリプションを共有する接続可能な監視可能なシーケンスでセレクターを呼び出した結果である監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32) オーバーロードされます。 bufferSize 通知を再生する基になるシーケンスに 1 つのサブスクリプションを共有する接続可能な監視可能なシーケンスでセレクターを呼び出した結果である監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, TimeSpan, IScheduler) オーバーロードされます。 ウィンドウ内のすべての通知を再生する基になるシーケンスに 1 つのサブスクリプションを共有する接続可能な監視可能なシーケンスでセレクターを呼び出した結果である監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32, IScheduler) オーバーロードされます。 bufferSize 通知を再生する基になるシーケンスに 1 つのサブスクリプションを共有する接続可能な監視可能なシーケンスでセレクターを呼び出した結果である監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32, TimeSpan) オーバーロードされます。 ウィンドウ内の bufferSize 通知を再生する基になるシーケンスに 1 つのサブスクリプションを共有する接続可能な監視可能なシーケンスでセレクターを呼び出した結果である監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32, TimeSpan, IScheduler) オーバーロードされます。 ウィンドウ内の bufferSize 通知を再生する基になるシーケンスに 1 つのサブスクリプションを共有する接続可能な監視可能なシーケンスでセレクターを呼び出した結果である監視可能なシーケンスを返します。 ( Observable によって定義されます。
パブリック拡張メソッド 再試行<T>() オーバーロードされます。 ソースの監視可能なシーケンスが正常に終了するまで繰り返します。 ( Observable によって定義されます。
パブリック拡張メソッド 再試行<T>(Int32) オーバーロードされます。 ソースの監視可能なシーケンスが正常に終了するまで繰り返します。 ( Observable によって定義されます。
パブリック拡張メソッド サンプル<T>(TimeSpan) オーバーロードされます。 各間隔で観測可能なシーケンスをサンプリングします。 ( Observable によって定義されます。
パブリック拡張メソッド サンプル<T>(TimeSpan, IScheduler) オーバーロードされます。 指定したソース、間隔、スケジューラを使用して、各間隔で監視可能なシーケンスをサンプリングします。 ( Observable によって定義されます。
パブリック拡張メソッド サンプル<T、TSample>(IObservable<TSample>) オーバーロードされます。 指定したソースとサンプラーを使用して、サンプリング ティックで監視可能なシーケンスをサンプリングします。 ( Observable によって定義されます。
パブリック拡張メソッド スキャン<T>(Func<T, T, T>) オーバーロードされます。 監視可能なシーケンスにアキュムレータ関数を適用し、指定されたソースとアキュムレータを使用して各中間結果を返します。 ( Observable によって定義されます。
パブリック拡張メソッド スキャン<T、TAccumulate>(TAccumulate、Func<TAccumulate、T、TAccumulate>) オーバーロードされます。 監視可能なシーケンスにアキュムレータ関数を適用し、指定されたソース、シード、アキュムレータを使用して各中間結果を返します。 ( Observable によって定義されます。
パブリック拡張メソッド T、TResult(Func<T、TResult>) を選択<します> オーバーロードされます。 監視可能なシーケンスの各要素を、指定したソースとセレクターを使用して新しいフォームに投影します。 ( Observable によって定義されます。
パブリック拡張メソッド T、TResult(Func<T、Int32、TResult>) を選択<します> オーバーロードされます。 指定したソースとセレクターに要素のインデックスを組み込むことで、監視可能なシーケンスの各要素を新しいフォームに投影します。 ( Observable によって定義されます。
パブリック拡張メソッド SelectMany<T,TOther>(IObservable<TOther>) オーバーロードされます。 監視可能なシーケンスの各要素を監視可能なシーケンスに投影し、結果として得られる観測可能なシーケンスを 1 つの監視可能なシーケンスにフラット化します。 ( Observable によって定義されます。
パブリック拡張メソッド SelectMany<T, TResult>(Func<T, IObservable<TResult>>) オーバーロードされます。 監視可能なシーケンスの各要素を監視可能なシーケンスに投影し、結果として得られる観測可能なシーケンスを 1 つの監視可能なシーケンスにフラット化します。 ( Observable によって定義されます。
パブリック拡張メソッド SelectMany<T, TResult>(Func<T, IEnumerable<TResult>>) オーバーロードされます。 監視可能なシーケンスの各要素を監視可能なシーケンスに投影し、結果として得られる観測可能なシーケンスを 1 つの監視可能なシーケンスにフラット化します。 ( Observable によって定義されます。
パブリック拡張メソッド SelectMany<T, TResult>(Func<T, IObservable<TResult>>, Func<Exception, IObservable<TResult>>, Func<IObservable<TResult>>) オーバーロードされます。 監視可能なシーケンスの各要素を監視可能なシーケンスに投影し、結果として得られる観測可能なシーケンスを 1 つの監視可能なシーケンスにフラット化します。 ( Observable によって定義されます。
パブリック拡張メソッド SelectMany<T,TCollection, TResult>(Func<T, IEnumerable<TCollection>>, Func<T, TCollection, TResult>) オーバーロードされます。 監視可能なシーケンスの各要素を監視可能なシーケンスに投影し、結果として得られる観測可能なシーケンスを 1 つの監視可能なシーケンスにフラット化します。 ( Observable によって定義されます。
パブリック拡張メソッド SelectMany<T、TCollection、TResult>(Func<T、IObservable<TCollection>>、Func<T、TCollection、TResult>) オーバーロードされます。 監視可能なシーケンスの各要素を監視可能なシーケンスに投影し、結果として得られる観測可能なシーケンスを 1 つの監視可能なシーケンスにフラット化します。 ( Observable によって定義されます。
パブリック拡張メソッド SequenceEqual<T>(IObservable<T>) オーバーロードされます。 要素をペアで比較して、2 つのシーケンスが等しいかどうかを判断します。 ( Observable によって定義されます。
パブリック拡張メソッド SequenceEqual<T>(IObservable<T>, IEqualityComparer<T>) オーバーロードされます。 指定した等値比較子を使用して要素をペアで比較することで、2 つのシーケンスが等しいかどうかを判断します。 ( Observable によって定義されます。
パブリック拡張メソッド 単一<T>() オーバーロードされます。 監視可能なシーケンスの唯一の要素を返し、監視可能なシーケンスに要素が 1 つも存在しない場合は例外をスローします。 ( Observable によって定義されます。
パブリック拡張メソッド 単一<T>(Func<T, Boolean>) オーバーロードされます。 述語に一致する監視可能なシーケンスの唯一の要素を返し、監視可能なシーケンスに要素が 1 つしかない場合は例外をスローします。 ( Observable によって定義されます。
パブリック拡張メソッド SingleOrDefault<T>() オーバーロードされます。 監視可能なシーケンスの唯一の要素を返します。監視可能なシーケンスが空の場合は既定値を返します。 ( Observable によって定義されます。
パブリック拡張メソッド SingleOrDefault<T>(Func<T, Boolean>) オーバーロードされます。 述語に一致する監視可能なシーケンスの唯一の要素を返します。値が見つからない場合は既定値を返します。 ( Observable によって定義されます。
パブリック拡張メソッド スキップ<T> 監視可能なシーケンス内の指定された数の値をバイパスし、残りの値を返します。 ( Observable によって定義されます。
パブリック拡張メソッド SkipLast<T> 監視可能なシーケンスの末尾にある指定した数の要素をバイパスします。 ( Observable によって定義されます。
パブリック拡張メソッド SkipUntil<T、TOther> 他の監視可能なシーケンスが値を生成した後にのみ、ソース監視可能シーケンスから値を返します。 ( Observable によって定義されます。
パブリック拡張メソッド SkipWhile<T>(Func<T, Boolean>) オーバーロードされます。 指定した条件が true である限り、監視可能なシーケンス内の値をバイパスし、残りの値を返します。 ( Observable によって定義されます。
パブリック拡張メソッド SkipWhile<T>(Func<T, Int32, Boolean>) オーバーロードされます。 指定した条件が true である限り、監視可能なシーケンス内の値をバイパスし、残りの値を返します。 ( Observable によって定義されます。
パブリック拡張メソッド StartWith<T>T[]) オーバーロードされます。 指定したソースと値を持つ監視可能なシーケンスに値のシーケンスを付加します。 ( Observable によって定義されます。
パブリック拡張メソッド StartWith<T>(IScheduler, T[]) オーバーロードされます。 指定したソース、スケジューラ、および値を使用して、監視可能なシーケンスに値のシーケンスを付加します。 ( Observable によって定義されます。
パブリック拡張メソッド Subscribe<T>() オーバーロードされます。 指定したソースで監視可能なシーケンスを評価します。 ( ObservableExtensions によって定義されます)。
パブリック拡張メソッド Subscribe<T>(Action<T>) オーバーロードされます。 監視可能なシーケンスに要素ハンドラーをサブスクライブします。 ( ObservableExtensions によって定義されます)。
パブリック拡張メソッド Subscribe<T>(Action<T>, Action<Exception>) オーバーロードされます。 要素ハンドラーと例外ハンドラーを監視可能なシーケンスにサブスクライブします。 ( ObservableExtensions によって定義されます)。
パブリック拡張メソッド Subscribe<T>(Action<T>, Action) オーバーロードされます。 要素ハンドラーと完了ハンドラーを監視可能なシーケンスにサブスクライブします。 ( ObservableExtensions によって定義されます)。
パブリック拡張メソッド Subscribe<T>(Action<T>, Action<Exception>, Action) オーバーロードされます。 要素ハンドラー、例外ハンドラー、および完了ハンドラーを監視可能なシーケンスにサブスクライブします。 ( ObservableExtensions によって定義されます)。
パブリック拡張メソッド SubscribeOn<T>(SynchronizationContext) オーバーロードされます。 指定した同期コンテキストでオブザーバーを非同期的にサブスクライブおよびサブスクライブ解除します。 ( Observable によって定義されます。
パブリック拡張メソッド SubscribeOn<T>(Control) オーバーロードされます。 ( ControlObservable によって定義されます。
パブリック拡張メソッド SubscribeOn<T>(Dispatcher) オーバーロードされます。 ( DispatcherObservable によって定義されます)。
パブリック拡張メソッド SubscribeOn<T>(DispatcherScheduler) オーバーロードされます。 ( DispatcherObservable によって定義されます)。
パブリック拡張メソッド SubscribeOn<T>(IScheduler) オーバーロードされます。 指定したスケジューラでオブザーバーを非同期的にサブスクライブおよびサブスクライブ解除します。 ( Observable によって定義されます。
パブリック拡張メソッド SubscribeOnDispatcher<T> ( DispatcherObservable によって定義されます)。
パブリック拡張メソッド 同期<T>() オーバーロードされます。 監視可能なシーケンスを同期します。 ( Observable によって定義されます。
パブリック拡張メソッド Synchronize<T>(Object) オーバーロードされます。 監視可能なシーケンスを同期します。 ( Observable によって定義されます。
パブリック拡張メソッド Take<T> 監視可能なシーケンスの先頭から、指定した数の連続した値を返します。 ( Observable によって定義されます。
パブリック拡張メソッド TakeLast<T> 監視可能なシーケンスの末尾から、指定した数の連続した要素を返します。 ( Observable によって定義されます)。
パブリック拡張メソッド TakeUntil<T、TOther> 他の監視可能シーケンスが値を生成するまで、ソース監視可能シーケンスから値を返します。 ( Observable によって定義されます)。
パブリック拡張メソッド TakeWhile<T>(Func<T, Boolean>) オーバーロードされます。 指定した条件が true である限り、監視可能なシーケンスから値を返し、残りの値をスキップします。 ( Observable によって定義されます)。
パブリック拡張メソッド TakeWhile<T>(Func<T, Int32, Boolean>) オーバーロードされます。 指定した条件が true である限り、監視可能なシーケンスから値を返し、残りの値をスキップします。 ( Observable によって定義されます)。
パブリック拡張メソッド 次に<T、TResult> 監視可能なシーケンスに使用可能な値があり、その値を投影する場合に一致します。 ( Observable によって定義されます)。
パブリック拡張メソッド スロットル<T>(TimeSpan) オーバーロードされます。 指定した source と dueTime の期限前に別の値が続く、監視可能なシーケンスの値を無視します。 ( Observable によって定義されます)。
パブリック拡張メソッド スロットル<T>(TimeSpan, IScheduler) オーバーロードされます。 監視可能なシーケンスの値を無視します。その後に、指定したソース、dueTime、およびスケジューラを使用して、期限前に別の値が続きます。 ( Observable によって定義されます)。
パブリック拡張メソッド TimeInterval<T>() オーバーロードされます。 指定したソースを持つ監視可能なシーケンス内の連続する値間の時間間隔を記録します。 ( Observable によって定義されます)。
パブリック拡張メソッド TimeInterval<T>(IScheduler) オーバーロードされます。 指定したソースとスケジューラを使用して、監視可能なシーケンス内の連続する値の時間間隔を記録します。 ( Observable によって定義されます)。
パブリック拡張メソッド タイムアウト<T>(TimeSpan) オーバーロードされます。 dueTime が経過した場合は、監視可能なシーケンスまたは TimeoutException を返します。 ( Observable によって定義されます)。
パブリック拡張メソッド Timeout<T>(DateTimeOffset) オーバーロードされます。 dueTime が経過した場合は、監視可能なシーケンスまたは TimeoutException を返します。 ( Observable によって定義されます)。
パブリック拡張メソッド Timeout<T>(TimeSpan, IObservable<T>) オーバーロードされます。 dueTime が経過した場合は、ソース監視可能シーケンスまたは他の監視可能なシーケンスを返します。 ( Observable によって定義されます)。
パブリック拡張メソッド Timeout<T>(DateTimeOffset, IObservable<T>) オーバーロードされます。 dueTime が経過した場合は、監視可能なシーケンスまたは TimeoutException を返します。 ( Observable によって定義されます)。
パブリック拡張メソッド Timeout<T>(TimeSpan, IScheduler) オーバーロードされます。 dueTime が経過した場合は、監視可能なシーケンスまたは TimeoutException を返します。 ( Observable によって定義されます)。
パブリック拡張メソッド Timeout<T>(DateTimeOffset, IScheduler) オーバーロードされます。 dueTime が経過した場合は、監視可能なシーケンスまたは TimeoutException を返します。 ( Observable によって定義されます)。
パブリック拡張メソッド Timeout<T>(TimeSpan, IObservable<T>, IScheduler) オーバーロードされます。 dueTime が経過した場合は、ソース監視可能シーケンスまたは他の監視可能なシーケンスを返します。 ( Observable によって定義されます)。
パブリック拡張メソッド Timeout<T>(DateTimeOffset, IObservable<T>, IScheduler) オーバーロードされます。 dueTime が経過した場合は、ソース監視可能シーケンスまたは他の監視可能なシーケンスを返します。 ( Observable によって定義されます)。
パブリック拡張メソッド Timestamp<T>() オーバーロードされます。 指定したソースを持つ監視可能なシーケンス内の各値のタイムスタンプを記録します。 ( Observable によって定義されます)。
パブリック拡張メソッド Timestamp<T>(IScheduler) オーバーロードされます。 指定したソースとスケジューラを使用して、監視可能なシーケンス内の各値のタイムスタンプを記録します。 ( Observable によって定義されます)。
パブリック拡張メソッド ToArray<T> 監視可能なシーケンスから配列を作成します。 ( Observable によって定義されます)。
パブリック拡張メソッド ToDictionary<T, TKey>(Func<T, TKey>) オーバーロードされます。 指定したキー セレクター関数に従って、監視可能なシーケンスからディクショナリを作成します。 ( Observable によって定義されます)。
パブリック拡張メソッド ToDictionary<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>) オーバーロードされます。 指定したキー セレクター関数と比較子に従って、監視可能なシーケンスからディクショナリを作成します。 ( Observable によって定義されます)。
パブリック拡張メソッド ToDictionary<T、TKey、TElement>(Func<T、TKey>、Func<T、TElement>) オーバーロードされます。 指定したキー セレクター関数と要素セレクター関数に従って、監視可能なシーケンスからディクショナリを作成します。 ( Observable によって定義されます)。
パブリック拡張メソッド ToDictionary<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>) オーバーロードされます。 指定したキー セレクター関数、比較子、および要素セレクター関数に従って、監視可能なシーケンスからディクショナリを作成します。 ( Observable によって定義されます)。
パブリック拡張メソッド ToEnumerable<T> 監視可能なシーケンスを列挙可能なシーケンスに変換します。 ( Observable によって定義されます)。
パブリック拡張メソッド ToEvent<T> 指定したソースを持つ .NET イベントを持つオブジェクトとして、監視可能なシーケンスを公開します。 ( Observable によって定義されます)。
パブリック拡張メソッド ToList<T> 監視可能なシーケンスからリストを作成します。 ( Observable によって定義されます)。
パブリック拡張メソッド ToLookup<T,TKey>(Func<T, TKey>) オーバーロードされます。 指定したキー セレクター関数に従って、監視可能なシーケンスから参照を作成します。 ( Observable によって定義されます)。
パブリック拡張メソッド ToLookup<T,TKey>(Func<T, TKey>, IEqualityComparer<TKey>) オーバーロードされます。 指定したキー セレクター関数と比較子に従って、監視可能なシーケンスからルックアップを作成します。 ( Observable によって定義されます)。
パブリック拡張メソッド ToLookup<T、TKey、TElement>(Func<T、TKey>、Func<T、TElement>) オーバーロードされます。 指定したキー セレクター関数と要素セレクター関数に従って、監視可能なシーケンスから参照を作成します。 ( Observable によって定義されます)。
パブリック拡張メソッド ToLookup<T、TKey、TElement>(Func<T、TKey>、Func<T、TElement>、IEqualityComparer<TKey>) オーバーロードされます。 指定したキー セレクター関数、比較子、および要素セレクター関数に従って、監視可能なシーケンスから参照を作成します。 ( Observable によって定義されます)。
パブリック拡張メソッド ToNotifier<T> オブザーバーから通知コールバックを作成します。 ( オブザーバーによって定義されます。
パブリック拡張メソッド ToTask<T>() オーバーロードされます。 監視可能シーケンスの最後の値を含むタスクを返します。 ( TaskObservableExtensions によって定義されます)。
パブリック拡張メソッド ToTask<T>(Object) オーバーロードされます。 監視可能シーケンスの最後の値を含むタスクを返します。 ( TaskObservableExtensions によって定義されます)。
パブリック拡張メソッド ToTask<T>(CancellationToken) オーバーロードされます。 監視可能シーケンスの最後の値を含むタスクを返します。 ( TaskObservableExtensions によって定義されます)。
パブリック拡張メソッド ToTask<T>(CancellationToken, Object) オーバーロードされます。 監視可能シーケンスの最後の値を含むタスクを返します。 ( TaskObservableExtensions によって定義されます)。
パブリック拡張メソッド Where<T>(Func<T, Boolean>) オーバーロードされます。 述語に基づいて監視可能なシーケンスの要素をフィルター処理します。 ( Observable によって定義されます)。
パブリック拡張メソッド Where<T>(Func<T, Int32, Boolean>) オーバーロードされます。 要素のインデックスを組み込むことによって、述語に基づいて監視可能なシーケンスの要素をフィルター処理します。 ( Observable によって定義されます)。
パブリック拡張メソッド Window<T>(Int32) オーバーロードされます。 監視可能シーケンスの各要素を、要素数情報に基づいて生成される連続した重複しないウィンドウに投影します。 ( Observable によって定義されます)。
パブリック拡張メソッド ウィンドウ<T>(TimeSpan) オーバーロードされます。 監視可能シーケンスの各要素を、タイミング情報に基づいて生成される連続した重複しないウィンドウに投影します。 ( Observable によって定義されます)。
パブリック拡張メソッド Window<T>(Int32, Int32) オーバーロードされます。 監視可能なシーケンスの各要素を、要素数情報に基づいて生成される 0 個以上のウィンドウに投影します。 ( Observable によって定義されます)。
パブリック拡張メソッド Window<T>(TimeSpan, IScheduler) オーバーロードされます。 監視可能シーケンスの各要素を、タイミング情報に基づいて生成される連続した重複しないウィンドウに投影します。 ( Observable によって定義されます)。
パブリック拡張メソッド Window<T>(TimeSpan, TimeSpan) オーバーロードされます。 監視可能なシーケンスの各要素を、タイミング情報に基づいて生成される 0 個以上のウィンドウに投影します。 ( Observable によって定義されます。
パブリック拡張メソッド Window<T>(TimeSpan, Int32) オーバーロードされます。 監視可能なシーケンスの各要素を、完全または特定の時間が経過したときに完了したウィンドウに投影します。 ( Observable によって定義されます。
パブリック拡張メソッド Window<T>(TimeSpan, TimeSpan, IScheduler) オーバーロードされます。 監視可能なシーケンスの各要素を、タイミング情報に基づいて生成される 0 個以上のウィンドウに投影します。 ( Observable によって定義されます。
パブリック拡張メソッド Window<T>(TimeSpan, Int32, IScheduler) オーバーロードされます。 監視可能なシーケンスの各要素を、完全または特定の時間が経過したときに完了したウィンドウに投影します。 ( Observable によって定義されます。
パブリック拡張メソッド ウィンドウ<T、TWindowClosing>(Func<IObservable<TWindowClosing>>) オーバーロードされます。 監視可能なシーケンスの各要素を連続する重複しないウィンドウに投影します。 ( Observable によって定義されます。
パブリック拡張メソッド Window<T、TWindowOpening、TWindowClosing>(IObservable<TWindowOpening>、Func<TWindowOpening、IObservable<TWindowClosing>>) オーバーロードされます。 監視可能なシーケンスの各要素を 0 個以上のウィンドウに投影します。 ( Observable によって定義されます。
パブリック拡張メソッド Zip<T、TSecond、TResult>(IObservable<TSecond>、Func<T、TSecond、TResult>) オーバーロードされます。 2 つの観測可能なシーケンスを 1 つの監視可能なシーケンスにマージします。その要素をペアワイズ形式で組み合わせて使用します。 ( Observable によって定義されます。
パブリック拡張メソッド Zip<T、TSecond、TResult>(IEnumerable<TSecond>、Func<T、TSecond、TResult>) オーバーロードされます。 セレクター関数を使用して、監視可能なシーケンスと列挙可能なシーケンスを 1 つの監視可能なシーケンスにマージします。 ( Observable によって定義されます。

上

解説

ISubject インターフェイスを実装すると、カスタム動作を使用して独自のサブジェクトを作成できます。

例

次のコード例では、メソッドの実行をコンソール ウィンドウにエコーアウトするだけの件名の例を実装しています。

using System;
using System.Collections.Generic;
using System.Reactive.Linq;
using System.Reactive.Subjects;
using System.Reactive.Concurrency;
using System.Reactive.Disposables;

namespace Example
{
  class Program
  {
    static void Main()
    {
      //************************************************************************************//
      //*** The ConsoleEchoSubject will just echo it's method calls out to the console   ***//
      //*** window.                                                                      ***//
      //***                                                                              ***//
      //*** Create an instance of the ConsoleEchoSubject and subscribe to a sequence of  ***//
      //*** the first 5 integers returned by the Interval operator.                      ***//
      //***                                                                              ***//
      //************************************************************************************//

      ConsoleEchoSubject<long> mySubject = new ConsoleEchoSubject<long>();
      var obs = Observable.Interval(TimeSpan.FromSeconds(1), Scheduler.ThreadPool).Take(5);
      Console.WriteLine("Subscribing ConsoleEchoSubject to observable sequence.\n");
      obs.Subscribe(mySubject);


      //************************************************************************************//
      //*** Subscribe to the subject's observable interface. Each value will be written  ***//
      //*** to the console window.                                                       ***//
      //************************************************************************************//

      IDisposable subscription = mySubject.Subscribe(x => Console.WriteLine(x), () => 
      {
        Console.WriteLine("\nSequence Completed.\n");
        Console.WriteLine("Press ENTER to exit...");
      });

      Console.ReadLine();


      //***************************************//
      //*** Explicitly releasing resources. ***//
      //***************************************//

      subscription.Dispose();
      mySubject.Dispose();
    }
  }



  //************************************************************************************//
  //***                                                                              ***//
  //*** The ConsoleEchoSubject will just echo it's method calls out to the console   ***//
  //*** window.                                                                      ***//
  //***                                                                              ***//
  //************************************************************************************//

  class ConsoleEchoSubject<T> : ISubject<T>, IDisposable
  { 
    private List<IObserver<T>> observerList;     
    private bool isDisposed;
    private bool isStopped;
    object gate = new object();
    Exception exception;

    public ConsoleEchoSubject()
    {
      observerList = new List<IObserver<T>>();     
    }

    public void OnCompleted()
    {      
      //****************************************************************************************//
      //*** Make sure the OnCompleted operation is not preempted by another operation        ***//
      //*** which would break the expected behavior.  For example, don't allow an error from ***//
      //*** OnError preempt OnCompleted from anotther thread. Then OnCompleted would follow  ***//
      //*** an error.  That would be an incorrect behavior.                                  ***//
      //****************************************************************************************//

      lock (gate) 
      {
        CheckDisposed();

        if (!isStopped)
        {
          Console.WriteLine("\nConsoleEchoSubject : OnCompleted()");

          foreach (IObserver<T> observer in observerList)
          {
            observer.OnCompleted();
          }

          observerList.Clear();
          isStopped = true;
        }
      }
    }

    public void OnError(Exception error)
    {
      if (error == null)
        throw new ArgumentException("Exception error should not be null.");

      //****************************************************************************************//
      //*** Make sure the OnError operation is not preempted by another operation which      ***//
      //*** would break the expected behavior.  For example, don't allow unsubscribe or an   ***//
      //*** OnCompleted operation to preempt OnError from another thread. This would result  ***//
      //*** in an error following completion.  That would be an incorrect behavior.          ***//
      //****************************************************************************************//

      lock (gate) 
      {
        CheckDisposed();

        if (!isStopped)
        {
          Console.WriteLine("\nConsoleEchoSubject : OnError({0})", error.Message);

          exception = error;

          foreach (IObserver<T> observer in observerList)
          {
            observer.OnError(error);
          }

          observerList.Clear();
          isStopped = true;  
        }
      }
    }

    public void OnNext(T value)
    {
      //****************************************************************************************//
      //*** Make sure the OnNext operation is not preempted by another operation which       ***//
      //*** would break the expected behavior.  For example, don't allow unsubscribe, errors ***//
      //*** or an OnCompleted operation to preempt OnNext from another thread. This would    ***//
      //*** have the result of items in a sequence following completion, errors, or          ***//
      //*** unsubscribe.  That would be an incorrect behavior.                               ***//
      //****************************************************************************************//

      lock (gate)
      {
        CheckDisposed();

        if (!isStopped)
        {
          Console.WriteLine("\nConsoleEchoSubject : OnNext({0})", value.ToString());

          foreach (IObserver<T> observer in observerList)
          {
            observer.OnNext(value);
          }
        }
      }
    } 

    public IDisposable Subscribe(IObserver<T> observer)
    {
      if (observer == null)
        throw new ArgumentException("observer should not BehaviorSubject null.");

      //****************************************************************************************//
      //*** Make sure Subscribe occurs in sync with the other operations so we keep the      ***//
      //*** correct behavior depending on whether an error has occurred or the observable    ***//
      //*** sequence has completed.                                                          ***//
      //****************************************************************************************//

      lock (gate)
      {
        CheckDisposed();

        if (!isStopped)
        {
          Console.WriteLine("\nConsoleEchoSubject : Creating new subscription.");
          observerList.Add(observer);
          return new Subscription(observer, this);
        }
        else if(exception != null)
        {
          observer.OnError(exception);
          return Disposable.Empty;
        }
        else
        {
          observer.OnCompleted();
          return Disposable.Empty;
        }
      }
    }

    private void Unsubscribe(IObserver<T> observer)
    {
      //****************************************************************************************//
      //*** Make sure Unsubscribe occurs in sync with the other operations so we keep the    ***//
      //*** correct behavior.                                                                ***//
      //****************************************************************************************//

      lock (gate)
      {
        Console.WriteLine("\nConsoleEchoSubject : Unsubscribing subscription.");
        observerList.Remove(observer);
      }
    }

    public void  Dispose()
    {
      //****************************************************************************************//
      //*** Make sure Dispose occurs in sync with the other operations so we keep the        ***//
      //*** correct behavior. For example, Dispose shouldn't preempt the other operations    ***//
      //*** changing state variables after they have been checked.                           ***//
      //****************************************************************************************//

      lock (gate)
      {
        Console.WriteLine("\nConsoleEchoSubject : Disposing resources.");
        observerList.Clear();
        isStopped = true;
        isDisposed = true;
      }
    }

    private void CheckDisposed()
    {
      if (isDisposed)
        throw new ObjectDisposedException("Subject has been disposed.");
    }


    //************************************************************************************//
    //***                                                                              ***//
    //*** The Subscription class wraps each observer that creates a subscription. This ***//
    //*** is needed to expose an IDisposable interface through which a observer can    ***//
    //*** cancel the subscription.                                                     ***//
    //***                                                                              ***//
    //************************************************************************************//

    class Subscription : IDisposable
    {
      private ConsoleEchoSubject<T> subject;
      private IObserver<T> observer;

      public Subscription(IObserver<T> obs, ConsoleEchoSubject<T> sub)
      {
        subject = sub;
        observer = obs;
      }

      public void Dispose()
      {
        subject.Unsubscribe(observer);  
      }
    }
  }
}

次の出力は、コード例によって生成されました。

Subscribing ConsoleEchoSubject to observable sequence.


ConsoleEchoSubject : Creating new subscription.

ConsoleEchoSubject : OnNext(0)
0

ConsoleEchoSubject : OnNext(1)
1

ConsoleEchoSubject : OnNext(2)
2

ConsoleEchoSubject : OnNext(3)
3

ConsoleEchoSubject : OnNext(4)
4

ConsoleEchoSubject : OnCompleted()

Sequence Completed.

Press ENTER to exit...


ConsoleEchoSubject : Unsubscribing subscription.

ConsoleEchoSubject : Disposing resources.

C:\

参照

リファレンス

System.Reactive.Subjects 名前空間