ISubject < T > 介面

發行項
06/28/2011

表示同時為可觀察序列和觀察者的物件。

Namespace：System.Reactive.Subjects
裝配： System.Reactive.dll) 中的 System.Reactive (

Syntax

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

'Usage
Dim instance As ISubject(Of T)

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

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

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

JScript does not support generic types and methods.

類型參數

T
主旨的類型。

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

方法

	名稱	描述
	OnCompleted	(繼承自IObserver< T > .)
	OnError	(繼承自IObserver< T > .)
	OnNext	(繼承自IObserver< T > .)
	訂閱	(繼承自IObservable< T > .)

頂端

擴充方法

	名稱	描述
	匯總 < T > (Func < T、T、T >)	多載。將累加器函式套用至可觀察序列。由 Observable.) 定義的 (
	匯總 < T、TAccumulate (TAccumulate > 、Func < TAccumulate、T、TAccumulate >)	多載。將累積器函式套用至具有指定種子值的可觀察序列。由 Observable.) 定義的 (
	全部 < T>	判斷可觀察序列的所有元素是否符合條件。由 Observable.) 定義的 (
	Amb < T>	傳播可觀察序列，其會先回應指定的第一個和第二個序列。由 Observable.) 定義的 (
	而 < T、TRight>	當兩個可觀察的序列都有可用的值時相符。由 Observable.) 定義的 (
	任何 < T > ()	多載。判斷可觀察序列是否包含任何專案。由 Observable.) 定義的 (
	任何 < T > (Func < T、布林值 >)	多載。判斷可觀察序列的所有元素是否符合條件。由 Observable.) 定義的 (
	AsObservable < T>	隱藏可觀察序列的身分識別。由 Observable.) 定義的 (
	AsObserver < T>	隱藏觀察者的身分識別。由 Observer.) 定義的 (
	AsQbservable < T>	將可觀察序列轉換成可查詢的可觀察序列。由 Qbservable.) 定義的 (
	AssertEqual < T>	由 Extensions.) 定義的 (
	Buffer < T > (Int32)	多載。會根據專案計數資訊，將可觀察序列的每個元素指出為連續的非重迭緩衝區。由 Observable.) 定義的 (
	Buffer < T > (TimeSpan)	多載。會根據計時資訊，將可觀察序列的每個元素指出為連續的非重迭緩衝區。由 Observable.) 定義的 (
	Buffer < T > (Int32、Int32)	多載。會根據專案計數資訊，將可觀察序列的每個元素指出為零個或多個緩衝區。由 Observable.) 定義的 (
	Buffer < T > (TimeSpan、IScheduler)	多載。會根據計時資訊，將可觀察序列的每個元素指出為連續的非重迭緩衝區。由 Observable.) 定義的 (
	Buffer < T > (TimeSpan、TimeSpan)	多載。會根據計時資訊，將可觀察序列的每個元素指出為零個或多個緩衝區。由 Observable.) 定義的 (
	Buffer < T > (TimeSpan、Int32)	多載。將可觀察序列的每個元素指出為已滿或已經過指定時間量時所傳送的緩衝區。由 Observable.) 定義的 (
	Buffer < T > (TimeSpan、TimeSpan、IScheduler)	多載。會根據計時資訊，將可觀察序列的每個元素指出為零個或多個緩衝區。由 Observable.) 定義的 (
	Buffer < T > (TimeSpan、Int32、IScheduler)	多載。將可觀察序列的每個元素指出為已滿或已經過指定時間量時所傳送的緩衝區。由 Observable.) 定義的 (
	Buffer < T、TBufferClosing > (Func < IObservable < TBufferClosing >>)	多載。將可觀察序列的每個元素指出為連續的非重迭緩衝區。由 Observable.) 定義的 (
	緩衝區 < 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>	每當其中一個可觀察序列產生元素時，使用選取器函式，將兩個可觀察序列合併成一個可觀察序列。由 Observable.) 定義的 (
	Concat < T>	串連兩個可觀察的序列。由 Observable.) 定義的 (
	包含 < T > (T)	多載。使用預設相等比較子，判斷可觀察序列是否包含指定的專案。由 Observable.) 定義的 (
	包含 < T > (T、IEqualityComparer < T >)	多載。使用指定的 System.Collections.Generic.IEqualityComparer & lt，判斷可觀察序列是否包含指定的專案;T & gt;。由 Observable.) 定義的 (
	計數 < T>	會傳回 Int32 ，代表可觀察序列中的元素總數。由 Observable.) 定義的 (
	DefaultIfEmpty < T > ()	多載。如果序列是空的，則會傳回指定序列的專案或類型參數的預設值。由 Observable.) 定義的 (
	DefaultIfEmpty < T > (T)	多載。如果序列是空的，則會傳回指定序列的專案或類型參數的預設值。由 Observable.) 定義的 (
	延遲 < T > (TimeSpan)	多載。使用指定的來源和 dueTime，依到期時間指出可觀察的序列。由 Observable.) 定義的 (
	延遲 < T > (DateTimeOffset)	多載。使用指定的來源和 dueTime，依到期時間指出可觀察的序列。由 Observable.) 定義的 (
	延遲 < T > (TimeSpan、IScheduler)	多載。使用指定的來源、dueTime 和排程器，依到期時間指出可觀察的序列。由 Observable.) 定義的 (
	延遲 < 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.) 定義的 (
	T <> (動作 < T >)	多載。針對可觀察序列中的每個專案叫用動作。由 Observable.) 定義的 (
	T <> (IObserver < T >)	多載。針對可觀察序列中的每個專案叫用動作，並在可觀察序列的例外終止時叫用動作。由 Observable.) 定義的 (
	Do < T > (Action T > ， Action <)	多載。針對可觀察序列中的每個專案叫用動作，並在可觀察序列的正常終止時叫用動作。由 Observable.) 定義的 (
	Do < T > (Action T > ， Action << Exception >)	多載。針對可觀察序列中的每個專案叫用動作，並在可觀察序列的例外終止時叫用動作。由 Observable.) 定義的 (
	T <> (動作 < T > 、動作 < 例外 > 狀況、動作)	多載。針對可觀察序列中的每個專案叫用動作，並在可觀察序列的正常或例外終止時叫用動作。由 Observable.) 定義的 (
	ElementAt < T>	傳回位於序列中指定索引處的項目。由 Observable.) 定義的 (
	ElementAtOrDefault < T>	傳回位於序列中指定索引處的元素；如果索引超出範圍，則傳回預設值。由 Observable.) 定義的 (
	<最後 T>	在來源可觀察序列正常終止或例外狀況之後叫用指定的動作。由 Observable.) 定義的 (
	第一 < 個 T > ()	多載。傳回具有指定來源之可觀察序列的第一個專案。由 Observable.) 定義的 (
	第一個 < T > (Func < T，布林 > 值)	多載。傳回符合述詞之可觀察序列的第一個專案。由 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>	根據重迭持續時間將兩個序列的專案相互關聯，並將結果分組。由 Observable.) 定義的 (
	IgnoreElements < T>	忽略可觀察序列中的所有值，只留下終止訊息。由 Observable.) 定義的 (
	Join < T、TRight、TLeftDuration、TRightDuration、TResult>	根據重迭持續時間，將兩個序列的專案相互關聯。由 Observable.) 定義的 (
	最後 < 一個 T > ()	多載。傳回具有指定來源之可觀察序列的最後一個專案。由 Observable.) 定義的 (
	最後 < 一個 T > (Func < T、布林 > 值)	多載。傳回符合述詞之可觀察序列的最後一個專案。由 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.) 定義的 (
	合併 < T > (IObservable < T > 、IScheduler)	多載。將兩個可觀察的序列合併成單一可觀察序列。由 Observable.) 定義的 (
	最小 < T > ()	多載。傳回可觀察序列中的最小元素。由 Observable.) 定義的 (
	最小 < T > (IComparer < T >)	多載。根據指定的比較子傳回可觀察序列中的最小值。由 Observable.) 定義的 (
	MinBy < T、TKey > (Func < T、TKey >)	多載。傳回具有最小索引鍵值之可觀察序列中的專案。由 Observable.) 定義的 (
	MinBy < T、TKey (Func < T、TKey >> 、IComparer < TKey >)	多載。根據指定的比較子，傳回具有最小索引鍵值之可觀察序列中的專案。由 Observable.) 定義的 (
	MostRecent < T>	取樣可觀察序列中最新的值。由 Observable.) 定義的 (
	多播 < 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 > (控制項)	多載。 ControlObservable.) 所定義的 (
	ObserveOn < T > (Dispatcher)	多載。由 DispatcherObservable.) 定義的 (
	ObserveOn < T > (DispatcherScheduler)	多載。由 DispatcherObservable.) 定義的 (
	ObserveOn < T > (IScheduler)	多載。以非同步方式在指定的排程器上通知觀察者。由 Observable.) 定義的 (
	ObserveOnDispatcher < T>	由 DispatcherObservable.) 定義的 (
	OnErrorResumeNext < T>	繼續一般終止的可觀察序列，或是以下一個可觀察序列的例外狀況終止。由 Observable.) 定義的 (
	Publish < T > ()	多載。傳回可連線的可觀察序列，該序列會將單一訂閱共用至基礎序列。由 Observable.) 定義的 (
	發佈 < T > (T)	多載。傳回可連線的可觀察序列，此序列會共用基礎序列的單一訂用帳戶，並以 initialValue 開頭。由 Observable.) 定義的 (
	發佈 < T、TResult > (Func < IObservable T > 、IObservable << TResult >>)	多載。傳回可觀察序列，這是在可連接可觀察序列上叫用選取器的結果，該序列會共用基礎序列的單一訂閱。由 Observable.) 定義的 (
	發佈 < T、TResult > (Func < IObservable T > 、IObservable << TResult >> 、T)	多載。傳回可連線的可觀察序列，此序列會共用基礎序列的單一訂用帳戶，並以 initialValue 開頭。由 Observable.) 定義的 (
	PublishLast < T > ()	多載。傳回可連線的可觀察序列，此序列會將單一訂用帳戶共用至僅包含最後一個通知的基礎序列。由 Observable.) 定義的 (
	PublishLast < T、TResult > (Func < IObservable T > 、IObservable << TResult >>)	多載。傳回可觀察序列，這是叫用可連接可觀察序列上選取器的結果，該序列只會共用包含最後一個通知之基礎序列的單一訂用帳戶。由 Observable.) 定義的 (
	重複 < T > ()	多載。無限期地重複可觀察的序列。由 Observable.) 定義的 (
	重複 < T > (Int32)	多載。無限期地重複可觀察的序列。由 Observable.) 定義的 (
	重新執行 < T > ()	多載。傳回可連線的可觀察序列，此序列會將單一訂用帳戶共用至基礎序列，以重新執行所有通知。由 Observable.) 定義的 (
	重新執行 < T > (TimeSpan)	多載。傳回可連線的可觀察序列，此序列會將單一訂閱共用至基礎序列，以重新執行視窗內的所有通知。由 Observable.) 定義的 (
	重新執行 < T > (Int32)	多載。傳回可連線的可觀察序列，此序列會共用單一訂閱給基礎序列重新執行 bufferSize 通知。由 Observable.) 定義的 (
	重新執行 < T > (IScheduler)	多載。傳回可連線的可觀察序列，此序列會將單一訂用帳戶共用至基礎序列，以重新執行所有通知。由 Observable.) 定義的 (
	重新執行 < T > (TimeSpan、IScheduler)	多載。傳回可連線的可觀察序列，此序列會將單一訂閱共用至基礎序列，以重新執行視窗內的所有通知。由 Observable.) 定義的 (
	重新執行 < T > (Int32、IScheduler)	多載。傳回可連線的可觀察序列，此序列會共用單一訂閱給基礎序列重新執行 bufferSize 通知。由 Observable.) 定義的 (
	重新執行 < T > (Int32、TimeSpan)	多載。傳回可連線的可觀察序列，此序列會共用單一訂閱給基礎序列重新執行 bufferSize 視窗中的通知。由 Observable.) 定義的 (
	重新執行 < T > (Int32、TimeSpan、IScheduler)	多載。傳回可連線的可觀察序列，此序列會共用單一訂閱給基礎序列重新執行 bufferSize 視窗中的通知。由 Observable.) 定義的 (
	重新執行 < T、TResult > (Func < IObservable T > 、IObservable << TResult >>)	多載。傳回可觀察序列，這是叫用可連接可觀察序列上選取器的結果，該序列會共用基礎序列的單一訂用帳戶，並以初始值開頭。由 Observable.) 定義的 (
	重新執行 < T、TResult > (Func < IObservable T、IObservable << TResult >>> 、IScheduler)	多載。傳回可觀察序列，這是叫用可連接可觀察序列上選取器的結果，該序列會將單一訂用帳戶共用至基礎序列重新執行所有通知。由 Observable.) 定義的 (
	Replay < T、TResult > (Func < IObservable T、IObservable << TResult >>> 、TimeSpan)	多載。傳回可觀察序列，這是叫用可連接可觀察序列上選取器的結果，該序列會共用單一訂用帳戶給基礎序列，以重新執行視窗內的所有通知。由 Observable.) 定義的 (
	重新執行 < T、TResult > (Func < IObservable T、IObservable << TResult >>> 、Int32)	多載。傳回可觀察序列，這是叫用可連接可觀察序列上選取器的結果，該序列會將單一訂用帳戶共用至基礎序列重新執行 bufferSize 通知。由 Observable.) 定義的 (
	重新執行 < T、TResult > (Func < IObservable T、IObservable << TResult >>> 、TimeSpan、IScheduler)	多載。傳回可觀察序列，這是叫用可連接可觀察序列上選取器的結果，該序列會共用單一訂用帳戶給基礎序列，以重新執行視窗內的所有通知。由 Observable.) 定義的 (
	重新執行 < T、TResult > (Func < IObservable T、IObservable << TResult >>> 、Int32、IScheduler)	多載。傳回可觀察序列，這是叫用可連接可觀察序列上選取器的結果，該序列會將單一訂用帳戶共用至基礎序列重新執行 bufferSize 通知。由 Observable.) 定義的 (
	重新執行 < T、TResult > (Func < IObservable T、IObservable << TResult >>> 、Int32、TimeSpan)	多載。傳回可觀察序列，這是在可連接可觀察序列上叫用選取器的結果，該序列會將單一訂用帳戶共用至基礎序列重新執行 bufferSize 視窗中的通知。由 Observable.) 定義的 (
	重新執行 < T、TResult > (Func < IObservable T、IObservable << TResult >>> 、Int32、TimeSpan、IScheduler)	多載。傳回可觀察序列，這是在可連接可觀察序列上叫用選取器的結果，該序列會將單一訂用帳戶共用至基礎序列重新執行 bufferSize 視窗中的通知。由 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 >)	多載。將可觀察序列的每個元素投影到可觀察的序列，並將產生的可觀察序列扁平化成一個可觀察序列。由 Observable.) 定義的 (
	SelectMany < T、TResult > (Func < T、IObservable < TResult >>)	多載。將可觀察序列的每個元素投影到可觀察的序列，並將產生的可觀察序列扁平化成一個可觀察序列。由 Observable.) 定義的 (
	SelectMany < T、TResult > (Func < T、IEnumerable < TResult >>)	多載。將可觀察序列的每個元素投影到可觀察的序列，並將產生的可觀察序列扁平化成一個可觀察序列。由 Observable.) 定義的 (
	SelectMany < T、TResult > (Func T、IObservable < TResult >> 、Func << Exception、IObservable TResult >> 、Func < IObservable << TResult >>)	多載。將可觀察序列的每個元素投影到可觀察的序列，並將產生的可觀察序列扁平化成一個可觀察序列。由 Observable.) 定義的 (
	SelectMany < T、TCollection、TResult > (Func < T、IEnumerable < TCollection、Func < T、TCollection >> 、TResult >)	多載。將可觀察序列的每個元素投影到可觀察的序列，並將產生的可觀察序列扁平化成一個可觀察序列。由 Observable.) 定義的 (
	SelectMany < T、TCollection、TResult > (Func < T、IObservable < TCollection、Func < T、TCollection >> 、TResult >)	多載。將可觀察序列的每個元素投影到可觀察的序列，並將產生的可觀察序列扁平化成一個可觀察序列。由 Observable.) 定義的 (
	SequenceEqual < T > (IObservable < T >)	多載。藉由比較專案成對，判斷兩個序列是否相等。由 Observable.) 定義的 (
	SequenceEqual < T > (IObservable < T > ， IEqualityComparer < T >)	多載。使用指定的相等比較子，判斷兩個序列是否相等。由 Observable.) 定義的 (
	單一 < T > ()	多載。傳回可觀察序列的唯一元素，如果可觀察序列中沒有一個元素，則會擲回例外狀況。由 Observable.) 定義的 (
	單 < 一 T > (Func < T、布林 > 值)	多載。傳回符合述詞之可觀察序列的唯一元素，如果可觀察序列中沒有一個元素，則會擲回例外狀況。由 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 > [])	多載。在具有指定來源和值的可觀察序列前面加上值序列。由 Observable.) 定義的 (
	StartWith < T > (IScheduler， T[])	多載。在具有指定來源、排程器和值的可觀察序列前面加上值序列。由 Observable.) 定義的 (
	訂閱 < T > ()	多載。使用指定的來源評估可觀察的序列。由 ObservableExtensions.) 定義的 (
	訂閱 < T > (動作 < T >)	多載。將專案處理常式訂閱至可觀察的序列。由 ObservableExtensions.) 定義的 (
	訂閱 < T > (動作 T > 、動作 << 例外 > 狀況)	多載。將專案處理常式和例外狀況處理常式訂閱至可觀察的序列。由 ObservableExtensions.) 定義的 (
	訂閱 < T > (動作 < T > 、動作)	多載。將專案處理常式和完成處理常式訂閱至可觀察的序列。由 ObservableExtensions.) 定義的 (
	訂閱 < T > (動作 T > 、動作 < 例外 > 狀況、動作 <)	多載。將專案處理常式、例外狀況處理常式和完成處理常式訂閱至可觀察的序列。由 ObservableExtensions.) 定義的 (
	SubscribeOn < T > (SynchronizationCoNtext)	多載。以非同步方式訂閱和取消訂閱指定同步處理內容上的觀察者。由 Observable.) 定義的 (
	SubscribeOn < T > (控制項)	多載。 ControlObservable.) 所定義的 (
	SubscribeOn < T > (Dispatcher)	多載。由 DispatcherObservable.) 定義的 (
	SubscribeOn < T > (DispatcherScheduler)	多載。由 DispatcherObservable.) 定義的 (
	SubscribeOn < T > (IScheduler)	多載。以非同步方式訂閱和取消訂閱指定排程器上的觀察者。由 Observable.) 定義的 (
	SubscribeOnDispatcher < T>	由 DispatcherObservable.) 定義的 (
	同步 < T > ()	多載。同步可觀察的序列。由 Observable.) 定義的 (
	同步 < 處理 T > (物件)	多載。同步可觀察的序列。由 Observable.) 定義的 (
	採用 < T>	從可觀察序列的開頭傳回指定的連續值數目。由 Observable.) 定義的 (
	TakeLast < T>	從可觀察序列結尾傳回指定的連續專案數目。由 Observable.) 定義的 (
	TakeUntil < T、TOther>	傳回來源可觀察序列的值，直到其他可觀察序列產生值為止。由 Observable.) 定義的 (
	TakeWhile < T > (Func < T， Boolean >)	多載。只要指定的條件為 true，就會傳回可觀察序列中的值，然後略過其餘的值。由 Observable.) 定義的 (
	TakeWhile < T > (Func < T、Int32、布林 > 值)	多載。只要指定的條件為 true，就會傳回可觀察序列中的值，然後略過其餘的值。由 Observable.) 定義的 (
	然後 < T、TResult>	符合可觀察序列具有可用的值，並投影值。由 Observable.) 定義的 (
	<節流 T > (TimeSpan)	多載。忽略可觀察序列中的值，這些值後面接著另一個值，然後才有指定的來源和 dueTime。由 Observable.) 定義的 (
	<節流 T > (TimeSpan、IScheduler)	多載。忽略可觀察序列中的值，這些值後面接著另一個值，然後才有指定的來源、dueTime 和排程器。由 Observable.) 定義的 (
	TimeInterval < T > ()	多載。使用指定的來源，記錄可觀察序列中連續值之間的時間間隔。由 Observable.) 定義的 (
	TimeInterval < T > (IScheduler)	多載。使用指定的來源和排程器，記錄可觀察序列中連續值之間的時間間隔。由 Observable.) 定義的 (
	逾時 < T > (TimeSpan)	多載。如果 dueTime 經過，則傳回可觀察的序列或 TimeoutException。由 Observable.) 定義的 (
	逾時 < T > (DateTimeOffset)	多載。如果 dueTime 經過，則傳回可觀察的序列或 TimeoutException。由 Observable.) 定義的 (
	逾 < 時 T > (TimeSpan、IObservable < T >)	多載。如果 dueTime 經過，則傳回來源可觀察序列或其他可觀察序列。由 Observable.) 定義的 (
	逾時 < T > (DateTimeOffset、IObservable < T >)	多載。如果 dueTime 經過，則傳回可觀察的序列或 TimeoutException。由 Observable.) 定義的 (
	逾時 < T > (TimeSpan、IScheduler)	多載。如果 dueTime 經過，則傳回可觀察的序列或 TimeoutException。由 Observable.) 定義的 (
	逾時 < T > (DateTimeOffset、IScheduler)	多載。如果 dueTime 經過，則傳回可觀察的序列或 TimeoutException。由 Observable.) 定義的 (
	逾 < 時 T > (TimeSpan、IObservable < T > 、IScheduler)	多載。如果 dueTime 經過，則傳回來源可觀察序列或其他可觀察序列。由 Observable.) 定義的 (
	逾 < 時 T > (DateTimeOffset、IObservable < T > 、IScheduler)	多載。如果 dueTime 經過，則傳回來源可觀察序列或其他可觀察序列。由 Observable.) 定義的 (
	Timestamp < T > ()	多載。使用指定的來源，記錄可觀察序列中每個值的時間戳記。由 Observable.) 定義的 (
	時間戳記 < 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>	從觀察者建立通知回呼。由 Observer.) 定義的 (
	ToTask < T > ()	多載。傳回工作，其中包含可觀察序列的最後一個值。 TaskObservableExtensions.) 所定義的 (
	ToTask < T > (物件)	多載。傳回工作，其中包含可觀察序列的最後一個值。 TaskObservableExtensions.) 所定義的 (
	ToTask < T > (CancellationToken)	多載。傳回工作，其中包含可觀察序列的最後一個值。 TaskObservableExtensions.) 所定義的 (
	ToTask < T > (CancellationToken，物件)	多載。傳回工作，其中包含可觀察序列的最後一個值。 TaskObservableExtensions.) 所定義的 (
	其中 < T > (Func < T，布林值 >)	多載。根據述詞篩選可觀察序列的專案。由 Observable.) 定義的 (
	其中 < T > (Func < T、Int32、布林值 >)	多載。藉由合併專案的索引，根據述詞篩選可觀察序列的專案。由 Observable.) 定義的 (
	視窗 < T > (Int32)	多載。將可觀察序列的每個元素投影到以專案計數資訊為基礎的連續非重迭視窗。由 Observable.) 定義的 (
	Window < T > (TimeSpan)	多載。將可觀察序列的每個元素投影到根據計時資訊產生的連續非重迭視窗。由 Observable.) 定義的 (
	視窗 < T > (Int32、Int32)	多載。將可觀察序列的每個元素投影成零個或多個以專案計數資訊為基礎的視窗。由 Observable.) 定義的 (
	Window < T > (TimeSpan、IScheduler)	多載。將可觀察序列的每個元素投影到根據計時資訊產生的連續非重迭視窗。由 Observable.) 定義的 (
	Window < T > (TimeSpan、TimeSpan)	多載。將可觀察序列的每個元素投影成以計時資訊為基礎的零個或多個視窗。由 Observable.) 定義的 (
	Window < T > (TimeSpan， Int32)	多載。將可觀察序列的每個元素投影到已滿或指定時間量已耗用時完成的視窗。由 Observable.) 定義的 (
	Window < T > (TimeSpan、 TimeSpan、 IScheduler)	多載。將可觀察序列的每個元素投影成以計時資訊為基礎的零個或多個視窗。由 Observable.) 定義的 (
	Window < T > (TimeSpan、Int32、IScheduler)	多載。將可觀察序列的每個元素投影到已滿或指定時間量已耗用時完成的視窗。由 Observable.) 定義的 (
	視窗 < T、TWindowClosing > (Func < IObservable < TWindowClosing >>)	多載。將可觀察序列的每個元素投影到連續的非重迭視窗。由 Observable.) 定義的 (
	視窗 < T、TWindowOpening、TWindowClosing > (IObservable < TWindowOpening > 、Func < TWindowOpening、IObservable < TWindowClosing >>)	多載。將可觀察序列的每個元素投影成零個或多個視窗。由 Observable.) 定義的 (
	Zip < T、TSecond、TResult > (IObservable < TSecond > 、Func < T、TSecond、TResult >)	多載。將兩個可觀察的序列合併成一個可觀察序列，方法是以配對方式結合其元素。由 Observable.) 定義的 (
	Zip < T、TSecond、TResult > (IEnumerable < TSecond > 、Func < T、TSecond、TResult >)	多載。使用選取器函式，將可觀察序列和可列舉序列合併成一個可觀察的序列。由 Observable.) 定義的 (

頂端

備註

實作 ISubject 介面可讓您使用自訂行為建立自己的主旨。

範例

下列範例程式碼會實作範例主旨，其只會回應主控台視窗執行的方法。

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

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

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


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

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

      Console.ReadLine();


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

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



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

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

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

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

      lock (gate) 
      {
        CheckDisposed();

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

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

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

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

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

      lock (gate) 
      {
        CheckDisposed();

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

          exception = error;

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

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

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

      lock (gate)
      {
        CheckDisposed();

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

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

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

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

      lock (gate)
      {
        CheckDisposed();

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

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

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

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

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

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


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

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

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

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

下列輸出是由範例程式碼所產生。

Subscribing ConsoleEchoSubject to observable sequence.


ConsoleEchoSubject : Creating new subscription.

ConsoleEchoSubject : OnNext(0)
0

ConsoleEchoSubject : OnNext(1)
1

ConsoleEchoSubject : OnNext(2)
2

ConsoleEchoSubject : OnNext(3)
3

ConsoleEchoSubject : OnNext(4)
4

ConsoleEchoSubject : OnCompleted()

Sequence Completed.

Press ENTER to exit...


ConsoleEchoSubject : Unsubscribing subscription.

ConsoleEchoSubject : Disposing resources.

C:\

另請參閱

參考

System.Reactive.Subjects 命名空間

共用方式為

ISubject < T > 介面

Syntax

類型參數

方法

擴充方法

備註

範例

另請參閱

參考

其他資源