IConnectableObservable<T> 介面

發行項
06/28/2011

表示可觀察的可檢視，可以連接和中斷連線。

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

語法

'Declaration
Public Interface IConnectableObservable(Of Out T) _
    Inherits IObservable(Of T)

'Usage
Dim instance As IConnectableObservable(Of Out T)

public interface IConnectableObservable<out T> : IObservable<T>

generic<typename T>
public interface class IConnectableObservable : IObservable<T>

type IConnectableObservable<'T> =  
    interface
        interface IObservable<'T>
    end

JScript does not support generic types and methods.

類型參數

outT
型別。

此類型參數為covariant。也就是說，您可以使用您指定的類型，或是衍生更多類型的類型。如需共變數和反變數的詳細資訊，請參閱。

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

方法

	名字	描述
	Connect	連線可觀察的。
	訂閱	（繼承自 IObservable<T>.

返回頁首

擴充方法

	名字	描述
	匯總<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>	隱藏可觀察序列的識別。（由可觀察定義。
	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>>）	重載。傳回可觀察序列，這是叫用可連接可觀察序列上選取器的結果，該序列只會將單一訂閱共用至包含最後一個通知的基礎序列。（由可觀察定義。
	RefCount<TSource>	傳回可觀察序列，只要至少有一個可觀察序列的訂用帳戶，就會維持與來源的連線。（由可觀察定義。
	重複<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>）	重載。根據指定的索引鍵選取器函式、比較子和元素選取器函式，從可觀察序列建立查閱。（由可觀察定義。
	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>）	重載。使用選取器函式，將可觀察序列和可列舉序列合併成一個可觀察序列。（由可觀察定義。

返回頁首

言論

冷觀察值會在訂閱時開始執行，也就是可觀察序列只會在呼叫 Subscribe 時開始將值推送至觀察者。值也不會在訂閱者之間共用。這與經常性觀察專案不同，例如滑鼠移動事件或股票刻度器，即使在訂用帳戶處於作用中狀態之前，也會產生值。當觀察者訂閱熱觀察序列時，它會取得數據流中的目前值。熱觀察序列會在所有訂閱者之間共用，且每個訂閱者都會推送序列中的下一個值。例如，即使沒有人訂閱特定的股票刻度器，滴答機將繼續根據市場移動來更新其價值。當訂閱者註冊此刻度器的興趣時，它會自動取得最新的刻度。

例子

在下列範例中，我們會使用 Publish 運算符，將冷觀察序列來源轉換成經常性存取序列來源，這會傳回名為 hot 的 IConnectableObservable<T> 實例。發佈操作員提供一種機制，藉由將單一訂閱廣播給多個訂閱者來共用訂閱。 hot 會做為 Proxy 並訂閱來源，然後在從來源接收值時，將它們推送至自己的訂閱者。若要建立備份來源的訂用帳戶並開始接收值，我們使用 IConnectableObservable.Connect（）方法。由於 IConnectableObservable 繼承 IObservable，因此即使在開始執行之前，我們仍可使用訂閱來訂閱此經常性序列。請注意，在範例中，當 subscription1 訂閱時，尚未啟動經常性序列。因此，不會將任何值推送至訂閱者。呼叫 Connect 之後，值會推送至 subscription1。延遲 3 秒之後，subscription2 會訂閱經常性存取，並開始立即從目前位置接收值（在此案例中為 3），直到結束為止。輸出看起來像這樣：

Current Time: 6/1/2011 3:38:49 PM

Current Time after 1st subscription: 6/1/2011 3:38:49 PM

Current Time after Connect: 6/1/2011 3:38:52 PM

Observer 1: OnNext: 0

Observer 1: OnNext: 1

Current Time just before 2nd subscription: 6/1/2011 3:38:55 PM 

Observer 1: OnNext: 2

Observer 1: OnNext: 3

Observer 2: OnNext: 3

Observer 1: OnNext: 4

Observer 2: OnNext: 4

       
Console.WriteLine("Current Time: " + DateTime.Now);
var source = Observable.Interval(TimeSpan.FromSeconds(1));   //creates a sequence

IConnectableObservable<long> hot = Observable.Publish<long>(source);  // convert the sequence into a hot sequence

IDisposable subscription1 = hot.Subscribe(     // no value is pushed to 1st subscription at this point
                            x => Console.WriteLine("Observer 1: OnNext: {0}", x),
                            ex => Console.WriteLine("Observer 1: OnError: {0}", ex.Message),
                            () => Console.WriteLine("Observer 1: OnCompleted"));
Console.WriteLine("Current Time after 1st subscription: " + DateTime.Now);
Thread.Sleep(3000);  //idle for 3 seconds
hot.Connect();       // hot is connected to source and starts pushing value to subscribers 
Console.WriteLine("Current Time after Connect: " + DateTime.Now);
Thread.Sleep(3000);  //idle for 3 seconds
Console.WriteLine("Current Time just before 2nd subscription: " + DateTime.Now);
IDisposable subscription2 = hot.Subscribe(     // value will immediately be pushed to 2nd subscription
                            x => Console.WriteLine("Observer 2: OnNext: {0}", x),
                            ex => Console.WriteLine("Observer 2: OnError: {0}", ex.Message),
                            () => Console.WriteLine("Observer 2: OnCompleted"));
Console.ReadKey();

另請參閱

參考

System.Reactive.Subjects 命名空間

共用方式為

IConnectableObservable<T> 介面

語法

類型參數

方法

擴充方法

言論

例子

另請參閱

參考

其他資源