IConnectableObservable<T> – rozhraní

Článek
06/28/2011

Představuje pozorovatelnou možnost připojení a odpojení.

obor názvů :System.Reactive.Subjects
sestavení : System.Reactive (v System.Reactive.dll)

Syntax

'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.

Parametry typu

outT
Typ.

Tento parametr typu je kovariantní. To znamená, že můžete použít buď zadaný typ, nebo jakýkoli typ, který je odvozenější. Další informace o kovarianci a kontravarianci naleznete v tématu .

Typ IConnectableObservable<T> zveřejňuje následující členy.

Metody

	Jméno	Popis
	Connect	Připojí pozorovatelnou.
	přihlásit k odběru	(Zděděno z IObservable<T>.)

Vrchol

Rozšiřující metody

	Jméno	Popis
	agregace<T>(func<T, T, T>)	Přetížený. Použije funkci akumulátoru na pozorovatelnou sekvenci. (Definováno Pozorovatelné.)
	Agregační<T, TAccumulate>(TAccumulate, Func<TAccumulate, T, TAccumulate>)	Přetížený. Použije funkci akumulátoru na pozorovatelnou sekvenci se zadanou počáteční hodnotou. (Definováno Pozorovatelné.)
	Všechny<T>	Určuje, zda všechny prvky pozorovatelné sekvence splňují podmínku. (Definováno Pozorovatelné.)
	Amb<T>	Rozšíří pozorovatelnou sekvenci, která reaguje jako první se zadanou první a druhou sekvencí. (Definováno Pozorovatelné.)
	A<T, TRight>	Odpovídá, pokud obě pozorovatelné sekvence mají dostupnou hodnotu. (Definováno Pozorovatelné.)
	T	Přetížený. Určuje, zda pozorovatelná sekvence obsahuje jakékoli prvky. (Definováno Pozorovatelné.)
	<T>(Func<T, Boolean>)	Přetížený. Určuje, zda všechny prvky pozorovatelné sekvence splňují podmínku. (Definováno Pozorovatelné.)
	<T>	Skryje identitu pozorovatelné sekvence. (Definováno Pozorovatelné.)
	<T>	Převede pozorovatelnou sekvenci na pozorovatelnou sekvenci. (Definované Qbservable.)
	AssertEqual<T>	(Definované rozšířeními .)
	vyrovnávací paměti<T>(Int32)	Přetížený. Označuje každý prvek pozorovatelné sekvence do po sobě jdoucích nepřekrývajících vyrovnávacích pamětí, které jsou vytvořeny na základě informací o počtu prvků. (Definováno Pozorovatelné.)
	vyrovnávací paměti<T>(TimeSpan)	Přetížený. Označuje každý prvek pozorovatelné sekvence do po sobě jdoucích nepřekrývajících vyrovnávacích pamětí, které jsou vytvořeny na základě informací o časování. (Definováno Pozorovatelné.)
	vyrovnávací paměti<T>(Int32, Int32)	Přetížený. Označuje každý prvek pozorovatelné sekvence do nuly nebo více vyrovnávacích pamětí, které jsou vytvořeny na základě informací o počtu prvků. (Definováno Pozorovatelné.)
	vyrovnávací paměti<T>(TimeSpan, IScheduler)	Přetížený. Označuje každý prvek pozorovatelné sekvence do po sobě jdoucích nepřekrývajících vyrovnávacích pamětí, které jsou vytvořeny na základě informací o časování. (Definováno Pozorovatelné.)
	vyrovnávací paměti<T>(TimeSpan, TimeSpan)	Přetížený. Označuje každý prvek pozorovatelné sekvence do nuly nebo více vyrovnávacích pamětí, které jsou vytvořeny na základě informací o načasování. (Definováno Pozorovatelné.)
	vyrovnávací paměti<T>(TimeSpan, Int32)	Přetížený. Označuje každý prvek pozorovatelné sekvence do vyrovnávací paměti, která se odešle, když je plná nebo uplynula daná doba. (Definováno Pozorovatelné.)
	vyrovnávací paměti<T>(TimeSpan, TimeSpan, IScheduler)	Přetížený. Označuje každý prvek pozorovatelné sekvence do nuly nebo více vyrovnávacích pamětí, které jsou vytvořeny na základě informací o načasování. (Definováno Pozorovatelné.)
	vyrovnávací paměti<T>(TimeSpan, Int32, IScheduler)	Přetížený. Označuje každý prvek pozorovatelné sekvence do vyrovnávací paměti, která se odešle, když je plná nebo uplynula daná doba. (Definováno Pozorovatelné.)
	vyrovnávací paměti<T, TBufferClosing>(func<IObservable<TBufferClosing>>)	Přetížený. Označuje každý prvek pozorovatelné sekvence do po sobě jdoucích nepřekrývajících se vyrovnávacích pamětí. (Definováno Pozorovatelné.)
	vyrovnávací paměti<T, TBufferOpening, TBufferClosing>(IObservable<TBufferOpening>, Func<TBufferOpening, IObservable<TBufferClosing>>)	Přetížený. Označuje každý prvek dotazovatelné pozorovatelné sekvence do po sobě jdoucích nepřekrývajících se vyrovnávacích pamětí. (Definováno Pozorovatelné.)
	T(T)	Přetížený. Pokračuje pozorovatelnou sekvenci, která je ukončena výjimkou s další pozorovatelnou sekvencí. (Definováno Pozorovatelné.)
	Catch<T, TException>(Func<TException, IObservable<T>>)	Přetížený. Pokračuje pozorovatelnou sekvenci ukončenou výjimkou zadaného typu s pozorovatelnou sekvencí vytvořenou obslužnou rutinou. (Definováno Pozorovatelné.)
	CombineLatest<T, TSecond, TResult>	Sloučí dvě pozorovatelné sekvence do jedné pozorovatelné sekvence pomocí funkce selektoru, kdykoli jedna z pozorovatelných sekvencí vytvoří prvek. (Definováno Pozorovatelné.)
	concat<T>	Zřetězí dvě pozorovatelné sekvence. (Definováno Pozorovatelné.)
	obsahuje<T>(T).	Přetížený. Určuje, zda pozorovatelná sekvence obsahuje zadaný prvek pomocí výchozího porovnávače rovnosti. (Definováno Pozorovatelné.)
	obsahuje<T>(T, IEqualityComparer<T>)	Přetížený. Určuje, zda pozorovatelná sekvence obsahuje zadaný prvek pomocí zadaného System.Collections.Generic.IEqualityComparer< T>. (Definováno Pozorovatelné.)
	Počet<T>	Vrátí Int32, který představuje celkový počet prvků v pozorovatelné sekvenci. (Definováno Pozorovatelné.)
	defaultIfEmpty<T>()	Přetížený. Vrátí prvky zadané sekvence nebo výchozí hodnotu parametru typu v jednotonové sekvenci, pokud je sekvence prázdná. (Definováno Pozorovatelné.)
	výchozí<>T (T)	Přetížený. Vrátí prvky zadané sekvence nebo výchozí hodnotu parametru typu v jednotonové sekvenci, pokud je sekvence prázdná. (Definováno Pozorovatelné.)
	zpoždění<T>(TimeSpan)	Přetížený. Určuje pozorovatelnou sekvenci podle času splnění se zadaným zdrojem a časem dueTime. (Definováno Pozorovatelné.)
	zpoždění<T>(DateTimeOffset)	Přetížený. Určuje pozorovatelnou sekvenci podle času splnění se zadaným zdrojem a časem dueTime. (Definováno Pozorovatelné.)
	zpoždění<T>(TimeSpan, IScheduler)	Přetížený. Určuje pozorovatelnou sekvenci podle času splnění se zadaným zdrojem, dueTime a plánovačem. (Definováno Pozorovatelné.)
	zpoždění<T>(DateTimeOffset, IScheduler)	Přetížený. Určuje pozorovatelnou sekvenci podle času splnění se zadaným zdrojem, dueTime a plánovačem. (Definováno Pozorovatelné.)
	distinctT()	Přetížený. Vrátí pozorovatelnou sekvenci, která obsahuje pouze jedinečné prvky se zadaným zdrojem. (Definováno Pozorovatelné.)
	distinctT(IEqualityComparerT)	Přetížený. Vrátí pozorovatelnou sekvenci, která obsahuje pouze odlišné prvky podle porovnávače. (Definováno Pozorovatelné.)
	distinct<T, TKey>(func<T, TKey>)	Přetížený. Vrátí pozorovatelnou sekvenci, která obsahuje pouze jedinečné prvky podle keySelectoru. (Definováno Pozorovatelné.)
	distinct<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	Přetížený. Vrátí pozorovatelnou sekvenci, která obsahuje pouze jedinečné prvky podle keySelectoru. (Definováno Pozorovatelné.)
	DistinctUntilChanged<T>()	Přetížený. Vrátí pozorovatelnou sekvenci, která obsahuje pouze jedinečné souvislé prvky se zadaným zdrojem. (Definováno Pozorovatelné.)
	DistinctUntilChangedT(IEqualityComparerT)	Přetížený. Vrátí pozorovatelnou sekvenci, která obsahuje pouze odlišné souvislé prvky podle porovnávače. (Definováno Pozorovatelné.)
	DistinctUntilChanged<T, TKey>(Func<T, TKey>)	Přetížený. Vrátí pozorovatelnou sekvenci, která obsahuje pouze odlišné souvislé prvky podle keySelectoru. (Definováno Pozorovatelné.)
	DistinctUntilChanged<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	Přetížený. Vrátí pozorovatelnou sekvenci, která obsahuje pouze odlišné souvislé prvky podle keySelectoru a porovnávače. (Definováno Pozorovatelné.)
	T(akceT)	Přetížený. Vyvolá akci pro každý prvek v pozorovatelné sekvenci. (Definováno Pozorovatelné.)
	T(IObserverT)	Přetížený. Vyvolá akci pro každý prvek v pozorovatelné sekvenci a vyvolá akci při výjimečném ukončení pozorovatelné sekvence. (Definováno Pozorovatelné.)
	<T>(akce<T>, akce)	Přetížený. Vyvolá akci pro každý prvek v pozorovatelné sekvenci a vyvolá akci po řádném ukončení pozorovatelné sekvence. (Definováno Pozorovatelné.)
	<T>(akce<T>,><< výjimka)	Přetížený. Vyvolá akci pro každý prvek v pozorovatelné sekvenci a vyvolá akci při výjimečném ukončení pozorovatelné sekvence. (Definováno Pozorovatelné.)
	<T>(akce<T>,>výjimka<akce, akce)	Přetížený. Vyvolá akci pro každý prvek v pozorovatelné sekvenci a vyvolá akci po řádném nebo výjimečném ukončení pozorovatelné sekvence. (Definováno Pozorovatelné.)
	ElementAt<T>	Vrátí prvek v zadaném indexu v sekvenci. (Definováno Pozorovatelné.)
	ElementAtOrDefault<T>	Vrátí prvek v zadaném indexu v sekvenci nebo výchozí hodnotu, pokud je index mimo rozsah. (Definováno Pozorovatelné.)
	konečně<T>	Vyvolá zadanou akci po ukončení pozorovatelné sekvence zdroje normálně nebo výjimkou. (Definováno Pozorovatelné.)
	T	Přetížený. Vrátí první prvek pozorovatelné sekvence se zadaným zdrojem. (Definováno Pozorovatelné.)
	první<T>(func<T, logická>)	Přetížený. Vrátí první prvek pozorovatelné sekvence, která odpovídá predikátu. (Definováno Pozorovatelné.)
	FirstOrDefaultT()	Přetížený. Vrátí první prvek pozorovatelné sekvence nebo výchozí hodnotu, pokud nebyla nalezena žádná hodnota. (Definováno Pozorovatelné.)
	FirstOrDefaultT(FuncT, Boolean)	Přetížený. Vrátí první prvek pozorovatelné sekvence, která odpovídá predikátu, nebo výchozí hodnotu, pokud se nenajde žádná hodnota. (Definováno Pozorovatelné.)
	Foo<T, R>	(Definováno MyExt.)
	ForEach<T>	Vyvolá akci pro každý prvek v pozorovatelné sekvenci a blokuje, dokud se sekvence neukončí. (Definováno Pozorovatelné.)
	GetEnumerator<T>	Vrátí enumerátor, který vyčíslí všechny hodnoty pozorovatelné sekvence. (Definováno Pozorovatelné.)
	GroupBy<T, TKey>(Func<T, TKey>)	Přetížený. Seskupí prvky pozorovatelné sekvence podle zadané funkce selektoru kláves. (Definováno Pozorovatelné.)
	GroupBy<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	Přetížený. Seskupí prvky pozorovatelné sekvence podle zadané funkce selektoru klíče a porovnávače. (Definováno Pozorovatelné.)
	GroupBy<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>)	Přetížený. Seskupí prvky pozorovatelné sekvence a vybere výsledné prvky pomocí zadané funkce. (Definováno Pozorovatelné.)
	GroupBy<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>)	Přetížený. Seskupí prvky pozorovatelné sekvence podle zadané funkce selektoru klíčů a porovnávače a vybere výsledné prvky pomocí zadané funkce. (Definováno Pozorovatelné.)
	GroupByUntil<T, TKey, TDuration>(Func<T, TKey>, Func<IGroupedObservable<TKey, T>, IObservable<TDuration>>)	Přetížený. Seskupí prvky pozorovatelné sekvence podle zadané funkce selektoru kláves. (Definováno Pozorovatelné.)
	GroupByUntil<T, TKey, TDuration>(Func<T, TKey>, Func<IGroupedObservable<TKey, T>, IObservable<TDuration>>, IEqualityComparer<TKey>)	Přetížený. Seskupí prvky pozorovatelné sekvence podle zadané funkce selektoru klíče a porovnávače. (Definováno Pozorovatelné.)
	GroupByUntil<T, TKey, TElement, TDuration>(Func<T, TKey>, Func<T, TElement>, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>)	Přetížený. Seskupí prvky pozorovatelné sekvence podle zadané funkce selektoru klíčů a vybere výsledné prvky pomocí zadané funkce. (Definováno Pozorovatelné.)
	GroupByUntil<T, TKey, TElement, TDuration>(Func<T, TKey>, Func<T, TElement>, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>, IEqualityComparer<TKey>)	Přetížený. Seskupí prvky pozorovatelné sekvence podle zadané funkce selektoru klíčů a porovnávače a vybere výsledné prvky pomocí zadané funkce. (Definováno Pozorovatelné.)
	GroupJoin<T, TRight, TLeftDuration, TRightDuration, TResult>	Koreluje prvky dvou sekvencí na základě překrývajících se dob trvání a seskupuje výsledky. (Definováno Pozorovatelné.)
	IgnoreElements<T>	Ignoruje všechny hodnoty v pozorovatelné sekvenci a ponechá jenom zprávy o ukončení. (Definováno Pozorovatelné.)
	Join<T, TRight, TLeftDuration, TRightDuration, TResult>	Koreluje prvky dvou sekvencí na základě překrývajících se dob trvání. (Definováno Pozorovatelné.)
	posledníT()	Přetížený. Vrátí poslední prvek pozorovatelné sekvence se zadaným zdrojem. (Definováno Pozorovatelné.)
	poslední<T>(func<T, logická>)	Přetížený. Vrátí poslední prvek pozorovatelné sekvence, která odpovídá predikátu. (Definováno Pozorovatelné.)
	LastOrDefaultT()	Přetížený. Vrátí poslední prvek v pozorovatelné sekvenci nebo výchozí hodnotu, pokud nebyla nalezena žádná hodnota. (Definováno Pozorovatelné.)
	LastOrDefault<T>(Func<T, Boolean>)	Přetížený. Vrátí poslední prvek pozorovatelné sekvence, která odpovídá predikátu, nebo výchozí hodnotu, pokud nebyla nalezena žádná hodnota. (Definováno Pozorovatelné.)
	nejnovější<T>	Vzorkuje nejnovější hodnotu v pozorovatelné sekvenci. (Definováno Pozorovatelné.)
	LongCount<T>	Vrátí Int64, který představuje celkový počet prvků v pozorovatelné sekvenci. (Definováno Pozorovatelné.)
	materializace<T>	Materializuje implicitní oznámení pozorovatelné sekvence jako explicitní hodnoty oznámení. (Definováno Pozorovatelné.)
	T()	Přetížený. Vrátí maximální prvek v pozorovatelné sekvenci. (Definováno Pozorovatelné.)
	T TT	Přetížený. Vrátí maximální hodnotu v pozorovatelné sekvenci podle zadaného porovnávače. (Definováno Pozorovatelné.)
	MaxBy<T, TKey>(Func<T, TKey>)	Přetížený. Vrátí prvky v pozorovatelné sekvenci s maximální hodnotou klíče. (Definováno Pozorovatelné.)
	MaxByT, TKey(FuncT, TKey, IComparerTKey)	Přetížený. Vrátí prvky v pozorovatelné sekvenci s maximální hodnotou klíče. (Definováno Pozorovatelné.)
	sloučeníT(T)	Přetížený. Sloučí pozorovatelnou sekvenci pozorovatelných sekvencí do pozorovatelné sekvence. (Definováno Pozorovatelné.)
	sloučeníT(IObservableT, IScheduler)	Přetížený. Sloučí dvě pozorovatelné sekvence do jedné pozorovatelné sekvence. (Definováno Pozorovatelné.)
	min.T	Přetížený. Vrátí minimální prvek v pozorovatelné sekvenci. (Definováno Pozorovatelné.)
	minT(IComparerT)	Přetížený. Vrátí minimální hodnotu v pozorovatelné sekvenci podle zadaného porovnávače. (Definováno Pozorovatelné.)
	MinBy<T, TKey>(Func<T, TKey>)	Přetížený. Vrátí prvky v pozorovatelné sekvenci s minimální hodnotou klíče. (Definováno Pozorovatelné.)
	MinBy<T, TKey>(Func<T, TKey>, IComparer<TKey>)	Přetížený. Vrátí prvky v pozorovatelné sekvenci s minimální hodnotou klíče podle zadaného porovnávače. (Definováno Pozorovatelné.)
	MostRecent<T>	Vzorkuje nejnovější hodnotu v pozorovatelné sekvenci. (Definováno Pozorovatelné.)
	vícesměrové vysílání<T, TResult>(ISubject<T, TResult>)	Přetížený. Vrátí spojitelnou pozorovatelnou sekvenci, která po připojení způsobí, že zdrojová sekvence odešle výsledky do zadaného předmětu. (Definováno Pozorovatelné.)
	vícesměrové vysílání<T, TIntermediate, TResult>(Func<ISubject<T, TIntermediate>>, Func<IObservable<TIntermediate>, IObservable<TResult>>)	Přetížený. Vrátí pozorovatelnou sekvenci, která obsahuje prvky sekvence vytvořené vícesměrovým vysíláním zdrojové sekvence v rámci funkce selektoru. (Definováno Pozorovatelné.)
	Další<T>	Vzorkuje další hodnotu (blokující bez ukládání do vyrovnávací paměti) z pozorovatelné sekvence. (Definováno Pozorovatelné.)
	ObserveOn<T>(SynchronizationContext)	Přetížený. Asynchronně upozorňují pozorovatele na zadaný kontext synchronizace. (Definováno Pozorovatelné.)
	Aplikace ObserveOn<T>(ovládací prvek)	Přetížený. (Definováno ControlObservable.)
	ObserveOnT(Dispatcher)	Přetížený. (Definováno DispatcherObservable.)
	ObserveOnT(DispatcherScheduler)	Přetížený. (Definováno DispatcherObservable.)
	ObserveOnT(IScheduler)	Přetížený. Asynchronně upozorňují pozorovatele na zadaný plánovač. (Definováno Pozorovatelné.)
	ObserveOnDispatcher<T>	(Definováno DispatcherObservable.)
	OnErrorResumeNext<T>	Pokračuje pozorovatelnou sekvenci, která je ukončena normálně nebo výjimkou s další pozorovatelnou sekvencí. (Definováno Pozorovatelné.)
	publikování<T>()	Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí. (Definováno Pozorovatelné.)
	publikování<T>(T)	Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí a začíná počáteční hodnotou. (Definováno Pozorovatelné.)
	Publikování<T, TResult>(Func<IObservable<T>, IObservable<TResult>>)	Přetížený. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru v připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou sekvencí. (Definováno Pozorovatelné.)
	Publikovat<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, T)	Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí a začíná počáteční hodnotou. (Definováno Pozorovatelné.)
	publishLast<T>()	Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí obsahující pouze poslední oznámení. (Definováno Pozorovatelné.)
	PublishLast<T, TResult>(Func<IObservable<T>, IObservable<TResult>>)	Přetížený. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru v připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou sekvencí obsahující pouze poslední oznámení. (Definováno Pozorovatelné.)
	RefCountTSource	Vrátí pozorovatelnou sekvenci, která zůstane připojená ke zdroji, pokud existuje alespoň jedno předplatné pozorovatelné sekvence. (Definováno Pozorovatelné.)
	opakovat<T>()	Přetížený. Opakuje pozorovatelnou sekvenci po neomezenou dobu. (Definováno Pozorovatelné.)
	opakování<T>(Int32)	Přetížený. Opakuje pozorovatelnou sekvenci po neomezenou dobu. (Definováno Pozorovatelné.)
	přehrání<T>()	Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí, která přehrává všechna oznámení. (Definováno Pozorovatelné.)
	přehrání< T>(TimeSpan)	Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí, která přehrává všechna oznámení v okně. (Definováno Pozorovatelné.)
	přehrání<T>(Int32)	Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí, která přehrává oznámení bufferSize. (Definováno Pozorovatelné.)
	přehráníT(IScheduler)	Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí, která přehrává všechna oznámení. (Definováno Pozorovatelné.)
	přehrání<T>(TimeSpan, IScheduler)	Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí, která přehrává všechna oznámení v okně. (Definováno Pozorovatelné.)
	<T>(Int32, IScheduler)	Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí, která přehrává oznámení bufferSize. (Definováno Pozorovatelné.)
	přehrání<T>(Int32, TimeSpan)	Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí přehrání oznámení bufferSize v okně. (Definováno Pozorovatelné.)
	přehrání<T>(Int32, TimeSpan, IScheduler)	Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí přehrání oznámení bufferSize v okně. (Definováno Pozorovatelné.)
	Přehrávání<T, TResult>(Func<IObservable<T>, IObservable<TResult>>)	Přetížený. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru na připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou sekvencí a začíná počáteční hodnotou. (Definováno Pozorovatelné.)
	Přehrát<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, IScheduler)	Přetížený. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru na připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou sekvencí, která přehrává všechna oznámení. (Definováno Pozorovatelné.)
	Přehrát<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, TimeSpan)	Přetížený. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru na připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou sekvencí, která přehrává všechna oznámení v okně. (Definováno Pozorovatelné.)
	Přehrát<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32)	Přetížený. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru na připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou sekvencí přehrání oznámení bufferSize. (Definováno Pozorovatelné.)
	Přehrát<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, TimeSpan, IScheduler)	Přetížený. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru na připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou sekvencí, která přehrává všechna oznámení v okně. (Definováno Pozorovatelné.)
	Přehrát<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32, IScheduler)	Přetížený. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru na připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou sekvencí přehrání oznámení bufferSize. (Definováno Pozorovatelné.)
	Přehrát<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32, TimeSpan)	Přetížený. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru v připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou sekvencí přehrání oznámení bufferSize v okně. (Definováno Pozorovatelné.)
	Přehrát<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32, TimeSpan, IScheduler)	Přetížený. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru v připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou sekvencí přehrání oznámení bufferSize v okně. (Definováno Pozorovatelné.)
	opakování<<T>()	Přetížený. Opakuje pozorovatelnou sekvenci zdroje, dokud se úspěšně neukončila. (Definováno Pozorovatelné.)
	opakování<T>(Int32)	Přetížený. Opakuje pozorovatelnou sekvenci zdroje, dokud se úspěšně neukončila. (Definováno Pozorovatelné.)
	ukázka<T>(TimeSpan)	Přetížený. Vzorkuje pozorovatelnou sekvenci v každém intervalu. (Definováno Pozorovatelné.)
	ukázky<T>(TimeSpan, IScheduler)	Přetížený. Vzorkuje pozorovatelnou sekvenci v každém intervalu pomocí zadaného zdroje, intervalu a plánovače. (Definováno Pozorovatelné.)
	<T, TSample>(IObservable<TSample>)	Přetížený. Vzorkuje pozorovatelnou sekvenci při vzorkování pomocí zadaného zdroje a vzorkovače. (Definováno Pozorovatelné.)
	skenováníT(funcT, T, T)	Přetížený. Použije funkci akumulátoru na pozorovatelnou sekvenci a vrátí každý zprostředkující výsledek se zadaným zdrojem a akumulátorem. (Definováno Pozorovatelné.)
	skenování<T, TAccumulate>(TAccumulate, Func<TAccumulate, T, TAccumulate>)	Přetížený. Použije funkci akumulátoru na pozorovatelnou sekvenci a vrátí každý zprostředkující výsledek se zadaným zdrojem, semenem a akumulátorem. (Definováno Pozorovatelné.)
	<T, TResult>(Func<T, TResult>)	Přetížený. Prodá každý prvek pozorovatelné sekvence do nového formuláře se zadaným zdrojem a selektorem. (Definováno Pozorovatelné.)
	Vyberte<T, TResult>(Func<T, Int32, TResult>)	Přetížený. Prodá každý prvek pozorovatelné sekvence do nového formuláře zahrnutím indexu prvku se zadaným zdrojem a selektorem. (Definováno Pozorovatelné.)
	SelectMany<T, TOther>(IObservable<TOther>)	Přetížený. Prodá každý prvek pozorovatelné sekvence do pozorovatelné sekvence a zploštějí výsledné pozorovatelné sekvence do jedné pozorovatelné sekvence. (Definováno Pozorovatelné.)
	SelectMany<T, TResult>(Func<T, IObservable<TResult>>)	Přetížený. Prodá každý prvek pozorovatelné sekvence do pozorovatelné sekvence a zploštějí výsledné pozorovatelné sekvence do jedné pozorovatelné sekvence. (Definováno Pozorovatelné.)
	SelectMany<T, TResult>(Func<T, IEnumerable<TResult>>)	Přetížený. Prodá každý prvek pozorovatelné sekvence do pozorovatelné sekvence a zploštějí výsledné pozorovatelné sekvence do jedné pozorovatelné sekvence. (Definováno Pozorovatelné.)
	SelectMany<T, TResult>(Func<T, IObservable<TResult>>, Func<Exception, IObservable<TResult>>, Func<IObservable<TResult>>)	Přetížený. Prodá každý prvek pozorovatelné sekvence do pozorovatelné sekvence a zploštějí výsledné pozorovatelné sekvence do jedné pozorovatelné sekvence. (Definováno Pozorovatelné.)
	SelectMany<T, TCollection, TResult>(Func<T, IEnumerable<TCollection>>, Func<T, TCollection, TResult>)	Přetížený. Prodá každý prvek pozorovatelné sekvence do pozorovatelné sekvence a zploštějí výsledné pozorovatelné sekvence do jedné pozorovatelné sekvence. (Definováno Pozorovatelné.)
	SelectMany<T, TCollection, TResult>(Func<T, IObservable<TCollection>>, Func<T, TCollection, TResult>)	Přetížený. Prodá každý prvek pozorovatelné sekvence do pozorovatelné sekvence a zploštějí výsledné pozorovatelné sekvence do jedné pozorovatelné sekvence. (Definováno Pozorovatelné.)
	SequenceEqual<T>(<T>)	Přetížený. Určuje, zda jsou dvě sekvence stejné porovnáním prvků spárováním. (Definováno Pozorovatelné.)
	SequenceEqual<T>(IObservable<T>, IEqualityComparer<T>)	Přetížený. Určuje, zda jsou dvě sekvence stejné porovnáním prvků ve dvojici pomocí zadaného porovnávače rovnosti. (Definováno Pozorovatelné.)
	TT	Přetížený. Vrátí jediný prvek pozorovatelné sekvence a vyvolá výjimku, pokud v pozorovatelné sekvenci není právě jeden prvek. (Definováno Pozorovatelné.)
	T(FuncT, Boolean)	Přetížený. Vrátí jediný prvek pozorovatelné sekvence, která odpovídá predikátu a vyvolá výjimku, pokud v pozorovatelné sekvenci není právě jeden prvek. (Definováno Pozorovatelné.)
	SingleOrDefaultT()	Přetížený. Vrátí jediný prvek pozorovatelné sekvence nebo výchozí hodnotu, pokud je pozorovatelná sekvence prázdná. (Definováno Pozorovatelné.)
	SingleOrDefault<T>(Func<T, Boolean>)	Přetížený. Vrátí jediný prvek pozorovatelné sekvence, která odpovídá predikátu, nebo výchozí hodnotu, pokud nebyla nalezena žádná hodnota. (Definováno Pozorovatelné.)
	přeskočit<T>	Obchází zadaný počet hodnot v pozorovatelné sekvenci a vrátí zbývající hodnoty. (Definováno Pozorovatelné.)
	SkipLast<T>	Obchází zadaný počet prvků na konci pozorovatelné sekvence. (Definováno Pozorovatelné.)
	SkipUntil<T, TOther>	Vrátí hodnoty ze zdrojové pozorovatelné sekvence až poté, co druhá pozorovatelná sekvence vytvoří hodnotu. (Definováno Pozorovatelné.)
	SkipWhile<T>(Func<T, Boolean>)	Přetížený. Obchází hodnoty v pozorovatelné sekvenci, pokud je zadaná podmínka pravdivá a vrátí zbývající hodnoty. (Definováno Pozorovatelné.)
	SkipWhile<T>(Func<T, Int32, Boolean>)	Přetížený. Obchází hodnoty v pozorovatelné sekvenci, pokud je zadaná podmínka pravdivá a vrátí zbývající hodnoty. (Definováno Pozorovatelné.)
	StartWith<T>T[])	Přetížený. Předzálohuje posloupnost hodnot na pozorovatelnou sekvenci se zadaným zdrojem a hodnotami. (Definováno Pozorovatelné.)
	StartWith<T>(IScheduler, T[])	Přetížený. Předpendí posloupnost hodnot do pozorovatelné sekvence se zadaným zdrojem, plánovačem a hodnotami. (Definováno Pozorovatelné.)
	přihlásit k odběru<T>()	Přetížený. Vyhodnotí pozorovatelnou sekvenci se zadaným zdrojem. (Definováno ObservableExtensions.)
	přihlásit k odběru<T>(akce<T>)	Přetížený. Přihlásí obslužnou rutinu elementu k pozorovatelné sekvenci. (Definováno ObservableExtensions.)
	přihlásit k odběru<T>(akce<T>, výjimka<akce>)	Přetížený. Přihlásí obslužnou rutinu elementu a obslužnou rutinu výjimky k pozorovatelné sekvenci. (Definováno ObservableExtensions.)
	přihlásit k odběru<T>(akce<T>, akce)	Přetížený. Přihlásí obslužnou rutinu elementu a obslužnou rutinu dokončení k pozorovatelné sekvenci. (Definováno ObservableExtensions.)
	přihlásit k odběru<T>(akce<T>,<výjimka>akce, akce)	Přetížený. Přihlásí obslužnou rutinu elementu, obslužnou rutinu výjimky a obslužnou rutinu dokončení k pozorovatelné sekvenci. (Definováno ObservableExtensions.)
	SubscribeOnT(SynchronizationContext)	Přetížený. Asynchronně odebírá a odebírá pozorovatele v zadaném kontextu synchronizace. (Definováno Pozorovatelné.)
	přihlásit k odběru< T>(ovládací prvek)	Přetížený. (Definováno ControlObservable.)
	přihlásit k odběru<T>(Dispatcher)	Přetížený. (Definováno DispatcherObservable.)
	přihlášení k odběru<T>(DispatcherScheduler)	Přetížený. (Definováno DispatcherObservable.)
	přihlásit k odběru<T>(IScheduler)	Přetížený. Asynchronně odebírá a odebírá pozorovatele v zadaném plánovači. (Definováno Pozorovatelné.)
	SubscribeOnDispatcher<T>	(Definováno DispatcherObservable.)
	synchronizace <T>()	Přetížený. Synchronizuje pozorovatelnou sekvenci. (Definováno Pozorovatelné.)
	synchronizovat<T>(objektu)	Přetížený. Synchronizuje pozorovatelnou sekvenci. (Definováno Pozorovatelné.)
	vezměte<T>	Vrátí zadaný počet souvislých hodnot od začátku pozorovatelné sekvence. (Definováno Pozorovatelné.)
	TakeLast<T>	Vrátí zadaný počet souvislých prvků od konce pozorovatelné sekvence. (Definováno Pozorovatelné.)
	TakeUntil<T, TOther>	Vrátí hodnoty ze zdrojové pozorovatelné sekvence, dokud druhá pozorovatelná sekvence nevytvoří hodnotu. (Definováno Pozorovatelné.)
	<T>(Func<T, Boolean>)	Přetížený. Vrátí hodnoty z pozorovatelné sekvence, pokud je zadaná podmínka pravdivá a zbývající hodnoty přeskočí. (Definováno Pozorovatelné.)
	<T>(Func<T, Int32, Boolean>)	Přetížený. Vrátí hodnoty z pozorovatelné sekvence, pokud je zadaná podmínka pravdivá a zbývající hodnoty přeskočí. (Definováno Pozorovatelné.)
	pak<T, TResult>	Porovná, když pozorovatelná posloupnost má dostupnou hodnotu a projektuje hodnotu. (Definováno Pozorovatelné.)
	omezování<T>(TimeSpan)	Přetížený. Přeskočí hodnoty z pozorovatelné sekvence, za kterou následuje jiná hodnota před časem splnění se zadaným zdrojem a časem dueTime. (Definováno Pozorovatelné.)
	omezení<T>(TimeSpan, IScheduler)	Přetížený. Přeskočí hodnoty z pozorovatelné sekvence, za kterou následuje jiná hodnota před časem splnění se zadaným zdrojem, dueTime a plánovačem. (Definováno Pozorovatelné.)
	TimeIntervalT()	Přetížený. Zaznamenává časový interval mezi po sobě jdoucími hodnotami v pozorovatelné sekvenci se zadaným zdrojem. (Definováno Pozorovatelné.)
	TimeIntervalT(IScheduler)	Přetížený. Zaznamenává časový interval mezi po sobě jdoucími hodnotami v pozorovatelné sekvenci se zadaným zdrojem a plánovačem. (Definováno Pozorovatelné.)
	vypršení časového limitu<T>(TimeSpan)	Přetížený. Vrátí pozorovatelnou sekvenci nebo výjimku TimeoutException, pokud vyprší dueTime. (Definováno Pozorovatelné.)
	vypršení časového limitu<T>(DateTimeOffset)	Přetížený. Vrátí pozorovatelnou sekvenci nebo hodnotu TimeoutException, pokud vyprší dueTime. (Definováno Pozorovatelné.)
	časový limit<T>(TimeSpan, IObservable<T>)	Přetížený. Vrátí pozorovatelnou sekvenci zdroje nebo jinou pozorovatelnou sekvenci, pokud dueTime uplynou. (Definováno Pozorovatelné.)
	vypršení časového limitu<T>(DateTimeOffset, IObservable<T>)	Přetížený. Vrátí pozorovatelnou sekvenci nebo výjimku TimeoutException, pokud vyprší dueTime. (Definováno Pozorovatelné.)
	vypršení časového limitu<T>(TimeSpan, IScheduler)	Přetížený. Vrátí pozorovatelnou sekvenci nebo výjimku TimeoutException, pokud vyprší dueTime. (Definováno Pozorovatelné.)
	vypršení časového limitu<T>(DateTimeOffset, IScheduler)	Přetížený. Vrátí pozorovatelnou sekvenci nebo výjimku TimeoutException, pokud vyprší dueTime. (Definováno Pozorovatelné.)
	časový limit<T>(TimeSpan, IObservable<T>, IScheduler)	Přetížený. Vrátí pozorovatelnou sekvenci zdroje nebo jinou pozorovatelnou sekvenci, pokud dueTime uplynou. (Definováno Pozorovatelné.)
	časový limit<T>(DateTimeOffset, IObservable<T>, IScheduler)	Přetížený. Vrátí pozorovatelnou sekvenci zdroje nebo jinou pozorovatelnou sekvenci, pokud dueTime uplynou. (Definováno Pozorovatelné.)
	časové razítko<T>()	Přetížený. Zaznamenává časové razítko pro každou hodnotu v pozorovatelné sekvenci se zadaným zdrojem. (Definováno Pozorovatelné.)
	časové razítkoT(IScheduler)	Přetížený. Zaznamenává časové razítko pro každou hodnotu v pozorovatelné sekvenci se zadaným zdrojem a plánovačem. (Definováno Pozorovatelné.)
	ToArray<T>	Vytvoří pole z pozorovatelné sekvence. (Definováno Pozorovatelné.)
	ToDictionary<T, TKey>(Func<T, TKey>)	Přetížený. Vytvoří slovník z pozorovatelné sekvence podle zadané funkce selektoru kláves. (Definováno Pozorovatelné.)
	ToDictionary<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	Přetížený. Vytvoří slovník z pozorovatelné sekvence podle zadané funkce selektoru klíčů a porovnávače. (Definováno Pozorovatelné.)
	ToDictionary<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>)	Přetížený. Vytvoří slovník z pozorovatelné sekvence podle zadané funkce selektoru kláves a funkce selektoru prvku. (Definováno Pozorovatelné.)
	ToDictionary<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>)	Přetížený. Vytvoří slovník z pozorovatelné sekvence podle zadané funkce selektoru klíče, porovnávače a funkce selektoru prvku. (Definováno Pozorovatelné.)
	ToEnumerable<T>	Převede pozorovatelnou sekvenci na výčet. (Definováno Pozorovatelné.)
	ToEvent<T>	Zveřejňuje pozorovatelnou sekvenci jako objekt s událostí .NET se zadaným zdrojem. (Definováno Pozorovatelné.)
	toList<T>	Vytvoří seznam z pozorovatelné sekvence. (Definováno Pozorovatelné.)
	ToLookup<T, TKey>(Func<T, TKey>)	Přetížený. Vytvoří vyhledávání z pozorovatelné sekvence podle zadané funkce selektoru kláves. (Definováno Pozorovatelné.)
	ToLookup<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	Přetížený. Vytvoří vyhledávání z pozorovatelné sekvence podle zadané funkce selektoru klíče a porovnávače. (Definováno Pozorovatelné.)
	ToLookup<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>)	Přetížený. Vytvoří vyhledávání z pozorovatelné sekvence podle zadané funkce selektoru kláves a funkce selektoru prvku. (Definováno Pozorovatelné.)
	ToLookup<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>)	Přetížený. Vytvoří vyhledávání z pozorovatelné sekvence podle zadané funkce selektoru klíče, porovnávače a funkce selektoru prvků. (Definováno Pozorovatelné.)
	totask<T>()	Přetížený. Vrátí úlohu, která obsahuje poslední hodnotu pozorovatelného pořadí. (Definované TaskObservableExtensions.)
	toTask<T>(object)	Přetížený. Vrátí úlohu, která obsahuje poslední hodnotu pozorovatelného pořadí. (Definované TaskObservableExtensions.)
	< <T>totask (CancellationToken)	Přetížený. Vrátí úlohu, která obsahuje poslední hodnotu pozorovatelného pořadí. (Definované TaskObservableExtensions.)
	ToTaskT(CancellationToken, Object)	Přetížený. Vrátí úlohu, která obsahuje poslední hodnotu pozorovatelného pořadí. (Definované TaskObservableExtensions.)
	<T>(Func<T, Boolean>)	Přetížený. Filtruje prvky pozorovatelné sekvence na základě predikátu. (Definováno Pozorovatelné.)
	kde<T>(func<T, Int32, boolean>)	Přetížený. Filtruje prvky pozorovatelné sekvence na základě predikátu zahrnutím indexu prvku. (Definováno Pozorovatelné.)
	okno<T>(Int32)	Přetížený. Prodá každý prvek pozorovatelné sekvence do po sobě jdoucích nepřekrývajících se oken, které jsou vytvářeny na základě informací o počtu prvků. (Definováno Pozorovatelné.)
	okna<T>(TimeSpan)	Přetížený. Prodá jednotlivé prvky pozorovatelné sekvence do po sobě jdoucích nepřekrývajících se oken vytvořených na základě informací o časování. (Definováno Pozorovatelné.)
	okno<T>(Int32, Int32)	Přetížený. Prodá každý prvek pozorovatelné sekvence do nuly nebo více oken vytvořených na základě informací o počtu prvků. (Definováno Pozorovatelné.)
	OknaT(TimeSpan, IScheduler)	Přetížený. Prodá jednotlivé prvky pozorovatelné sekvence do po sobě jdoucích nepřekrývajících se oken vytvořených na základě informací o časování. (Definováno Pozorovatelné.)
	oknaT(TimeSpan, TimeSpan)	Přetížený. Prodá každý prvek pozorovatelné sekvence do nuly nebo více oken vytvořených na základě informací o časování. (Definováno Pozorovatelné.)
	okno<T>(TimeSpan, Int32)	Přetížený. Prodá každý prvek pozorovatelné sekvence do okna, které je dokončeno, když je plný nebo uplynula daná doba. (Definováno Pozorovatelné.)
	WindowT(TimeSpan, TimeSpan, IScheduler)	Přetížený. Prodá každý prvek pozorovatelné sekvence do nuly nebo více oken vytvořených na základě informací o časování. (Definováno Pozorovatelné.)
	<okna<T>(TimeSpan, Int32, IScheduler)	Přetížený. Prodá každý prvek pozorovatelné sekvence do okna, které je dokončeno, když je plný nebo uplynula daná doba. (Definováno Pozorovatelné.)
	Okna<T, TWindowClosing>(Func<IObservable<TWindowClosing>>)	Přetížený. Prodá jednotlivé prvky pozorovatelné sekvence do po sobě jdoucích nepřekrývajících se oken. (Definováno Pozorovatelné.)
	Window<T, TWindowOpening, TWindowClosing>(IObservable<TWindowOpening>, Func<TWindowOpening, IObservable<TWindowClosing>>)	Přetížený. Prodá každý prvek pozorovatelné sekvence do nuly nebo více oken. (Definováno Pozorovatelné.)
	Zip<T, TSecond, TResult>(IObservable<TSecond>, Func<T, TSecond, TResult>)	Přetížený. Sloučí dvě pozorovatelné sekvence do jedné pozorovatelné sekvence tím, že zkombinuje jejich prvky spárováním. (Definováno Pozorovatelné.)
	Zip<T, TSecond, TResult>(IEnumerable<TSecond>, Func<T, TSecond, TResult>)	Přetížený. Sloučí pozorovatelnou sekvenci a výčet do jedné pozorovatelné sekvence pomocí funkce selektoru. (Definováno Pozorovatelné.)

Vrchol

Poznámky

Studená pozorovatelná data začínají běžet při odběru, tj. pozorovatelná posloupnost začne tlačit hodnoty pozorovatelům pouze při zavolání odběru. Hodnoty se také nesdílejí mezi předplatiteli. To se liší od horkých pozorovatelných událostí, jako jsou události přesunutí myši nebo burzovní tickery, které už vytvářejí hodnoty ještě před tím, než je předplatné aktivní. Když se pozorovatel přihlásí k odběru horké pozorovatelné sekvence, získá aktuální hodnotu ve streamu. Horká pozorovatelná posloupnost je sdílena mezi všemi odběrateli a každý odběratel je vložen další hodnotu v sekvenci. Například i když se nikdo nezaplatil k odběru určitého burzovního tickeru, bude ticker nadále aktualizovat svou hodnotu na základě tržního pohybu. Když předplatitel zaregistruje zájem o tento ticker, automaticky získá nejnovější tick.

Příklady

V následujícím příkladu převedeme studený pozorovatelný sekvenční zdroj na horkou pomocí operátoru Publish, který vrátí IConnectableObservable<T> instanci, kterou pojmenujeme horkou. Operátor publikování poskytuje mechanismus sdílení předplatných vysíláním jednoho předplatného více odběratelům. Hot funguje jako proxy server a přihlásí se k odběru zdroje, pak když přijímá hodnoty ze zdroje, nasdílí je svým vlastním odběratelům. K vytvoření předplatného záložního zdroje a zahájení příjmu hodnot používáme metodu IConnectableObservable.Connect(). Vzhledem k tomu, IConnectableObservable dědí IObservable, můžeme použít přihlásit k odběru této horké sekvence ještě předtím, než začne běžet. Všimněte si, že v tomto příkladu nebyla spuštěna horká sekvence, když se předplatné 1 přihlásí k odběru. Proto se odběrateli nenasdílí žádná hodnota. Po volání connect se hodnoty pak nasdílí do předplatného 1. Po zpoždění 3 sekund se odběr 2 přihlásí k odběru horké a začne přijímat hodnoty okamžitě od aktuální pozice (v tomto případě 3) až do konce. Výstup vypadá takto:

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();

Viz také

Odkaz

System.Reactive.Subjects – obor názvů

Sdílet prostřednictvím