BehaviorSubject<T> クラス

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

時間の経過と同時に変化する値を表します。

継承階層

System.Object
System.Reactive.Subjects.BehaviorSubject<T>

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

構文

'Declaration
Public NotInheritable Class BehaviorSubject(Of T) _
    Implements ISubject(Of T), ISubject(Of T, T),  _
    IObserver(Of T), IObservable(Of T), IDisposable

'Usage
Dim instance As BehaviorSubject(Of T)

public sealed class BehaviorSubject<T> : ISubject<T>, 
    ISubject<T, T>, IObserver<T>, IObservable<T>, IDisposable

generic<typename T>
public ref class BehaviorSubject sealed : ISubject<T>, 
    ISubject<T, T>, IObserver<T>, IObservable<T>, IDisposable

[<SealedAttribute>]
type BehaviorSubject<'T> =  
    class
        interface ISubject<'T>
        interface ISubject<'T, 'T>
        interface IObserver<'T>
        interface IObservable<'T>
        interface IDisposable
    end

JScript does not support generic types and methods.

型パラメーター

T
型。

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

コンストラクター

	名前	説明
	BehaviorSubject<T>	最後の値をキャッシュし、指定した値で始まるサブジェクトを作成する BehaviorSubject<T> クラスの新しいインスタンスを初期化します。

上

メソッド

	名前	説明
	Dispose	すべてのオブザーバーの登録を解除し、リソースを解放します。
	[等しい]	( オブジェクトから継承されます)。
	Finalize	( オブジェクトから継承されます)。
	GetHashCode	( オブジェクトから継承されます)。
	GetType	( オブジェクトから継承されます)。
	MemberwiseClone	( オブジェクトから継承されます)。
	OnCompleted	サブスクライブされているすべてのオブザーバーに、シーケンスの末尾を通知します。
	OnError	サブスクライブされているすべてのオブザーバーに例外を通知します。
	Onnext	サブスクライブされているすべてのオブザーバーに値を通知します。
	サブスクライブ	オブザーバーをサブジェクトにサブスクライブします。
	ToString	( オブジェクトから継承されます)。

上

拡張メソッド

	名前	説明
	集計<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>. ( 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 によって定義されます)。
	Publish<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 によって定義されます)。
	Replay<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 によって定義されます。
	ウィンドウ<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 によって定義されます。

上

解説

サブジェクトは、サブスクライバーとパブリッシャーの両方として機能するという点で、プロキシに似ています。その IObserver インターフェイスを使用して、複数のストリームまたはデータシーケンスをサブスクライブできます。その後、データは IObservable インターフェイスを介して公開されます。

BehaviorSubject は、IObservable インターフェイスを介して発行された最後の項目をバッファーに格納します。 IObservable インターフェイスを介してアイテムが発行されていない場合、コンストラクターで提供される最初の項目は、現在バッファーに格納されている項目です。 BehaviorSubject の IObservable インターフェイスにサブスクリプションが作成されると、発行されるシーケンスは、現在バッファーに格納されている項目から始まります。

IObserver インターフェイスが完了を受け取ると、BehaviorSubject から項目がバッファーまたは発行されません。

例

この例では、BehaviorSubject を示します。この例では、Interval 演算子を使用して、整数を 1 秒ごとに整数シーケンスに発行します。シーケンスは、10 個の整数がパブリッシュされた後に Take 演算子によって完了します。これは BehaviorSubject がサブスクライブするシーケンスです。

BehaviorSubject の IObservable インターフェイス用に 2 つのサブスクリプションが作成され、データの発行方法が示されます。

サブスクリプション #1 : このサブスクリプションは最初から開始され、シーケンス内のコンストラクター (-9) からの初期バッファー値が表示されます。
サブスクリプション #2 : このサブスクリプションは、5 秒のスリープ後に開始されます。このサブスクリプションは、シーケンスが現在バッファーに格納されている項目で始まることを示しています。

using System;
using System.Reactive.Linq;
using System.Reactive.Subjects;
using System.Reactive.Concurrency;
using System.Threading;

namespace Example
{
  class Program
  {
    static void Main()
    {
      //********************************************************************************************************//
      //*** A subject acts similar to a proxy in that it acts as both a subscriber and a publisher           ***//
      //*** It's IObserver interface can be used to subscribe to multiple streams or sequences of data.      ***//
      //*** The data is then published through it's IObservable interface.                                   ***//
      //***                                                                                                  ***//
      //*** A BehaviorSubject buffers the last item it published through its IObservable interface. If no    ***//
      //*** item has been published through its IObservable interface then the initial item provided in the  ***//
      //*** constructor is the current buffered item. When a subscription is made to the BehaviorSubject's   ***//
      //*** IObservable interface, the sequence published begins with the currently buffered item.           ***//
      //***                                                                                                  ***//
      //*** No items are buffered or published from a BehaviorSubject once its IObserver interface receives  ***//
      //*** a completion.                                                                                    ***//
      //***                                                                                                  ***//
      //*** In this example, we use the Interval operator to publish an integer to a integer sequence every  ***//
      //*** second. The sequence will be completed by the Take operator after 10 integers are published.     ***//
      //*** This will be the sequence that the BehaviorSubject subscribes to.                                ***//
      //***                                                                                                  ***//
      //*** We will create 2 subscriptions to the BehaviorSubject's IObservable interface to show how it     ***//
      //*** publishes it's data.                                                                             ***//
      //***                                                                                                  ***//
      //*** Subscription #1 : This subscription will start at the very beginning and will show the initial   ***//
      //***                   buffered value from the constructor (-9) in the sequence.                      ***//
      //***                                                                                                  ***//
      //*** Subscription #2 : This subscription will start after a 5 sec. sleep showing the sequence starts  ***//
      //***                   with the currently buffered item.                                              ***//
      //********************************************************************************************************//

      BehaviorSubject<long> myBehaviorSubject = new BehaviorSubject<long>((-9));
      Observable.Interval(TimeSpan.FromSeconds(1), Scheduler.ThreadPool).Take(10).Subscribe(myBehaviorSubject);

      
      //********************************************************************************************************//
      //*** Subscription #1 : This subscription will start at the very beginning and will show the initial   ***//
      //***                   buffered value from the constructor (-9) in the sequence.                      ***//
      //********************************************************************************************************//

      EventWaitHandle wait1 = new EventWaitHandle(false, EventResetMode.ManualReset);
      myBehaviorSubject.Subscribe(x => Console.WriteLine("Subscription #1 observes : " + x),
                                  () => 
                                  {
                                    Console.WriteLine("Subscription #1 completed.");
                                    wait1.Set();
                                  });


      //********************************************************************************************************//
      //*** Subscription #2 : This subscription will start after a 5 sec. sleep showing the sequence starts  ***//
      //***                   with the currently buffered item.                                              ***//
      //********************************************************************************************************//
    
      Thread.Sleep(5000);
      EventWaitHandle wait2 = new EventWaitHandle(false, EventResetMode.ManualReset);
      myBehaviorSubject.Subscribe(x => Console.WriteLine("{0,30}Subscription #2 observes : {1}", " ", x), 
                                  () => 
                                  {
                                    Console.WriteLine("{0,30}Subscription #2 completed.", " ");
                                    wait2.Set();
                                  });


      //**************************************************//
      // *** Wait for completion on both subscriptions ***//
      //**************************************************//

      WaitHandle.WaitAll(new WaitHandle[] { wait1, wait2 });
      myBehaviorSubject.Dispose();

      Console.WriteLine("\nPress ENTER to exit...");
      Console.ReadLine();
    }
  }
}

コード例からの次の出力は、重複するサブスクリプションを示しています。

Subscription #1 observes : -9
Subscription #1 observes : 0
Subscription #1 observes : 1
Subscription #1 observes : 2
Subscription #1 observes : 3
Subscription #1 observes : 4
                              Subscription #2 observes : 4
Subscription #1 observes : 5
                              Subscription #2 observes : 5
Subscription #1 observes : 6
                              Subscription #2 observes : 6
Subscription #1 observes : 7
                              Subscription #2 observes : 7
Subscription #1 observes : 8
                              Subscription #2 observes : 8
Subscription #1 observes : 9
                              Subscription #2 observes : 9
Subscription #1 completed.
                              Subscription #2 completed.

Press ENTER to exit...

スレッドセーフ

この型の public static (Visual Basic では Shared) のメンバーはすべて、スレッドセーフです。インスタンスメンバーの場合は、スレッドセーフであるとは限りません。

参照

リファレンス

System.Reactive.Subjects 名前空間

次の方法で共有

BehaviorSubject<T> クラス

継承階層

構文

型パラメーター

コンストラクター

メソッド

拡張メソッド

解説

例

スレッドセーフ

参照

リファレンス

その他のリソース

次の方法で共有

BehaviorSubject<T> クラス

継承階層

構文

型パラメーター

コンストラクター

メソッド

拡張メソッド

解説

例

スレッド セーフ

参照

リファレンス

その他のリソース

スレッドセーフ