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 jakýkoli typ, který je méně odvozený. Další informace o kovarianci a kontravarianci naleznete v tématu .
outTResult
Typ výsledku.Tento parametr typu je kovariantní. To znamená, že můžete použít buď zadaný typ, nebo jakýkoli typ, který je odvozenější. Další informace o kovarianci a kontravarianci naleznete v tématu .
Typ ISubject<TSource, TResult> zveřejňuje následující členy.
Metody
| Jméno | Popis | |
|---|---|---|
.gif "veřejná metoda")
|
|
(Zděděno z IObserver<TSource>.) |
|
|
OnError | (Zděděno z IObserver<TSource>.) |
|
|
OnNext | (Zděděno z IObserver<TSource>.) |
|
|
přihlásit k odběru | (Zděděno z IObservable<TResult>.) |
Vrchol
Rozšiřující metody
| Jméno | Popis | |
|---|---|---|
.gif "Metoda veřejného rozšíření")
|
|
Přetížený. Použije funkci akumulátoru na pozorovatelnou sekvenci. (Definováno Pozorovatelné.) |
|
|
Aggregate<TResult, TAccumulate>(TAccumulate, Func<TAccumulate, TResult, TAccumulate>) | Přetížený. Použije funkci akumulátoru na pozorovatelnou sekvenci se zadanou počáteční hodnotou. (Definováno Pozorovatelné.) |
|
|
všechny<> TResult | Určuje, zda všechny prvky pozorovatelné sekvence splňují podmínku. (Definováno Pozorovatelné.) |
|
|
Amb<TResult> | Rozšíří pozorovatelnou sekvenci, která reaguje jako první se zadanou první a druhou sekvencí. (Definováno Pozorovatelné.) |
|
|
A<TResult, TRight> | Odpovídá, pokud obě pozorovatelné sekvence mají dostupnou hodnotu. (Definováno Pozorovatelné.) |
|
|
>TResult< | Přetížený. Určuje, zda pozorovatelná sekvence obsahuje jakékoli prvky. (Definováno Pozorovatelné.) |
|
|
libovolný<>TResult (func<TResult, boolean>) | Přetížený. Určuje, zda všechny prvky pozorovatelné sekvence splňují podmínku. (Definováno Pozorovatelné.) |
|
|
< > TResult | Skryje identitu pozorovatelné sekvence. (Definováno Pozorovatelné.) |
|
|
AsObserver<> TSource | Skryje identitu pozorovatele. (Definovánopozorovatelem |
|
|
<TResult> asQbservable | Převede pozorovatelnou sekvenci na pozorovatelnou sekvenci. (Definované Qbservable.) |
|
|
AssertEqual<TResult> | (Definované rozšířeními .) |
|
|
vyrovnávací paměti< TResult>(Int32) | Přetížený. Označuje každý prvek pozorovatelné sekvence do po sobě jdoucích nepřekrývajících vyrovnávacích pamětí, které jsou vytvořeny na základě informací o počtu prvků. (Definováno Pozorovatelné.) |
|
|
vyrovnávací paměti< TResult>(TimeSpan) | Přetížený. Označuje každý prvek pozorovatelné sekvence do po sobě jdoucích nepřekrývajících vyrovnávacích pamětí, které jsou vytvořeny na základě informací o časování. (Definováno Pozorovatelné.) |
|
|
vyrovnávací paměti< TRes>ult (Int32, Int32) | Přetížený. Označuje každý prvek pozorovatelné sekvence do nuly nebo více vyrovnávacích pamětí, které jsou vytvořeny na základě informací o počtu prvků. (Definováno Pozorovatelné.) |
|
|
vyrovnávací paměti<TResult>(TimeSpan, IScheduler) | Přetížený. Označuje každý prvek pozorovatelné sekvence do po sobě jdoucích nepřekrývajících vyrovnávacích pamětí, které jsou vytvořeny na základě informací o časování. (Definováno Pozorovatelné.) |
|
|
vyrovnávací paměti< TResult>(TimeSpan, TimeSpan) | Přetížený. Označuje každý prvek pozorovatelné sekvence do nuly nebo více vyrovnávacích pamětí, které jsou vytvořeny na základě informací o načasování. (Definováno Pozorovatelné.) |
|
|
vyrovnávací paměti< TResult>(TimeSpan, Int32) | Přetížený. Označuje každý prvek pozorovatelné sekvence do vyrovnávací paměti, která se odešle, když je plná nebo uplynula daná doba. (Definováno Pozorovatelné.) |
|
|
|
Přetížený. Označuje každý prvek pozorovatelné sekvence do nuly nebo více vyrovnávacích pamětí, které jsou vytvořeny na základě informací o načasování. (Definováno Pozorovatelné.) |
|
|
|
Přetížený. Označuje každý prvek pozorovatelné sekvence do vyrovnávací paměti, která se odešle, když je plná nebo uplynula daná doba. (Definováno Pozorovatelné.) |
|
|
vyrovnávací paměti<TResult, TBufferClosing>(func<IObservable<TBufferClosing>>) | Přetížený. Označuje každý prvek pozorovatelné sekvence do po sobě jdoucích nepřekrývajících se vyrovnávacích pamětí. (Definováno Pozorovatelné.) |
|
|
vyrovnávací paměti<TResult, TBufferOpening, TBufferClosing>(IObservable<TBufferOpening>, Func<TBufferOpening, IObservable<TBufferClosing>>) | Přetížený. Označuje každý prvek dotazovatelné pozorovatelné sekvence do po sobě jdoucích nepřekrývajících se vyrovnávacích pamětí. (Definováno Pozorovatelné.) |
|
|
|
Přetížený. Pokračuje pozorovatelnou sekvenci, která je ukončena výjimkou s další pozorovatelnou sekvencí. (Definováno Pozorovatelné.) |
|
|
Catch<TResult, TException>(Func<TException, IObservable<TResult>>) | Přetížený. Pokračuje pozorovatelnou sekvenci ukončenou výjimkou zadaného typu s pozorovatelnou sekvencí vytvořenou obslužnou rutinou. (Definováno Pozorovatelné.) |
|
|
CombineLatest<TResult, TSecond, TResult> | Sloučí dvě pozorovatelné sekvence do jedné pozorovatelné sekvence pomocí funkce selektoru, kdykoli jedna z pozorovatelných sekvencí vytvoří prvek. (Definováno Pozorovatelné.) |
|
|
< > TResult | Zřetězí dvě pozorovatelné sekvence. (Definováno Pozorovatelné.) |
|
|
obsahuje<TResult>(TResult). | Přetížený. Určuje, zda pozorovatelná sekvence obsahuje zadaný prvek pomocí výchozího porovnávače rovnosti. (Definováno Pozorovatelné.) |
|
|
obsahuje<TResult>(TResult, IEqualityComparer<TResult>) | Přetížený. Určuje, zda pozorovatelná sekvence obsahuje zadaný prvek pomocí zadaného System.Collections.Generic.IEqualityComparer< T>. (Definováno Pozorovatelné.) |
|
|
Count<TResult> | Vrátí Int32, který představuje celkový počet prvků v pozorovatelné sekvenci. (Definováno Pozorovatelné.) |
|
|
výchozí<TResult>() | Přetížený. Vrátí prvky zadané sekvence nebo výchozí hodnotu parametru typu v jednotonové sekvenci, pokud je sekvence prázdná. (Definováno Pozorovatelné.) |
|
|
|
Přetížený. Vrátí prvky zadané sekvence nebo výchozí hodnotu parametru typu v jednotonové sekvenci, pokud je sekvence prázdná. (Definováno Pozorovatelné.) |
|
|
zpoždění<>TResult (TimeSpan) | Přetížený. Určuje pozorovatelnou sekvenci podle času splnění se zadaným zdrojem a časem dueTime. (Definováno Pozorovatelné.) |
|
|
zpoždění<TResult>(DateTimeOffset) | Přetížený. Určuje pozorovatelnou sekvenci podle času splnění se zadaným zdrojem a časem dueTime. (Definováno Pozorovatelné.) |
|
|
zpoždění<>TResult (TimeSpan, IScheduler) | Přetížený. Určuje pozorovatelnou sekvenci podle času splnění se zadaným zdrojem, dueTime a plánovačem. (Definováno Pozorovatelné.) |
|
|
|
Přetížený. Určuje pozorovatelnou sekvenci podle času splnění se zadaným zdrojem, dueTime a plánovačem. (Definováno Pozorovatelné.) |
|
|
jedinečné< TResult>() | Přetížený. Vrátí pozorovatelnou sekvenci, která obsahuje pouze jedinečné prvky se zadaným zdrojem. (Definováno Pozorovatelné.) |
|
|
|
Přetížený. Vrátí pozorovatelnou sekvenci, která obsahuje pouze odlišné prvky podle porovnávače. (Definováno Pozorovatelné.) |
|
|
distinct<TResult, TKey>(Func<TResult, TKey>) | Přetížený. Vrátí pozorovatelnou sekvenci, která obsahuje pouze jedinečné prvky podle keySelectoru. (Definováno Pozorovatelné.) |
|
|
distinct<TResult, TKey>(Func<TResult, TKey>, IEqualityComparer<TKey>) | Přetížený. Vrátí pozorovatelnou sekvenci, která obsahuje pouze jedinečné prvky podle keySelectoru. (Definováno Pozorovatelné.) |
|
|
DistinctUntilChanged<TResult>() | Přetížený. Vrátí pozorovatelnou sekvenci, která obsahuje pouze jedinečné souvislé prvky se zadaným zdrojem. (Definováno Pozorovatelné.) |
|
|
|
Přetížený. Vrátí pozorovatelnou sekvenci, která obsahuje pouze odlišné souvislé prvky podle porovnávače. (Definováno Pozorovatelné.) |
|
|
DistinctUntilChanged<TResult, TKey>(Func<TResult, TKey>) | Přetížený. Vrátí pozorovatelnou sekvenci, která obsahuje pouze odlišné souvislé prvky podle keySelectoru. (Definováno Pozorovatelné.) |
|
|
DistinctUntilChanged<TResult, TKey>(Func<TResult, TKey>, IEqualityComparer<TKey>) | Přetížený. Vrátí pozorovatelnou sekvenci, která obsahuje pouze odlišné souvislé prvky podle keySelectoru a porovnávače. (Definováno Pozorovatelné.) |
|
|
|
Přetížený. Vyvolá akci pro každý prvek v pozorovatelné sekvenci. (Definováno Pozorovatelné.) |
|
|
|
Přetížený. Vyvolá akci pro každý prvek v pozorovatelné sekvenci a vyvolá akci při výjimečném ukončení pozorovatelné sekvence. (Definováno Pozorovatelné.) |
|
|
|
Přetížený. Vyvolá akci pro každý prvek v pozorovatelné sekvenci a vyvolá akci po řádném ukončení pozorovatelné sekvence. (Definováno Pozorovatelné.) |
|
|
< >TResult (>>akce<TResult,>výjimce< akcí) | Přetížený. Vyvolá akci pro každý prvek v pozorovatelné sekvenci a vyvolá akci při výjimečném ukončení pozorovatelné sekvence. (Definováno Pozorovatelné.) |
|
|
< >TResult (>akce<TResult,>výjimky<akce, akce) | Přetížený. Vyvolá akci pro každý prvek v pozorovatelné sekvenci a vyvolá akci po řádném nebo výjimečném ukončení pozorovatelné sekvence. (Definováno Pozorovatelné.) |
|
|
ElementAt<TResult> | Vrátí prvek v zadaném indexu v sekvenci. (Definováno Pozorovatelné.) |
|
|
elementAtOrDefault<TResult> | Vrátí prvek v zadaném indexu v sekvenci nebo výchozí hodnotu, pokud je index mimo rozsah. (Definováno Pozorovatelné.) |
|
|
< > TResult | Vyvolá zadanou akci po ukončení pozorovatelné sekvence zdroje normálně nebo výjimkou. (Definováno Pozorovatelné.) |
|
|
<TResult>() | Přetížený. Vrátí první prvek pozorovatelné sekvence se zadaným zdrojem. (Definováno Pozorovatelné.) |
|
|
|
Přetížený. Vrátí první prvek pozorovatelné sekvence, která odpovídá predikátu. (Definováno Pozorovatelné.) |
|
|
|
Přetížený. Vrátí první prvek pozorovatelné sekvence nebo výchozí hodnotu, pokud nebyla nalezena žádná hodnota. (Definováno Pozorovatelné.) |
|
|
FirstOrDefault<TResult>(Func<TResult, Boolean>) | Přetížený. Vrátí první prvek pozorovatelné sekvence, která odpovídá predikátu, nebo výchozí hodnotu, pokud se nenajde žádná hodnota. (Definováno Pozorovatelné.) |
|
|
Foo<TResult, R> | (Definováno MyExt.) |
|
|
< > ForEach | Vyvolá akci pro každý prvek v pozorovatelné sekvenci a blokuje, dokud se sekvence neukončí. (Definováno Pozorovatelné.) |
|
|
getEnumerator<TResult> | Vrátí enumerátor, který vyčíslí všechny hodnoty pozorovatelné sekvence. (Definováno Pozorovatelné.) |
|
|
GroupBy<TResult, TKey>(Func<TResult, TKey>) | Přetížený. Seskupí prvky pozorovatelné sekvence podle zadané funkce selektoru kláves. (Definováno Pozorovatelné.) |
|
|
GroupBy<TResult, TKey>(Func<TResult, TKey>, IEqualityComparer<TKey>) | Přetížený. Seskupí prvky pozorovatelné sekvence podle zadané funkce selektoru klíče a porovnávače. (Definováno Pozorovatelné.) |
|
|
GroupBy<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, TElement>) | Přetížený. Seskupí prvky pozorovatelné sekvence a vybere výsledné prvky pomocí zadané funkce. (Definováno Pozorovatelné.) |
|
|
GroupBy<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, TElement>, IEqualityComparer<TKey>) | Přetížený. Seskupí prvky pozorovatelné sekvence podle zadané funkce selektoru klíčů a porovnávače a vybere výsledné prvky pomocí zadané funkce. (Definováno Pozorovatelné.) |
|
|
GroupByUntil<TResult, TKey, TDuration>(Func<TResult, TKey>, Func<IGroupedObservable<TKey, TResult>, IObservable<TDuration>>) | Přetížený. Seskupí prvky pozorovatelné sekvence podle zadané funkce selektoru kláves. (Definováno Pozorovatelné.) |
|
|
GroupByUntil<TResult, TKey, TDuration>(Func<TResult, TKey>, Func<IGroupedObservable<TKey, TResult>, IObservable<TDuration>>, IEqualityComparer<TKey>) | Přetížený. Seskupí prvky pozorovatelné sekvence podle zadané funkce selektoru klíče a porovnávače. (Definováno Pozorovatelné.) |
|
|
GroupByUntil<TResult, TKey, TElement, TDuration>(Func<TResult, TKey>, Func<TResult, TElement>, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>) | Přetížený. Seskupí prvky pozorovatelné sekvence podle zadané funkce selektoru klíčů a vybere výsledné prvky pomocí zadané funkce. (Definováno Pozorovatelné.) |
|
|
GroupByUntil<TResult, TKey, TElement, TDuration>(Func<TResult, TKey>, Func<TResult, TElement>, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>, IEqualityComparer<TKey>) | Přetížený. Seskupí prvky pozorovatelné sekvence podle zadané funkce selektoru klíčů a porovnávače a vybere výsledné prvky pomocí zadané funkce. (Definováno Pozorovatelné.) |
|
|
GroupJoin<TResult, TRight, TLeftDuration, TRightDuration, TResult> | Koreluje prvky dvou sekvencí na základě překrývajících se dob trvání a seskupuje výsledky. (Definováno Pozorovatelné.) |
|
|
IgnoreElements<> | Ignoruje všechny hodnoty v pozorovatelné sekvenci a ponechá jenom zprávy o ukončení. (Definováno Pozorovatelné.) |
|
|
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é.) |
|
|
< < > TResult () | Přetížený. Vrátí poslední prvek pozorovatelné sekvence se zadaným zdrojem. (Definováno Pozorovatelné.) |
|
|
poslední<>TResult (Func<TResult, Boolean>) | Přetížený. Vrátí poslední prvek pozorovatelné sekvence, která odpovídá predikátu. (Definováno Pozorovatelné.) |
|
|
<TResult> | Přetížený. Vrátí poslední prvek v pozorovatelné sekvenci nebo výchozí hodnotu, pokud nebyla nalezena žádná hodnota. (Definováno Pozorovatelné.) |
|
|
LastOrDefault<TResult>(Func<TResult, Boolean>) | Přetížený. Vrátí poslední prvek pozorovatelné sekvence, která odpovídá predikátu, nebo výchozí hodnotu, pokud nebyla nalezena žádná hodnota. (Definováno Pozorovatelné.) |
|
|
nejnovější<> TResult | Vzorkuje nejnovější hodnotu v pozorovatelné sekvenci. (Definováno Pozorovatelné.) |
|
|
LongCount<TResult> | Vrátí Int64, který představuje celkový počet prvků v pozorovatelné sekvenci. (Definováno Pozorovatelné.) |
|
|
materializace<> TResult | Materializuje implicitní oznámení pozorovatelné sekvence jako explicitní hodnoty oznámení. (Definováno Pozorovatelné.) |
|
|
|
Přetížený. Vrátí maximální prvek v pozorovatelné sekvenci. (Definováno Pozorovatelné.) |
|
|
Přetížený. Vrátí maximální hodnotu v pozorovatelné sekvenci podle zadaného porovnávače. (Definováno Pozorovatelné.) | |
|
|
MaxBy<TResult, TKey>(Func<TResult, TKey>) | Přetížený. Vrátí prvky v pozorovatelné sekvenci s maximální hodnotou klíče. (Definováno Pozorovatelné.) |
|
|
MaxBy<TResult, TKey>(Func<TResult, TKey>, IComparer<TKey>) | Přetížený. Vrátí prvky v pozorovatelné sekvenci s maximální hodnotou klíče. (Definováno Pozorovatelné.) |
|
|
sloučení<>TResult (<TResult>IObservable) | Přetížený. Sloučí pozorovatelnou sekvenci pozorovatelných sekvencí do pozorovatelné sekvence. (Definováno Pozorovatelné.) |
|
|
|
Přetížený. Sloučí dvě pozorovatelné sekvence do jedné pozorovatelné sekvence. (Definováno Pozorovatelné.) |
|
|
<TResult>() | Přetížený. Vrátí minimální prvek v pozorovatelné sekvenci. (Definováno Pozorovatelné.) |
|
|
|
Přetížený. Vrátí minimální hodnotu v pozorovatelné sekvenci podle zadaného porovnávače. (Definováno Pozorovatelné.) |
|
|
MinBy<TResult, TKey>(Func<TResult, TKey>) | Přetížený. Vrátí prvky v pozorovatelné sekvenci s minimální hodnotou klíče. (Definováno Pozorovatelné.) |
|
|
MinBy<TResult, TKey>(Func<TResult, TKey>, IComparer<TKey>) | Přetížený. Vrátí prvky v pozorovatelné sekvenci s minimální hodnotou klíče podle zadaného porovnávače. (Definováno Pozorovatelné.) |
|
|
MostRecent<TResult> | Vzorkuje nejnovější hodnotu v pozorovatelné sekvenci. (Definováno Pozorovatelné.) |
|
|
vícesměrové vysílání<TResult,>TResult (ISubject<TResult, TResult>) | Přetížený. Vrátí spojitelnou pozorovatelnou sekvenci, která po připojení způsobí, že zdrojová sekvence odešle výsledky do zadaného předmětu. (Definováno Pozorovatelné.) |
|
|
vícesměrové vysílání<TResult, TIntermediate, TResult>(Func<ISubject<TResult, TIntermediate>>, Func<IObservable<TIntermediate>, IObservable<TResult>>) | Přetížený. Vrátí pozorovatelnou sekvenci, která obsahuje prvky sekvence vytvořené vícesměrovým vysíláním zdrojové sekvence v rámci funkce selektoru. (Definováno Pozorovatelné.) |
|
|
další<> TResult | Vzorkuje další hodnotu (blokující bez ukládání do vyrovnávací paměti) z pozorovatelné sekvence. (Definováno Pozorovatelné.) |
|
|
<TResult>(SynchronizationContext) | Přetížený. Asynchronně upozorňují pozorovatele na zadaný kontext synchronizace. (Definováno Pozorovatelné.) |
|
|
< TResult>(ovládací prvek) | Přetížený. (Definováno ControlObservable.) |
|
|
< TResult>(Dispatcher) | Přetížený. (Definováno DispatcherObservable.) |
|
|
< TResult>(DispatcherScheduler) | Přetížený. (Definováno DispatcherObservable.) |
|
|
|
Přetížený. Asynchronně upozorňují pozorovatele na zadaný plánovač. (Definováno Pozorovatelné.) |
|
|
(Definováno DispatcherObservable.) | |
|
|
OnErrorResumeNext<TResult> | Pokračuje pozorovatelnou sekvenci, která je ukončena normálně nebo výjimkou s další pozorovatelnou sekvencí. (Definováno Pozorovatelné.) |
|
|
publikování< TResult>() | Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí. (Definováno Pozorovatelné.) |
|
|
publikování<TResult>(TResult) | Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí a začíná počáteční hodnotou. (Definováno Pozorovatelné.) |
|
|
Publikovat<TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>) | Přetížený. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru v připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou sekvencí. (Definováno Pozorovatelné.) |
|
|
Publikování<TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>, TResult) | Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí a začíná počáteční hodnotou. (Definováno Pozorovatelné.) |
|
|
Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí obsahující pouze poslední oznámení. (Definováno Pozorovatelné.) | |
|
|
PublishLast<TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>) | Přetížený. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru v připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou sekvencí obsahující pouze poslední oznámení. (Definováno Pozorovatelné.) |
|
|
opakovat< TResult>() | Přetížený. Opakuje pozorovatelnou sekvenci po neomezenou dobu. (Definováno Pozorovatelné.) |
|
|
opakování<>TResult (Int32) | Přetížený. Opakuje pozorovatelnou sekvenci po neomezenou dobu. (Definováno Pozorovatelné.) |
|
|
přehrání<> TResult () | Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí, která přehrává všechna oznámení. (Definováno Pozorovatelné.) |
|
|
přehrání< TResult>(TimeSpan) | Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí, která přehrává všechna oznámení v okně. (Definováno Pozorovatelné.) |
|
|
přehrání<>TResult (Int32) | Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí, která přehrává oznámení bufferSize. (Definováno Pozorovatelné.) |
|
|
|
Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí, která přehrává všechna oznámení. (Definováno Pozorovatelné.) |
|
|
přehrání<>TResult (TimeSpan, IScheduler) | Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí, která přehrává všechna oznámení v okně. (Definováno Pozorovatelné.) |
|
|
přehrání<>TResult (Int32, IScheduler) | Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí, která přehrává oznámení bufferSize. (Definováno Pozorovatelné.) |
|
|
přehrání<>TResult (Int32, TimeSpan) | Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí přehrání oznámení bufferSize v okně. (Definováno Pozorovatelné.) |
|
|
přehrání<>TResult (Int32, TimeSpan, IScheduler) | Přetížený. Vrátí připojitelnou pozorovatelnou sekvenci, která sdílí jedno předplatné s podkladovou sekvencí přehrání oznámení bufferSize v okně. (Definováno Pozorovatelné.) |
|
|
Přehrání<TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>) | Přetížený. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru na připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou sekvencí a začíná počáteční hodnotou. (Definováno Pozorovatelné.) |
|
|
Přehrát<TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>, IScheduler) | Přetížený. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru na připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou sekvencí, která přehrává všechna oznámení. (Definováno Pozorovatelné.) |
|
|
Přehrát<TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>, TimeSpan) | Přetížený. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru na připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou sekvencí, která přehrává všechna oznámení v okně. (Definováno Pozorovatelné.) |
|
|
Přehrát<TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>, Int32) | Přetížený. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru na připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou sekvencí přehrání oznámení bufferSize. (Definováno Pozorovatelné.) |
|
|
Přehrát<TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>, TimeSpan, IScheduler) | Přetížený. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru na připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou sekvencí, která přehrává všechna oznámení v okně. (Definováno Pozorovatelné.) |
|
|
Přehrát<TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>, Int32, IScheduler) | Přetížený. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru na připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou sekvencí přehrání oznámení bufferSize. (Definováno Pozorovatelné.) |
|
|
Přehrání<TResult,>TResult (Func<IObservable<TResult>, IObservable<TResult>>, Int32, TimeSpan) | Přetížený. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru v připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou sekvencí přehrání oznámení bufferSize v okně. (Definováno Pozorovatelné.) |
|
|
Přehrání<TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>, Int32, TimeSpan, IScheduler) | Přetížený. Vrátí pozorovatelnou sekvenci, která je výsledkem vyvolání selektoru v připojitelné pozorovatelné sekvenci, která sdílí jedno předplatné s podkladovou sekvencí přehrání oznámení bufferSize v okně. (Definováno Pozorovatelné.) |
|
|
opakování< TResult>() | Přetížený. Opakuje pozorovatelnou sekvenci zdroje, dokud se úspěšně neukončila. (Definováno Pozorovatelné.) |
|
|
opakování<TResult>(Int32) | Přetížený. Opakuje pozorovatelnou sekvenci zdroje, dokud se úspěšně neukončila. (Definováno Pozorovatelné.) |
|
|
ukázka<>TResult (TimeSpan) | Přetížený. Vzorkuje pozorovatelnou sekvenci v každém intervalu. (Definováno Pozorovatelné.) |
|
|
ukázky<>TResult (TimeSpan, IScheduler) | Přetížený. Vzorkuje pozorovatelnou sekvenci v každém intervalu pomocí zadaného zdroje, intervalu a plánovače. (Definováno Pozorovatelné.) |
|
|
ukázka<TResult, TSample>(>TSample<IObservable) | Přetížený. Vzorkuje pozorovatelnou sekvenci při vzorkování pomocí zadaného zdroje a vzorkovače. (Definováno Pozorovatelné.) |
|
|
<TResult>(Func<TResult, TResult, TResult>) | Přetížený. Použije funkci akumulátoru na pozorovatelnou sekvenci a vrátí každý zprostředkující výsledek se zadaným zdrojem a akumulátorem. (Definováno Pozorovatelné.) |
|
|
Skenování<TResult, TAccumulate>(TAccumulate, Func<TAccumulate, TResult, TAccumulate>) | Přetížený. Použije funkci akumulátoru na pozorovatelnou sekvenci a vrátí každý zprostředkující výsledek se zadaným zdrojem, semenem a akumulátorem. (Definováno Pozorovatelné.) |
|
|
vyberte<TResult, TResult>(Func<TResult, TResult>) | Přetížený. Prodá každý prvek pozorovatelné sekvence do nového formuláře se zadaným zdrojem a selektorem. (Definováno Pozorovatelné.) |
|
|
vyberte<TResult, TResult>(Func<TResult, Int32, TResult>) | Přetížený. Prodá každý prvek pozorovatelné sekvence do nového formuláře zahrnutím indexu prvku se zadaným zdrojem a selektorem. (Definováno Pozorovatelné.) |
|
|
SelectMany<TResult, TOther>(IObservable<TOther>) | Přetížený. Prodá každý prvek pozorovatelné sekvence do pozorovatelné sekvence a zploštějí výsledné pozorovatelné sekvence do jedné pozorovatelné sekvence. (Definováno Pozorovatelné.) |
|
|
SelectMany<TResult, TResult>(Func<TResult, IObservable<TResult>>) | Přetížený. Prodá každý prvek pozorovatelné sekvence do pozorovatelné sekvence a zploštějí výsledné pozorovatelné sekvence do jedné pozorovatelné sekvence. (Definováno Pozorovatelné.) |
|
|
SelectMany<TResult, TResult>(Func<TResult, IEnumerable<TResult>>) | Přetížený. Prodá každý prvek pozorovatelné sekvence do pozorovatelné sekvence a zploštějí výsledné pozorovatelné sekvence do jedné pozorovatelné sekvence. (Definováno Pozorovatelné.) |
|
|
SelectMany<TResult, TResult>(Func<TResult, IObservable<TResult>>, Func<Exception, IObservable<TResult>>, Func<IObservable<TResult>>) | Přetížený. Prodá každý prvek pozorovatelné sekvence do pozorovatelné sekvence a zploštějí výsledné pozorovatelné sekvence do jedné pozorovatelné sekvence. (Definováno Pozorovatelné.) |
|
|
SelectMany<TResult, TCollection, TResult>(Func<TResult, IEnumerable<TCollection>>, Func<TResult, TCollection, TResult>) | Přetížený. Prodá každý prvek pozorovatelné sekvence do pozorovatelné sekvence a zploštějí výsledné pozorovatelné sekvence do jedné pozorovatelné sekvence. (Definováno Pozorovatelné.) |
|
|
SelectMany<TResult, TCollection, TResult>(Func<TResult, IObservable<TCollection>>, Func<TResult, TCollection, TResult>) | Přetížený. Prodá každý prvek pozorovatelné sekvence do pozorovatelné sekvence a zploštějí výsledné pozorovatelné sekvence do jedné pozorovatelné sekvence. (Definováno Pozorovatelné.) |
|
|
|
Přetížený. Určuje, zda jsou dvě sekvence stejné porovnáním prvků spárováním. (Definováno Pozorovatelné.) |
|
|
SequenceEqual<TResult>(IObservable<TResult>, IEqualityComparer<TResult>) | Přetížený. Určuje, zda jsou dvě sekvence stejné porovnáním prvků ve dvojici pomocí zadaného porovnávače rovnosti. (Definováno Pozorovatelné.) |
|
|
Přetížený. Vrátí jediný prvek pozorovatelné sekvence a vyvolá výjimku, pokud v pozorovatelné sekvenci není právě jeden prvek. (Definováno Pozorovatelné.) | |
|
|
< > <TResult<TResult, boolean>) | Přetížený. Vrátí jediný prvek pozorovatelné sekvence, která odpovídá predikátu a vyvolá výjimku, pokud v pozorovatelné sekvenci není právě jeden prvek. (Definováno Pozorovatelné.) |
|
|
<TResult> | Přetížený. Vrátí jediný prvek pozorovatelné sekvence nebo výchozí hodnotu, pokud je pozorovatelná sekvence prázdná. (Definováno Pozorovatelné.) |
|
|
SingleOrDefault<TResult>(Func<TResult, Boolean>) | Přetížený. Vrátí jediný prvek pozorovatelné sekvence, která odpovídá predikátu, nebo výchozí hodnotu, pokud nebyla nalezena žádná hodnota. (Definováno Pozorovatelné.) |
|
|
přeskočit<> TResult | Obchází zadaný počet hodnot v pozorovatelné sekvenci a vrátí zbývající hodnoty. (Definováno Pozorovatelné.) |
|
|
SkipLast<TResult> | Obchází zadaný počet prvků na konci pozorovatelné sekvence. (Definováno Pozorovatelné.) |
|
|
SkipUntil<TResult, TOther> | Vrátí hodnoty ze zdrojové pozorovatelné sekvence až poté, co druhá pozorovatelná sekvence vytvoří hodnotu. (Definováno Pozorovatelné.) |
|
|
SkipWhile<TResult>(Func<TResult, Boolean>) | Přetížený. Obchází hodnoty v pozorovatelné sekvenci, pokud je zadaná podmínka pravdivá a vrátí zbývající hodnoty. (Definováno Pozorovatelné.) |
|
|
SkipWhile<TResult>(Func<TResult, Int32, Boolean>) | Přetížený. Obchází hodnoty v pozorovatelné sekvenci, pokud je zadaná podmínka pravdivá a vrátí zbývající hodnoty. (Definováno Pozorovatelné.) |
|
|
StartWith<TResult>TResult[]) | Přetížený. Předzálohuje posloupnost hodnot na pozorovatelnou sekvenci se zadaným zdrojem a hodnotami. (Definováno Pozorovatelné.) |
|
|
StartWith<TResult>(IScheduler, TResult[]) | Přetížený. Předpendí posloupnost hodnot do pozorovatelné sekvence se zadaným zdrojem, plánovačem a hodnotami. (Definováno Pozorovatelné.) |
|
|
přihlásit k odběru< TResult>() | Přetížený. Vyhodnotí pozorovatelnou sekvenci se zadaným zdrojem. (Definováno ObservableExtensions.) |
|
|
přihlásit k odběru<>TResult (akce<TResult>) | Přetížený. Přihlásí obslužnou rutinu elementu k pozorovatelné sekvenci. (Definováno ObservableExtensions.) |
|
|
přihlásit k odběru<>TResult (>akce<TResult ,>výjimka<akcí ) | Přetížený. Přihlásí obslužnou rutinu elementu a obslužnou rutinu výjimky k pozorovatelné sekvenci. (Definováno ObservableExtensions.) |
|
|
přihlásit k odběru<>TResult (akce<TResult>, akce) | Přetížený. Přihlásí obslužnou rutinu elementu a obslužnou rutinu dokončení k pozorovatelné sekvenci. (Definováno ObservableExtensions.) |
|
|
přihlásit k odběru<>TResult (akce<TResult>,>výjimka<akce, akce) | Přetížený. Přihlásí obslužnou rutinu elementu, obslužnou rutinu výjimky a obslužnou rutinu dokončení k pozorovatelné sekvenci. (Definováno ObservableExtensions.) |
|
|
< odběru TResult>(SynchronizationContext) | Přetížený. Asynchronně odebírá a odebírá pozorovatele v zadaném kontextu synchronizace. (Definováno Pozorovatelné.) |
|
|
přihlásit k odběru<>TResult (ovládací prvek) | Přetížený. (Definováno ControlObservable.) |
|
|
< < TResult>(Dispatcher) | Přetížený. (Definováno DispatcherObservable.) |
|
|
|
Přetížený. (Definováno DispatcherObservable.) |
|
|
předplatného<TResult>(IScheduler) | Přetížený. Asynchronně odebírá a odebírá pozorovatele v zadaném plánovači. (Definováno Pozorovatelné.) |
|
|
SubscribeOnDispatcher<TResult> | (Definováno DispatcherObservable.) |
|
|
synchronizace< TResult>() | Přetížený. Synchronizuje pozorovatelnou sekvenci. (Definováno Pozorovatelné.) |
|
|
synchronizace<TResult>(objektu) | Přetížený. Synchronizuje pozorovatelnou sekvenci. (Definováno Pozorovatelné.) |
|
|
> <TResult | Vrátí zadaný počet souvislých hodnot od začátku pozorovatelné sekvence. (Definováno Pozorovatelné.) |
|
|
< > TResult<TakeLast | Vrátí zadaný počet souvislých prvků od konce pozorovatelné sekvence. (Definováno Pozorovatelné.) |
|
|
TakeUntil<TResult, TOther> | Vrátí hodnoty ze zdrojové pozorovatelné sekvence, dokud druhá pozorovatelná sekvence nevytvoří hodnotu. (Definováno Pozorovatelné.) |
|
|
<TResult>(Func<TResult, Boolean>) | Přetížený. Vrátí hodnoty z pozorovatelné sekvence, pokud je zadaná podmínka pravdivá a zbývající hodnoty přeskočí. (Definováno Pozorovatelné.) |
|
|
<TResult>(Func<TResult, Int32, Boolean>) | Přetížený. Vrátí hodnoty z pozorovatelné sekvence, pokud je zadaná podmínka pravdivá a zbývající hodnoty přeskočí. (Definováno Pozorovatelné.) |
|
|
pak<TResult, TResult> | Porovná, když pozorovatelná posloupnost má dostupnou hodnotu a projektuje hodnotu. (Definováno Pozorovatelné.) |
|
|
omezení<>TResult (TimeSpan) | Přetížený. Přeskočí hodnoty z pozorovatelné sekvence, za kterou následuje jiná hodnota před časem splnění se zadaným zdrojem a časem dueTime. (Definováno Pozorovatelné.) |
|
|
omezení<>TResult (TimeSpan, IScheduler) | Přetížený. Přeskočí hodnoty z pozorovatelné sekvence, za kterou následuje jiná hodnota před časem splnění se zadaným zdrojem, dueTime a plánovačem. (Definováno Pozorovatelné.) |
|
|
|
Přetížený. Zaznamenává časový interval mezi po sobě jdoucími hodnotami v pozorovatelné sekvenci se zadaným zdrojem. (Definováno Pozorovatelné.) |
|
|
|
Přetížený. Zaznamenává časový interval mezi po sobě jdoucími hodnotami v pozorovatelné sekvenci se zadaným zdrojem a plánovačem. (Definováno Pozorovatelné.) |
|
|
vypršení časového limitu< TResult>(TimeSpan) | Přetížený. Vrátí pozorovatelnou sekvenci nebo výjimku TimeoutException, pokud vyprší dueTime. (Definováno Pozorovatelné.) |
|
|
vypršení časového limitu<TResult>(DateTimeOffset) | Přetížený. Vrátí pozorovatelnou sekvenci nebo hodnotu TimeoutException, pokud vyprší dueTime. (Definováno Pozorovatelné.) |
|
|
vypršení časového limitu<>TResult (TimeSpan, IObservable<TResult>) | Přetížený. Vrátí pozorovatelnou sekvenci zdroje nebo jinou pozorovatelnou sekvenci, pokud dueTime uplynou. (Definováno Pozorovatelné.) |
|
|
vypršení časového limitu<TResult>(DateTimeOffset, IObservable<TResult>) | Přetížený. Vrátí pozorovatelnou sekvenci nebo výjimku TimeoutException, pokud vyprší dueTime. (Definováno Pozorovatelné.) |
|
|
vypršení časového limitu<>TResult (TimeSpan, IScheduler) | Přetížený. Vrátí pozorovatelnou sekvenci nebo výjimku TimeoutException, pokud vyprší dueTime. (Definováno Pozorovatelné.) |
|
|
vypršení časového limitu<TResult>(DateTimeOffset, IScheduler) | Přetížený. Vrátí pozorovatelnou sekvenci nebo výjimku TimeoutException, pokud vyprší dueTime. (Definováno Pozorovatelné.) |
|
|
vypršení časového limitu<TResult>(TimeSpan, IObservable<TResult>, IScheduler) | Přetížený. Vrátí pozorovatelnou sekvenci zdroje nebo jinou pozorovatelnou sekvenci, pokud dueTime uplynou. (Definováno Pozorovatelné.) |
|
|
vypršení časového limitu<TResult>(DateTimeOffset, IObservable<TResult>, IScheduler) | Přetížený. Vrátí pozorovatelnou sekvenci zdroje nebo jinou pozorovatelnou sekvenci, pokud dueTime uplynou. (Definováno Pozorovatelné.) |
|
|
časové razítko< TResult>() | Přetížený. Zaznamenává časové razítko pro každou hodnotu v pozorovatelné sekvenci se zadaným zdrojem. (Definováno Pozorovatelné.) |
|
|
|
Přetížený. Zaznamenává časové razítko pro každou hodnotu v pozorovatelné sekvenci se zadaným zdrojem a plánovačem. (Definováno Pozorovatelné.) |
|
|
ToArray<> TResult | Vytvoří pole z pozorovatelné sekvence. (Definováno Pozorovatelné.) |
|
|
ToDictionary<TResult, TKey>(Func<TResult, TKey>) | Přetížený. Vytvoří slovník z pozorovatelné sekvence podle zadané funkce selektoru kláves. (Definováno Pozorovatelné.) |
|
|
ToDictionary<TResult, TKey>(Func<TResult, TKey>, IEqualityComparer<TKey>) | Přetížený. Vytvoří slovník z pozorovatelné sekvence podle zadané funkce selektoru klíčů a porovnávače. (Definováno Pozorovatelné.) |
|
|
ToDictionary<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, TElement>) | Přetížený. Vytvoří slovník z pozorovatelné sekvence podle zadané funkce selektoru kláves a funkce selektoru prvku. (Definováno Pozorovatelné.) |
|
|
ToDictionary<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, TElement>, IEqualityComparer<TKey>) | Přetížený. Vytvoří slovník z pozorovatelné sekvence podle zadané funkce selektoru klíče, porovnávače a funkce selektoru prvku. (Definováno Pozorovatelné.) |
|
|
toEnumerable<TResult> | Převede pozorovatelnou sekvenci na výčet. (Definováno Pozorovatelné.) |
|
|
toEvent<TResult> | Zveřejňuje pozorovatelnou sekvenci jako objekt s událostí .NET se zadaným zdrojem. (Definováno Pozorovatelné.) |
|
|
toList<TResult> | Vytvoří seznam z pozorovatelné sekvence. (Definováno Pozorovatelné.) |
|
|
ToLookup<TResult, TKey>(Func<TResult, TKey>) | Přetížený. Vytvoří vyhledávání z pozorovatelné sekvence podle zadané funkce selektoru kláves. (Definováno Pozorovatelné.) |
|
|
ToLookup<TResult, TKey>(Func<TResult, TKey>, IEqualityComparer<TKey>) | Přetížený. Vytvoří vyhledávání z pozorovatelné sekvence podle zadané funkce selektoru klíče a porovnávače. (Definováno Pozorovatelné.) |
|
|
ToLookup<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, TElement>) | Přetížený. Vytvoří vyhledávání z pozorovatelné sekvence podle zadané funkce selektoru kláves a funkce selektoru prvku. (Definováno Pozorovatelné.) |
|
|
ToLookup<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, TElement>, IEqualityComparer<TKey>) | Přetížený. Vytvoří vyhledávání z pozorovatelné sekvence podle zadané funkce selektoru klíče, porovnávače a funkce selektoru prvků. (Definováno Pozorovatelné.) |
|
|
< > TSource toNotifier | Vytvoří zpětné volání oznámení od pozorovatele. (Definovánopozorovatelem |
|
|
<TResult>() | Přetížený. Vrátí úlohu, která obsahuje poslední hodnotu pozorovatelného pořadí. (Definované TaskObservableExtensions.) |
|
|
toTask<TResult>(objekt) | Přetížený. Vrátí úlohu, která obsahuje poslední hodnotu pozorovatelného pořadí. (Definované TaskObservableExtensions.) |
|
|
|
Přetížený. Vrátí úlohu, která obsahuje poslední hodnotu pozorovatelného pořadí. (Definované TaskObservableExtensions.) |
|
|
|
Přetížený. Vrátí úlohu, která obsahuje poslední hodnotu pozorovatelného pořadí. (Definované TaskObservableExtensions.) |
|
|
kde<>TResult (Func<TResult, Boolean>) | Přetížený. Filtruje prvky pozorovatelné sekvence na základě predikátu. (Definováno Pozorovatelné.) |
|
|
kde<>TResult (Func<TResult, Int32, Boolean>) | Přetížený. Filtruje prvky pozorovatelné sekvence na základě predikátu zahrnutím indexu prvku. (Definováno Pozorovatelné.) |
|
|
okna |
Přetížený. Prodá každý prvek pozorovatelné sekvence do po sobě jdoucích nepřekrývajících se oken, které jsou vytvářeny na základě informací o počtu prvků. (Definováno Pozorovatelné.) |
|
|
|
Přetížený. Prodá jednotlivé prvky pozorovatelné sekvence do po sobě jdoucích nepřekrývajících se oken vytvořených na základě informací o časování. (Definováno Pozorovatelné.) |
|
|
okno< TResult>(Int32, Int32) | Přetížený. Prodá každý prvek pozorovatelné sekvence do nuly nebo více oken vytvořených na základě informací o počtu prvků. (Definováno Pozorovatelné.) |
|
|
okno<TResult>(TimeSpan, IScheduler) | Přetížený. Prodá jednotlivé prvky pozorovatelné sekvence do po sobě jdoucích nepřekrývajících se oken vytvořených na základě informací o časování. (Definováno Pozorovatelné.) |
|
|
okno< TResult>(TimeSpan, TimeSpan) | Přetížený. Prodá každý prvek pozorovatelné sekvence do nuly nebo více oken vytvořených na základě informací o časování. (Definováno Pozorovatelné.) |
|
|
okno< TResult>(TimeSpan, Int32) | Přetížený. Prodá každý prvek pozorovatelné sekvence do okna, které je dokončeno, když je plný nebo uplynula daná doba. (Definováno Pozorovatelné.) |
|
|
okno<>TResult (TimeSpan, TimeSpan, IScheduler) | Přetížený. Prodá každý prvek pozorovatelné sekvence do nuly nebo více oken vytvořených na základě informací o časování. (Definováno Pozorovatelné.) |
|
|
Okno<TResult>(TimeSpan, Int32, IScheduler) | Přetížený. Prodá každý prvek pozorovatelné sekvence do okna, které je dokončeno, když je plný nebo uplynula daná doba. (Definováno Pozorovatelné.) |
|
|
Okno<TResult, TWindowClosing>(Func<IObservable<TWindowClosing>>) | Přetížený. Prodá jednotlivé prvky pozorovatelné sekvence do po sobě jdoucích nepřekrývajících se oken. (Definováno Pozorovatelné.) |
|
|
Window<TResult, TWindowOpening, TWindowClosing>(IObservable<TWindowOpening>, Func<TWindowOpening, IObservable<TWindowClosing>>) | Přetížený. Prodá každý prvek pozorovatelné sekvence do nuly nebo více oken. (Definováno Pozorovatelné.) |
|
|
Zip<TResult, TSecond, TResult>(IObservable<TSecond>, Func<TResult, TSecond, TResult>) | Přetížený. Sloučí dvě pozorovatelné sekvence do jedné pozorovatelné sekvence tím, že zkombinuje jejich prvky spárováním. (Definováno Pozorovatelné.) |
|
|
Zip<TResult, TSecond, TResult>(IEnumerable<TSecond>, Func<TResult, TSecond, TResult>) | Přetížený. Sloučí pozorovatelnou sekvenci a výčet do jedné pozorovatelné sekvence pomocí funkce selektoru. (Definováno Pozorovatelné.) |
Vrchol
Poznámky
Toto rozhraní předmětu poskytuje flexibilitu předmětu 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á sleduje pozorovatelnou posloupnost jednoho typu při publikování pozorovatelné sekvence jiného typu. AsciiConverterSubject v tomto příkladu ukazuje implementaci sledováním sekvencí typu char a publikování pozorovatelné sekvence int. Publikovaná pozorovatelná posloupnost int je kód ASCII pro každou hodnotu znaku, kterou sleduje.
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);
}
}
}
}
Ukázkový kód vygeneroval následující výstup.
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.