ISubject<TSource, TResult> – rozhraní
Představuje objekt, který je pozorovatelnou sekvencí i pozorovatelem.
Obor názvů:System.Reactive.Subjects
Sestavení: System.Reactive (v System.Reactive.dll)
Syntax
'Declaration
Public Interface ISubject(Of In TSource, Out TResult) _
Inherits IObserver(Of TSource), IObservable(Of TResult)
'Usage
Dim instance As ISubject(Of In TSource, Out TResult)
public interface ISubject<in TSource, out TResult> : IObserver<TSource>,
IObservable<TResult>
generic<typename TSource, typename TResult>
public interface class ISubject : IObserver<TSource>,
IObservable<TResult>
type ISubject<'TSource, 'TResult> =
interface
interface IObserver<'TSource>
interface IObservable<'TResult>
end
JScript does not support generic types and methods.
Parametry typu
inTSource
Typ zdroje.Tento parametr typu je kontravariantní. To znamená, že můžete použít buď zadaný typ, nebo libovolný typ, který je méně odvozený. Další informace o kovarianci a kontravarianci najdete v tématu .
outTResult
Typ výsledku.Tento 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 ISubject<TSource, TResult> zveřejňuje následující členy.
Metody
| Název | Description | |
|---|---|---|
.gif "Veřejná metoda") |
Při dokončení | (Zděděno z IObserveru<>Zdroj.) |
|
OnError | (Zděděno z IObserveru<>Zdroj.) |
|
OnNext | (Zděděno z IObserveru<>Zdroj.) |
|
Přihlásit k odběru | (Zděděno z IObservable<TResult>.) |
Nahoře
Metody rozšíření
| Název | Description | |
|---|---|---|
.gif "Metoda veřejného rozšíření") |
Aggregate<TResult>(Func<TResult; TResult; TResult>) | Přetíženo. Použije funkci akumulátoru na pozorovatelnou sekvenci. (Definováno pozorovatelným.) |
|
Aggregate<TResult, TAccumulate>(TAccumulate, Func<TAccumulate, TResult, TAccumulate>) | Přetíženo. Použije funkci akumulátoru na pozorovatelnou sekvenci se zadanou počáteční hodnotou. (Definováno pozorovatelným.) |
|
Hodnota TResult – vše<> | Určuje, zda všechny prvky pozorovatelné sekvence splňují podmínku. (Definováno pozorovatelným.) |
|
Amb<TResult> | Šíří pozorovatelnou sekvenci, která reaguje jako první se zadanou první a druhou sekvencí. (Definováno pozorovatelným.) |
|
A<TResult, TRight> | Odpovídá, pokud obě pozorovatelné sekvence mají dostupnou hodnotu. (Definováno pozorovatelným.) |
|
Any<TResult>() | Přetíženo. Určuje, zda pozorovatelná sekvence obsahuje nějaké prvky. (Definováno pozorovatelným.) |
|
Any<TResult>(Func<TResult, Boolean>) | Přetíženo. Určuje, zda všechny prvky pozorovatelné sekvence splňují podmínku. (Definováno pozorovatelným.) |
|
AsObservable<TResult> | Skryje identitu pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
AsObserver<TSource> | Skryje identitu pozorovatele. (Definováno pozorovatelem.) |
|
AsQbservable<TResult> | Převede pozorovatelnou sekvenci na dotazovatelnou sekvenci. (Definuje Qbservable.) |
|
AssertEqual<TResult> | (Definované rozšířeními.) |
|
Vyrovnávací paměť<TResult>(Int32) | Přetíženo. Urč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ěť<TResult>(TimeSpan) | Přetíženo. Urč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 časování. (Definováno pozorovatelným.) |
|
Buffer<TResult>(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<TResult>(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ěť<TResult>(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ěť<TResult>(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<TResult>(TimeSpan, TimeSpan, IScheduler) | 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.) |
|
Buffer<TResult>(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<TResult, 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<TResult, 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<TResult>(IObservable<TResult>) | Přetíženo. Pokračuje v pozorovatelné sekvenci, která je ukončena výjimkou s další pozorovatelnou sekvencí. (Definováno pozorovatelným.) |
|
Catch<TResult, TException>(Func<TException, IObservable<TResult>>) | 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<TResult, 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<TResult> | Zřetězí dvě pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
Obsahuje<TResult>(TResult) | Přetíženo. Určuje, zda pozorovatelná sekvence obsahuje zadaný prvek pomocí výchozího porovnávače rovnosti. (Definováno pozorovatelným.) |
|
Obsahuje<TResult>(TResult, IEqualityComparer<TResult>) | Přetíženo. Určuje, zda pozorovatelná sekvence obsahuje zadaný prvek pomocí zadané System.Collections.Generic.IEqualityComparer< T>. (Definováno pozorovatelným.) |
|
Count<TResult> | Vrátí hodnotu Int32 , která představuje celkový počet prvků v pozorovatelné sekvenci. (Definováno pozorovatelným.) |
|
DefaultIfEmpty<TResult>() | 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<TResult>(TResult) | 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<TResult>(TimeSpan) | Přetíženo. Označuje pozorovatelnou sekvenci podle času splnění se zadaným zdrojem a dueTime. (Definováno pozorovatelným.) |
|
Delay<TResult>(DateTimeOffset) | Přetíženo. Označuje pozorovatelnou sekvenci podle času splnění se zadaným zdrojem a dueTime. (Definováno pozorovatelným.) |
|
Delay<TResult>(TimeSpan; IScheduler) | Přetíženo. Označuje pozorovatelnou sekvenci podle času splnění se zadaným zdrojem, dueTime a plánovačem. (Definováno pozorovatelným.) |
|
Delay<TResult>(DateTimeOffset, IScheduler) | Přetíženo. Označuje pozorovatelnou sekvenci podle času splnění se zadaným zdrojem, dueTime a plánovačem. (Definováno pozorovatelným.) |
|
Distinct<TResult>() | Přetíženo. Vrátí pozorovatelnou sekvenci, která obsahuje pouze jedinečné prvky se zadaným zdrojem. (Definováno pozorovatelným.) |
|
Distinct<TResult>(IEqualityComparer<TResult>) | Přetíženo. Vrátí pozorovatelnou sekvenci, která obsahuje pouze jedinečné prvky podle porovnávače. (Definováno pozorovatelným.) |
|
Distinct<TResult, TKey>(Func<TResult, TKey>) | Přetíženo. Vrátí pozorovatelnou sekvenci, která obsahuje pouze odlišné prvky podle keySelector. (Definováno pozorovatelným.) |
|
Distinct<TResult, TKey>(Func<TResult, TKey>, IEqualityComparer<TKey>) | Přetíženo. Vrátí pozorovatelnou sekvenci, která obsahuje pouze odlišné prvky podle keySelector. (Definováno pozorovatelným.) |
|
DistinctUntilChanged<TResult>() | Přetíženo. Vrátí pozorovatelnou sekvenci, která obsahuje pouze jedinečné souvislé prvky se zadaným zdrojem. (Definováno pozorovatelným.) |
|
DistinctUntilChanged<TResult>(IEqualityComparer<TResult>) | Přetíženo. Vrátí pozorovatelnou sekvenci, která obsahuje pouze odlišné souvislé prvky podle porovnávače. (Definováno pozorovatelným.) |
|
DistinctUntilChanged<TResult, TKey>(Func<TResult, TKey>) | Přetíženo. Vrátí pozorovatelnou sekvenci, která obsahuje pouze odlišné souvislé prvky podle keySelector. (Definováno pozorovatelným.) |
|
DistinctUntilChanged<TResult, TKey>(Func<TResult, 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<TResult>(Action<TResult>) | Přetíženo. Vyvolá akci pro každý prvek v pozorovatelné sekvenci. (Definováno pozorovatelným.) |
|
Do<TResult>(IObserver<TResult>) | 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<TResult>(Akce<TResult>; 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<TResult>(Akce<TResult>; 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<TResult>(Action<TResult>; Action<Exception>, Action) | Přetíženo. 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ým.) |
|
ElementAt<TResult> | Vrátí element v zadaném indexu v sekvenci. (Definováno pozorovatelným.) |
|
ElementAtOrDefault<TResult> | Vrátí prvek v zadaném indexu v sekvenci nebo výchozí hodnotu, pokud je index mimo rozsah. (Definováno pozorovatelným.) |
|
Konečně<TResult> | Vyvolá zadanou akci poté, co se pozorovatelná sekvence zdroje ukončí normálně nebo výjimkou. (Definováno pozorovatelným.) |
|
První<TResult>() | Přetíženo. Vrátí první prvek pozorovatelné sekvence se zadaným zdrojem. (Definováno pozorovatelným.) |
|
First<TResult>(Func<TResult, Boolean>) | Přetíženo. Vrátí první prvek pozorovatelné sekvence, která odpovídá predikátu. (Definováno pozorovatelným.) |
|
FirstOrDefault<TResult>() | Přetíženo. Vrátí první prvek pozorovatelné sekvence nebo výchozí hodnotu, pokud není nalezena žádná hodnota. (Definováno pozorovatelným.) |
|
FirstOrDefault<TResult>(Func<TResult, logická> hodnota) | 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<TResult, R> | (Definováno v MyExt.) |
|
ForEach<TResult> | Vyvolá akci pro každý prvek v pozorovatelné sekvenci a blokuje, dokud se sekvence neukončila. (Definováno pozorovatelným.) |
|
GetEnumerator<TResult> | Vrátí enumerátor, který vyčíslí všechny hodnoty pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
GroupBy<TResult, TKey>(Func<TResult, TKey>) | Přetíženo. Seskupí prvky pozorovatelné sekvence podle zadané funkce voliče klíčů. (Definováno pozorovatelným.) |
|
GroupBy<TResult, TKey>(Func<TResult, TKey>, IEqualityComparer<TKey>) | Přetíženo. Seskupí prvky pozorovatelné sekvence podle zadané funkce selektoru klíčů a porovnávače. (Definováno pozorovatelným.) |
|
GroupBy<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, TElement>) | Přetíženo. Seskupí prvky pozorovatelné sekvence a vybere výsledné prvky pomocí zadané funkce. (Definováno pozorovatelným.) |
|
GroupBy<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, 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<TResult, TKey, TDuration>(Func<TResult, TKey>, Func<IGroupedObservable<TKey, TResult>, IObservable<TDuration>>) | Přetíženo. Seskupí prvky pozorovatelné sekvence podle zadané funkce voliče klíčů. (Definováno pozorovatelným.) |
|
GroupByUntil<TResult, TKey, TDuration>(Func<TResult, TKey>, Func<IGroupedObservable<TKey, TResult>, 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<TResult, TKey, TElement, TDuration>(Func<TResult, TKey>, Func<TResult, 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<TResult, TKey, TElement, TDuration>(Func<TResult, TKey>, Func<TResult, 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<TResult, 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<TResult> | Ignoruje všechny hodnoty v pozorovatelné sekvenci a ponechá pouze zprávy ukončení. (Definováno pozorovatelným.) |
|
Join<TResult, TRight, TLeftDuration, TRightDuration, TResult> | Koreluje prvky dvou sekvencí na základě překrývajících se dob trvání. (Definováno pozorovatelným.) |
|
Last<TResult>() | Přetíženo. Vrátí poslední prvek pozorovatelné sekvence se zadaným zdrojem. (Definováno pozorovatelným.) |
|
Last<TResult>(Func<TResult, Boolean>) | Přetíženo. Vrátí poslední prvek pozorovatelné sekvence, která odpovídá predikátu. (Definováno pozorovatelným.) |
|
LastOrDefault<TResult>() | Přetíženo. Vrátí poslední prvek v pozorovatelné sekvenci nebo výchozí hodnotu, pokud není nalezena žádná hodnota. (Definováno pozorovatelným.) |
|
LastOrDefault<TResult>(Func<TResult, Boolean>) | 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ší<hodnota TResult> | Vzorkuje nejnovější hodnotu v pozorovatelné sekvenci. (Definováno pozorovatelným.) |
|
LongCount<TResult> | Vrátí hodnotu Int64 , která představuje celkový počet prvků v pozorovatelné sekvenci. (Definováno pozorovatelným.) |
|
Materializace<TResult> | Materializuje implicitní oznámení pozorovatelné sekvence jako explicitní hodnoty oznámení. (Definováno pozorovatelným.) |
|
Max<TResult>() | Přetíženo. Vrátí maximální prvek v pozorovatelné sekvenci. (Definováno pozorovatelným.) |
|
Max<TResult>(IComparer<TResult>) | Přetíženo. Vrátí maximální hodnotu v pozorovatelné sekvenci podle zadaného porovnávače. (Definováno pozorovatelným.) |
|
MaxBy<TResult, TKey>(Func<TResult, TKey>) | Přetíženo. Vrátí prvky v pozorovatelné sekvenci s maximální hodnotou klíče. (Definováno pozorovatelným.) |
|
MaxBy<TResult, TKey>(Func<TResult, TKey>, IComparer<TKey>) | Přetíženo. Vrátí prvky v pozorovatelné sekvenci s maximální hodnotou klíče. (Definováno pozorovatelným.) |
|
Merge<TResult>(IObservable<TResult>) | Přetíženo. Sloučí pozorovatelnou sekvenci pozorovatelných sekvencí do pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
Merge<TResult>(IObservable<TResult>, IScheduler) | Přetíženo. Sloučí dvě pozorovatelné sekvence do jedné pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
Min<TResult>() | Přetíženo. Vrátí minimální prvek v pozorovatelné sekvenci. (Definováno pozorovatelným.) |
|
Min<TResult>(IComparer<TResult>) | Přetíženo. Vrátí minimální hodnotu v pozorovatelné sekvenci podle zadaného porovnávače. (Definováno pozorovatelným.) |
|
MinBy<TResult, TKey>(Func<TResult, TKey>) | Přetíženo. Vrátí prvky v pozorovatelné sekvenci s minimální hodnotou klíče. (Definováno pozorovatelným.) |
|
MinBy<TResult, TKey>(Func<TResult, 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<TResult> | Vzorkuje nejnovější hodnotu v pozorovatelné sekvenci. (Definováno pozorovatelným.) |
|
Vícesměrové vysílání<TResult, TResult>(ISubject<TResult, TResult>) | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která po 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í<TResult, TIntermediate, TResult>(Func<ISubject<TResult, 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ší<hodnota TResult> | Vzorkuje další hodnotu (blokování bez ukládání do vyrovnávací paměti) z v pozorovatelné sekvenci. (Definováno pozorovatelným.) |
|
ObserveOn<TResult>(SynchronizationContext) | Přetíženo. Asynchronně upozorňovat pozorovatele na zadaný kontext synchronizace. (Definováno pozorovatelným.) |
|
ObserveOn<TResult>(ovládací prvek) | Přetíženo. (Definováno pomocí ControlObservable.) |
|
ObserveOn<TResult>(Dispatcher) | Přetíženo. (Definováno pomocí DispatcherObservable.) |
|
ObserveOn<TResult>(DispatcherScheduler) | Přetíženo. (Definováno pomocí DispatcherObservable.) |
|
ObserveOn<TResult>(IScheduler) | Přetíženo. Asynchronně upozorňovat pozorovatele v zadaném plánovači. (Definováno pozorovatelným.) |
|
ObserveOnDispatcher<TResult> | (Definováno pomocí DispatcherObservable.) |
|
OnErrorResumeNext<TResult> | Pokračuje v pozorovatelné sekvenci, která je ukončena normálně nebo výjimkou, s další pozorovatelnou sekvencí. (Definováno pozorovatelným.) |
|
Publish<TResult>() | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí. (Definováno pozorovatelným.) |
|
Publikovat<TResult>(TResult) | 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<TResult, TResult>(Func<IObservable<TResult>, 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é sekvenci. (Definováno pozorovatelným.) |
|
Publish<TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>, TResult) | 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<TResult>() | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jeden odběr s podkladovou sekvencí obsahující pouze poslední oznámení. (Definováno pozorovatelným.) |
|
PublishLast<TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>) | Přetíženo. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru na připojitelné pozorovatelné sekvenci, která sdílí jeden odběr podkladové sekvence obsahující pouze poslední oznámení. (Definováno pozorovatelným.) |
|
Repeat<TResult>() | Přetíženo. Opakuje pozorovatelnou sekvenci po neomezenou dobu. (Definováno pozorovatelným.) |
|
Repeat<TResult>(Int32) | Přetíženo. Opakuje pozorovatelnou sekvenci po neomezenou dobu. (Definováno pozorovatelným.) |
|
Replay<TResult>() | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jeden odběr s podkladovou sekvencí, která přehrává všechna oznámení. (Definováno pozorovatelným.) |
|
Replay<TResult>(TimeSpan) | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jeden odběr podkladové sekvence a přehrává všechna oznámení v okně. (Definováno pozorovatelným.) |
|
Replay<TResult>(Int32) | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jeden odběr s podkladovou vyrovnávací pamětí přehrání sekvence Oznámení o velikosti. (Definováno pozorovatelným.) |
|
Replay<TResult>(IScheduler) | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jeden odběr s podkladovou sekvencí, která přehrává všechna oznámení. (Definováno pozorovatelným.) |
|
Replay<TResult>(TimeSpan, IScheduler) | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jeden odběr podkladové sekvence a přehrává všechna oznámení v okně. (Definováno pozorovatelným.) |
|
Replay<TResult>(Int32, IScheduler) | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jeden odběr s podkladovou vyrovnávací pamětí přehrání sekvence Oznámení o velikosti. (Definováno pozorovatelným.) |
|
Replay<TResult>(Int32; TimeSpan) | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jeden odběr s podkladovou vyrovnávací pamětí přehrání sekvence Oznámení velikosti v okně. (Definováno pozorovatelným.) |
|
Replay<TResult>(Int32, TimeSpan, IScheduler) | Přetíženo. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jeden odběr s podkladovou vyrovnávací pamětí přehrání sekvence Oznámení velikosti v okně. (Definováno pozorovatelným.) |
|
Replay<TResult, TResult>(Func<IObservable<TResult>, 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<TResult, TResult>(Func<IObservable<TResult>, 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í jeden odběr podkladové sekvence, která přehrává všechna oznámení. (Definováno pozorovatelným.) |
|
Replay<TResult, TResult>(Func<IObservable<TResult>, 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í jeden odběr podkladové sekvence a přehrává všechna oznámení v rámci okna. (Definováno pozorovatelným.) |
|
Replay<TResult, TResult>(Func<IObservable<TResult>, 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í jeden odběr základní sekvence přehrání bufferSize oznámení. (Definováno pozorovatelným.) |
|
Replay<TResult, TResult>(Func<IObservable<TResult>, 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í jeden odběr podkladové sekvence a přehrává všechna oznámení v rámci okna. (Definováno pozorovatelným.) |
|
Replay<TResult, TResult>(Func<IObservable<TResult>, 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í jeden odběr základní sekvence přehrání bufferSize oznámení. (Definováno pozorovatelným.) |
|
Replay<TResult, TResult>(Func<IObservable<TResult>, 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í jeden odběr základní sekvence přehrání vyrovnávací paměti Oznámení velikosti v okně. (Definováno pozorovatelným.) |
|
Replay<TResult, TResult>(Func<IObservable<TResult>, 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.) |
|
Opakovat<TResult>() | Přetíženo. Opakuje zdroj pozorovatelné sekvence, dokud se úspěšně neskončila. (Definováno pozorovatelným.) |
|
Opakovat<TResult>(Int32) | Přetíženo. Opakuje zdroj pozorovatelné sekvence, dokud se úspěšně neskončila. (Definováno pozorovatelným.) |
|
Ukázka<TResult>(TimeSpan) | Přetíženo. Vzorkuje pozorovatelnou sekvenci v každém intervalu. (Definováno pozorovatelným.) |
|
Ukázka<TResult>(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<TResult, TSample>(IObservable<TSample>) | Přetíženo. Vzorkuje pozorovatelnou sekvenci při vzorkování pomocí zadaného zdroje a vzorkovače. (Definováno pozorovatelným.) |
|
Scan<TResult>(Func<TResult; TResult; TResult>) | 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.) |
|
Scan<TResult, TAccumulate>(TAccumulate, Func<TAccumulate, TResult, 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<TResult, TResult>(Func<TResult, TResult>) | Přetíženo. Promítne každý prvek pozorovatelné sekvence do nové podoby se zadaným zdrojem a selektorem. (Definováno pozorovatelným.) |
|
Vyberte<TResult, TResult>(Func<TResult, 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<TResult, 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<TResult, TResult>(Func<TResult, 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<TResult, TResult>(Func<TResult, 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<TResult, TResult>(Func<TResult, 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<TResult, TCollection, TResult>(Func<TResult, IEnumerable<TCollection>>, Func<TResult, 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<TResult, TCollection, TResult>(Func<TResult, IObservable<TCollection>>, Func<TResult, 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<TResult>(IObservable<TResult>) | Přetíženo. Určuje, zda jsou dvě sekvence rovny porovnáním prvků párově. (Definováno pozorovatelným.) |
|
SequenceEqual<TResult>(IObservable<TResult>, IEqualityComparer<TResult>) | 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.) |
|
Single<TResult>() | 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.) |
|
Single<TResult>(Func<TResult, Boolean>) | 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<TResult>() | Přetíženo. Vrátí jediný prvek pozorovatelné sekvence nebo výchozí hodnotu, pokud je pozorovatelná sekvence prázdná. (Definováno pozorovatelným.) |
|
SingleOrDefault<TResult>(Func<TResult, 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<TResult> | Obchází zadaný počet hodnot v pozorovatelné sekvenci a pak vrátí zbývající hodnoty. (Definováno pozorovatelným.) |
|
SkipLast<TResult> | Obchází zadaný počet prvků na konci pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
SkipUntil<TResult, TOjiné> | Vrátí hodnoty ze zdrojové pozorovatelné sekvence až poté, co druhá pozorovatelná sekvence vytvoří hodnotu. (Definováno pozorovatelným.) |
|
SkipWhile<TResult>(Func<TResult, 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<TResult>(Func<TResult; 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<TResult>TResult[]) | Přetíženo. Předehodí posloupnost hodnot na pozorovatelnou sekvenci se zadaným zdrojem a hodnotami. (Definováno pozorovatelným.) |
|
StartWith<TResult>(IScheduler, TResult[]) | Přetíženo. Předepisuje 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<TResult>() | Přetíženo. Vyhodnotí pozorovatelnou sekvenci se zadaným zdrojem. (Definováno pomocí ObservableExtensions.) |
|
Přihlásit se k odběru<TResult>(Action<TResult>) | Přetíženo. Přihlásí obslužnou rutinu elementu k pozorovatelné sekvenci. (Definováno pomocí ObservableExtensions.) |
|
Přihlásit se k odběru<TResult>(akce<TResult>, výjimka> akce<) | Přetíženo. Přihlásí obslužnou rutinu elementu a obslužnou rutinu výjimky k pozorovatelné sekvenci. (Definováno pomocí ObservableExtensions.) |
|
Přihlásit se k odběru<TResult>(Action<TResult>, Action) | Přetíženo. Přihlásí obslužnou rutinu elementu a obslužnou rutinu dokončení k pozorovatelné sekvenci. (Definováno pomocí ObservableExtensions.) |
|
Přihlásit se k odběru<TResult>(Akce<TResult>, 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 pomocí ObservableExtensions.) |
|
<Přihlásit se k odběru TResult>(SynchronizationContext) | Přetíženo. Asynchronně se přihlásí k odběru a odhlásí odběr pozorovatelů v zadaném kontextu synchronizace. (Definováno pozorovatelným.) |
|
<Přihlásit se k odběru TResult>(ovládací prvek) | Přetíženo. (Definováno pomocí ControlObservable.) |
|
<Přihlásit se k odběru TResult>(Dispatcher) | Přetíženo. (Definováno pomocí DispatcherObservable.) |
|
<Přihlásit se k odběru TResult>(DispatcherScheduler) | Přetíženo. (Definováno pomocí DispatcherObservable.) |
|
<Přihlásit se k odběru TResult>(IScheduler) | Přetíženo. Asynchronně se přihlásí k odběru a zruší odběr pozorovatelů v zadaném plánovači. (Definováno pozorovatelným.) |
|
SubscribeOnDispatcher<TResult> | (Definováno pomocí DispatcherObservable.) |
|
Synchronizovat<TResult>() | Přetíženo. Synchronizuje pozorovatelnou sekvenci. (Definováno pozorovatelným.) |
|
Synchronizovat<TResult>(Object) | Přetíženo. Synchronizuje pozorovatelnou sekvenci. (Definováno pozorovatelným.) |
|
Vezměte TResult<> | Vrátí zadaný počet souvislých hodnot od začátku pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
TakeLast<TResult> | Vrátí zadaný počet souvislých prvků z konce pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
TakeUntil<TResult, TOjiné> | Vrátí hodnoty ze zdrojové pozorovatelné sekvence, dokud druhá pozorovatelná sekvence nevygeneruje hodnotu. (Definováno pozorovatelným.) |
|
TakeWhile<TResult>(Func<TResult, Boolean>) | Přetíženo. Vrátí hodnoty z pozorovatelné sekvence, pokud je zadaná podmínka pravdivá, a pak přeskočí zbývající hodnoty. (Definováno pozorovatelným.) |
|
TakeWhile<TResult>(Func<TResult; Int32; Logická hodnota>) | Přetíženo. Vrátí hodnoty z pozorovatelné sekvence, pokud je zadaná podmínka pravdivá, a pak přeskočí zbývající hodnoty. (Definováno pozorovatelným.) |
|
Pak<TResult, TResult> | Porovná, když má pozorovatelná sekvence dostupnou hodnotu a promítá ji. (Definováno pozorovatelným.) |
|
<Omezení TResult>(TimeSpan) | Přetíženo. Ignoruje hodnoty z pozorovatelné sekvence, za nimiž následuje další hodnota před termínem splnění se zadaným zdrojem a dueTime. (Definováno pozorovatelným.) |
|
<Omezení TResult>(TimeSpan, IScheduler) | Přetíženo. Ignoruje hodnoty z pozorovatelné sekvence, za nimiž následuje další hodnota před termínem splnění se zadaným zdrojem, dueTime a plánovačem. (Definováno pozorovatelným.) |
|
TimeInterval<TResult>() | 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<TResult>(IScheduler) | Přetíženo. Zaznamenává časový interval mezi po sobě jdoucími hodnotami v pozorovatelné sekvenci pomocí zadaného zdroje a plánovače. (Definováno pozorovatelným.) |
|
Timeout<TResult>(TimeSpan) | Přetíženo. Vrátí buď pozorovatelnou sekvenci, nebo výjimku TimeoutException, pokud dueTime uplynula. (Definováno pozorovatelným.) |
|
Timeout<TResult>(DateTimeOffset) | Přetíženo. Vrátí pozorovatelnou sekvenci nebo TimeoutException, pokud dueTime uplynula. (Definováno pozorovatelným.) |
|
Timeout<TResult>(TimeSpan; IObservable<TResult>) | Přetíženo. Vrátí zdrojovou pozorovatelnou sekvenci nebo jinou pozorovatelnou sekvenci, pokud dueTime uplynula. (Definováno pozorovatelným.) |
|
Timeout<TResult>(DateTimeOffset, IObservable<TResult>) | Přetíženo. Vrátí buď pozorovatelnou sekvenci, nebo výjimku TimeoutException, pokud dueTime uplynula. (Definováno pozorovatelným.) |
|
Timeout<TResult>(TimeSpan, IScheduler) | Přetíženo. Vrátí buď pozorovatelnou sekvenci, nebo výjimku TimeoutException, pokud dueTime uplynula. (Definováno pozorovatelným.) |
|
Timeout<TResult>(DateTimeOffset, IScheduler) | Přetíženo. Vrátí buď pozorovatelnou sekvenci, nebo výjimku TimeoutException, pokud dueTime uplynula. (Definováno pozorovatelným.) |
|
Timeout<TResult>(TimeSpan; IObservable<TResult>; IScheduler) | Přetíženo. Vrátí zdrojovou pozorovatelnou sekvenci nebo jinou pozorovatelnou sekvenci, pokud dueTime uplynula. (Definováno pozorovatelným.) |
|
Timeout<TResult>(DateTimeOffset, IObservable<TResult>, IScheduler) | Přetíženo. Vrátí zdrojovou pozorovatelnou sekvenci nebo jinou pozorovatelnou sekvenci, pokud dueTime uplynula. (Definováno pozorovatelným.) |
|
Časové razítko<TResult>() | Přetíženo. Zaznamenává časové razítko pro každou hodnotu v pozorovatelné sekvenci se zadaným zdrojem. (Definováno pozorovatelným.) |
|
Časové razítko<TResult>(IScheduler) | Přetíženo. Zaznamenává časové razítko pro každou hodnotu v pozorovatelné sekvenci se zadaným zdrojem a plánovačem. (Definováno pozorovatelným.) |
|
ToArray<TResult> | Vytvoří pole z pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
ToDictionary<TResult, TKey>(Func<TResult, TKey>) | Přetíženo. Vytvoří slovník z pozorovatelné sekvence podle zadané funkce selektoru klíčů. (Definováno pozorovatelným.) |
|
ToDictionary<TResult, TKey>(Func<TResult, 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<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, TElement>) | Přetíženo. Vytvoří slovník z pozorovatelné sekvence podle zadané funkce selektoru klíčů a funkce selektoru prvků. (Definováno pozorovatelným.) |
|
ToDictionary<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, 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<TResult> | Převede pozorovatelnou sekvenci na výčtovou sekvenci. (Definováno pozorovatelným.) |
|
ToEvent<TResult> | Zveřejňuje pozorovatelnou sekvenci jako objekt s událostí .NET se zadaným zdrojem. (Definováno pozorovatelným.) |
|
ToList<TResult> | Vytvoří seznam z pozorovatelné sekvence. (Definováno pozorovatelným.) |
|
ToLookup<TResult, TKey>(Func<TResult, TKey>) | Přetíženo. Vytvoří vyhledávání z pozorovatelné sekvence podle zadané funkce selektoru klíčů. (Definováno pozorovatelným.) |
|
ToLookup<TResult, TKey>(Func<TResult, 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<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, 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<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, 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.) |
|
ToNotifier<TSource> | Vytvoří zpětné volání oznámení z pozorovatele. (Definováno pozorovatelem.) |
|
ToTask<TResult>() | Přetíženo. Vrátí úlohu, která obsahuje poslední hodnotu pozorovatelné sekvence. (Definuje TaskObservableExtensions.) |
|
ToTask<TResult>(Objekt) | Přetíženo. Vrátí úlohu, která obsahuje poslední hodnotu pozorovatelné sekvence. (Definuje TaskObservableExtensions.) |
|
ToTask<TResult>(CancellationToken) | Přetíženo. Vrátí úlohu, která obsahuje poslední hodnotu pozorovatelné sekvence. (Definuje TaskObservableExtensions.) |
|
ToTask<TResult>(CancellationToken, object) | Přetíženo. Vrátí úlohu, která obsahuje poslední hodnotu pozorovatelné sekvence. (Definuje TaskObservableExtensions.) |
|
Where<TResult>(Func<TResult, Boolean>) | Přetíženo. Filtruje prvky pozorovatelné sekvence na základě predikátu. (Definováno pozorovatelným.) |
|
Where<TResult>(Func<TResult, Int32, Boolean>) | Přetíženo. Filtruje prvky pozorovatelné sekvence na základě predikátu zahrnutím indexu prvku. (Definováno pozorovatelným.) |
|
Window<TResult>(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<TResult>(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.) |
|
Window<TResult>(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.) |
|
Window<TResult>(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.) |
|
Window<TResult>(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.) |
|
Window<TResult>(TimeSpan; Int32) | Přetíženo. Promítá každý prvek pozorovatelné sekvence do okna, které je dokončeno, když je plné nebo uplynula daná doba. (Definováno pozorovatelným.) |
|
Window<TResult>(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.) |
|
Window<TResult>(TimeSpan; Int32; IScheduler) | Přetíženo. Promítá každý prvek pozorovatelné sekvence do okna, které je dokončeno, když je plné nebo uplynula daná doba. (Definováno pozorovatelným.) |
|
Window<TResult, 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<TResult, 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<TResult, TSecond, TResult>(IObservable<TSecond>, Func<TResult, TSecond, TResult>) | Přetíženo. Sloučí dvě pozorovatelné sekvence do jedné pozorovatelné sekvence tím, že zkombinuje jejich prvky párovým způsobem. (Definováno pozorovatelným.) |
|
Zip<TResult, TSecond, TResult>(IEnumerable<TSecond>, Func<TResult, TSecond, TResult>) | Přetíženo. Sloučí pozorovatelnou sekvenci a sekvenci výčtu do jedné pozorovatelné sekvence pomocí funkce selektoru. (Definováno pozorovatelným.) |
Nahoře
Poznámky
Toto rozhraní předmětu poskytuje subjektu flexibilitu sledovat pozorovatelnou sekvenci jednoho typu při publikování pozorovatelné sekvence jiného typu.
Příklady
Tento příklad ukazuje implementaci ISubject<TSource, TResult> , který pozoruje pozorovatelnou sekvenci jednoho typu při publikování pozorovatelné sekvence jiného typu. AsciiConverterSubject v tomto příkladu demonstruje implementaci sledováním sekvencí typu char a publikování pozorovatelné sekvence int. Publikovaná pozorovatelná sekvence int je kód ASCII pro každou hodnotu znaku, kterou pozoruje.
using System;
using System.Collections.Generic;
using System.Reactive.Linq;
using System.Reactive.Subjects;
using System.Reactive.Concurrency;
using System.Reactive.Disposables;
using System.Threading;
namespace Example
{
class Program
{
static void Main()
{
//****************************************************************************************//
//*** Create an observable sequence of char from console input until enter is pressed. ***//
//****************************************************************************************//
IObservable<char> keySequence = Observable.Create<char>(observer =>
{
bool bContinue = true;
while (bContinue)
{
ConsoleKeyInfo keyInfo = Console.ReadKey(true);
if (keyInfo.Key != ConsoleKey.Enter)
{
observer.OnNext(keyInfo.KeyChar);
}
else
{
observer.OnCompleted();
bContinue = false;
}
}
return (() => { });
});
//****************************************************************************************//
//*** Create an AsciiConverterSubject which takes a source type of char and returns an ***//
//*** observable sequence of int which is the ASCII code for source items of char. ***//
//****************************************************************************************//
AsciiConverterSubject myConverterSubject = new AsciiConverterSubject();
//****************************************************************************************//
//*** Subscribe to the keySequence on the .NET threadpool so the main thread can ***//
//*** create subscriptions to the AsciiConverterSubject ***//
//****************************************************************************************//
IDisposable subscription = keySequence.SubscribeOn(Scheduler.ThreadPool).Subscribe(myConverterSubject);
Console.WriteLine("\nEnter a sequence of keys to have the AsciiConverterSubject\nconvert the keys to their ASCII code values.\n");
Console.WriteLine("Press ENTER to terminate the observable sequence...\n");
//****************************************************************************************//
//*** Subscribe to the AsciiConverterSubject and write the ASCII code values to the ***//
//*** console window. ***//
//*** ***//
//*** The main thread will wait on the completion of the keySequence. It completes ***//
//*** when ENTER is pressed. ***//
//****************************************************************************************//
EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset);
myConverterSubject.Subscribe(c => Console.WriteLine("Ascii Char code {0} entered.",c), () => waitHandle.Set());
waitHandle.WaitOne();
//***************************************//
//*** Explicitly releasing resources. ***//
//***************************************//
subscription.Dispose();
myConverterSubject.Dispose();
}
}
//***********************************************************************************************//
//*** ***//
//*** The AsciiConverterSubject demonstrates an implementation of ISubject<TSource, TResult>. ***//
//*** It is used to subscribe to an observable sequence of char. It publishes an observable ***//
//*** sequence of int which should be the ASCII code for each char value it observes. ***//
//*** ***//
//***********************************************************************************************//
class AsciiConverterSubject : ISubject<char, int>, IDisposable
{
private List<IObserver<int>> observerList;
private bool isDisposed;
private bool isStopped;
object gate = new object();
Exception exception;
public AsciiConverterSubject()
{
observerList = new List<IObserver<int>>();
}
public void OnCompleted()
{
//****************************************************************************************//
//*** Make sure the OnCompleted operation is not preempted by another operation ***//
//*** which would break the expected behavior. For example, don't allow an error from ***//
//*** OnError preempt OnCompleted from anotther thread. Then OnCompleted would follow ***//
//*** an error. That would be an incorrect behavior. ***//
//****************************************************************************************//
lock (gate)
{
CheckDisposed();
if (!isStopped)
{
foreach (IObserver<int> observer in observerList)
{
observer.OnCompleted();
}
observerList.Clear();
isStopped = true;
}
}
}
public void OnError(Exception error)
{
if (error == null)
throw new ArgumentException("Exception error should not be null.");
//****************************************************************************************//
//*** Make sure the OnError operation is not preempted by another operation which ***//
//*** would break the expected behavior. For example, don't allow unsubscribe or an ***//
//*** OnCompleted operation to preempt OnError from another thread. This would result ***//
//*** in an error following completion. That would be an incorrect behavior. ***//
//****************************************************************************************//
lock (gate)
{
CheckDisposed();
if (!isStopped)
{
exception = error;
foreach (IObserver<int> observer in observerList)
{
observer.OnError(error);
}
observerList.Clear();
isStopped = true;
}
}
}
public void OnNext(char value)
{
//****************************************************************************************//
//*** Make sure the OnNext operation is not preempted by another operation which ***//
//*** would break the expected behavior. For example, don't allow unsubscribe, errors ***//
//*** or an OnCompleted operation to preempt OnNext from another thread. This would ***//
//*** have the result of items in a sequence following completion, errors, or ***//
//*** unsubscribe. That would be an incorrect behavior. ***//
//****************************************************************************************//
lock (gate)
{
CheckDisposed();
if (!isStopped)
{
foreach (IObserver<int> observer in observerList)
{
observer.OnNext(Convert.ToInt32(value));
}
}
}
}
public IDisposable Subscribe(IObserver<int> observer)
{
if (observer == null)
throw new ArgumentException("observer should not BehaviorSubject null.");
//****************************************************************************************//
//*** Make sure Subscribe occurs in sync with the other operations so we keep the ***//
//*** correct behavior depending on whether an error has occurred or the observable ***//
//*** sequence has completed. ***//
//****************************************************************************************//
lock (gate)
{
CheckDisposed();
if (!isStopped)
{
observerList.Add(observer);
return new Subscription(observer, this);
}
else if (exception != null)
{
observer.OnError(exception);
return Disposable.Empty;
}
else
{
observer.OnCompleted();
return Disposable.Empty;
}
}
}
private void Unsubscribe(IObserver<int> observer)
{
//****************************************************************************************//
//*** Make sure Unsubscribe occurs in sync with the other operations so we keep the ***//
//*** correct behavior. ***//
//****************************************************************************************//
lock (gate)
{
observerList.Remove(observer);
}
}
public void Dispose()
{
//****************************************************************************************//
//*** Make sure Dispose occurs in sync with the other operations so we keep the ***//
//*** correct behavior. For example, Dispose shouldn't preempt the other operations ***//
//*** changing state variables after they have been checked. ***//
//****************************************************************************************//
lock (gate)
{
observerList.Clear();
isStopped = true;
isDisposed = true;
}
}
private void CheckDisposed()
{
if (isDisposed)
throw new ObjectDisposedException("Subject has been disposed.");
}
//************************************************************************************//
//*** ***//
//*** The Subscription class wraps each observer that creates a subscription. This ***//
//*** is needed to expose an IDisposable interface through which a observer can ***//
//*** cancel the subscription. ***//
//*** ***//
//************************************************************************************//
class Subscription : IDisposable
{
private AsciiConverterSubject subject;
private IObserver<int> observer;
public Subscription(IObserver<int> obs, AsciiConverterSubject sub)
{
subject = sub;
observer = obs;
}
public void Dispose()
{
subject.Unsubscribe(observer);
}
}
}
}
Následující výstup byl vygenerován ukázkovým kódem.
Enter a sequence of keys to have the AsciiConverterSubject
convert the keys to their ASCII code values.
Press ENTER to terminate the observable sequence...
Ascii Char code 59 entered.
Ascii Char code 108 entered.
Ascii Char code 115 entered.
Ascii Char code 100 entered.
Ascii Char code 107 entered.
Ascii Char code 102 entered.
Ascii Char code 59 entered.
Ascii Char code 108 entered.
Ascii Char code 115 entered.
Ascii Char code 100 entered.
Ascii Char code 107 entered.
Ascii Char code 102 entered.
Ascii Char code 59 entered.
Ascii Char code 108 entered.
Ascii Char code 115 entered.
Ascii Char code 107 entered.
Ascii Char code 100 entered.
Ascii Char code 59 entered.
Ascii Char code 102 entered.
Ascii Char code 108 entered.
Ascii Char code 115 entered.
Ascii Char code 107 entered.
Ascii Char code 100 entered.