Subject<T> 類別

發行項
06/28/2011

表示對象，這個物件既是可觀察序列，又是觀察者。

繼承階層

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

命名空間：System.Reactive.Subjects
元件： System.Reactive （System.Reactive.dll）

語法

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

'Usage
Dim instance As Subject(Of T)

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

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

[<SealedAttribute>]
type Subject<'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
型別。

Subject<T> 類型會公開下列成員。

構造函數

	名字	描述
	主題<T>	初始化 Subject<T> 類別的新實例。

返回頁首

方法

	名字	描述
	Dispose	釋放目前 Subject<T> 類別實例所使用的所有資源，並取消訂閱所有觀察者
	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 介面來完成。 IObserver 介面可用來訂閱多個數據流或數據序列的主體。然後，數據會透過其 IObservable 介面發佈給所有已訂閱觀察者。一般主旨會使用排程器，將傳出呼叫同步處理至子加密觀察者。

例子

此範例示範主旨類別的使用方式。字串類型的 Subject 實例可用來訂閱兩個範例新聞摘要。這些摘要只會以間隔發佈隨機新聞頭條新聞，相隔不超過五秒。接著會針對主體可觀察介面建立兩個訂用帳戶，以接收合併的數據流。一個訂用帳戶會將數據流中的每個項目報告為「所有新聞」。另一個訂用帳戶會篩選數據流中的每個標題，只報告本機頭條新聞。訂用帳戶都會寫入主控台視窗收到的每個頭條新聞。當使用者按下 Enter 鍵並呼叫 Dispose 來取消這兩個訂用帳戶時，處理就會終止。

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.                                ***//
      //***                                                                                               ***//
      //*** In this example a simple string based subject is used to subscribe to multiple news feeds     ***//
      //*** that provide random news headlines. Subscribers can then subscribe to the subject's           ***//
      //*** observable interface to observe the data stream(s) or a subset ofthe stream(s). Below we      ***//
      //*** subscribe the subject to two different news headline feeds. Then two subscriptions are        ***//
      //*** created: one for delivery of all news headlines, the other receives only local news headlines ***//
      //***                                                                                               ***//
      //*** A local news headline just contains the newsLocation substring ("in your area.").             ***//
      //***                                                                                               ***//
      //*****************************************************************************************************//

      Subject<string> mySubject = new Subject<string>();


      //*********************************************************//
      //*** Create news feed #1 and subscribe mySubject to it ***//
      //*********************************************************//
      NewsHeadlineFeed NewsFeed1 = new NewsHeadlineFeed("Headline News Feed #1");
      NewsFeed1.HeadlineFeed.Subscribe(mySubject);

      //*********************************************************//
      //*** Create news feed #2 and subscribe mySubject to it ***//
      //*********************************************************//
      NewsHeadlineFeed NewsFeed2 = new NewsHeadlineFeed("Headline News Feed #2");
      NewsFeed2.HeadlineFeed.Subscribe(mySubject);


      Console.WriteLine("Subscribing to news headline feeds.\n\nPress ENTER to exit.\n");

      //*****************************************************************************************************//
      //*** Create a subscription to the subject's observable sequence. This subscription will receive    ***//
      //*** all headlines.                                                                                ***//
      //*****************************************************************************************************//
      IDisposable allNewsSubscription = mySubject.Subscribe(x => 
      {
        Console.WriteLine("Subscription : All news subscription\n{0}\n", x);
      });


      //*****************************************************************************************************//
      //*** Create a subscription to the subject's observable sequence. This subscription will filter for ***//
      //*** only local headlines.                                                                         ***//
      //*****************************************************************************************************//

      IDisposable localNewsSubscription = mySubject.Where(x => x.Contains("in your area.")).Subscribe(x => 
      {
        Console.WriteLine("\n************************************\n" +
                          "***[ Local news headline report ]***\n" +
                          "************************************\n{0}\n\n", x);
      });

      Console.ReadLine();


      //*********************************//
      //*** Cancel both subscriptions ***//
      //*********************************//

      allNewsSubscription.Dispose();
      localNewsSubscription.Dispose();
    }
  }



  //*********************************************************************************//
  //*** The NewsHeadlineFeed class is just a mock news feed in the form of an     ***//
  //*** observable sequence in Reactive Extensions.                               ***//
  //*********************************************************************************//
  class NewsHeadlineFeed
  {
    private string feedName;                     // Feedname used to label the stream
    private IObservable<string> headlineFeed;    // The actual data stream
    private readonly Random rand = new Random(); // Used to stream random headlines.


    //*** A list of predefined news events to combine with a simple location string ***//
    static readonly string[] newsEvents = { "A tornado occurred ",
                                            "Weather watch for snow storm issued ",
                                            "A robbery occurred ",
                                            "We have a lottery winner ",
                                            "An earthquake occurred ",
                                            "Severe automobile accident "};

    //*** A list of predefined location strings to combine with a news event. ***//
    static readonly string[] newsLocations = { "in your area.",
                                               "in Dallas, Texas.",
                                               "somewhere in Iraq.",
                                               "Lincolnton, North Carolina",
                                               "Redmond, Washington"};

    public IObservable<string> HeadlineFeed
    {
      get { return headlineFeed; }
    }

    public NewsHeadlineFeed(string name)
    {
      feedName = name;

      //*****************************************************************************************//
      //*** Using the Generate operator to generate a continous stream of headline that occur ***//
      //*** randomly within 5 seconds.                                                        ***//
      //*****************************************************************************************//
      headlineFeed = Observable.Generate(RandNewsEvent(),
                                         evt => true,
                                         evt => RandNewsEvent(),
                                         evt => { Thread.Sleep(rand.Next(5000)); return evt; },
                                         Scheduler.ThreadPool);
    }


    //****************************************************************//
    //*** Some very simple formatting of the headline event string ***//
    //****************************************************************//
    private string RandNewsEvent()
    {
      return "Feedname     : " + feedName + "\nHeadline     : " + newsEvents[rand.Next(newsEvents.Length)] + 
             newsLocations[rand.Next(newsLocations.Length)];
    }
  }
}

下列輸出是使用範例程式代碼所產生。

Subscribing to news headline feeds.

Press ENTER to exit.

Subscription : All news subscription
Feedname     : Headline News Feed #2
Headline     : A robbery occurred somewhere in Iraq.

Subscription : All news subscription
Feedname     : Headline News Feed #2
Headline     : An earthquake occurred in Dallas, Texas.

Subscription : All news subscription
Feedname     : Headline News Feed #1
Headline     : We have a lottery winner in your area.

********************************** [當地新聞頭條報導]********************************** 摘要名稱：頭條新聞摘要 #1 標題：我們有彩票優勝者在您的地區。

Subscription : All news subscription
Feedname     : Headline News Feed #2
Headline     : Severe automobile accident Redmond, Washington

Subscription : All news subscription
Feedname     : Headline News Feed #2
Headline     : We have a lottery winner in Dallas, Texas.

Subscription : All news subscription
Feedname     : Headline News Feed #2
Headline     : An earthquake occurred in Dallas, Texas.

Subscription : All news subscription
Feedname     : Headline News Feed #1
Headline     : We have a lottery winner somewhere in Iraq.

Subscription : All news subscription
Feedname     : Headline News Feed #2
Headline     : Severe automobile accident somewhere in Iraq.

Subscription : All news subscription
Feedname     : Headline News Feed #2
Headline     : An earthquake occurred in your area.

********************************** [當地新聞頭條報導]********************************** 摘要名稱：頭條新聞摘要 #2 標題：您的地區發生地震。

線程安全性

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

另請參閱

參考

System.Reactive.Subjects 命名空間

共用方式為

Subject<T> 類別

繼承階層

語法

類型參數

構造函數

方法

擴充方法

言論

例子

線程安全性

另請參閱

參考

其他資源

共用方式為

Subject<T> 類別

繼承階層

語法

類型參數

構造 函數

方法

擴充方法

言論

例子

線程安全性

另請參閱

參考

其他資源

構造函數