ISubject<TSource、TResult> インターフェイス

[アーティクル]
06/28/2011

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

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

構文

'Declaration
Public Interface ISubject(Of In TSource, Out TResult) _
    Inherits IObserver(Of TSource), IObservable(Of TResult)

'Usage
Dim instance As ISubject(Of In TSource, Out TResult)

public interface ISubject<in TSource, out TResult> : IObserver<TSource>, 
    IObservable<TResult>

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

type ISubject<'TSource, 'TResult> =  
    interface
        interface IObserver<'TSource>
        interface IObservable<'TResult>
    end

JScript does not support generic types and methods.

型パラメーター

inTSource
ソースの種類。

この型パラメーターは反変です。つまり、指定した型、または弱い派生型のいずれかを使用することができます。共変性と反変性の詳細については、「」を参照してください。

outTResult
結果の型。

この型パラメーターは共変です。つまり、指定した型、または強い派生型のいずれかを使用することができます。共変性と反変性の詳細については、「」を参照してください。

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

メソッド

	名前	説明
	OnCompleted	(IObserver から継承されます)<TSource>.)
	OnError	(IObserver から継承されます)<TSource>.)
	Onnext	(IObserver から継承されます)<TSource>.)
	サブスクライブ	(IObservable から継承されます)<TResult>.)

上

拡張メソッド

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

上

解説

このサブジェクトインターフェイスは、別の型の監視可能なシーケンスを公開するときに、ある型の監視可能なシーケンスを観察する柔軟性をサブジェクトに提供します。

例

この例では、別の型の監視可能なシーケンスを公開するときに、1 つの型の監視可能なシーケンスを観察する ISubject<TSource TSource TResult> を実装する方法を示します。この例の AsciiConverterSubject は、char 型のシーケンスを監視し、監視可能な int シーケンスを公開することによって実装を示しています。発行された監視可能な int シーケンスは、観察される各文字値の ASCII コードです。

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

namespace Example
{
  class Program
  {
    static void Main()
    {
      //****************************************************************************************//
      //*** Create an observable sequence of char from console input until enter is pressed. ***//
      //****************************************************************************************//
      IObservable<char> keySequence = Observable.Create<char>(observer =>
      {
        bool bContinue = true;

        while (bContinue)
        {
          ConsoleKeyInfo keyInfo = Console.ReadKey(true);

          if (keyInfo.Key != ConsoleKey.Enter)
          {
            observer.OnNext(keyInfo.KeyChar);
          }
          else
          {
            observer.OnCompleted();
            bContinue = false;
          }
        }

        return (() => { });
      });


      //****************************************************************************************//
      //*** Create an AsciiConverterSubject which takes a source type of char and returns an ***//
      //*** observable sequence of int which is the ASCII code for source items of char.     ***//
      //****************************************************************************************//

      AsciiConverterSubject myConverterSubject = new AsciiConverterSubject();


      //****************************************************************************************//
      //*** Subscribe to the keySequence on the .NET threadpool so the main thread can       ***//
      //*** create subscriptions to the AsciiConverterSubject                                ***//
      //****************************************************************************************//

      IDisposable subscription = keySequence.SubscribeOn(Scheduler.ThreadPool).Subscribe(myConverterSubject);


      Console.WriteLine("\nEnter a sequence of keys to have the AsciiConverterSubject\nconvert the keys to their ASCII code values.\n"); 
      Console.WriteLine("Press ENTER to terminate the observable sequence...\n");


      //****************************************************************************************//
      //*** Subscribe to the AsciiConverterSubject and write the ASCII code values to the    ***//
      //*** console window.                                                                  ***//
      //***                                                                                  ***//
      //*** The main thread will wait on the completion of the keySequence. It completes     ***//
      //*** when ENTER is pressed.                                                           ***//
      //****************************************************************************************//

      EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset);
      myConverterSubject.Subscribe(c => Console.WriteLine("Ascii Char code {0} entered.",c), () => waitHandle.Set());
      waitHandle.WaitOne();


      //***************************************//
      //*** Explicitly releasing resources. ***//
      //***************************************//
      
      subscription.Dispose();
      myConverterSubject.Dispose();
    }
  }



  //***********************************************************************************************//
  //***                                                                                         ***//
  //*** The AsciiConverterSubject demonstrates an implementation of ISubject<TSource, TResult>. ***//
  //*** It is used to subscribe to an observable sequence of char. It publishes an observable   ***//
  //*** sequence of int which should be the ASCII code for each char value it observes.         ***//
  //***                                                                                         ***//
  //***********************************************************************************************//

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

    public AsciiConverterSubject()
    {
      observerList = new List<IObserver<int>>();
    }

    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)
        {
          foreach (IObserver<int> 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)
        {
          exception = error;

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

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

    public void OnNext(char 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)
        {
          foreach (IObserver<int> observer in observerList)
          {
            observer.OnNext(Convert.ToInt32(value));
          }
        }
      }
    }

    public IDisposable Subscribe(IObserver<int> 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)
        {
          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<int> observer)
    {
      //****************************************************************************************//
      //*** Make sure Unsubscribe occurs in sync with the other operations so we keep the    ***//
      //*** correct behavior.                                                                ***//
      //****************************************************************************************//

      lock (gate)
      {
        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)
      {
        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 AsciiConverterSubject subject;
      private IObserver<int> observer;

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

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

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

Enter a sequence of keys to have the AsciiConverterSubject
convert the keys to their ASCII code values.

Press ENTER to terminate the observable sequence...

Ascii Char code 59 entered.
Ascii Char code 108 entered.
Ascii Char code 115 entered.
Ascii Char code 100 entered.
Ascii Char code 107 entered.
Ascii Char code 102 entered.
Ascii Char code 59 entered.
Ascii Char code 108 entered.
Ascii Char code 115 entered.
Ascii Char code 100 entered.
Ascii Char code 107 entered.
Ascii Char code 102 entered.
Ascii Char code 59 entered.
Ascii Char code 108 entered.
Ascii Char code 115 entered.
Ascii Char code 107 entered.
Ascii Char code 100 entered.
Ascii Char code 59 entered.
Ascii Char code 102 entered.
Ascii Char code 108 entered.
Ascii Char code 115 entered.
Ascii Char code 107 entered.
Ascii Char code 100 entered.

参照

リファレンス

System.Reactive.Subjects 名前空間

次の方法で共有

ISubject<TSource、TResult> インターフェイス

構文

型パラメーター

メソッド

拡張メソッド

解説

例

参照

リファレンス

その他のリソース