ISubject<TSource, TResult>, interfejs
Reprezentuje obiekt, który jest zarówno obserwowaną sekwencją, jak i obserwatorem.
przestrzeni nazw:System.Reactive.Subjects
zestaw : system.Reaktywny (w System.Reactive.dll)
Składnia
'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 źródła.Ten parametr typu jest kontrawariantny. Oznacza to, że można użyć określonego typu lub dowolnego typu, który jest mniej pochodny. Aby uzyskać więcej informacji na temat kowariancji i kontrawariancji, zobacz .
outTResult
Typ wyniku.Ten parametr typu jest kowariantny. Oznacza to, że można użyć określonego typu lub dowolnego typu, który jest bardziej pochodny. Aby uzyskać więcej informacji na temat kowariancji i kontrawariancji, zobacz .
Typ ISubject<TSource, TResult> uwidacznia następujące elementy członkowskie.
Metody
| Nazwa | Opis | |
|---|---|---|
| |
OnCompleted | (Dziedziczone z IObserver<TSource>.) |
| |
OnError | (Dziedziczone z IObserver<TSource>.) |
| |
OnNext | (Dziedziczone z IObserver<TSource>.) |
| |
subskrybuj | (Dziedziczone z IObservable<TResult>.) |
Do góry
Metody rozszerzeń
| Nazwa | Opis | |
|---|---|---|
.gif "metodę publicznego rozszerzenia")
|
aggregate<TResult>(Func<TResult, TResult, TResult, TResult>) | Przeciążone. Stosuje funkcję akumula w obserwowalnej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
Agregacja<TResult, TAccumulate>(TAccumulate, Func<TAccumulate, TResult, TAccumulate>) | Przeciążone. Stosuje funkcję akumula w obserwowalnej sekwencji z określoną wartością nasion. (Zdefiniowane przez obserwowalne.) |
|
|
Wszystkie<TResult> | Określa, czy wszystkie elementy obserwowanej sekwencji spełniają warunek. (Zdefiniowane przez obserwowalne.) |
|
|
> TResult<Amb | Propaguje obserwowaną sekwencję, która reaguje najpierw z określoną pierwszą i drugą sekwencją. (Zdefiniowane przez obserwowalne.) |
|
|
I<TResult, TRight> | Dopasowania, gdy obie obserwowane sekwencje mają dostępną wartość. (Zdefiniowane przez obserwowalne.) |
|
|
< > < | Przeciążone. Określa, czy obserwowana sekwencja zawiera jakiekolwiek elementy. (Zdefiniowane przez obserwowalne.) |
|
|
< >TResult (Func<TResult, logiczna>) | Przeciążone. Określa, czy wszystkie elementy obserwowanej sekwencji spełniają warunek. (Zdefiniowane przez obserwowalne.) |
|
|
AsObservable<TResult> | Ukrywa tożsamość obserwowanej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
AsObserver<TSource> | Ukrywa tożsamość obserwatora. (Zdefiniowane przez Observer.) |
|
|
AsQbservable<TResult> | Konwertuje obserwowaną sekwencję na sekwencję obserwowaną z możliwością wykonywania zapytań. (Zdefiniowane przez Qbservable). |
|
|
AssertEqual<TResult> | (Zdefiniowane przez Extensions.) |
|
|
|
Przeciążone. Wskazuje każdy element obserwowalnej sekwencji do kolejnych nienakładających się, które są generowane na podstawie informacji o liczbie elementów. (Zdefiniowane przez obserwowalne.) |
|
|
Przeciążone. Wskazuje każdy element obserwowalnej sekwencji do kolejnych nienakładających się, które są generowane na podstawie informacji o chronometrażu. (Zdefiniowane przez obserwowalne.) | |
|
|
|
Przeciążone. Wskazuje każdy element obserwowalnej sekwencji na zero lub więcej, które są generowane na podstawie informacji o liczbie elementów. (Zdefiniowane przez obserwowalne.) |
|
|
Przeciążone. Wskazuje każdy element obserwowalnej sekwencji do kolejnych nienakładających się, które są generowane na podstawie informacji o chronometrażu. (Zdefiniowane przez obserwowalne.) | |
|
|
|
Przeciążone. Wskazuje każdy element obserwowalnej sekwencji na zero lub więcej, które są generowane na podstawie informacji o chronometrażu. (Zdefiniowane przez obserwowalne.) |
|
|
|
Przeciążone. Wskazuje każdy element obserwowalnej sekwencji w bufor, który jest wysyłany, gdy upłynie pełny lub określony czas. (Zdefiniowane przez obserwowalne.) |
|
|
|
Przeciążone. Wskazuje każdy element obserwowalnej sekwencji na zero lub więcej, które są generowane na podstawie informacji o chronometrażu. (Zdefiniowane przez obserwowalne.) |
|
|
Przeciążone. Wskazuje każdy element obserwowalnej sekwencji w bufor, który jest wysyłany, gdy upłynie pełny lub określony czas. (Zdefiniowane przez obserwowalne.) | |
|
|
Buffer<TResult, TBufferClosing>(Func<IObservable<TBufferClosing>>) | Przeciążone. Wskazuje każdy element obserwowalnej sekwencji w kolejnych nienakładających się. (Zdefiniowane przez obserwowalne.) |
|
|
Buffer<TResult, TBufferOpening, TBufferClosing>(IObservable<TBufferOpening>, Func<TBufferOpening, IObservable<TBufferClosing>>) | Przeciążone. Wskazuje każdy element możliwej do obserwowania sekwencji zapytań do kolejnych nienakładających się. (Zdefiniowane przez obserwowalne.) |
|
|
|
Przeciążone. Kontynuuje obserwowaną sekwencję, która jest przerywana przez wyjątek z kolejną obserwowaną sekwencją. (Zdefiniowane przez obserwowalne.) |
|
|
Catch<TResult, TException>(Func<TException, IObservable<TResult>>) | Przeciążone. Kontynuuje obserwowaną sekwencję, która jest przerywana przez wyjątek określonego typu z obserwowaną sekwencją utworzoną przez program obsługi. (Zdefiniowane przez obserwowalne.) |
|
|
CombineLatest<TResult, TSecond, TResult> | Scala dwie obserwowane sekwencje w jedną zauważalną sekwencję przy użyciu funkcji selektora, gdy jedna z obserwowanych sekwencji tworzy element. (Zdefiniowane przez obserwowalne.) |
|
|
Concat<TResult> | Łączy dwie obserwowane sekwencje. (Zdefiniowane przez obserwowalne.) |
|
|
zawiera<TResult>(TResult) | Przeciążone. Określa, czy obserwowana sekwencja zawiera określony element przy użyciu domyślnego modułu porównywania równości. (Zdefiniowane przez obserwowalne.) |
|
|
zawiera><TResult (TResult, IEqualityComparer<TResult>) | Przeciążone. Określa, czy obserwowana sekwencja zawiera określony element przy użyciu określonego elementu System.Collections.Generic.IEqualityComparer< T>. (Zdefiniowane przez obserwowalne.) |
|
|
count<TResult> | Zwraca Int32, która reprezentuje łączną liczbę elementów w obserwowalnej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
DefaultIfEmpty<>TResult () | Przeciążone. Zwraca elementy określonej sekwencji lub wartość domyślną parametru typu w pojedynczej sekwencji, jeśli sekwencja jest pusta. (Zdefiniowane przez obserwowalne.) |
|
|
|
Przeciążone. Zwraca elementy określonej sekwencji lub wartość domyślną parametru typu w pojedynczej sekwencji, jeśli sekwencja jest pusta. (Zdefiniowane przez obserwowalne.) |
|
|
Przeciążone. Wskazuje obserwowaną sekwencję w odpowiednim czasie z określonym źródłem i dueTime. (Zdefiniowane przez obserwowalne.) | |
|
|
|
Przeciążone. Wskazuje obserwowaną sekwencję w odpowiednim czasie z określonym źródłem i dueTime. (Zdefiniowane przez obserwowalne.) |
|
|
< >TResult (TimeSpan, IScheduler) | Przeciążone. Wskazuje obserwowaną sekwencję według czasu ukończenia z określonym źródłem, dueTime i harmonogramem. (Zdefiniowane przez obserwowalne.) |
|
|
|
Przeciążone. Wskazuje obserwowaną sekwencję według czasu ukończenia z określonym źródłem, dueTime i harmonogramem. (Zdefiniowane przez obserwowalne.) |
|
|
Distinct<TResult>() | Przeciążone. Zwraca obserwowaną sekwencję zawierającą tylko odrębne elementy z określonym źródłem. (Zdefiniowane przez obserwowalne.) |
|
|
Distinct<TResult>(IEqualityComparer<TResult>) | Przeciążone. Zwraca obserwowaną sekwencję zawierającą tylko odrębne elementy zgodnie z porównaniem. (Zdefiniowane przez obserwowalne.) |
|
|
|
Przeciążone. Zwraca obserwowaną sekwencję zawierającą tylko odrębne elementy zgodnie z elementem keySelector. (Zdefiniowane przez obserwowalne.) |
|
|
Distinct<TResult, TKey>(Func<TResult, TKey>, IEqualityComparer<TKey>) | Przeciążone. Zwraca obserwowaną sekwencję zawierającą tylko odrębne elementy zgodnie z elementem keySelector. (Zdefiniowane przez obserwowalne.) |
|
|
DistinctUntilChanged<TResult>() | Przeciążone. Zwraca obserwowaną sekwencję zawierającą tylko odrębne elementy ciągłe z określonym źródłem. (Zdefiniowane przez obserwowalne.) |
|
|
|
Przeciążone. Zwraca obserwowaną sekwencję zawierającą tylko odrębne elementy ciągłe zgodnie z porównaniem. (Zdefiniowane przez obserwowalne.) |
|
|
DistinctUntilChanged<TResult, TKey>(Func<TResult, TKey>) | Przeciążone. Zwraca obserwowaną sekwencję zawierającą tylko odrębne elementy ciągłe zgodnie z elementem keySelector. (Zdefiniowane przez obserwowalne.) |
|
|
DistinctUntilChanged<TResult, TKey>(Func<TResult, TKey>, IEqualityComparer<TKey>) | Przeciążone. Zwraca obserwowaną sekwencję zawierającą tylko odrębne elementy ciągłe zgodnie z elementami keySelector i comparer. (Zdefiniowane przez obserwowalne.) |
|
|
Przeciążone. Wywołuje akcję dla każdego elementu w obserwowalnej sekwencji. (Zdefiniowane przez obserwowalne.) | |
|
|
< >TResult (IObserver<TResult>) | Przeciążone. Wywołuje akcję dla każdego elementu w obserwowalnej sekwencji i wywołuje akcję po wyjątkowym zakończeniu obserwowanej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
< >TResult (akcja<TResult>, akcja) | Przeciążone. Wywołuje akcję dla każdego elementu w obserwowalnej sekwencji i wywołuje akcję po bezproblemowym zakończeniu obserwowanej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
< >TResult (>>><<akcji ) | Przeciążone. Wywołuje akcję dla każdego elementu w obserwowalnej sekwencji i wywołuje akcję po wyjątkowym zakończeniu obserwowanej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
< >TResult<(>>>akcji,>>>akcji)< | Przeciążone. Wywołuje akcję dla każdego elementu w obserwowalnej sekwencji i wywołuje akcję po łaskawym lub wyjątkowym zakończeniu obserwowanej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
, elementAt<TResult> | Zwraca element w określonym indeksie w sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
ElementAtOrDefault<TResult> | Zwraca element w określonym indeksie w sekwencji lub wartość domyślną, jeśli indeks jest poza zakresem. (Zdefiniowane przez obserwowalne.) |
|
|
wreszcie<> TResult | Wywołuje określoną akcję po zakończeniu sekwencji obserwowanej przez źródło normalnie lub przez wyjątek. (Zdefiniowane przez obserwowalne.) |
|
|
|
Przeciążone. Zwraca pierwszy element obserwowanej sekwencji z określonym źródłem. (Zdefiniowane przez obserwowalne.) |
|
|
|
Przeciążone. Zwraca pierwszy element obserwowanej sekwencji zgodnej z predykatem. (Zdefiniowane przez obserwowalne.) |
|
|
FirstOrDefault<>TResult () | Przeciążone. Zwraca pierwszy element obserwowanej sekwencji lub wartość domyślną, jeśli nie zostanie znaleziona żadna wartość. (Zdefiniowane przez obserwowalne.) |
|
|
FirstOrDefault<TResult>(Func<TResult, wartość logiczna>) | Przeciążone. Zwraca pierwszy element obserwowanej sekwencji zgodnej z predykatem lub wartością domyślną, jeśli nie zostanie znaleziona żadna wartość. (Zdefiniowane przez obserwowalne.) |
|
|
Foo<TResult, R> | (Zdefiniowane przez MyExt.) |
|
|
ForEach<TResult> | Wywołuje akcję dla każdego elementu w obserwowalnej sekwencji i blokuje do momentu zakończenia sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
getenumerator<TResult> | Zwraca moduł wyliczający, który wylicza wszystkie wartości obserwowanej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
GroupBy<TResult, TKey>(Func<TResult, TKey>) | Przeciążone. Grupuje elementy obserwowanej sekwencji zgodnie z określoną funkcją selektora kluczy. (Zdefiniowane przez obserwowalne.) |
|
|
GroupBy<TResult, TKey>(Func<TResult, TKey>, IEqualityComparer<TKey>) | Przeciążone. Grupuje elementy obserwowalnej sekwencji zgodnie z określoną funkcją selektora kluczy i modułem porównującym. (Zdefiniowane przez obserwowalne.) |
|
|
GroupBy<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, TElement>) | Przeciążone. Grupuje elementy obserwowanej sekwencji i wybiera wynikowe elementy przy użyciu określonej funkcji. (Zdefiniowane przez obserwowalne.) |
|
|
GroupBy<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, TElement>, IEqualityComparer<TKey>) | Przeciążone. Grupuje elementy obserwowalnej sekwencji zgodnie z określoną funkcją selektora kluczy i porównuje i wybiera wynikowe elementy przy użyciu określonej funkcji. (Zdefiniowane przez obserwowalne.) |
|
|
GroupByUntil<TResult, TKey, TDuration>(Func<TResult, TKey>, Func<IGroupedObservable<TKey, TResult>, IObservable<TDuration>>) | Przeciążone. Grupuje elementy obserwowanej sekwencji zgodnie z określoną funkcją selektora kluczy. (Zdefiniowane przez obserwowalne.) |
|
|
GroupByUntil<TResult, TKey, TDuration>(Func<TResult, TKey>, Func<IGroupedObservable<TKey, TResult>, IObservable<TDuration>>, IEqualityComparer<TKey>) | Przeciążone. Grupuje elementy obserwowalnej sekwencji zgodnie z określoną funkcją selektora kluczy i modułem porównującym. (Zdefiniowane przez obserwowalne.) |
|
|
GroupByUntil<TResult, TKey, TElement, TDuration>(Func<TResult, TKey>, Func<TResult, TElement>, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>) | Przeciążone. Grupuje elementy obserwowanej sekwencji zgodnie z określoną funkcją selektora kluczy i wybiera wynikowe elementy przy użyciu określonej funkcji. (Zdefiniowane przez obserwowalne.) |
|
|
GroupByUntil<TResult, TKey, TElement, TDuration>(Func<TResult, TKey>, Func<TResult, TElement>, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>, IEqualityComparer<TKey>) | Przeciążone. Grupuje elementy obserwowalnej sekwencji zgodnie z określoną funkcją selektora kluczy i porównuje i wybiera wynikowe elementy przy użyciu określonej funkcji. (Zdefiniowane przez obserwowalne.) |
|
|
GroupJoin<TResult, TRight, TLeftDuration, TRightDuration, TResult> | Koreluje elementy dwóch sekwencji na podstawie nakładających się czasów trwania i grupuje wyniki. (Zdefiniowane przez obserwowalne.) |
|
|
IgnoreElements<> TResult | Ignoruje wszystkie wartości w obserwowalnej sekwencji, pozostawiając tylko komunikaty zakończenia. (Zdefiniowane przez obserwowalne.) |
|
|
Join<TResult, TRight, TLeftDuration, TRightDuration, TResult> | Koreluje elementy dwóch sekwencji na podstawie nakładających się czasów trwania. (Zdefiniowane przez obserwowalne.) |
|
|
< > <TResult () | Przeciążone. Zwraca ostatni element obserwowanej sekwencji z określonym źródłem. (Zdefiniowane przez obserwowalne.) |
|
|
Last<TResult>(Func<TResult, wartość logiczna>) | Przeciążone. Zwraca ostatni element obserwowalnej sekwencji zgodnej z predykatem. (Zdefiniowane przez obserwowalne.) |
|
|
LastOrDefault<TResult>() | Przeciążone. Zwraca ostatni element w obserwowalnej sekwencji lub wartość domyślną, jeśli nie zostanie znaleziona żadna wartość. (Zdefiniowane przez obserwowalne.) |
|
|
LastOrDefault<TResult>(Func<TResult, wartość logiczna>) | Przeciążone. Zwraca ostatni element obserwowalnej sekwencji zgodnej z predykatem lub wartością domyślną, jeśli nie zostanie znaleziona żadna wartość. (Zdefiniowane przez obserwowalne.) |
|
|
najnowsze<> TResult | Próbkuje najnowszą wartość w obserwowalnej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
Zwraca Int64, która reprezentuje łączną liczbę elementów w obserwowalnej sekwencji. (Zdefiniowane przez obserwowalne.) | |
|
|
materializowanie<> TResult | Materializuje niejawne powiadomienia o obserwowanej sekwencji jako jawne wartości powiadomień. (Zdefiniowane przez obserwowalne.) |
|
|
> < <TResult () | Przeciążone. Zwraca maksymalny element w obserwowalnej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
> < <TResult (IComparer<TResult>) | Przeciążone. Zwraca wartość maksymalną w obserwowalnej sekwencji zgodnie z określonym modułem porównującym. (Zdefiniowane przez obserwowalne.) |
|
|
MaxBy<TResult, TKey>(Func<TResult, TKey>) | Przeciążone. Zwraca elementy w zauważalnej sekwencji z maksymalną wartością klucza. (Zdefiniowane przez obserwowalne.) |
|
|
MaxBy<TResult, TKey>(Func<TResult, TKey>, IComparer<TKey>) | Przeciążone. Zwraca elementy w zauważalnej sekwencji z maksymalną wartością klucza. (Zdefiniowane przez obserwowalne.) |
|
|
scalanie<TResult>(IObservable<TResult>) | Przeciążone. Scala zauważalną sekwencję obserwowalnych sekwencji w obserwowalnej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
merge<TResult>(IObservable<TResult>, IScheduler) | Przeciążone. Scala dwie obserwowane sekwencje w jedną obserwowaną sekwencję. (Zdefiniowane przez obserwowalne.) |
|
|
< >TResult () | Przeciążone. Zwraca minimalny element w obserwowalnej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
|
Przeciążone. Zwraca wartość minimalną w obserwowalnej sekwencji zgodnie z określonym modułem porównującym. (Zdefiniowane przez obserwowalne.) |
|
|
MinBy<TResult, TKey>(Func<TResult, TKey>) | Przeciążone. Zwraca elementy w obserwowalnej sekwencji z minimalną wartością klucza. (Zdefiniowane przez obserwowalne.) |
|
|
MinBy<TResult, TKey>(Func<TResult, TKey>, IComparer<TKey>) | Przeciążone. Zwraca elementy w zauważalnej sekwencji z minimalną wartością klucza zgodnie z określonym modułem porównującym. (Zdefiniowane przez obserwowalne.) |
|
|
< <TResult> | Próbkuje najnowszą wartość w obserwowalnej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
multiemisji<TResult, TResult>(ISubject<TResult, TResult>) | Przeciążone. Zwraca zauważalną sekwencję, która po połączeniu powoduje wypychanie wyników do określonego tematu przez sekwencję źródłową. (Zdefiniowane przez obserwowalne.) |
|
|
multiemisji<TResult, TIntermediate, TResult>(Func<ISubject<TResult, TIntermediate>>, Func<IObservable<TIntermediate>, IObservable<TResult>>) | Przeciążone. Zwraca obserwowaną sekwencję zawierającą elementy sekwencji generowane przez multiemisję sekwencji źródłowej w ramach funkcji selektora. (Zdefiniowane przez obserwowalne.) |
|
|
Następne<> TResult | Próbkuje następną wartość (blokowanie bez buforowania) z w obserwowalnej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
Obserwowanie<TResult>(SynchronizationContext) | Przeciążone. Asynchronicznie powiadamiaj obserwatorów o określonym kontekście synchronizacji. (Zdefiniowane przez obserwowalne.) |
|
|
Obserwowanie<TResult> (kontrolka) | Przeciążone. (Zdefiniowane przez ControlObservable.) |
|
|
Obserwowanie<TResult>(Dyspozytor) | Przeciążone. (Zdefiniowane przez DispatcherObservable.) |
|
|
Obserwuj<TResult>(DispatcherScheduler) | Przeciążone. (Zdefiniowane przez DispatcherObservable.) |
|
|
Obserwowanie<TResult>(IScheduler) | Przeciążone. Asynchronicznie powiadamiaj obserwatorów o określonym harmonogramie. (Zdefiniowane przez obserwowalne.) |
|
|
ObserveOnDispatcher<TResult> | (Zdefiniowane przez DispatcherObservable.) |
|
|
OnErrorResumeNext<> TResult | Kontynuuje obserwowaną sekwencję, która jest przerywana normalnie lub przez wyjątek z kolejną obserwowaną sekwencją. (Zdefiniowane przez obserwowalne.) |
|
|
publikowanie<>TResult () | Przeciążone. Zwraca zauważalną sekwencję, która udostępnia pojedynczą subskrypcję do bazowej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
|
Przeciążone. Zwraca zauważalną sekwencję, która udostępnia pojedynczą subskrypcję do bazowej sekwencji i rozpoczyna się od initialValue. (Zdefiniowane przez obserwowalne.) |
|
|
publish<TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>) | Przeciążone. Zwraca zauważalną sekwencję, która jest wynikiem wywoływania selektora w możliwej do obserwowalnej sekwencji, która udostępnia jedną subskrypcję do bazowej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
publish<TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>, TResult) | Przeciążone. Zwraca zauważalną sekwencję, która udostępnia pojedynczą subskrypcję do bazowej sekwencji i rozpoczyna się od initialValue. (Zdefiniowane przez obserwowalne.) |
|
|
PublishLast<TResult>() | Przeciążone. Zwraca zauważalną sekwencję łączącą, która współudzieli pojedynczą subskrypcję do bazowej sekwencji zawierającej tylko ostatnie powiadomienie. (Zdefiniowane przez obserwowalne.) |
|
|
PublishLast<TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>) | Przeciążone. Zwraca obserwowaną sekwencję, która jest wynikiem wywołania selektora w możliwej do obserwowalnej sekwencji, która udostępnia jedną subskrypcję do bazowej sekwencji zawierającej tylko ostatnie powiadomienie. (Zdefiniowane przez obserwowalne.) |
|
|
powtarzać<TResult>() | Przeciążone. Powtarza obserwowaną sekwencję w nieskończoność. (Zdefiniowane przez obserwowalne.) |
|
|
|
Przeciążone. Powtarza obserwowaną sekwencję w nieskończoność. (Zdefiniowane przez obserwowalne.) |
|
|
< >TResult | Przeciążone. Zwraca możliwą do obserwowania sekwencję, która współudzieli pojedynczą subskrypcję do bazowej sekwencji, ponownie zapisując wszystkie powiadomienia. (Zdefiniowane przez obserwowalne.) |
|
|
Przeciążone. Zwraca możliwą do obserwowania sekwencję, która współudzieli pojedynczą subskrypcję do bazowej sekwencji, ponownie zapisując wszystkie powiadomienia w oknie. (Zdefiniowane przez obserwowalne.) | |
|
|
< <TRes>ult (Int32) | Przeciążone. Zwraca zauważalną sekwencję łączącą, która współudzieli pojedynczą subskrypcję do bazowej sekwencji reping bufferSize powiadomień. (Zdefiniowane przez obserwowalne.) |
|
|
< >TResult (IScheduler) | Przeciążone. Zwraca możliwą do obserwowania sekwencję, która współudzieli pojedynczą subskrypcję do bazowej sekwencji, ponownie zapisując wszystkie powiadomienia. (Zdefiniowane przez obserwowalne.) |
|
|
replay<TResult>(TimeSpan, IScheduler) | Przeciążone. Zwraca możliwą do obserwowania sekwencję, która współudzieli pojedynczą subskrypcję do bazowej sekwencji, ponownie zapisując wszystkie powiadomienia w oknie. (Zdefiniowane przez obserwowalne.) |
|
|
< <TResult>(Int32, IScheduler) | Przeciążone. Zwraca zauważalną sekwencję łączącą, która współudzieli pojedynczą subskrypcję do bazowej sekwencji reping bufferSize powiadomień. (Zdefiniowane przez obserwowalne.) |
|
|
> < <TResult (Int32, TimeSpan) | Przeciążone. Zwraca możliwą do obserwowania sekwencję, która współudzieli pojedynczą subskrypcję do bazowego repozytorium bufferSize powiadomień w oknie. (Zdefiniowane przez obserwowalne.) |
|
|
< >TResult (Int32, TimeSpan, IScheduler) | Przeciążone. Zwraca możliwą do obserwowania sekwencję, która współudzieli pojedynczą subskrypcję do bazowego repozytorium bufferSize powiadomień w oknie. (Zdefiniowane przez obserwowalne.) |
|
|
< <TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>) | Przeciążone. Zwraca obserwowaną sekwencję, która jest wynikiem wywołania selektora w możliwej do obserwowalnej sekwencji, która udostępnia pojedynczą subskrypcję do bazowej sekwencji i rozpoczyna się od wartości początkowej. (Zdefiniowane przez obserwowalne.) |
|
|
< <TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>, IScheduler) | Przeciążone. Zwraca obserwowaną sekwencję, która jest wynikiem wywołania selektora w możliwej do obserwowalnej sekwencji, która udostępnia jedną subskrypcję do bazowej sekwencji reping wszystkich powiadomień. (Zdefiniowane przez obserwowalne.) |
|
|
< <TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>, TimeSpan) | Przeciążone. Zwraca zauważalną sekwencję, która jest wynikiem wywołania selektora w możliwej do obserwowalnej sekwencji, która udostępnia jedną subskrypcję do bazowej sekwencji, w ramach którego są ponownie wyświetlane wszystkie powiadomienia w oknie. (Zdefiniowane przez obserwowalne.) |
|
|
replay<TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>, Int32) | Przeciążone. Zwraca obserwowaną sekwencję, która jest wynikiem wywołania selektora w możliwej do obserwowalnej sekwencji, która udostępnia jedną subskrypcję do bazowego repozytorium buforuSize powiadomień. (Zdefiniowane przez obserwowalne.) |
|
|
replay<TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>, TimeSpan, IScheduler) | Przeciążone. Zwraca zauważalną sekwencję, która jest wynikiem wywołania selektora w możliwej do obserwowalnej sekwencji, która udostępnia jedną subskrypcję do bazowej sekwencji, w ramach którego są ponownie wyświetlane wszystkie powiadomienia w oknie. (Zdefiniowane przez obserwowalne.) |
|
|
replay<TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>, Int32, IScheduler) | Przeciążone. Zwraca obserwowaną sekwencję, która jest wynikiem wywołania selektora w możliwej do obserwowalnej sekwencji, która udostępnia jedną subskrypcję do bazowego repozytorium buforuSize powiadomień. (Zdefiniowane przez obserwowalne.) |
|
|
replay<TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>, Int32, TimeSpan) | Przeciążone. Zwraca obserwowaną sekwencję, która jest wynikiem wywołania selektora w możliwej do obserwowalnej sekwencji, która udostępnia jedną subskrypcję do bazowej sekwencji reping bufferSize powiadomień w oknie. (Zdefiniowane przez obserwowalne.) |
|
|
< <TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>, Int32, TimeSpan, IScheduler) | Przeciążone. Zwraca obserwowaną sekwencję, która jest wynikiem wywołania selektora w możliwej do obserwowalnej sekwencji, która udostępnia jedną subskrypcję do bazowej sekwencji reping bufferSize powiadomień w oknie. (Zdefiniowane przez obserwowalne.) |
|
|
< >TResult | Przeciążone. Powtarza sekwencję obserwowaną przez źródło do momentu pomyślnego zakończenia. (Zdefiniowane przez obserwowalne.) |
|
|
< < >TResult (Int32) | Przeciążone. Powtarza sekwencję obserwowaną przez źródło do momentu pomyślnego zakończenia. (Zdefiniowane przez obserwowalne.) |
|
|
przykład<>TResult (TimeSpan) | Przeciążone. Próbkuje obserwowaną sekwencję w każdym interwale. (Zdefiniowane przez obserwowalne.) |
|
|
przykład<>TResult (TimeSpan, IScheduler) | Przeciążone. Próbkuje obserwowaną sekwencję w każdym interwale z określonym źródłem, interwałem i harmonogramem. (Zdefiniowane przez obserwowalne.) |
|
|
przykładowe<TResult, TSample>(IObservable<TSample>) | Przeciążone. Próbkuje obserwowaną sekwencję przy znacznikach próbkowania z określonym źródłem i próbkatorem. (Zdefiniowane przez obserwowalne.) |
|
|
skanowanie<TResult>(Func<TResult, TResult, TResult, TResult>) | Przeciążone. Stosuje funkcję akumulatorową w obserwowalnej sekwencji i zwraca każdy wynik pośredni z określonym źródłem i akumulatorem. (Zdefiniowane przez obserwowalne.) |
|
|
Skanowanie<TResult, TAccumulate>(TAccumulate, Func<TAccumulate, TResult, TAccumulate>) | Przeciążone. Stosuje funkcję akumula w obserwowalnej sekwencji i zwraca każdy wynik pośredni z określonym źródłem, nasionami i akumulatorem. (Zdefiniowane przez obserwowalne.) |
|
|
select<TResult, TResult>(Func<TResult, TResult>) | Przeciążone. Projektuje każdy element obserwowalnej sekwencji w nowym formularzu z określonym źródłem i selektorem. (Zdefiniowane przez obserwowalne.) |
|
|
select<TResult, TResult>(Func<TResult, Int32, TResult>) | Przeciążone. Projektuje każdy element obserwowalnej sekwencji w nowym formularzu, włączając indeks elementu z określonym źródłem i selektorem. (Zdefiniowane przez obserwowalne.) |
|
|
SelectMany<TResult, TOther>(IObservable<TOther>) | Przeciążone. Projektuje każdy element obserwowalnej sekwencji do obserwowalnej sekwencji i spłaszcza wynikowe obserwowane sekwencje w jedną obserwowaną sekwencję. (Zdefiniowane przez obserwowalne.) |
|
|
SelectMany<TResult, TResult>(Func<TResult, IObservable<TResult>>) | Przeciążone. Projektuje każdy element obserwowalnej sekwencji do obserwowalnej sekwencji i spłaszcza wynikowe obserwowane sekwencje w jedną obserwowaną sekwencję. (Zdefiniowane przez obserwowalne.) |
|
|
SelectMany<TResult, TResult>(Func<TResult, IEnumerable<TResult>>) | Przeciążone. Projektuje każdy element obserwowalnej sekwencji do obserwowalnej sekwencji i spłaszcza wynikowe obserwowane sekwencje w jedną obserwowaną sekwencję. (Zdefiniowane przez obserwowalne.) |
|
|
SelectMany<TResult, TResult>(Func<TResult, IObservable<TResult>>, Func<Exception, IObservable<TResult>>, Func<IObservable<TResult>>) | Przeciążone. Projektuje każdy element obserwowalnej sekwencji do obserwowalnej sekwencji i spłaszcza wynikowe obserwowane sekwencje w jedną obserwowaną sekwencję. (Zdefiniowane przez obserwowalne.) |
|
|
SelectMany<TResult, TCollection, TResult>(Func<TResult, IEnumerable<TCollection>>, Func<TResult, TCollection, TResult>) | Przeciążone. Projektuje każdy element obserwowalnej sekwencji do obserwowalnej sekwencji i spłaszcza wynikowe obserwowane sekwencje w jedną obserwowaną sekwencję. (Zdefiniowane przez obserwowalne.) |
|
|
SelectMany<TResult, TCollection, TResult>(Func<TResult, IObservable<TCollection>>, Func<TResult, TCollection, TResult>) | Przeciążone. Projektuje każdy element obserwowalnej sekwencji do obserwowalnej sekwencji i spłaszcza wynikowe obserwowane sekwencje w jedną obserwowaną sekwencję. (Zdefiniowane przez obserwowalne.) |
|
|
SequenceEqual<TResult>(IObservable<TResult>) | Przeciążone. Określa, czy dwie sekwencje są równe, porównując elementy parowo. (Zdefiniowane przez obserwowalne.) |
|
|
SequenceEqual<TResult>(IObservable<TResult>, IEqualityComparer<TResult>) | Przeciążone. Określa, czy dwie sekwencje są równe, porównując elementy sparowane przy użyciu określonego porównania równości. (Zdefiniowane przez obserwowalne.) |
|
|
|
Przeciążone. Zwraca jedyny element obserwowanej sekwencji i zgłasza wyjątek, jeśli nie ma dokładnie jednego elementu w obserwowalnej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
|
Przeciążone. Zwraca jedyny element obserwowanej sekwencji, który pasuje do predykatu i zgłasza wyjątek, jeśli nie ma dokładnie jednego elementu w obserwowalnej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
SingleOrDefault<TResult>() | Przeciążone. Zwraca jedyny element obserwowanej sekwencji lub wartość domyślną, jeśli obserwowana sekwencja jest pusta. (Zdefiniowane przez obserwowalne.) |
|
|
|
Przeciążone. Zwraca jedyny element obserwowanej sekwencji zgodnej z predykatem lub wartością domyślną, jeśli nie zostanie znaleziona żadna wartość. (Zdefiniowane przez obserwowalne.) |
|
|
pomiń<> TResult | Pomija określoną liczbę wartości w obserwowalnej sekwencji, a następnie zwraca pozostałe wartości. (Zdefiniowane przez obserwowalne.) |
|
|
SkipLast<> TResult | Pomija określoną liczbę elementów na końcu obserwowanej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
SkipUntil<TResult, TOther> | Zwraca wartości ze źródłowej sekwencji obserwowanej dopiero po utworzeniu wartości przez inną obserwowaną sekwencję. (Zdefiniowane przez obserwowalne.) |
|
|
SkipWhile<TResult>(Func<TResult, wartość logiczna>) | Przeciążone. Pomija wartości w obserwowalnej sekwencji, o ile określony warunek jest spełniony, a następnie zwraca pozostałe wartości. (Zdefiniowane przez obserwowalne.) |
|
|
SkipWhile<TResult>(Func<TResult, Int32, Wartość logiczna>) | Przeciążone. Pomija wartości w obserwowalnej sekwencji, o ile określony warunek jest spełniony, a następnie zwraca pozostałe wartości. (Zdefiniowane przez obserwowalne.) |
|
|
|
Przeciążone. Poprzedza sekwencję wartości do obserwowalnej sekwencji z określonym źródłem i wartościami. (Zdefiniowane przez obserwowalne.) |
|
|
StartWith<>TResult (IScheduler, TResult[]) | Przeciążone. Poprzedza sekwencję wartości do obserwowalnej sekwencji z określonym źródłem, harmonogramem i wartościami. (Zdefiniowane przez obserwowalne.) |
|
|
subskrybuj<TResult>() | Przeciążone. Ocenia obserwowaną sekwencję przy użyciu określonego źródła. (Zdefiniowane przez ObservableExtensions.) |
|
|
subskrybuj<>TResult (<TResult>) | Przeciążone. Subskrybuje procedurę obsługi elementów do obserwowanej sekwencji. (Zdefiniowane przez ObservableExtensions.) |
|
|
subskrybuj<>TResult (<>><><wyjątku akcji ) | Przeciążone. Subskrybuje procedurę obsługi elementów i program obsługi wyjątków do obserwowanej sekwencji. (Zdefiniowane przez ObservableExtensions.) |
|
|
|
Przeciążone. Subskrybuje program obsługi elementów i program obsługi uzupełniania do obserwowanej sekwencji. (Zdefiniowane przez ObservableExtensions.) |
|
|
|
Przeciążone. Subskrybuje procedurę obsługi elementów, program obsługi wyjątków i procedurę obsługi uzupełniania do obserwowalnej sekwencji. (Zdefiniowane przez ObservableExtensions.) |
|
|
|
Przeciążone. Asynchronicznie subskrybuje i anuluje subskrypcję obserwatorów w określonym kontekście synchronizacji. (Zdefiniowane przez obserwowalne.) |
|
|
Subskrybuj<TResult>(kontrolk a) | Przeciążone. (Zdefiniowane przez ControlObservable.) |
|
|
Przeciążone. (Zdefiniowane przez DispatcherObservable.) | |
|
|
|
Przeciążone. (Zdefiniowane przez DispatcherObservable.) |
|
|
< <TResult>(IScheduler) | Przeciążone. Asynchronicznie subskrybuje i anuluje subskrypcję obserwatorów w określonym harmonogramie. (Zdefiniowane przez obserwowalne.) |
|
|
SubscribeOnDispatcher<> TResult | (Zdefiniowane przez DispatcherObservable.) |
|
|
synchronizuj<>TResult () | Przeciążone. Synchronizuje obserwowaną sekwencję. (Zdefiniowane przez obserwowalne.) |
|
|
synchronizuj<>TResult (obiekt) | Przeciążone. Synchronizuje obserwowaną sekwencję. (Zdefiniowane przez obserwowalne.) |
|
|
Take<TResult> | Zwraca określoną liczbę ciągłych wartości od początku obserwowanej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
TakeLast<TResult> | Zwraca określoną liczbę ciągłych elementów z końca obserwowanej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
TakeUntil<TResult, TOther> | Zwraca wartości ze źródłowej sekwencji obserwowanej do momentu, aż druga obserwowana sekwencja generuje wartość. (Zdefiniowane przez obserwowalne.) |
|
|
TakeWhile<TResult>(Func<TResult, wartość logiczna>) | Przeciążone. Zwraca wartości z obserwowanej sekwencji, o ile określony warunek jest spełniony, a następnie pomija pozostałe wartości. (Zdefiniowane przez obserwowalne.) |
|
|
TakeWhile<TResult>(Func<TResult, Int32, logiczna>) | Przeciążone. Zwraca wartości z obserwowanej sekwencji, o ile określony warunek jest spełniony, a następnie pomija pozostałe wartości. (Zdefiniowane przez obserwowalne.) |
|
|
następnie<TResult, TResult> | Pasuje, gdy obserwowana sekwencja ma dostępną wartość i projektuje wartość. (Zdefiniowane przez obserwowalne.) |
|
|
ograniczanie przepustowości<>TResult (TimeSpan) | Przeciążone. Ignoruje wartości z obserwowanej sekwencji, po której następuje inna wartość przed terminem z określonym źródłem i dueTime. (Zdefiniowane przez obserwowalne.) |
|
|
Przeciążone. Ignoruje wartości z obserwowanej sekwencji, po której następuje inna wartość przed terminem z określonym źródłem, dueTime i scheduler. (Zdefiniowane przez obserwowalne.) | |
|
|
TimeInterval<TResult>() | Przeciążone. Rejestruje przedział czasu między kolejnymi wartościami w obserwowalnej sekwencji z określonym źródłem. (Zdefiniowane przez obserwowalne.) |
|
|
|
Przeciążone. Rejestruje interwał czasu między kolejnymi wartościami w obserwowalnej sekwencji z określonym źródłem i harmonogramem. (Zdefiniowane przez obserwowalne.) |
|
|
|
Przeciążone. Zwraca obserwowaną sekwencję lub wyjątek TimeoutException, jeśli upłynie dueTime. (Zdefiniowane przez obserwowalne.) |
|
|
limit czasu<>TResult (DateTimeOffset) | Przeciążone. Zwraca obserwowaną sekwencję lub wyjątek TimeoutException, jeśli upłynie dueTime. (Zdefiniowane przez obserwowalne.) |
|
|
limit czasu<>TResult (TimeSpan, IObservable<TResult>) | Przeciążone. Zwraca sekwencję obserwowaną źródła lub inną obserwowaną sekwencję, jeśli upłynie dueTime. (Zdefiniowane przez obserwowalne.) |
|
|
limit czasu<>TResult (DateTimeOffset, IObservable<TResult>) | Przeciążone. Zwraca obserwowaną sekwencję lub wyjątek TimeoutException, jeśli upłynie dueTime. (Zdefiniowane przez obserwowalne.) |
|
|
limit czasu<>TResult (TimeSpan, IScheduler) | Przeciążone. Zwraca obserwowaną sekwencję lub wyjątek TimeoutException, jeśli upłynie dueTime. (Zdefiniowane przez obserwowalne.) |
|
|
|
Przeciążone. Zwraca obserwowaną sekwencję lub wyjątek TimeoutException, jeśli upłynie dueTime. (Zdefiniowane przez obserwowalne.) |
|
|
limit czasu <>TResult (TimeSpan, IObservable<TResult>, IScheduler) | Przeciążone. Zwraca sekwencję obserwowaną źródła lub inną obserwowaną sekwencję, jeśli upłynie dueTime. (Zdefiniowane przez obserwowalne.) |
|
|
limit czasu<>TResult (DateTimeOffset, IObservable<TResult>, IScheduler) | Przeciążone. Zwraca sekwencję obserwowaną źródła lub inną obserwowaną sekwencję, jeśli upłynie dueTime. (Zdefiniowane przez obserwowalne.) |
|
|
znacznik czasu<>TResult () | Przeciążone. Rejestruje znacznik czasu dla każdej wartości w obserwowalnej sekwencji z określonym źródłem. (Zdefiniowane przez obserwowalne.) |
|
|
Przeciążone. Rejestruje znacznik czasu dla każdej wartości w obserwowalnej sekwencji z określonym źródłem i harmonogramem. (Zdefiniowane przez obserwowalne.) | |
|
|
ToArray<TResult> | Tworzy tablicę na podstawie obserwowanej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
ToDictionary<TResult, TKey>(Func<TResult, TKey>) | Przeciążone. Tworzy słownik z obserwowanej sekwencji zgodnie z określoną funkcją selektora kluczy. (Zdefiniowane przez obserwowalne.) |
|
|
ToDictionary<TResult, TKey>(Func<TResult, TKey>, IEqualityComparer<TKey>) | Przeciążone. Tworzy słownik z obserwowanej sekwencji zgodnie z określoną funkcją selektora kluczy i modułem porównującym. (Zdefiniowane przez obserwowalne.) |
|
|
ToDictionary<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, TElement>) | Przeciążone. Tworzy słownik z obserwowanej sekwencji zgodnie z określoną funkcją selektora kluczy i funkcją selektora elementów. (Zdefiniowane przez obserwowalne.) |
|
|
ToDictionary<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, TElement>, IEqualityComparer<TKey>) | Przeciążone. Tworzy słownik z obserwowanej sekwencji zgodnie z określoną funkcją selektora kluczy, modułem porównującym i funkcją selektora elementów. (Zdefiniowane przez obserwowalne.) |
|
|
toenumerable<TResult> | Konwertuje obserwowaną sekwencję na sekwencję wyliczalną. (Zdefiniowane przez obserwowalne.) |
|
|
ToEvent<TResult> | Uwidacznia zauważalną sekwencję jako obiekt ze zdarzeniem platformy .NET z określonym źródłem. (Zdefiniowane przez obserwowalne.) |
|
|
ToList<TResult> | Tworzy listę na podstawie obserwowanej sekwencji. (Zdefiniowane przez obserwowalne.) |
|
|
ToLookup<TResult, TKey>(Func<TResult, TKey>) | Przeciążone. Tworzy wyszukiwanie na podstawie obserwowanej sekwencji zgodnie z określoną funkcją selektora kluczy. (Zdefiniowane przez obserwowalne.) |
|
|
ToLookup<TResult, TKey>(Func<TResult, TKey>, IEqualityComparer<TKey>) | Przeciążone. Tworzy wyszukiwanie na podstawie obserwowanej sekwencji zgodnie z określoną funkcją selektora kluczy i modułem porównującym. (Zdefiniowane przez obserwowalne.) |
|
|
ToLookup<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, TElement>) | Przeciążone. Tworzy wyszukiwanie na podstawie obserwowanej sekwencji zgodnie z określoną funkcją selektora kluczy i funkcją selektora elementów. (Zdefiniowane przez obserwowalne.) |
|
|
ToLookup<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, TElement>, IEqualityComparer<TKey>) | Przeciążone. Tworzy wyszukiwanie na podstawie obserwowanej sekwencji zgodnie z określoną funkcją selektora kluczy, modułem porównującym i funkcją selektora elementów. (Zdefiniowane przez obserwowalne.) |
|
|
ToNotifier<> TSource | Tworzy wywołanie zwrotne powiadomień od obserwatora. (Zdefiniowane przez Observer.) |
|
|
ToTask<>TResult () | Przeciążone. Zwraca zadanie zawierające ostatnią wartość obserwowanej sekwencji. (Zdefiniowane przez TaskObservableExtensions.) |
|
|
ToTask<TResult>(object) | Przeciążone. Zwraca zadanie zawierające ostatnią wartość obserwowanej sekwencji. (Zdefiniowane przez TaskObservableExtensions.) |
|
|
toTask<TResult>(CancellationToken) | Przeciążone. Zwraca zadanie zawierające ostatnią wartość obserwowanej sekwencji. (Zdefiniowane przez TaskObservableExtensions.) |
|
|
|
Przeciążone. Zwraca zadanie zawierające ostatnią wartość obserwowanej sekwencji. (Zdefiniowane przez TaskObservableExtensions.) |
|
|
where<TResult>(Func<TResult, boolean>) | Przeciążone. Filtruje elementy obserwowalnej sekwencji na podstawie predykatu. (Zdefiniowane przez obserwowalne.) |
|
|
Where<TResult>(Func<TResult, Int32, Boolean>) | Przeciążone. Filtruje elementy obserwowalnej sekwencji na podstawie predykatu, włączając indeks elementu. (Zdefiniowane przez obserwowalne.) |
|
|
Przeciążone. Projektuje każdy element obserwowalnej sekwencji w kolejnych oknach nienakładających się, które są generowane na podstawie informacji o liczbie elementów. (Zdefiniowane przez obserwowalne.) | |
|
|
|
Przeciążone. Projektuje każdy element obserwowalnej sekwencji w kolejnych oknach nienakładających się, które są tworzone na podstawie informacji o chronometrażu. (Zdefiniowane przez obserwowalne.) |
|
|
|
Przeciążone. Projektuje każdy element obserwowalnej sekwencji na zero lub więcej okien, które są generowane na podstawie informacji o liczbie elementów. (Zdefiniowane przez obserwowalne.) |
|
|
okna<>TResult (TimeSpan, IScheduler) | Przeciążone. Projektuje każdy element obserwowalnej sekwencji w kolejnych oknach nienakładających się, które są tworzone na podstawie informacji o chronometrażu. (Zdefiniowane przez obserwowalne.) |
|
|
okna<TResult>(TimeSpan, TimeSpan) | Przeciążone. Projektuje każdy element obserwowalnej sekwencji na zero lub więcej okien, które są generowane na podstawie informacji o chronometrażu. (Zdefiniowane przez obserwowalne.) |
|
|
|
Przeciążone. Projektuje każdy element obserwowalnej sekwencji w oknie, które zostało ukończone po jego pełnym lub określonym czasie. (Zdefiniowane przez obserwowalne.) |
|
|
okna<TResult>(TimeSpan, TimeSpan, IScheduler) | Przeciążone. Projektuje każdy element obserwowalnej sekwencji na zero lub więcej okien, które są generowane na podstawie informacji o chronometrażu. (Zdefiniowane przez obserwowalne.) |
|
|
okna<>TResult (TimeSpan, Int32, IScheduler) | Przeciążone. Projektuje każdy element obserwowalnej sekwencji w oknie, które zostało ukończone po jego pełnym lub określonym czasie. (Zdefiniowane przez obserwowalne.) |
|
|
okna<TResult, TWindowClosing>(Func<IObservable<TWindowClosing>>) | Przeciążone. Projektuje każdy element obserwowalnej sekwencji w kolejnych oknach nienakładających się. (Zdefiniowane przez obserwowalne.) |
|
|
okna<TResult, TWindowOpening, TWindowClosing>(IObservable<TWindowOpening>, Func<TWindowOpening, IObservable<TWindowClosing>>) | Przeciążone. Projektuje każdy element obserwowalnej sekwencji na zero lub więcej okien. (Zdefiniowane przez obserwowalne.) |
|
|
Zip<TResult, TSecond, TResult>(IObservable<TSecond>, Func<TResult, TSecond, TResult>) | Przeciążone. Scala dwie obserwowane sekwencje w jedną zauważalną sekwencję, łącząc swoje elementy w sposób sparowany. (Zdefiniowane przez obserwowalne.) |
|
|
Zip<TResult, TSecond, TResult>(IEnumerable<TSecond>, Func<TResult, TSecond, TResult>) | Przeciążone. Scala obserwowaną sekwencję i sekwencję wyliczalną w jedną obserwowaną sekwencję przy użyciu funkcji selektora. (Zdefiniowane przez obserwowalne.) |
Do góry
Uwagi
Ten interfejs tematu zapewnia elastyczność obserwowanej sekwencji jednego typu podczas publikowania zauważalnej sekwencji innego typu.
Przykłady
W tym przykładzie pokazano implementację<<TSource, TResult>, która obserwuje obserwowaną sekwencję jednego typu podczas publikowania zauważalnej sekwencji innego typu. W tym przykładzie AsciiConverterSubject demonstruje implementację, obserwując sekwencje typu char i publikując zauważalną sekwencję int. Opublikowana obserwowana sekwencja int to kod ASCII dla każdej obserwowanej wartości char.
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);
}
}
}
}
Następujące dane wyjściowe zostały wygenerowane przez przykładowy kod.
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.
Zobacz też
Odniesienie
Przestrzeń nazw System.Reactive.Subjects