BehaviorSubject<T> 類別

發行項
06/28/2011

表示隨著時間變更的值。

繼承階層

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

命名空間：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	取消訂閱所有觀察者並釋放資源。
	Equals	（繼承自物件。
	完成	（繼承自物件。
	GetHashCode	（繼承自物件。
	GetType	（繼承自物件。
	MemberwiseClone	（繼承自物件。
	OnCompleted	通知序列結尾的所有訂閱觀察者。
	OnError	通知所有已訂閱的觀察者，但例外狀況。
	OnNext	以值通知所有已訂閱觀察者。
	訂閱	訂閱主旨的觀察者。
	ToString	（繼承自物件。

返回頁首

擴充方法

	名字	描述
	匯總<T>（Func<T， T， T>）	重載。將累加器函式套用至可觀察序列。（由可觀察定義。
	匯總<T、TAccumulate>（TAccumulate、Func<TAccumulate、T、T、TAccumulate>）	重載。在具有指定種子值的可觀察序列上套用累加器函式。（由可觀察定義。
	所有<T>	判斷可觀察序列的所有專案是否符合條件。（由可觀察定義。
	Amb<T>	傳播可觀察序列，其會先回應指定的第一個和第二個序列。（由可觀察定義。
	和<T、TRight>	當兩個可觀察序列都有可用的值時相符。（由可觀察定義。
	任何<T>（）	重載。判斷可觀察序列是否包含任何專案。（由可觀察定義。
	任何<T>（Func<T， Boolean>）	重載。判斷可觀察序列的所有專案是否符合條件。（由可觀察定義。
	AsObservable<T>	隱藏可觀察序列的識別。（由可觀察定義。
	AsObserver<T>	隱藏觀察者的身分識別。（由觀察家定義。
	AsQbservable<T>	將可觀察序列轉換成可查詢的可觀察序列。（由 Qbservable定義。
	AssertEqual<T>	（由延伸模組定義。
	緩衝區<T>（Int32）	重載。將可觀察序列的每個元素，指出根據專案計數資訊產生的連續非重疊緩衝區。（由可觀察定義。
	緩衝區<T>（TimeSpan）	重載。會指出可觀察序列的每個專案，以根據計時資訊產生連續的非重疊緩衝區。（由可觀察定義。
	緩衝區<T>（Int32， Int32）	重載。將可觀察序列的每個專案指出為零個或多個緩衝區，這些緩衝區是根據專案計數資訊所產生的。（由可觀察定義。
	緩衝區<T>（TimeSpan， IScheduler）	重載。會指出可觀察序列的每個專案，以根據計時資訊產生連續的非重疊緩衝區。（由可觀察定義。
	緩衝區<T>（TimeSpan， TimeSpan）	重載。將可觀察序列的每個專案指出為零個或多個緩衝區，這些緩衝區是根據計時資訊所產生的。（由可觀察定義。
	Buffer<T>（TimeSpan， Int32）	重載。將可觀察序列的每個專案，指出在已滿或經過指定時間量時所傳送的緩衝區。（由可觀察定義。
	Buffer<T>（TimeSpan， TimeSpan， IScheduler）	重載。將可觀察序列的每個專案指出為零個或多個緩衝區，這些緩衝區是根據計時資訊所產生的。（由可觀察定義。
	Buffer<T>（TimeSpan， Int32， IScheduler）	重載。將可觀察序列的每個專案，指出在已滿或經過指定時間量時所傳送的緩衝區。（由可觀察定義。
	緩衝區<T、TBufferClosing>（Func<IObservable<TBufferClosing>>）	重載。將可觀察序列的每個專案指出成連續的非重疊緩衝區。（由可觀察定義。
	Buffer<T、TBufferOpening、TBufferClosing>（IObservable<TBufferOpening>、 Func<TBufferOpening、 IObservable<TBufferClosing>>）	重載。將可查詢的可觀察序列的每個專案，指出成連續的非重疊緩衝區。（由可觀察定義。
	Catch<T>（IObservable<T>）	重載。繼續以下一個可觀察序列的例外狀況終止的可觀察序列。（由可觀察定義。
	Catch<T、 TException>（Func<TException， IObservable<T>>）	重載。使用處理程式所產生的可觀察序列，繼續以指定型別的例外狀況終止的可觀察序列。（由可觀察定義。
	CombineLatest<T、 TSecond、 TResult>	每當其中一個可觀察序列產生元素時，使用選取器函式，將兩個可觀察序列合併成一個可觀察序列。（由可觀察定義。
	Concat<T>	串連兩個可觀察序列。（由可觀察定義。
	包含<T>（T）	重載。使用預設相等比較子，判斷可觀察序列是否包含指定的專案。（由可觀察定義。
	包含<T>（T， IEqualityComparer<T>）	重載。使用指定的 System.Collections.Generic.IEqualityComparer<，判斷可觀察序列是否包含指定的專案;T>。（由可觀察定義。
	計數<T>	會傳回 Int32，代表可觀察序列中的項目總數。（由可觀察定義。
	DefaultIfEmpty<T>（）	重載。如果序列是空的，則傳回指定序列的專案或類型參數在單一序列中的預設值。（由可觀察定義。
	DefaultIfEmpty<T>（T）	重載。如果序列是空的，則傳回指定序列的專案或類型參數在單一序列中的預設值。（由可觀察定義。
	延遲<T>（TimeSpan）	重載。使用指定的來源和 dueTime，依到期時間指出可觀察的序列。（由可觀察定義。
	延遲<T>（DateTimeOffset）	重載。使用指定的來源和 dueTime，依到期時間指出可觀察的序列。（由可觀察定義。
	延遲<T>（TimeSpan， IScheduler）	重載。使用指定的來源、dueTime 和排程器，依到期時間指出可觀察的序列。（由可觀察定義。
	延遲<T>（DateTimeOffset， IScheduler）	重載。使用指定的來源、dueTime 和排程器，依到期時間指出可觀察的序列。（由可觀察定義。
	Distinct<T>（）	重載。傳回只包含具有指定來源之相異專案的可觀察序列。（由可觀察定義。
	Distinct<T>（IEqualityComparer<T>）	重載。根據比較子傳回只包含相異元素的可觀察序列。（由可觀察定義。
	Distinct<T、TKey>（Func<T、TKey>）	重載。根據keySelector傳回只包含相異元素的可觀察序列。（由可觀察定義。
	Distinct<T、TKey>（Func<T、TKey>、IEqualityComparer<TKey>）	重載。根據keySelector傳回只包含相異元素的可觀察序列。（由可觀察定義。
	DistinctUntilChanged<T>（）	重載。傳回只包含具有指定來源之相異連續專案的可觀察序列。（由可觀察定義。
	DistinctUntilChanged<T>（IEqualityComparer<T>）	重載。根據比較子傳回只包含相異連續專案的可觀察序列。（由可觀察定義。
	DistinctUntilChanged<T， TKey>（Func<T， TKey>）	重載。根據keySelector傳回只包含相異連續元素的可觀察序列。（由可觀察定義。
	DistinctUntilChanged<T， TKey>（Func<T， TKey>， IEqualityComparer<TKey>）	重載。根據keySelector和比較子，傳回只包含相異連續專案的可觀察序列。（由可觀察定義。
	do<T>（action<T>）	重載。針對可觀察序列中的每個專案叫用動作。（由可觀察定義。
	do<T>（IObserver<T>）	重載。針對可觀察序列中的每個專案叫用動作，並在可觀察序列的特殊終止時叫用動作。（由可觀察定義。
	做<T>（動作<T>，動作）	重載。針對可觀察序列中的每個專案叫用動作，並在可觀察序列正常終止時叫用動作。（由可觀察定義。
	do<T>（action<T>， action<exception>）	重載。針對可觀察序列中的每個專案叫用動作，並在可觀察序列的特殊終止時叫用動作。（由可觀察定義。
	做<T>（動作<T>，動作<例外狀況>，動作）	重載。針對可觀察序列中的每個專案叫用動作，並在可觀察序列的正常或例外終止時叫用動作。（由可觀察定義。
	ElementAt<T>	傳回序列中指定索引處的專案。（由可觀察定義。
	ElementAtOrDefault<T>	傳回序列中指定索引處的專案，如果索引超出範圍，則傳回預設值。（由可觀察定義。
	最後<T>	在來源可觀察序列正常終止或由例外狀況終止之後，叫用指定的動作。（由可觀察定義。
	第一<T>（）	重載。傳回具有指定來源之可觀察序列的第一個專案。（由可觀察定義。
	第一<T>（Func<T，布爾值>）	重載。傳回符合述詞之可觀察序列的第一個專案。（由可觀察定義。
	FirstOrDefault<T>（）	重載。傳回可觀察序列的第一個專案，如果沒有找到任何值，則傳回預設值。（由可觀察定義。
	FirstOrDefault<T>（Func<T， Boolean>）	重載。傳回符合述詞之可觀察序列的第一個專案，如果沒有找到任何值，則傳回預設值。（由可觀察定義。
	Foo<T、 R>	（由 MyExt定義。
	Foreach<T>	叫用可觀察序列中每個項目的動作，並封鎖直到序列終止為止。（由可觀察定義。
	GetEnumerator<T>	傳回列舉值，列舉可觀察序列的所有值。（由可觀察定義。
	GroupBy<T、TKey>（Func<T、TKey>）	重載。根據指定的索引鍵選取器函式，將可觀察序列的專案分組。（由可觀察定義。
	GroupBy<T、TKey>（Func<T、TKey>、IEqualityComparer<TKey>）	重載。根據指定的索引鍵選取器函式和比較子，將可觀察序列的專案分組。（由可觀察定義。
	GroupBy<T、TKey、TElement>（Func<T、TKey>、Func<T、TElement>）	重載。將可觀察序列的專案分組，並使用指定的函式來選取產生的專案。（由可觀察定義。
	GroupBy<T、TKey、TElement>（Func<T、TKey>、Func<T、TElement>、IEqualityComparer<TKey>）	重載。根據指定的索引鍵選取器函式和比較子，將可觀察序列的專案分組，並使用指定的函式來選取產生的專案。（由可觀察定義。
	GroupByUntil<T、TKey、TDuration>（Func<T、TKey>、Func<IGroupedObservable<TKey、T>、IObservable<TDuration>>）	重載。根據指定的索引鍵選取器函式，將可觀察序列的專案分組。（由可觀察定義。
	GroupByUntil<T， TKey， TDuration>（Func<T， TKey>， Func<IGroupedObservable<TKey， T>， IObservable<TDuration>>， IEqualityComparer<TKey>）	重載。根據指定的索引鍵選取器函式和比較子，將可觀察序列的專案分組。（由可觀察定義。
	GroupByUntil<T、TKey、TElement、TDuration>（Func<T、TKey>、Func<T、TElement>、Func<IGroupedObservable<TKey、TElement>、IObservable<TDuration>>）	重載。根據指定的索引鍵選取器函式，將可觀察序列的專案分組，並使用指定的函式來選取產生的專案。（由可觀察定義。
	GroupByUntil<T， TKey、TElement、TDuration>（Func<T、TKey>、Func<T、TElement>、Func<IGroupedObservable<TKey、TElement>、IObservable<TDuration>>、IEqualityComparer<TKey>）	重載。根據指定的索引鍵選取器函式和比較子，將可觀察序列的專案分組，並使用指定的函式來選取產生的專案。（由可觀察定義。
	GroupJoin<T、TRight、TLeftDuration、TRightDuration、TResult>	根據重疊的持續時間，將兩個序列的專案相互關聯，並將結果分組。（由可觀察定義。
	IgnoreElements<T>	忽略可觀察序列中的所有值，只留下終止訊息。（由可觀察定義。
	Join<T、TRight、TLeftDuration、TRightDuration、TResult>	根據重疊持續時間，將兩個序列的專案相互關聯。（由可觀察定義。
	上次<T>（）	重載。傳回具有指定來源之可觀察序列的最後一個專案。（由可觀察定義。
	上次<T>（Func<T，布爾值>）	重載。傳回符合述詞之可觀察序列的最後一個專案。（由可觀察定義。
	LastOrDefault<T>（）	重載。傳回可觀察序列中的最後一個專案，如果沒有找到任何值，則傳回預設值。（由可觀察定義。
	LastOrDefault<T>（Func<T， Boolean>）	重載。傳回符合述詞之可觀察序列的最後一個專案，如果沒有找到任何值，則傳回預設值。（由可觀察定義。
	最新<T>	取樣可觀察序列中最新的值。（由可觀察定義。
	LongCount<T>	會傳回 Int64，代表可觀察序列中的項目總數。（由可觀察定義。
	具體化<T>	將可觀察序列的隱含通知具體化為明確通知值。（由可觀察定義。
	最大<T>（）	重載。傳回可觀察序列中的最大專案。（由可觀察定義。
	最大<T>（IComparer<T>）	重載。根據指定的比較子傳回可觀察序列中的最大值。（由可觀察定義。
	MaxBy<T、TKey>（Func<T、TKey>）	重載。傳回具有最大索引鍵值之可觀察序列中的專案。（由可觀察定義。
	MaxBy<T、TKey>（Func<T、TKey>、IComparer<TKey>）	重載。傳回具有最大索引鍵值之可觀察序列中的專案。（由可觀察定義。
	合併<T>（IObservable<T>）	重載。將可觀察序列的可觀察序列合併成可觀察序列。（由可觀察定義。
	合併<T>（IObservable<T>， IScheduler）	重載。將兩個可觀察序列合併成單一可觀察序列。（由可觀察定義。
	Min<T>（）	重載。傳回可觀察序列中的最小專案。（由可觀察定義。
	Min<T>（IComparer<T>）	重載。根據指定的比較子傳回可觀察序列中的最小值。（由可觀察定義。
	MinBy<T、TKey>（Func<T、TKey>）	重載。傳回具有最小索引鍵值之可觀察序列中的專案。（由可觀察定義。
	MinBy<T、TKey>（Func<T、TKey>、IComparer<TKey>）	重載。根據指定的比較子，傳回具有最小索引鍵值之可觀察序列中的專案。（由可觀察定義。
	MostRecent<T>	取樣可觀察序列中最新的值。（由可觀察定義。
	多播<T，TResult>（ISubject<T， TResult>）	重載。傳回可連線的可觀察序列，當連接導致來源序列將結果推送至指定的主旨時。（由可觀察定義。
	多播<T、TIntermediate、TResult>（Func<ISubject<T、TIntermediate>>、Func<IObservable<TIntermediate>、IObservable<TResult>>）	重載。傳回可觀察序列，其中包含在選取器函式中多播來源序列所產生的序列元素。（由可觀察定義。
	下一個<T>	從可觀察序列中取樣下一個值（封鎖而不緩衝）。（由可觀察定義。
	ObserveOn<T>（SynchronizationContext）	重載。以異步方式在指定的同步處理內容上通知觀察者。（由可觀察定義。
	ObserveOn<T>（控制）	重載。（由 ControlObservable定義。
	ObserveOn<T>	重載。（由 DispatcherObservable定義。
	ObserveOn<T>（DispatcherScheduler）	重載。（由 DispatcherObservable定義。
	ObserveOn<T>（IScheduler）	重載。以異步方式在指定的排程器上通知觀察者。（由可觀察定義。
	ObserveOnDispatcher<T>	（由 DispatcherObservable定義。
	OnErrorResumeNext<T>	繼續正常終止的可觀察序列，或由下一個可觀察序列的例外狀況終止。（由可觀察定義。
	發佈<T>（）	重載。傳回可連線的可觀察序列，該序列會將單一訂閱共用至基礎序列。（由可觀察定義。
	發佈<T>（T）	重載。傳回可連線的可觀察序列，該序列會將單一訂閱共用至基礎序列，並以initialValue 開頭。（由可觀察定義。
	發佈<T、TResult>（Func<IObservable<T>、IObservable<TResult>>）	重載。傳回可觀察序列，這是在可連接可觀察序列上叫用選取器的結果，該序列會將單一訂閱共用至基礎序列。（由可觀察定義。
	發佈<T、TResult>（Func<IObservable<T>、IObservable<TResult>>、T）	重載。傳回可連線的可觀察序列，該序列會將單一訂閱共用至基礎序列，並以initialValue 開頭。（由可觀察定義。
	PublishLast<T>（）	重載。傳回可連線的可觀察序列，該序列會將單一訂用帳戶共用至只包含最後一個通知的基礎序列。（由可觀察定義。
	PublishLast<T、TResult>（Func<IObservable<T>、 IObservable<TResult>>）	重載。傳回可觀察序列，這是叫用可連接可觀察序列上選取器的結果，該序列只會將單一訂閱共用至包含最後一個通知的基礎序列。（由可觀察定義。
	重複<T>（）	重載。無限期地重複可觀察的序列。（由可觀察定義。
	重複<T>（Int32）	重載。無限期地重複可觀察的序列。（由可觀察定義。
	重播<T>（）	重載。傳回可連線的可觀察序列，將單一訂閱共用至基礎序列重新執行所有通知。（由可觀察定義。
	重播<T>（TimeSpan）	重載。傳回可連線的可觀察序列，將單一訂閱共用至基礎序列重新執行視窗內的所有通知。（由可觀察定義。
	重播<T>（Int32）	重載。傳回可連線的可觀察序列，將單一訂閱共用至基礎序列重新執行 bufferSize 通知。（由可觀察定義。
	重新執行<T>（IScheduler）	重載。傳回可連線的可觀察序列，將單一訂閱共用至基礎序列重新執行所有通知。（由可觀察定義。
	重新執行<T>（TimeSpan， IScheduler）	重載。傳回可連線的可觀察序列，將單一訂閱共用至基礎序列重新執行視窗內的所有通知。（由可觀察定義。
	重新執行<T>（Int32， IScheduler）	重載。傳回可連線的可觀察序列，將單一訂閱共用至基礎序列重新執行 bufferSize 通知。（由可觀察定義。
	重新執行<T>（Int32， TimeSpan）	重載。傳回可連線的可觀察序列，將單一訂用帳戶共用至視窗內的基礎序列重新執行 bufferSize 通知。（由可觀察定義。
	重新執行<T>（Int32， TimeSpan， IScheduler）	重載。傳回可連線的可觀察序列，將單一訂用帳戶共用至視窗內的基礎序列重新執行 bufferSize 通知。（由可觀察定義。
	重新執行<T、TResult>（Func<IObservable<T>、IObservable<TResult>>）	重載。傳回可觀察序列，這是叫用可連接可觀察序列上選取器的結果，該序列會共用基礎序列的單一訂閱，並以初始值開頭。（由可觀察定義。
	重新執行<T、TResult>（Func<IObservable<T>、IObservable<TResult>>、IScheduler）	重載。傳回可觀察序列，這是叫用可連接可觀察序列上選取器的結果，該序列會將單一訂閱共用至基礎序列重新執行所有通知。（由可觀察定義。
	重新執行<T、TResult>（Func<IObservable<T>、IObservable<TResult>>、TimeSpan）	重載。傳回可觀察序列，這是叫用可連接可觀察序列上選取器的結果，該序列會將單一訂閱共用至基礎序列重新執行視窗內的所有通知。（由可觀察定義。
	重新執行<T、TResult>（Func<IObservable<T>、IObservable<TResult>>、Int32）	重載。傳回可觀察序列，這是叫用可連接可觀察序列上選取器的結果，該序列會將單一訂閱共用至基礎序列重新執行bufferSize通知。（由可觀察定義。
	重新執行<T、TResult>（Func<IObservable<T>、IObservable<TResult>>、TimeSpan、IScheduler）	重載。傳回可觀察序列，這是叫用可連接可觀察序列上選取器的結果，該序列會將單一訂閱共用至基礎序列重新執行視窗內的所有通知。（由可觀察定義。
	重新執行<T、TResult>（Func<IObservable<T>、IObservable<TResult>>、Int32、IScheduler）	重載。傳回可觀察序列，這是叫用可連接可觀察序列上選取器的結果，該序列會將單一訂閱共用至基礎序列重新執行bufferSize通知。（由可觀察定義。
	重新執行<T、TResult>（Func<IObservable<T>、IObservable<TResult>>、Int32、TimeSpan）	重載。傳回可觀察序列，這是叫用可連接可觀察序列上選取器的結果，該序列會將單一訂閱共用至基礎序列重新執行bufferSize視窗中的通知。（由可觀察定義。
	重新執行<T， TResult>（Func<IObservable<T>， IObservable<TResult>>， Int32， TimeSpan， IScheduler）	重載。傳回可觀察序列，這是叫用可連接可觀察序列上選取器的結果，該序列會將單一訂閱共用至基礎序列重新執行bufferSize視窗中的通知。（由可觀察定義。
	重試<T>（）	重載。重複來源可觀察序列，直到成功終止為止。（由可觀察定義。
	重試<T>（Int32）	重載。重複來源可觀察序列，直到成功終止為止。（由可觀察定義。
	範例<T>（TimeSpan）	重載。在每個間隔取樣可觀察的序列。（由可觀察定義。
	範例<T>（TimeSpan， IScheduler）	重載。使用指定的來源、間隔和排程器，在每個間隔取樣可觀察的序列。（由可觀察定義。
	範例<T、TSample>（IObservable<TSample>）	重載。使用指定的來源和取樣器，在取樣刻度時取樣可觀察序列。（由可觀察定義。
	掃描<T>（Func<T， T， T>）	重載。將累加器函式套用至可觀察序列，並傳回具有指定來源和累積器的每個中繼結果。（由可觀察定義。
	掃描<T、TAccumulate>（TAccumulate、Func<TAccumulate、T、T、TAccumulate>）	重載。將累加器函式套用至可觀察序列，並傳回具有指定來源、種子和累積器的每個中繼結果。（由可觀察定義。
	選取<T、TResult>（Func<T、TResult>）	重載。使用指定的來源和選取器，將可觀察序列的每個專案投影到新表單中。（由可觀察定義。
	選取<T、TResult>（Func<T、Int32、TResult>）	重載。藉由將元素的索引與指定的來源和選取器結合，將可觀察序列的每個專案投影到新的表單中。（由可觀察定義。
	SelectMany<T、TOther>（IObservable<TOther>）	重載。將可觀察序列的每個專案投影到可觀察序列，並將產生的可觀察序列壓平成一個可觀察序列。（由可觀察定義。
	SelectMany<T， TResult>（Func<T， IObservable<TResult>>）	重載。將可觀察序列的每個專案投影到可觀察序列，並將產生的可觀察序列壓平成一個可觀察序列。（由可觀察定義。
	SelectMany<T， TResult>（Func<T， IEnumerable<TResult>>）	重載。將可觀察序列的每個專案投影到可觀察序列，並將產生的可觀察序列壓平成一個可觀察序列。（由可觀察定義。
	SelectMany<T， TResult>（Func<T， IObservable<TResult>>， Func<Exception， IObservable<TResult>>， Func<IObservable<TResult>>）	重載。將可觀察序列的每個專案投影到可觀察序列，並將產生的可觀察序列壓平成一個可觀察序列。（由可觀察定義。
	SelectMany<T， TCollection， TResult>（Func<T， IEnumerable<TCollection>>， Func<T， TCollection， TResult>）	重載。將可觀察序列的每個專案投影到可觀察序列，並將產生的可觀察序列壓平成一個可觀察序列。（由可觀察定義。
	SelectMany<T、TCollection、TResult>（Func<T、IObservable<TCollection>>、Func<T、TCollection、TResult>）	重載。將可觀察序列的每個專案投影到可觀察序列，並將產生的可觀察序列壓平成一個可觀察序列。（由可觀察定義。
	SequenceEqual<T>（IObservable<T>）	重載。藉由比較專案成對，判斷兩個序列是否相等。（由可觀察定義。
	SequenceEqual<T>（IObservable<T>， IEqualityComparer<T>）	重載。使用指定的相等比較子，判斷兩個序列是否相等。（由可觀察定義。
	單<T>（）	重載。傳回可觀察序列的唯一元素，如果可觀察序列中沒有一個專案，則會擲回例外狀況。（由可觀察定義。
	單<T>（Func<T，布爾值>）	重載。傳回符合述詞之可觀察序列的唯一元素，如果可觀察序列中沒有一個專案，則會擲回例外狀況。（由可觀察定義。
	SingleOrDefault<T>（）	重載。傳回可觀察序列的唯一元素，如果可觀察序列是空的，則傳回預設值。（由可觀察定義。
	SingleOrDefault<T>（Func<T， Boolean>）	重載。傳回符合述詞之可觀察序列的唯一元素，如果沒有找到任何值，則傳回預設值。（由可觀察定義。
	略過 T<>	略過可觀察序列中的指定值數目，然後傳回其餘的值。（由可觀察定義。
	SkipLast<T>	略過可觀察序列結尾的指定項目數目。（由可觀察定義。
	SkipUntil<T、TOther>	只有在其他可觀察序列產生值之後，才會從來源可觀察序列傳回值。（由可觀察定義。
	SkipWhile<T>（Func<T， Boolean>）	重載。只要指定的條件為 true，就會略過可觀察序列中的值，然後傳回其餘的值。（由可觀察定義。
	SkipWhile<T>（Func<T， Int32， Boolean>）	重載。只要指定的條件為 true，就會略過可觀察序列中的值，然後傳回其餘的值。（由可觀察定義。
	StartWith<T>T[]）	重載。在具有指定來源和值的可觀察序列前面加上值序列。（由可觀察定義。
	StartWith<T>（IScheduler， T[]）	重載。在具有指定來源、排程器和值的可觀察序列前面加上值序列。（由可觀察定義。
	訂閱<T>（）	重載。評估具有指定來源的可觀察序列。（由 ObservableExtensions定義。
	訂閱<T>（動作<T>）	重載。將專案處理程式訂閱至可觀察的序列。（由 ObservableExtensions定義。
	訂閱<T>（動作<T>，動作<例外狀況>）	重載。將專案處理程式和例外狀況處理程式訂閱到可觀察的序列。（由 ObservableExtensions定義。
	訂閱<T>（動作<T>， action）	重載。將專案處理程式和完成處理程式訂閱到可觀察的序列。（由 ObservableExtensions定義。
	訂閱<T>（動作<T>、動作<例外狀況>、動作）	重載。將項目處理程式、例外狀況處理程式和完成處理程式訂閱至可觀察序列。（由 ObservableExtensions定義。
	SubscribeOn<T>	重載。以異步方式在指定的同步處理內容上訂閱和取消訂閱觀察者。（由可觀察定義。
	SubscribeOn<T>	重載。（由 ControlObservable定義。
	SubscribeOn<T>	重載。（由 DispatcherObservable定義。
	SubscribeOn<T>	重載。（由 DispatcherObservable定義。
	SubscribeOn<T>（IScheduler）	重載。以異步方式在指定的排程器上訂閱和取消訂閱觀察者。（由可觀察定義。
	SubscribeOnDispatcher<T>	（由 DispatcherObservable定義。
	同步處理<T>（）	重載。同步處理可觀察序列。（由可觀察定義。
	同步處理<T>（物件）	重載。同步處理可觀察序列。（由可觀察定義。
	<T>	從可觀察序列的開頭傳回指定的連續值數目。（由可觀察定義。
	TakeLast<T>	從可觀察序列結尾傳回指定的連續項目數目。（由可觀察定義。
	TakeUntil<T、TOther>	從來源可觀察序列傳回值，直到其他可觀察序列產生值為止。（由可觀察定義。
	TakeWhile<T>（Func<T， Boolean>）	重載。只要指定的條件為 true，就會從可觀察序列傳回值，然後略過其餘的值。（由可觀察定義。
	TakeWhile<T>（Func<T， Int32， Boolean>）	重載。只要指定的條件為 true，就會從可觀察序列傳回值，然後略過其餘的值。（由可觀察定義。
	然後<T、TResult>	比對可觀察序列具有可用的值，並投影值。（由可觀察定義。
	節流<T>（TimeSpan）	重載。忽略可觀察序列中的值，其後面接著另一個值，再使用指定的來源和 dueTime。（由可觀察定義。
	節流<T>（TimeSpan， IScheduler）	重載。忽略可觀察序列中的值，其後面接著另一個值，再使用指定的來源、dueTime 和排程器。（由可觀察定義。
	TimeInterval<T>（）	重載。使用指定的來源，記錄可觀察序列中連續值之間的時間間隔。（由可觀察定義。
	TimeInterval<T>（IScheduler）	重載。使用指定的來源和排程器，記錄可觀察序列中連續值之間的時間間隔。（由可觀察定義。
	逾時<T>（TimeSpan）	重載。如果 dueTime 經過，則傳回可觀察序列或 TimeoutException。（由可觀察定義。
	逾時<T>（DateTimeOffset）	重載。如果 dueTime 經過，則傳回可觀察序列或 TimeoutException。（由可觀察定義。
	逾時<T>（TimeSpan， IObservable<T>）	重載。如果 dueTime 經過，則傳回來源可觀察序列或其他可觀察序列。（由可觀察定義。
	逾時<T>（DateTimeOffset， IObservable<T>）	重載。如果 dueTime 經過，則傳回可觀察序列或 TimeoutException。（由可觀察定義。
	逾時<T>（TimeSpan， IScheduler）	重載。如果 dueTime 經過，則傳回可觀察序列或 TimeoutException。（由可觀察定義。
	逾時<T>（DateTimeOffset， IScheduler）	重載。如果 dueTime 經過，則傳回可觀察序列或 TimeoutException。（由可觀察定義。
	逾時<T>（TimeSpan， IObservable<T>， IScheduler）	重載。如果 dueTime 經過，則傳回來源可觀察序列或其他可觀察序列。（由可觀察定義。
	逾時<T>（DateTimeOffset， IObservable<T>， IScheduler）	重載。如果 dueTime 經過，則傳回來源可觀察序列或其他可觀察序列。（由可觀察定義。
	時間戳<T>（）	重載。使用指定的來源，記錄可觀察序列中每個值的時間戳。（由可觀察定義。
	時間戳<T>（IScheduler）	重載。使用指定的來源和排程器，記錄可觀察序列中每個值的時間戳。（由可觀察定義。
	ToArray<T>	從可觀察序列建立陣列。（由可觀察定義。
	ToDictionary<T， TKey>（Func<T， TKey>）	重載。根據指定的索引鍵選取器函式，從可觀察序列建立字典。（由可觀察定義。
	ToDictionary<T， TKey>（Func<T， TKey>， IEqualityComparer<TKey>）	重載。根據指定的索引鍵選取器函式和比較子，從可觀察序列建立字典。（由可觀察定義。
	ToDictionary<T、TKey、TElement>（Func<T、TKey>、Func<T、TElement>）	重載。根據指定的索引鍵選取器函式和元素選取器函式，從可觀察序列建立字典。（由可觀察定義。
	ToDictionary<T、TKey、TElement>（Func<T、TKey>、Func<T、TElement>、IEqualityComparer<TKey>）	重載。根據指定的索引鍵選取器函式、比較子和元素選取器函式，從可觀察序列建立字典。（由可觀察定義。
	ToEnumerable<T>	將可觀察序列轉換成可列舉序列。（由可觀察定義。
	ToEvent<T>	以具有指定來源的 .NET 事件，公開可觀察序列做為物件。（由可觀察定義。
	ToList<T>	從可觀察序列建立清單。（由可觀察定義。
	ToLookup<T， TKey>（Func<T， TKey>）	重載。根據指定的索引鍵選取器函式，從可觀察序列建立查閱。（由可觀察定義。
	ToLookup<T， TKey>（Func<T， TKey>， IEqualityComparer<TKey>）	重載。根據指定的索引鍵選取器函式和比較子，從可觀察序列建立查閱。（由可觀察定義。
	ToLookup<T， TKey， TElement>（Func<T， TKey>， Func<T， TElement>）	重載。根據指定的索引鍵選取器函式和元素選取器函式，從可觀察序列建立查閱。（由可觀察定義。
	ToLookup<T、TKey、TElement>（Func<T、TKey>、Func<T、TElement>、IEqualityComparer<TKey>）	重載。根據指定的索引鍵選取器函式、比較子和元素選取器函式，從可觀察序列建立查閱。（由可觀察定義。
	ToNotifier<T>	從觀察者建立通知回呼。（由觀察家定義。
	ToTask<T>（）	重載。傳回工作，其中包含可觀察序列的最後一個值。（由 TaskObservableExtensions定義。
	ToTask<T>（物件）	重載。傳回工作，其中包含可觀察序列的最後一個值。（由 TaskObservableExtensions定義。
	ToTask<T>（CancellationToken）	重載。傳回工作，其中包含可觀察序列的最後一個值。（由 TaskObservableExtensions定義。
	ToTask<T>（CancellationToken， Object）	重載。傳回工作，其中包含可觀察序列的最後一個值。（由 TaskObservableExtensions定義。
	其中<T>（Func<T，布爾值>）	重載。根據述詞篩選可觀察序列的專案。（由可觀察定義。
	其中<T>（Func<T， Int32，布爾值>）	重載。藉由合併元素的索引，根據述詞篩選可觀察序列的專案。（由可觀察定義。
	視窗<T>（Int32）	重載。將可觀察序列的每個專案投影成連續的非重疊視窗，這些視窗是根據專案計數資訊產生的。（由可觀察定義。
	視窗<T>（TimeSpan）	重載。將可觀察序列的每個元素投影成連續的非重疊視窗，這些視窗是根據計時資訊所產生的。（由可觀察定義。
	視窗<T>（Int32， Int32）	重載。將可觀察序列的每個專案投影成零個或多個視窗，這些視窗是根據專案計數資訊產生的。（由可觀察定義。
	視窗<T>（TimeSpan， IScheduler）	重載。將可觀察序列的每個元素投影成連續的非重疊視窗，這些視窗是根據計時資訊所產生的。（由可觀察定義。
	視窗<T>（TimeSpan， TimeSpan）	重載。將可觀察序列的每個專案投影成零個或多個視窗，這些視窗是根據計時資訊所產生的。（由可觀察定義。
	視窗<T>（TimeSpan， Int32）	重載。將可觀察序列的每個專案投影到已完成的視窗中，當它已滿或經過指定的時間量時。（由可觀察定義。
	視窗<T>（TimeSpan， TimeSpan， IScheduler）	重載。將可觀察序列的每個專案投影成零個或多個視窗，這些視窗是根據計時資訊所產生的。（由可觀察定義。
	視窗<T>（TimeSpan， Int32， IScheduler）	重載。將可觀察序列的每個專案投影到已完成的視窗中，當它已滿或經過指定的時間量時。（由可觀察定義。
	視窗<T、TWindowClosing>（Func<IObservable<TWindowClosing>>）	重載。將可觀察序列的每個專案投影成連續的非重疊視窗。（由可觀察定義。
	視窗<T、TWindowOpening、TWindowClosing>（IObservable<TWindowOpening>、Func<TWindowOpening、IObservable<TWindowClosing>>）	重載。將可觀察序列的每個專案投影成零個或多個視窗。（由可觀察定義。
	Zip<T、 TSecond、 TResult>（IObservable<TSecond>、 Func<T、 TSecond、 TResult>）	重載。藉由以配對方式結合兩個可觀察序列，將兩個可觀察序列合併成一個可觀察序列。（由可觀察定義。
	Zip<T， TSecond， TResult>（IEnumerable<TSecond>， Func<T， TSecond， TResult>）	重載。使用選取器函式，將可觀察序列和可列舉序列合併成一個可觀察序列。（由可觀察定義。

返回頁首

言論

主體的作用類似於 Proxy，因為它同時做為訂閱者和發行者。其 IObserver 介面可用來訂閱多個數據流或數據序列。然後，數據會透過其 IObservable 介面發布。

BehaviorSubject 會緩衝它透過其 IObservable 介面發行的最後一個專案。如果尚未透過其 IObservable 介面發行任何專案，則建構函式中提供的初始專案是目前緩衝的專案。當訂閱成為 BehaviorSubject 的 IObservable 介面時，發行的序列會以目前緩衝的項目開始。

一旦 IObserver 介面收到完成，就不會從 BehaviorSubject 緩衝或發布任何專案。

例子

此範例示範 BehaviorSubject。此範例會使用 Interval 運算元，每秒將整數發佈至整數序列。發行 10 個整數之後，Take 運算子將會完成序列。這是 BehaviorSubject 訂閱的順序。

系統會為 BehaviorSubject 的 IObservable 介面建立兩個訂用帳戶，以顯示其發佈數據的方式。

訂閱 #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...

線程安全性

此類型的任何公用靜態（在 Visual Basic 中共用）成員都是安全線程。不保證任何實例成員都是安全線程。

另請參閱

參考

System.Reactive.Subjects 命名空間

共用方式為

BehaviorSubject<T> 類別

繼承階層

語法

類型參數

構造函數

方法

擴充方法

言論

例子

線程安全性

另請參閱

參考

其他資源

共用方式為

BehaviorSubject<T> 類別

繼承階層

語法

類型參數

構造 函數

方法

擴充方法

言論

例子

線程安全性

另請參閱

參考

其他資源

構造函數