IConnectableObservable<T> – rozhraní
Představuje pozorovatelné, které lze připojit a odpojit.
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
TypTento parametr typu je kovariantní. To znamená, že můžete použít buď zadaný typ, nebo libovolný typ, který je více odvozený. Další informace o kovarianci a kontravarianci najdete v tématu .
Typ IConnectableObservable<T> zveřejňuje následující členy.
Metody
| Název | Description | |
|---|---|---|
.gif "Veřejná metoda") |
Připojit | Připojí pozorovatelné. |
|
Přihlásit k odběru | (Zděděno z IObservable<T>.) |
Nahoře
Metody rozšíření
| Název | Description | |
|---|---|---|
.gif "Metoda veřejného rozšíření") |
Agregované<T>(Func<T, T, T>) | Přetíženo. Použije funkci akumulátoru na pozorovatelnou sekvenci. (Definováno pozorovatelným.) |
|
Aggregate<T, TAccumulate>(TAccumulate, Func<TAccumulate, T, TAccumulate>) | Přetíženo. Použije funkci akumulátoru na pozorovatelnou sekvenci se zadanou počáteční hodnotou. (Definováno pozorovatelným.) |
|
Vše<T> | Určuje, zda všechny prvky pozorovatelné sekvence splňují podmínku. (Definováno pozorovatelným.) |
|
Amb<T> | Šíří pozorovatelnou sekvenci, která reaguje jako první se zadanou první a druhou sekvencí. (Definováno pozorovatelným.) |
|
A<T, TRight> | Shoduje se v případech, kdy obě pozorovatelné sekvence mají dostupnou hodnotu. (Definováno pozorovatelným.) |
|
Libovolný<T>() | Přetíženo. Určuje, zda pozorovatelná sekvence obsahuje nějaké prvky. (Definováno pozorovatelným.) |
|
Any<T>(Func<T, Boolean>) | Přetíženo. Určuje, zda všechny prvky pozorovatelné sekvence splňují podmínku. (Definováno pozorovatelným.) |
|
AsObservable<T> | Skryje identitu pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
AsQbservable<T> | Převede pozorovatelnou sekvenci na dotazovatelnou pozorovatelnou sekvenci. (Definováno nástrojem Qbservable.) |
|
AssertEqual<T> | (Definováno rozšířeními.) |
|
Vyrovnávací paměť<T>(Int32) | Přetíženo. Označuje každý prvek pozorovatelné sekvence do po sobě jdoucích nepřekrývajících se vyrovnávacích pamětí, které jsou vytvořeny na základě informací o počtu prvků. (Definováno pozorovatelným.) |
|
Vyrovnávací paměť<T>(TimeSpan) | Přetíženo. Označuje každý prvek pozorovatelné sekvence do po sobě jdoucích nepřekrývajících se vyrovnávacích pamětí, které jsou vytvořeny na základě informací o načasování. (Definováno pozorovatelným.) |
|
Vyrovnávací paměť<T>(Int32, Int32) | Přetíženo. 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ým.) |
|
Buffer<T>(TimeSpan, IScheduler) | Přetíženo. Označuje každý prvek pozorovatelné sekvence do po sobě jdoucích nepřekrývajících se vyrovnávacích pamětí, které jsou vytvořeny na základě informací o načasování. (Definováno pozorovatelným.) |
|
Vyrovnávací paměť<T>(TimeSpan, TimeSpan) | Přetíženo. 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ým.) |
|
Vyrovnávací paměť<T>(TimeSpan; Int32) | Přetíženo. Označuje každý prvek pozorovatelné sekvence do vyrovnávací paměti, která je odeslána, když je plná nebo uplynula daná doba. (Definováno pozorovatelným.) |
|
Buffer<T>(TimeSpan; TimeSpan; IScheduler) | Přetíženo. Urč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 časování. (Definováno pozorovatelným.) |
|
Buffer<T>(TimeSpan; Int32; IScheduler) | Přetíženo. Označuje každý prvek pozorovatelné sekvence do vyrovnávací paměti, která je odeslána, když je plná nebo uplynula daná doba. (Definováno pozorovatelným.) |
|
Buffer<T, TBufferClosing>(Func<IObservable<TBufferClosing>>) | Přetíženo. 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ým.) |
|
Buffer<T, TBufferOpening, TBufferClosing>(IObservable<TBufferOpening>, Func<TBufferOpening, IObservable<TBufferClosing>>) | Přetíženo. 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ým.) |
|
Catch<T>(IObservable<T>) | Přetíženo. Pokračuje v pozorovatelné sekvenci, která je ukončena výjimkou, s další pozorovatelnou sekvencí. (Definováno pozorovatelným.) |
|
Catch<T, TException>(Func<TException, IObservable<T>>) | Přetíženo. Pokračuje v pozorovatelné sekvenci, která je ukončena výjimkou zadaného typu s pozorovatelnou sekvencí vytvořenou obslužnou rutinou. (Definováno pozorovatelným.) |
|
CombineLatest<T, TSecond, TResult> | Sloučí dvě pozorovatelné sekvence do jedné pozorovatelné sekvence pomocí funkce selektoru vždy, když jedna z pozorovatelných sekvencí vytvoří prvek. (Definováno pozorovatelným.) |
|
Concat<T> | Zřetězí dvě pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
Obsahuje<T>(T) | Přetíženo. Určuje, zda pozorovatelná sekvence obsahuje zadaný prvek pomocí výchozího porovnávače rovnosti. (Definováno pozorovatelným.) |
|
Obsahuje<T>(T, IEqualityComparer<T>). | Přetíženo. Určuje, zda pozorovatelná sekvence obsahuje zadaný prvek pomocí zadané System.Collections.Generic.IEqualityComparer< T>. (Definováno pozorovatelným.) |
|
Počet<T> | Vrátí hodnotu Int32 , která představuje celkový počet prvků v pozorovatelné sekvenci. (Definováno pozorovatelným.) |
|
DefaultIfEmpty<T>() | Přetíženo. Vrátí prvky zadané sekvence nebo výchozí hodnotu parametru typu v jednoúčelové sekvenci, pokud je posloupnost prázdná. (Definováno pozorovatelným.) |
|
DefaultIfEmpty<T>(T) | Přetíženo. Vrátí prvky zadané sekvence nebo výchozí hodnotu parametru typu v jednoúčelové sekvenci, pokud je posloupnost prázdná. (Definováno pozorovatelným.) |
|
Delay<T>(TimeSpan) | Přetíženo. Určuje pozorovatelnou sekvenci podle času splnění se zadaným zdrojem a časem dueTime. (Definováno pozorovatelným.) |
|
Delay<T>(DateTimeOffset) | Přetíženo. Určuje pozorovatelnou sekvenci podle času splnění se zadaným zdrojem a časem dueTime. (Definováno pozorovatelným.) |
|
Delay<T>(TimeSpan, IScheduler) | Přetíženo. Určuje pozorovatelnou sekvenci podle času splnění se zadaným zdrojem, dueTime a plánovačem. (Definováno pozorovatelným.) |
|
Delay<T>(DateTimeOffset, IScheduler) | Přetíženo. Určuje pozorovatelnou sekvenci podle času splnění se zadaným zdrojem, dueTime a plánovačem. (Definováno pozorovatelným.) |
|
Distinct<T>() | Přetíženo. Vrátí pozorovatelnou sekvenci, která obsahuje pouze jedinečné prvky se zadaným zdrojem. (Definováno pozorovatelným.) |
|
Distinct<T>(IEqualityComparer<T>) | Přetíženo. Vrátí pozorovatelnou sekvenci, která obsahuje pouze jedinečné prvky podle porovnávače. (Definováno pozorovatelným.) |
|
Distinct<T, TKey>(Func<T, TKey>) | Přetíženo. Vrátí pozorovatelnou sekvenci, která obsahuje pouze jedinečné prvky podle keySelector. (Definováno pozorovatelným.) |
|
Distinct<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>) | Přetíženo. Vrátí pozorovatelnou sekvenci, která obsahuje pouze jedinečné prvky podle keySelector. (Definováno pozorovatelným.) |
|
DistinctUntilChanged<T>() | Přetíženo. Vrátí pozorovatelnou sekvenci, která obsahuje pouze jedinečné souvislé prvky se zadaným zdrojem. (Definováno pozorovatelným.) |
|
DistinctUntilChanged<T>(IEqualityComparer<T>) | Přetíženo. Vrátí pozorovatelnou sekvenci, která obsahuje pouze odlišné souvislé prvky podle porovnávače. (Definováno pozorovatelným.) |
|
DistinctUntilChanged<T, TKey>(Func<T, TKey>) | Přetíženo. Vrátí pozorovatelnou sekvenci, která obsahuje pouze odlišné souvislé prvky podle keySelector. (Definováno pozorovatelným.) |
|
DistinctUntilChanged<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>) | Přetíženo. Vrátí pozorovatelnou sekvenci, která obsahuje pouze odlišné souvislé prvky podle keySelector a porovnávače. (Definováno pozorovatelným.) |
|
Do<T>(Akce<T>) | Přetíženo. Vyvolá akci pro každý prvek v pozorovatelné sekvenci. (Definováno pozorovatelným.) |
|
Do<T>(IObserver<T>) | Přetíženo. 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ým.) |
|
Do<T>(Akce<T>, Akce) | Přetíženo. Vyvolá akci pro každý prvek v pozorovatelné sekvenci a vyvolá akci při řádném ukončení pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
Do<T>(Akce<T>, Výjimka> akce<) | Přetíženo. 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ým.) |
|
Do<T>(Akce<T>, Výjimka> akce<, Akce) | Přetíženo. Vyvolá akci pro každý prvek v pozorovatelné sekvenci a vyvolá akci při řádném nebo výjimečném ukončení pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
ElementAt<T> | Vrátí prvek v zadaném indexu v sekvenci. (Definováno pozorovatelným.) |
|
ElementAtOrDefault<T> | Vrátí prvek v zadaném indexu v sekvenci nebo výchozí hodnotu, pokud je index mimo rozsah. (Definováno pozorovatelným.) |
|
Konečně<T> | Vyvolá zadanou akci poté, co zdroj pozorovatelná sekvence ukončí normálně nebo výjimkou. (Definováno pozorovatelným.) |
|
První<T>() | Přetíženo. Vrátí první prvek pozorovatelné sekvence se zadaným zdrojem. (Definováno pozorovatelným.) |
|
First<T>(Func<T, Boolean>) | Přetíženo. Vrátí první prvek pozorovatelné sekvence, která odpovídá predikátu. (Definováno pozorovatelným.) |
|
FirstOrDefault<T>() | Přetíženo. Vrátí první prvek pozorovatelné sekvence nebo výchozí hodnotu, pokud není nalezena žádná hodnota. (Definováno pozorovatelným.) |
|
FirstOrDefault<T>(Func<T, Boolean>) | Přetíženo. Vrátí první prvek pozorovatelné sekvence, která odpovídá predikátu, nebo výchozí hodnotu, pokud není nalezena žádná hodnota. (Definováno pozorovatelným.) |
|
Foo<T, R> | (Definuje ho MyExt.) |
|
ForEach<T> | Vyvolá akci pro každý prvek v pozorovatelné sekvenci a blokuje, dokud sekvence není ukončena. (Definováno pozorovatelným.) |
|
GetEnumerator<T> | Vrátí enumerátor, který vytvoří výčet všech hodnot pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
GroupBy<T, TKey>(Func<T, TKey>) | Přetíženo. Seskupí prvky pozorovatelné sekvence podle zadané funkce selektoru klíčů. (Definováno pozorovatelným.) |
|
GroupBy<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>) | Přetíženo. Seskupí prvky pozorovatelné sekvence podle zadané funkce selektoru klíčů a porovnávače. (Definováno pozorovatelným.) |
|
GroupBy<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>) | Přetíženo. Seskupí prvky pozorovatelné sekvence a vybere výsledné prvky pomocí zadané funkce. (Definováno pozorovatelným.) |
|
GroupBy<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>) | Přetíženo. Seskupí prvky pozorovatelné sekvence podle zadané funkce selektoru klíčů a porovnávače a vybere výsledné prvky pomocí zadané funkce. (Definováno pozorovatelným.) |
|
GroupByUntil<T, TKey, TDuration>(Func<T, TKey>, Func<IGroupedObservable<TKey, T>, IObservable<TDuration>>) | Přetíženo. Seskupí prvky pozorovatelné sekvence podle zadané funkce voliče klíčů. (Definováno pozorovatelným.) |
|
GroupByUntil<T, TKey, TDuration>(Func<T, TKey>, Func<IGroupedObservable<TKey, T>, IObservable<TDuration>>, IEqualityComparer<TKey>) | Přetíženo. Seskupí prvky pozorovatelné sekvence podle zadané funkce selektoru klíčů a porovnávače. (Definováno pozorovatelným.) |
|
GroupByUntil<T, TKey, TElement, TDuration>(Func<T, TKey>, Func<T, TElement>, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>) | Přetíženo. Seskupí prvky pozorovatelné sekvence podle zadané funkce výběru klíčů a vybere výsledné prvky pomocí zadané funkce. (Definováno pozorovatelným.) |
|
GroupByUntil<T, TKey, TElement, TDuration>(Func<T, TKey>, Func<T, TElement>, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>, IEqualityComparer<TKey>) | Přetíženo. Seskupí prvky pozorovatelné sekvence podle zadané funkce selektoru klíčů a porovnávače a vybere výsledné prvky pomocí zadané funkce. (Definováno pozorovatelným.) |
|
GroupJoin<T, TRight, TLeftDuration, TRightDuration, TResult> | Koreluje prvky dvou sekvencí na základě překrývajících se trvání a seskupuje výsledky. (Definováno pozorovatelným.) |
|
IgnoreElements<T> | Ignoruje všechny hodnoty v pozorovatelné sekvenci a ponechá pouze zprávy ukončení. (Definováno pozorovatelným.) |
|
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ým.) |
|
Poslední<T>() | Přetíženo. Vrátí poslední prvek pozorovatelné sekvence se zadaným zdrojem. (Definováno pozorovatelným.) |
|
Last<T>(Func<T, Boolean>) | Přetíženo. Vrátí poslední prvek pozorovatelné sekvence, která odpovídá predikátu. (Definováno pozorovatelným.) |
|
LastOrDefault<T>() | Přetíženo. Vrátí poslední prvek v pozorovatelné sekvenci nebo výchozí hodnotu, pokud není nalezena žádná hodnota. (Definováno pozorovatelným.) |
|
LastOrDefault<T>(Func<T, Logická hodnota>) | Přetíženo. Vrátí poslední prvek pozorovatelné sekvence, která odpovídá predikátu, nebo výchozí hodnotu, pokud není nalezena žádná hodnota. (Definováno pozorovatelným.) |
|
Nejnovější<T> | Vzorkuje nejnovější hodnotu v pozorovatelné sekvenci. (Definováno pozorovatelným.) |
|
LongCount<T> | Vrátí hodnotu Int64 , která představuje celkový počet prvků v pozorovatelné sekvenci. (Definováno pozorovatelným.) |
|
Materializace<T> | Materializuje implicitní oznámení pozorovatelné sekvence jako explicitní hodnoty oznámení. (Definováno pozorovatelným.) |
|
Maximální<hodnota T>() | Přetíženo. Vrátí maximální prvek v pozorovatelné sekvenci. (Definováno pozorovatelným.) |
|
Max<T>(IComparer<T>) | Přetíženo. Vrátí maximální hodnotu v pozorovatelné sekvenci podle zadaného porovnávače. (Definováno pozorovatelným.) |
|
MaxBy<T, TKey>(Func<T, TKey>) | Přetíženo. Vrátí prvky v pozorovatelné sekvenci s maximální hodnotou klíče. (Definováno pozorovatelným.) |
|
MaxBy<T, TKey>(Func<T, TKey>, IComparer<TKey>) | Přetíženo. Vrátí prvky v pozorovatelné sekvenci s maximální hodnotou klíče. (Definováno pozorovatelným.) |
|
Sloučení<T>(IObservable<T>) | Přetíženo. Sloučí pozorovatelnou sekvenci pozorovatelných sekvencí do pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
Sloučení<T>(IObservable<T>, IScheduler) | Přetíženo. Sloučí dvě pozorovatelné sekvence do jedné pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
Min T<>() | Přetíženo. Vrátí minimální prvek v pozorovatelné sekvenci. (Definováno pozorovatelným.) |
|
Min<T>(IComparer<T>) | Přetíženo. Vrátí minimální hodnotu v pozorovatelné sekvenci podle zadaného porovnávače. (Definováno pozorovatelným.) |
|
MinBy<T, TKey>(Func<T, TKey>) | Přetíženo. Vrátí prvky v pozorovatelné sekvenci s minimální hodnotou klíče. (Definováno pozorovatelným.) |
|
MinBy<T, TKey>(Func<T, TKey>, IComparer<TKey>) | Přetíženo. Vrátí prvky v pozorovatelné sekvenci s minimální hodnotou klíče podle zadaného porovnávače. (Definováno pozorovatelným.) |
|
MostRecent<T> | Vzorkuje nejnovější hodnotu v pozorovatelné sekvenci. (Definováno pozorovatelným.) |
|
Vícesměrové vysílání<T, TResult>(ISubject<T, TResult>) | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která při připojení způsobí, že zdrojová sekvence odešle výsledky do zadaného předmětu. (Definováno pozorovatelným.) |
|
Vícesměrové vysílání<T, TIntermediate, TResult>(Func<ISubject<T, TIntermediate>>, Func<IObservable<TIntermediate>, IObservable<TResult>>) | Přetíženo. Vrátí pozorovatelnou sekvenci, která obsahuje prvky sekvence vytvořené vícesměrovým vysíláním zdrojové sekvence v rámci selektorové funkce. (Definováno pozorovatelným.) |
|
Další<T> | Vzorkuje další hodnotu (blokující bez ukládání do vyrovnávací paměti) v pozorovatelné sekvenci. (Definováno pozorovatelným.) |
|
ObserveOn<T>(SynchronizationContext) | Přetíženo. Asynchronně upozorňovat pozorovatele na zadaný kontext synchronizace. (Definováno pozorovatelným.) |
|
ObserveOn<T>(Control) | Přetíženo. (Definováno pomocí ControlObservable.) |
|
ObserveOn<T>(Dispatcher) | Přetíženo. (Definováno pomocí DispatcherObservable.) |
|
ObserveOn<T>(DispatcherScheduler) | Přetíženo. (Definováno pomocí DispatcherObservable.) |
|
ObserveOn<T>(IScheduler) | Přetíženo. Asynchronně upozorňovat pozorovatele v zadaném plánovači. (Definováno pozorovatelným.) |
|
ObserveOnDispatcher<T> | (Definováno pomocí DispatcherObservable.) |
|
OnErrorResumeNext<T> | Pokračuje v pozorovatelné sekvenci, která je ukončena normálně nebo výjimkou s další pozorovatelnou sekvencí. (Definováno pozorovatelným.) |
|
Publikovat<T>() | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí. (Definováno pozorovatelným.) |
|
Publikovat<T>(T) | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí a začíná na initialValue. (Definováno pozorovatelným.) |
|
Publish<T, TResult>(Func<IObservable<T>, IObservable<TResult>>) | Přetíženo. 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í. (Definováno pozorovatelným.) |
|
Publish<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, T) | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí a začíná na initialValue. (Definováno pozorovatelným.) |
|
PublishLast<T>() | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí obsahující pouze poslední oznámení. (Definováno pozorovatelným.) |
|
PublishLast<T, TResult>(Func<IObservable<T>, IObservable<TResult>>) | Přetíženo. 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í obsahující pouze poslední oznámení. (Definováno pozorovatelným.) |
|
RefCount<TSource> | Vrátí pozorovatelnou sekvenci, která zůstává připojená ke zdroji, pokud existuje alespoň jedno předplatné pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
Opakovat<T>() | Přetíženo. Opakuje pozorovatelnou sekvenci po neomezenou dobu. (Definováno pozorovatelným.) |
|
Opakovat<T>(Int32) | Přetíženo. Opakuje pozorovatelnou sekvenci po neomezenou dobu. (Definováno pozorovatelným.) |
|
Přehrání<T>() | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí přehrávání všech oznámení. (Definováno pozorovatelným.) |
|
Přehrání<T>(TimeSpan) | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou posloupností, která přehrává všechna oznámení v okně. (Definováno pozorovatelným.) |
|
Přehrání<T>(Int32) | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou vyrovnávací pamětí přehrávání sekvence Oznámení velikosti. (Definováno pozorovatelným.) |
|
Přehrání<T>(IScheduler) | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí přehrávání všech oznámení. (Definováno pozorovatelným.) |
|
Replay<T>(TimeSpan, IScheduler) | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou posloupností, která přehrává všechna oznámení v okně. (Definováno pozorovatelným.) |
|
Replay<T>(Int32, IScheduler) | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou vyrovnávací pamětí přehrávání sekvence Oznámení velikosti. (Definováno pozorovatelným.) |
|
Přehrání<T>(Int32, TimeSpan) | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou vyrovnávací pamětí přehrání sekvence Oznámení velikosti v okně. (Definováno pozorovatelným.) |
|
Přehrání<T>(Int32, TimeSpan, IScheduler) | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou vyrovnávací pamětí přehrání sekvence Oznámení velikosti v okně. (Definováno pozorovatelným.) |
|
Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>) | Přetíženo. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru na připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné podkladové sekvence a začíná počáteční hodnotou. (Definováno pozorovatelným.) |
|
Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, IScheduler) | Přetíženo. 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ým.) |
|
Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, TimeSpan) | Přetíženo. 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ým.) |
|
Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32) | Přetíženo. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru na připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou sekvenční vyrovnávací pamětí přehráníSize. (Definováno pozorovatelným.) |
|
Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, TimeSpan, IScheduler) | Přetíženo. 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ým.) |
|
Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32, IScheduler) | Přetíženo. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru na připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou sekvenční vyrovnávací pamětí přehráníSize. (Definováno pozorovatelným.) |
|
Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32, TimeSpan) | Přetíženo. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru na připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou vyrovnávací pamětí přehrání sekvenceSize oznámení v okně. (Definováno pozorovatelným.) |
|
Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32, TimeSpan, IScheduler) | Přetíženo. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru na připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou vyrovnávací pamětí přehrání sekvenceSize oznámení v okně. (Definováno pozorovatelným.) |
|
Zopakujte<T>() | Přetíženo. Opakuje zdroj pozorovatelné sekvence, dokud se úspěšně neskončila. (Definováno pozorovatelným.) |
|
Opakovat<T>(Int32) | Přetíženo. Opakuje zdroj pozorovatelné sekvence, dokud se úspěšně neskončila. (Definováno pozorovatelným.) |
|
Ukázka<T>(TimeSpan) | Přetíženo. Vzorkuje pozorovatelnou sekvenci v každém intervalu. (Definováno pozorovatelným.) |
|
Ukázka<T>(TimeSpan, IScheduler) | Přetíženo. Vzorkuje pozorovatelnou sekvenci v každém intervalu se zadaným zdrojem, intervalem a plánovačem. (Definováno pozorovatelným.) |
|
Ukázka<T, TSample>(IObservable<TSample>) | Přetíženo. Vzorkuje pozorovatelnou sekvenci při vzorkování pomocí zadaného zdroje a vzorkovače. (Definováno pozorovatelným.) |
|
Skenování<T>(Func<T, T, T>) | Přetíženo. Použije funkci akumulátoru na pozorovatelnou sekvenci a vrátí každý průběžný výsledek se zadaným zdrojem a akumulátorem. (Definováno pozorovatelným.) |
|
Skenování<T, TAccumulate>(TAccumulate, Func<TAccumulate, T, TAccumulate>) | Přetíženo. Použije funkci akumulátoru na pozorovatelnou sekvenci a vrátí každý mezivýsledek se zadaným zdrojem, semenem a akumulátorem. (Definováno pozorovatelným.) |
|
Vyberte<T, TResult>(Func<T, TResult>) | Přetíženo. Promítne každý prvek pozorovatelné sekvence do nové podoby se zadaným zdrojem a selektorem. (Definováno pozorovatelným.) |
|
Select<T, TResult>(Func<T; Int32; TResult>) | Přetíženo. Promítne každý prvek pozorovatelné sekvence do nové podoby začleněním indexu elementu se zadaným zdrojem a selektorem. (Definováno pozorovatelným.) |
|
SelectMany<T, TOther>(IObservable<TOTher>) | Přetíženo. Promítá každý prvek pozorovatelné sekvence na pozorovatelnou sekvenci a zploštědí výsledné pozorovatelné sekvence do jedné pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
SelectMany<T, TResult>(Func<T, IObservable<TResult>>) | Přetíženo. Promítá každý prvek pozorovatelné sekvence na pozorovatelnou sekvenci a zploštědí výsledné pozorovatelné sekvence do jedné pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
SelectMany<T, TResult>(Func<T, IEnumerable<TResult>>) | Přetíženo. Promítá každý prvek pozorovatelné sekvence na pozorovatelnou sekvenci a zploštědí výsledné pozorovatelné sekvence do jedné pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
SelectMany<T, TResult>(Func<T, IObservable<TResult>>, Func<Exception, IObservable<TResult>>, Func<IObservable<TResult>>) | Přetíženo. Promítá každý prvek pozorovatelné sekvence na pozorovatelnou sekvenci a zploštědí výsledné pozorovatelné sekvence do jedné pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
SelectMany<T, TCollection, TResult>(Func<T, IEnumerable<TCollection>>, Func<T, TCollection, TResult>) | Přetíženo. Promítá každý prvek pozorovatelné sekvence na pozorovatelnou sekvenci a zploštědí výsledné pozorovatelné sekvence do jedné pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
SelectMany<T, TCollection, TResult>(Func<T, IObservable<TCollection>>, Func<T, TCollection, TResult>) | Přetíženo. Promítá každý prvek pozorovatelné sekvence na pozorovatelnou sekvenci a zploštědí výsledné pozorovatelné sekvence do jedné pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
SequenceEqual<T>(IObservable<T>) | Přetíženo. Určuje, zda jsou dvě sekvence rovny porovnáním prvků párově. (Definováno pozorovatelným.) |
|
SequenceEqual<T>(IObservable<T>, IEqualityComparer<T>) | Přetíženo. Určuje, zda jsou dvě sekvence rovny porovnáním prvků párově pomocí zadaného porovnávače rovnosti. (Definováno pozorovatelným.) |
|
Jeden T<>() | Přetíženo. Vrátí jediný prvek pozorovatelné sekvence a vyvolá výjimku, pokud v pozorovatelné sekvenci není přesně jeden prvek. (Definováno pozorovatelným.) |
|
Jednoduché<T>(func<T, logická hodnota>) | Přetíženo. Vrátí jediný prvek pozorovatelné sekvence, který odpovídá predikátu, a vyvolá výjimku, pokud v pozorovatelné sekvenci není přesně jeden prvek. (Definováno pozorovatelným.) |
|
SingleOrDefault<T>() | Přetíženo. Vrátí jediný prvek pozorovatelné sekvence nebo výchozí hodnotu, pokud je pozorovatelná sekvence prázdná. (Definováno pozorovatelným.) |
|
SingleOrDefault<T>(Func<T, Logická hodnota>) | Přetíženo. Vrátí jediný prvek pozorovatelné sekvence, který odpovídá predikátu, nebo výchozí hodnotu, pokud není nalezena žádná hodnota. (Definováno pozorovatelným.) |
|
Přeskočit<T> | Obchází zadaný počet hodnot v pozorovatelné sekvenci a pak vrátí zbývající hodnoty. (Definováno pozorovatelným.) |
|
SkipLast<T> | Obchází zadaný počet prvků na konci pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
SkipUntil<T, TOther> | Vrátí hodnoty ze zdrojové pozorovatelné sekvence až poté, co druhá pozorovatelná sekvence vytvoří hodnotu. (Definováno pozorovatelným.) |
|
SkipWhile<T>(Func<T, Boolean>) | Přetíženo. Obchází hodnoty v pozorovatelné sekvenci, pokud je zadaná podmínka pravdivá, a pak vrátí zbývající hodnoty. (Definováno pozorovatelným.) |
|
SkipWhile<T>(Func<T, Int32, Logická> hodnota) | Přetíženo. Obchází hodnoty v pozorovatelné sekvenci, pokud je zadaná podmínka pravdivá, a pak vrátí zbývající hodnoty. (Definováno pozorovatelným.) |
|
StartWith<T>[]) | Přetíženo. Předpeněžuje posloupnost hodnot na pozorovatelnou sekvenci se zadaným zdrojem a hodnotami. (Definováno pozorovatelným.) |
|
StartWith<T>(IScheduler; T[]) | Přetíženo. Předřadí posloupnost hodnot na pozorovatelnou sekvenci se zadaným zdrojem, plánovačem a hodnotami. (Definováno pozorovatelným.) |
|
Přihlásit se k odběru<T>() | Přetíženo. Vyhodnotí pozorovatelnou sekvenci se zadaným zdrojem. (Definováno observableExtensions.) |
|
Přihlásit se k odběru<T>(akce<T>) | Přetíženo. Přihlásí obslužnou rutinu prvku k pozorovatelné sekvenci. (Definováno observableExtensions.) |
|
Přihlásit se k odběru<T>(akce<T>, výjimka> akce<) | Přetíženo. Přihlásí obslužnou rutinu elementu a obslužnou rutinu výjimky k pozorovatelné sekvenci. (Definováno observableExtensions.) |
|
Přihlásit se k odběru<T>(Akce<T>, Akce) | Přetíženo. Přihlásí obslužnou rutinu prvku a obslužnou rutinu dokončení k pozorovatelné sekvenci. (Definováno observableExtensions.) |
|
Přihlásit se k odběru<T>(Akce<T>, Výjimka> akce<, Akce) | Přetíženo. Přihlásí obslužnou rutinu elementu, obslužnou rutinu výjimky a obslužnou rutinu dokončení k pozorovatelné sekvenci. (Definováno observableExtensions.) |
|
SubscribeOn<T>(SynchronizationContext) | Přetíženo. Asynchronně odebírá a odebírá pozorovatele v zadaném kontextu synchronizace. (Definováno pozorovatelným.) |
|
SubscribeOn<T>(Control) | Přetíženo. (Definováno pomocí ControlObservable.) |
|
SubscribeOn<T>(Dispatcher) | Přetíženo. (Definováno pomocí DispatcherObservable.) |
|
SubscribeOn<T>(DispatcherScheduler) | Přetíženo. (Definováno pomocí DispatcherObservable.) |
|
SubscribeOn<T>(IScheduler) | Přetíženo. Asynchronně se přihlásí k odběru a odhlásí pozorovatele v zadaném plánovači. (Definováno pozorovatelným.) |
|
SubscribeOnDispatcher<T> | (Definováno pomocí DispatcherObservable.) |
|
Synchronizovat<T>() | Přetíženo. Synchronizuje pozorovatelnou sekvenci. (Definováno pozorovatelným.) |
|
Synchronizovat<objekt T>(Object) | Přetíženo. Synchronizuje pozorovatelnou sekvenci. (Definováno pozorovatelným.) |
|
Vezměte T<> | Vrátí zadaný počet souvislých hodnot od začátku pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
TakeLast<T> | Vrátí zadaný počet souvislých prvků z konce pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
TakeUntil<T, TOther> | Vrátí hodnoty ze zdrojové pozorovatelné sekvence, dokud druhá pozorovatelná sekvence nevytváří hodnotu. (Definováno pozorovatelným.) |
|
TakeWhile<T>(Func<T, Boolean>) | Přetíženo. Vrátí hodnoty ze pozorovatelné posloupnosti, pokud je zadaná podmínka pravdivá, a pak přeskočí zbývající hodnoty. (Definováno pozorovatelným.) |
|
TakeWhile<T>(Func<T, Int32, Boolean>) | Přetíženo. Vrátí hodnoty ze pozorovatelné posloupnosti, pokud je zadaná podmínka pravdivá, a pak přeskočí zbývající hodnoty. (Definováno pozorovatelným.) |
|
Pak<T, TResult> | Odpovídá, když má pozorovatelná posloupnost dostupnou hodnotu a promítá ji. (Definováno pozorovatelným.) |
|
<Omezení T>(TimeSpan) | Přetíženo. Ignoruje hodnoty z pozorovatelné sekvence, za nimiž následuje jiná hodnota před termínem splnění se zadaným zdrojem a dueTime. (Definováno pozorovatelným.) |
|
<Omezení T>(TimeSpan, IScheduler) | Přetíženo. Ignoruje hodnoty z pozorovatelné sekvence, po kterých následuje jiná hodnota před termínem splnění se zadaným zdrojem, dueTime a plánovačem. (Definováno pozorovatelným.) |
|
TimeInterval<T>() | Přetíženo. Zaznamenává časový interval mezi po sobě jdoucími hodnotami v pozorovatelné sekvenci se zadaným zdrojem. (Definováno pozorovatelným.) |
|
TimeInterval<T>(IScheduler) | Přetíženo. Zaznamenává časový interval mezi po sobě jdoucími hodnotami v pozorovatelné sekvenci se zadaným zdrojem a plánovačem. (Definováno pozorovatelným.) |
|
Časový limit<T>(TimeSpan) | Přetíženo. Vrátí pozorovatelnou sekvenci nebo Výjimku TimeoutException, pokud dueTime uplynula. (Definováno pozorovatelným.) |
|
Časový limit<T>(DateTimeOffset) | Přetíženo. Vrátí buď pozorovatelnou sekvenci, nebo TimeoutException, pokud dueTime uplynula. (Definováno pozorovatelným.) |
|
Časový limit<T>(TimeSpan; IObservable<T>) | Přetíženo. Vrátí zdroj pozorovatelnou sekvenci nebo jinou pozorovatelnou sekvenci, pokud dueTime uplynula. (Definováno pozorovatelným.) |
|
Časový limit<T>(DateTimeOffset; IObservable<T>) | Přetíženo. Vrátí pozorovatelnou sekvenci nebo Výjimku TimeoutException, pokud dueTime uplynula. (Definováno pozorovatelným.) |
|
Časový limit<T>(TimeSpan, IScheduler) | Přetíženo. Vrátí pozorovatelnou sekvenci nebo Výjimku TimeoutException, pokud dueTime uplynula. (Definováno pozorovatelným.) |
|
Časový limit<T>(DateTimeOffset, IScheduler) | Přetíženo. Vrátí pozorovatelnou sekvenci nebo Výjimku TimeoutException, pokud dueTime uplynula. (Definováno pozorovatelným.) |
|
Časový limit<T>(TimeSpan, IObservable<T>, IScheduler) | Přetíženo. Vrátí zdroj pozorovatelnou sekvenci nebo jinou pozorovatelnou sekvenci, pokud dueTime uplynula. (Definováno pozorovatelným.) |
|
Časový limit<T>(DateTimeOffset, IObservable<T>, IScheduler) | Přetíženo. Vrátí zdroj pozorovatelnou sekvenci nebo jinou pozorovatelnou sekvenci, pokud dueTime uplynula. (Definováno pozorovatelným.) |
|
Časové razítko<T>() | Přetíženo. Zaznamenává časové razítko pro každou hodnotu v pozorovatelné sekvenci se zadaným zdrojem. (Definováno pozorovatelným.) |
|
Timestamp<T>(IScheduler) | Přetíženo. Zaznamenává časové razítko pro každou hodnotu v pozorovatelné posloupnosti se zadaným zdrojem a plánovačem. (Definováno pozorovatelným.) |
|
ToArray<T> | Vytvoří pole z pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
ToDictionary<T, TKey>(Func<T, TKey>) | Přetíženo. Vytvoří slovník z pozorovatelné sekvence podle zadané funkce selektoru klíčů. (Definováno pozorovatelným.) |
|
ToDictionary<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>) | Přetíženo. Vytvoří slovník z pozorovatelné sekvence podle zadané funkce selektoru klíčů a porovnávače. (Definováno pozorovatelným.) |
|
ToDictionary<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>) | Přetíženo. Vytvoří slovník z pozorovatelné sekvence podle zadané funkce selektoru klíčů a funkce selektoru prvků. (Definováno pozorovatelným.) |
|
ToDictionary<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>) | Přetíženo. Vytvoří slovník z pozorovatelné sekvence podle zadané funkce selektoru klíčů, porovnávače a funkce selektoru prvků. (Definováno pozorovatelným.) |
|
ToEnumerable<T> | Převede pozorovatelnou sekvenci na výčtovou sekvenci. (Definováno pozorovatelným.) |
|
ToEvent<T> | Zveřejňuje pozorovatelnou sekvenci jako objekt s událostí .NET se zadaným zdrojem. (Definováno pozorovatelným.) |
|
ToList<T> | Vytvoří seznam z pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
ToLookup<T, TKey>(Func<T, TKey>) | Přetíženo. Vytvoří vyhledávání z pozorovatelné sekvence podle zadané funkce selektoru klíčů. (Definováno pozorovatelným.) |
|
ToLookup<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>) | Přetíženo. Vytvoří vyhledávání z pozorovatelné sekvence podle zadané funkce selektoru klíčů a porovnávače. (Definováno pozorovatelným.) |
|
ToLookup<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>) | Přetíženo. Vytvoří vyhledávání z pozorovatelné sekvence podle zadané funkce selektoru klíčů a funkce selektoru prvků. (Definováno pozorovatelným.) |
|
ToLookup<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>) | Přetíženo. Vytvoří vyhledávání z pozorovatelné sekvence podle zadané funkce selektoru klíčů, porovnávače a funkce selektoru prvků. (Definováno pozorovatelným.) |
|
ToTask<T>() | Přetíženo. Vrátí úlohu, která obsahuje poslední hodnotu pozorovatelné sekvence. (Definuje TaskObservableExtensions.) |
|
ToTask<T>(Object) | Přetíženo. Vrátí úlohu, která obsahuje poslední hodnotu pozorovatelné sekvence. (Definuje TaskObservableExtensions.) |
|
ToTask<T>(CancellationToken) | Přetíženo. Vrátí úlohu, která obsahuje poslední hodnotu pozorovatelné sekvence. (Definuje TaskObservableExtensions.) |
|
ToTask<T>(CancellationToken, Object) | Přetíženo. Vrátí úlohu, která obsahuje poslední hodnotu pozorovatelné sekvence. (Definuje TaskObservableExtensions.) |
|
Where<T>(Func<T; Boolean>) | Přetíženo. Filtruje prvky pozorovatelné sekvence na základě predikátu. (Definováno pozorovatelným.) |
|
Where<T>(Func<T; Int32; Boolean>) | Přetíženo. Filtruje prvky pozorovatelné sekvence na základě predikátu zahrnutím indexu prvku. (Definováno pozorovatelným.) |
|
Okno<T>(Int32) | Přetíženo. Promítá každý prvek pozorovatelné sekvence do po sobě jdoucích nepřekrývajících se oken, která jsou vytvořena na základě informací o počtu prvků. (Definováno pozorovatelným.) |
|
Window<T>(TimeSpan) | Přetíženo. Projektuje každý prvek pozorovatelné sekvence do po sobě jdoucích nepřekrývajících se oken, která jsou vytvořena na základě informací o načasování. (Definováno pozorovatelným.) |
|
Okno<T>(Int32; Int32) | Přetíženo. Promítá každý prvek pozorovatelné sekvence do nula nebo více oken, která jsou vytvořena na základě informací o počtu prvků. (Definováno pozorovatelným.) |
|
Okno<T>(TimeSpan, IScheduler) | Přetíženo. Projektuje každý prvek pozorovatelné sekvence do po sobě jdoucích nepřekrývajících se oken, která jsou vytvořena na základě informací o načasování. (Definováno pozorovatelným.) |
|
Okno<T>(TimeSpan; TimeSpan) | Přetíženo. Promítá každý prvek pozorovatelné sekvence do nula nebo více oken, která jsou vytvořena na základě informací o načasování. (Definováno pozorovatelným.) |
|
Okno<T>(TimeSpan; Int32) | Přetíženo. Promítá každý prvek pozorovatelné sekvence do okna, které je dokončeno, když je buď plné nebo uplynula daná doba. (Definováno pozorovatelným.) |
|
Okno<T>(TimeSpan, TimeSpan, IScheduler) | Přetíženo. Promítá každý prvek pozorovatelné sekvence do nula nebo více oken, která jsou vytvořena na základě informací o načasování. (Definováno pozorovatelným.) |
|
Okno<T>(TimeSpan; Int32; IScheduler) | Přetíženo. Promítá každý prvek pozorovatelné sekvence do okna, které je dokončeno, když je buď plné nebo uplynula daná doba. (Definováno pozorovatelným.) |
|
Window<T, TWindowClosing>(Func<IObservable<TWindowClosing>>) | Přetíženo. Promítá každý prvek pozorovatelné sekvence do po sobě jdoucích nepřekrývajících se oken. (Definováno pozorovatelným.) |
|
Window<T, TWindowOpening, TWindowClosing>(IObservable<TWindowOpening>, Func<TWindowOpening, IObservable<TWindowClosing>>) | Přetíženo. Promítá každý prvek pozorovatelné sekvence do nula nebo více oken. (Definováno pozorovatelným.) |
|
Zip<T, TSecond, TResult>(IObservable<TSecond>, Func<T, TSecond, TResult>) | Přetíženo. Sloučí dvě pozorovatelné sekvence do jedné pozorovatelné sekvence tím, že jejich prvky zkombinuje v párovém pořadí. (Definováno pozorovatelným.) |
|
Zip<T, TSecond, TResult>(IEnumerable<TSecond>, Func<T, TSecond, TResult>) | Přetíženo. Pomocí funkce selektoru sloučí pozorovatelnou sekvenci a sekvenci s výčetem do jedné pozorovatelné sekvence. (Definováno pozorovatelným.) |
Nahoře
Poznámky
Při odběru začnou běžet studené pozorovatelné položky, tj. pozorovatelná posloupnost začne pozorovatelům tlačit hodnoty 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řesunu myší nebo burzovní akcie, které již vytvářejí hodnoty ještě před aktivací předplatného. Když se pozorovatel přihlásí k odběru horké pozorovatelné sekvence, získá aktuální hodnotu v datovém proudu. Horká pozorovatelná sekvence se sdílí mezi všemi předplatiteli a každému odběrateli se nasdílí další hodnota v sekvenci. Například i když nikdo neuplatní konkrétní akciový burzovní kód, bude tato burza dál aktualizovat svou hodnotu na základě pohybu na trhu. Když si předplatitel zaregistruje zájem o tento ticker, automaticky získá nejnovější odškrtávku.
Příklady
V následujícím příkladu převedeme zdroj studené pozorovatelné sekvence na horký pomocí operátoru Publish, který vrátí instanci IConnectableObservable<T> , kterou pojmenujeme hot. Operátor Publish poskytuje mechanismus pro 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 vlastním odběratelům. K vytvoření předplatného záložního zdroje a zahájení přijímání hodnot používáme metodu IConnectableObservable.Connect(). Vzhledem k tomu, že IConnectableObservable dědí IObservable, můžeme použít Přihlásit se k odběru této horké sekvence ještě před spuštěním. Všimněte si, že v 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 nasdílí do předplatného1. Po 3sekundovém zpoždění předplatné 2 se 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();