IConnectableObservable<T> Interface

Stellt eine feststellbare, die verbunden und getrennt werden kann.

Namespace:System.Reactive.Subjects
Assembly: System.Reactive (in System.Reactive.dll)

Syntax

'Declaration
Public Interface IConnectableObservable(Of Out T) _
    Inherits IObservable(Of T)

'Usage
Dim instance As IConnectableObservable(Of Out T)

public interface IConnectableObservable<out T> : IObservable<T>

generic<typename T>
public interface class IConnectableObservable : IObservable<T>

type IConnectableObservable<'T> =  
    interface
        interface IObservable<'T>
    end

JScript does not support generic types and methods.

Typparameter

• outT
  Der Typ.

  Dieser Typparameter ist kovariant. Das heißt, Sie können entweder den angegebenen Typ oder einen beliebigen Typ verwenden, der abgeleitet ist. Weitere Informationen zur Kovarianz und Kontravarianz finden Sie unter .

Der Typ "IConnectableObservable"<T> macht die folgenden Member verfügbar.

Methodik

	Name	Beschreibung
	Connect	Verbindet die feststellbare.
	Abonnieren	(Geerbt von IObservable<T>.)

Nach oben

Erweiterungsmethoden

	Name	Beschreibung
	Aggregat<T>(Func<T, T, T>)	Überladen. Wendet eine Akkumulatorfunktion auf eine feststellbare Sequenz an. (Definiert durch Observable.)
	Aggregate<T, TAccumulate>(TAccumulate, Func<TAccumulate, T, TAccumulate>)	Überladen. Wendet eine Akkumulatorfunktion auf eine feststellbare Sequenz mit dem angegebenen Ausgangswert an. (Definiert durch Observable.)
	Alle<T->	Bestimmt, ob alle Elemente einer feststellbaren Sequenz eine Bedingung erfüllen. (Definiert durch Observable.)
	Amb<T>	Verteilt die observable Sequenz, die zuerst mit der angegebenen ersten und zweiten Sequenz reagiert. (Definiert durch Observable.)
	Und<T, TRight>	Übereinstimmungen, wenn beide feststellbaren Sequenzen einen verfügbaren Wert aufweisen. (Definiert durch Observable.)
	<T->()	Überladen. Bestimmt, ob eine feststellbare Sequenz Elemente enthält. (Definiert durch Observable.)
	Any<T>(Func<T, boolean>)	Überladen. Bestimmt, ob alle Elemente einer feststellbaren Sequenz eine Bedingung erfüllen. (Definiert durch Observable.)
	AsObservable<T>	Blendet die Identität einer feststellbaren Sequenz aus. (Definiert durch Observable.)
	AsQbservable<T>	Wandelt eine observable Sequenz in eine abfragbare Observable-Sequenz um. (Definiert durch Qbservable.)
	AssertEqual<T->	(Definiert durch Erweiterungen.)
	Puffer-<T->(Int32)	Überladen. Gibt jedes Element einer observierbaren Sequenz in aufeinander folgende nicht überlappende Puffer an, die basierend auf Elementanzahlsinformationen erzeugt werden. (Definiert durch Observable.)
	Puffer-<T->(TimeSpan)	Überladen. Gibt jedes Element einer feststellbaren Sequenz in aufeinander folgende nicht überlappende Puffer an, die basierend auf Zeitangaben erzeugt werden. (Definiert durch Observable.)
	Puffer-<T->(Int32, Int32)	Überladen. Gibt jedes Element einer observierbaren Sequenz in null oder mehr Puffer an, die basierend auf Elementanzahlsinformationen erzeugt werden. (Definiert durch Observable.)
	Puffer<T>(TimeSpan, IScheduler)	Überladen. Gibt jedes Element einer feststellbaren Sequenz in aufeinander folgende nicht überlappende Puffer an, die basierend auf Zeitangaben erzeugt werden. (Definiert durch Observable.)
	Puffer<T>(TimeSpan, TimeSpan)	Überladen. Gibt jedes Element einer observierbaren Sequenz in null oder mehr Puffer an, die basierend auf Zeitangaben erzeugt werden. (Definiert durch Observable.)
	Puffer<T>(TimeSpan, Int32)	Überladen. Gibt jedes Element einer feststellbaren Sequenz in einen Puffer an, der gesendet wird, wenn es voll ist oder eine bestimmte Zeitspanne verstrichen ist. (Definiert durch Observable.)
	Puffer<T>(TimeSpan, TimeSpan, IScheduler)	Überladen. Gibt jedes Element einer observierbaren Sequenz in null oder mehr Puffer an, die basierend auf Zeitangaben erzeugt werden. (Definiert durch Observable.)
	Puffer<T>(TimeSpan, Int32, IScheduler)	Überladen. Gibt jedes Element einer feststellbaren Sequenz in einen Puffer an, der gesendet wird, wenn es voll ist oder eine bestimmte Zeitspanne verstrichen ist. (Definiert durch Observable.)
	Buffer<T, TBufferClosing>(Func<IObservable<TBufferClosing>>)	Überladen. Gibt jedes Element einer observablen Sequenz in aufeinander folgende nicht überlappende Puffer an. (Definiert durch Observable.)
	Buffer<T, TBufferOpening, TBufferClosing>(IObservable<TBufferOpening>, Func<TBufferOpening, IObservable<TBufferClosing>>)	Überladen. Gibt jedes Element einer abfragbaren Observable-Sequenz in aufeinander folgende nicht überlappende Puffer an. (Definiert durch Observable.)
	catch<T>(IObservable<T>)	Überladen. Setzt eine observable Sequenz fort, die von einer Ausnahme mit der nächsten observablen Sequenz beendet wird. (Definiert durch Observable.)
	Catch<T, TException>(Func<TException, IObservable<T>>)	Überladen. Setzt eine feststellbare Sequenz fort, die von einer Ausnahme des angegebenen Typs mit der observablen Sequenz beendet wird, die vom Handler erzeugt wird. (Definiert durch Observable.)
	CombineLatest<T, TSecond, TResult>	Führt zwei feststellbare Sequenzen mit einer feststellbaren Sequenz zusammen, indem die Selektorfunktion verwendet wird, wenn eine der observablen Sequenzen ein Element erzeugt. (Definiert durch Observable.)
	Verketten<T->	Verkettet zwei observierbare Sequenzen. (Definiert durch Observable.)
	enthält<T->(T)	Überladen. Bestimmt, ob eine Observable-Sequenz ein angegebenes Element mithilfe des Standardmäßigen Gleichheitsabgleichs enthält. (Definiert durch Observable.)
	enthält<T>(T, IEqualityComparer<T>)	Überladen. Bestimmt, ob eine observable Sequenz ein angegebenes Element mit einer angegebenen System.Collections.Generic.IEqualityComparer< T>. (Definiert durch Observable.)
	Anzahl<T>	Gibt einen Int32- zurück, der die Gesamtanzahl der Elemente in einer observierbaren Sequenz darstellt. (Definiert durch Observable.)
	DefaultIfEmpty<T>()	Überladen. Gibt die Elemente der angegebenen Sequenz oder des Standardwerts des Typparameters in einer Singletonsequenz zurück, wenn die Sequenz leer ist. (Definiert durch Observable.)
	DefaultIfEmpty<T->(T)	Überladen. Gibt die Elemente der angegebenen Sequenz oder des Standardwerts des Typparameters in einer Singletonsequenz zurück, wenn die Sequenz leer ist. (Definiert durch Observable.)
	Verzögerung<T>(TimeSpan)	Überladen. Gibt die observable Sequenz nach Fälligkeitszeit mit der angegebenen Quelle und dueTime an. (Definiert durch Observable.)
	Delay<T>(DateTimeOffset)	Überladen. Gibt die observable Sequenz nach Fälligkeitszeit mit der angegebenen Quelle und dueTime an. (Definiert durch Observable.)
	Verzögerung<T>(TimeSpan, IScheduler)	Überladen. Gibt die observable Sequenz nach Fälligkeitszeit mit der angegebenen Quelle, dueTime und Scheduler an. (Definiert durch Observable.)
	Delay<T>(DateTimeOffset, IScheduler)	Überladen. Gibt die observable Sequenz nach Fälligkeitszeit mit der angegebenen Quelle, dueTime und Scheduler an. (Definiert durch Observable.)
	Distinct<T>()	Überladen. Gibt eine observable Sequenz zurück, die nur unterschiedliche Elemente mit einer angegebenen Quelle enthält. (Definiert durch Observable.)
	Distinct<T>(IEqualityComparer<T>)	Überladen. Gibt eine Observable-Sequenz zurück, die nur unterschiedliche Elemente gemäß dem Vergleich enthält. (Definiert durch Observable.)
	Distinct<T, TKey>(Func<T, TKey>)	Überladen. Gibt eine observable Sequenz zurück, die nur unterschiedliche Elemente gemäß keySelector enthält. (Definiert durch Observable.)
	Distinct<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	Überladen. Gibt eine observable Sequenz zurück, die nur unterschiedliche Elemente gemäß keySelector enthält. (Definiert durch Observable.)
	DistinctUntilChanged<T>()	Überladen. Gibt eine feststellbare Sequenz zurück, die nur unterschiedliche zusammenhängende Elemente mit einer angegebenen Quelle enthält. (Definiert durch Observable.)
	DistinctUntilChanged<T>(IEqualityComparer<T>)	Überladen. Gibt eine feststellbare Sequenz zurück, die nur unterschiedliche zusammenhängende Elemente gemäß dem Vergleich enthält. (Definiert durch Observable.)
	DistinctUntilChanged<T, TKey>(Func<T, TKey>)	Überladen. Gibt eine feststellbare Sequenz zurück, die nur unterschiedliche zusammenhängende Elemente gemäß keySelector enthält. (Definiert durch Observable.)
	DistinctUntilChanged<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	Überladen. Gibt eine feststellbare Sequenz zurück, die nur unterschiedliche zusammenhängende Elemente gemäß keySelector und dem Comparer enthält. (Definiert durch Observable.)
	<T>(Aktion<T>)	Überladen. Ruft eine Aktion für jedes Element in der observablen Sequenz auf. (Definiert durch Observable.)
	<T>(IObserver<T>)	Überladen. Ruft eine Aktion für jedes Element in der observablen Sequenz auf und ruft eine Aktion nach einer außergewöhnlichen Beendigung der observablen Sequenz auf. (Definiert durch Observable.)
	T<T>(Aktion<T>, Aktion)	Überladen. Ruft eine Aktion für jedes Element in der observablen Sequenz auf und ruft eine Aktion nach einer ordnungsgemäßen Beendigung der observablen Sequenz auf. (Definiert durch Observable.)
	T<T>(Aktion<T>, Aktion<Ausnahme>)	Überladen. Ruft eine Aktion für jedes Element in der observablen Sequenz auf und ruft eine Aktion nach einer außergewöhnlichen Beendigung der observablen Sequenz auf. (Definiert durch Observable.)
	T<T>(Aktion<T>, Aktion<Ausnahme>, Aktion)	Überladen. Ruft eine Aktion für jedes Element in der observablen Sequenz auf und ruft eine Aktion nach einer ordnungsgemäßen oder außergewöhnlichen Beendigung der observablen Sequenz auf. (Definiert durch Observable.)
	ElementAt<T>	Gibt das Element an einem angegebenen Index in einer Sequenz zurück. (Definiert durch Observable.)
	ElementAtOrDefault<T->	Gibt das Element an einem angegebenen Index in einer Sequenz oder einem Standardwert zurück, wenn der Index außerhalb des Bereichs liegt. (Definiert durch Observable.)
	Schließlich<T>	Ruft eine angegebene Aktion auf, nachdem die Observable-Quellsequenz normal oder durch eine Ausnahme beendet wurde. (Definiert durch Observable.)
	First<T>()	Überladen. Gibt das erste Element einer feststellbaren Sequenz mit einer angegebenen Quelle zurück. (Definiert durch Observable.)
	First<T>(Func<T, Boolean>)	Überladen. Gibt das erste Element einer observierbaren Sequenz zurück, die dem Prädikat entspricht. (Definiert durch Observable.)
	FirstOrDefault<T>()	Überladen. Gibt das erste Element einer observablen Sequenz oder einen Standardwert zurück, wenn kein Wert gefunden wird. (Definiert durch Observable.)
	FirstOrDefault<T>(Func<T, boolean>)	Überladen. Gibt das erste Element einer observablen Sequenz zurück, das dem Prädikat entspricht, oder einen Standardwert, wenn kein Wert gefunden wird. (Definiert durch Observable.)
	Foo<T, R>	(Definiert durch MyExt.)
	ForEach<T>	Ruft eine Aktion für jedes Element in der observablen Sequenz auf und blockiert, bis die Sequenz beendet wird. (Definiert durch Observable.)
	GetEnumerator<T->	Gibt einen Enumerator zurück, der alle Werte der observablen Sequenz aufzählt. (Definiert durch Observable.)
	GroupBy<T, TKey>(Func<T, TKey>)	Überladen. Gruppiert die Elemente einer observierbaren Sequenz gemäß einer angegebenen Schlüsselmarkierfunktion. (Definiert durch Observable.)
	GroupBy<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	Überladen. Gruppiert die Elemente einer feststellbaren Sequenz gemäß einer angegebenen Schlüsselmarkierfunktion und einem Vergleich. (Definiert durch Observable.)
	GroupBy<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>)	Überladen. Gruppiert die Elemente einer feststellbaren Sequenz und wählt die resultierenden Elemente mithilfe einer angegebenen Funktion aus. (Definiert durch Observable.)
	GroupBy<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>)	Überladen. Gruppiert die Elemente einer feststellbaren Sequenz gemäß einer angegebenen Schlüsselmarkierfunktion und dem Vergleich und wählt die resultierenden Elemente mithilfe einer angegebenen Funktion aus. (Definiert durch Observable.)
	GroupByUntil<T, TKey, TDuration>(Func<T, TKey>, Func<IGroupedObservable<TKey, T>, IObservable<TDuration>>)	Überladen. Gruppiert die Elemente einer observierbaren Sequenz gemäß einer angegebenen Schlüsselmarkierfunktion. (Definiert durch Observable.)
	GroupByUntil<T, TKey, TDuration>(Func<T, TKey>, Func<IGroupedObservable<TKey, T>, IObservable<TDuration>>, IEqualityComparer<TKey>)	Überladen. Gruppiert die Elemente einer feststellbaren Sequenz gemäß einer angegebenen Schlüsselmarkierfunktion und einem Vergleich. (Definiert durch Observable.)
	GroupByUntil<T, TKey, TElement, TDuration>(Func<T, TKey>, Func<T, TElement>, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>)	Überladen. Gruppiert die Elemente einer feststellbaren Sequenz entsprechend einer angegebenen Schlüsselmarkierfunktion und wählt die resultierenden Elemente mithilfe einer angegebenen Funktion aus. (Definiert durch Observable.)
	GroupByUntil<T, TKey, TElement, TDuration>(Func<T, TKey>, Func<T, TElement>, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>, IEqualityComparer<TKey>)	Überladen. Gruppiert die Elemente einer feststellbaren Sequenz gemäß einer angegebenen Schlüsselmarkierfunktion und dem Vergleich und wählt die resultierenden Elemente mithilfe einer angegebenen Funktion aus. (Definiert durch Observable.)
	GroupJoin<T, TRight, TLeftDuration, TRightDuration, TResult>	Korreliert die Elemente zweier Sequenzen basierend auf überlappenden Daueren und gruppiert die Ergebnisse. (Definiert durch Observable.)
	IgnoreElements<T->	Ignoriert alle Werte in einer observierbaren Sequenz, wobei nur die Beendigungsmeldungen verbleiben. (Definiert durch Observable.)
	Join<T, TRight, TLeftDuration, TRightDuration, TResult>	Korreliert die Elemente zweier Sequenzen basierend auf überlappenden Daueren. (Definiert durch Observable.)
	Letzten<T>()	Überladen. Gibt das letzte Element einer feststellbaren Sequenz mit einer angegebenen Quelle zurück. (Definiert durch Observable.)
	Last<T>(Func<T, Boolean>)	Überladen. Gibt das letzte Element einer observierbaren Sequenz zurück, die dem Prädikat entspricht. (Definiert durch Observable.)
	LastOrDefault<T>()	Überladen. Gibt das letzte Element in der observablen Sequenz oder einen Standardwert zurück, wenn kein Wert gefunden wird. (Definiert durch Observable.)
	LastOrDefault<T>(Func<T, boolean>)	Überladen. Gibt das letzte Element einer feststellbaren Sequenz zurück, das dem Prädikat entspricht, oder einen Standardwert, wenn kein Wert gefunden wird. (Definiert durch Observable.)
	Neuesten<T->	Gibt den neuesten Wert in einer observablen Sequenz an. (Definiert durch Observable.)
	LongCount<T>	Gibt einen Int64- zurück, der die Gesamtanzahl der Elemente in einer observierbaren Sequenz darstellt. (Definiert durch Observable.)
	Materialisieren<T->	Materialisiert die impliziten Benachrichtigungen einer feststellbaren Sequenz als explizite Benachrichtigungswerte. (Definiert durch Observable.)
	Max<T>()	Überladen. Gibt das maximale Element in einer observablen Sequenz zurück. (Definiert durch Observable.)
	Max<T>(IComparer<T>)	Überladen. Gibt den Maximalwert in einer observablen Sequenz gemäß dem angegebenen Vergleich zurück. (Definiert durch Observable.)
	MaxBy<T, TKey>(Func<T, TKey>)	Überladen. Gibt die Elemente in einer feststellbaren Sequenz mit dem maximalen Schlüsselwert zurück. (Definiert durch Observable.)
	MaxBy<T, TKey>(Func<T, TKey>, IComparer<TKey>)	Überladen. Gibt die Elemente in einer feststellbaren Sequenz mit dem maximalen Schlüsselwert zurück. (Definiert durch Observable.)
	Zusammenführen<T>(IObservable<T>)	Überladen. Führt eine feststellbare Sequenz von observierbaren Sequenzen in eine observierbare Sequenz zusammen. (Definiert durch Observable.)
	Zusammenführen<T>(IObservable<T>, IScheduler)	Überladen. Führt zwei feststellbare Sequenzen in einer einzelnen observierbaren Sequenz zusammen. (Definiert durch Observable.)
	Min<T->()	Überladen. Gibt das Mindestelement in einer observierbaren Sequenz zurück. (Definiert durch Observable.)
	Min<T>(IComparer<T>)	Überladen. Gibt den Minimalwert in einer feststellbaren Sequenz gemäß dem angegebenen Vergleich zurück. (Definiert durch Observable.)
	MinBy<T, TKey>(Func<T, TKey>)	Überladen. Gibt die Elemente in einer feststellbaren Sequenz mit dem Minimalschlüsselwert zurück. (Definiert durch Observable.)
	MinBy<T, TKey>(Func<T, TKey>, IComparer<TKey>)	Überladen. Gibt die Elemente in einer feststellbaren Sequenz mit dem minimalen Schlüsselwert gemäß dem angegebenen Vergleich zurück. (Definiert durch Observable.)
	MostRecent<T>	Gibt den neuesten Wert in einer observablen Sequenz an. (Definiert durch Observable.)
	Multicast<T, TResult>(ISubject<T, TResult>)	Überladen. Gibt eine verbindebare feststellbare Sequenz zurück, die bei verbindung dazu führt, dass die Quellsequenz Ergebnisse in den angegebenen Betreff überträgt. (Definiert durch Observable.)
	Multicast<T, TIntermediate, TResult>(Func<ISubject<T, TIntermediate>>, Func<IObservable<TIntermediate>, IObservable<TResult>>)	Überladen. Gibt eine feststellbare Sequenz zurück, die die Elemente einer Sequenz enthält, die durch Multicasting der Quellsequenz innerhalb einer Selektorfunktion erzeugt wird. (Definiert durch Observable.)
	Next<T>	Gibt den nächsten Wert (Blockierung ohne Pufferung) in einer observierbaren Sequenz an. (Definiert durch Observable.)
	ObserveOn<T>(SynchronizationContext)	Überladen. Benachrichtigen Sie Beobachter asynchron über den angegebenen Synchronisierungskontext. (Definiert durch Observable.)
	ObserveOn<T>(Steuerelement)	Überladen. (Definiert durch ControlObservable.)
	ObserveOn<T>(Dispatcher)	Überladen. (Definiert durch DispatcherObservable.)
	ObserveOn<T>(DispatcherScheduler)	Überladen. (Definiert durch DispatcherObservable.)
	ObserveOn<T>(IScheduler)	Überladen. Benachrichtigen Sie Beobachter asynchron über den angegebenen Zeitplan. (Definiert durch Observable.)
	ObserveOnDispatcher<T>	(Definiert durch DispatcherObservable.)
	OnErrorResumeNext<T->	Setzt eine feststellbare Sequenz fort, die normal oder von einer Ausnahme mit der nächsten observablen Sequenz beendet wird. (Definiert durch Observable.)
	veröffentlichen<T>()	Überladen. Gibt eine verbindungsfähige Observable-Sequenz zurück, die ein einzelnes Abonnement für die zugrunde liegende Sequenz gemeinsam verwendet. (Definiert durch Observable.)
	<T>(T) veröffentlichen	Überladen. Gibt eine verbindungsfähige Observable-Sequenz zurück, die ein einzelnes Abonnement für die zugrunde liegende Sequenz gemeinsam verwendet und mit initialValue beginnt. (Definiert durch Observable.)
	Veröffentlichen<T, TResult>(Func<IObservable<T>, IObservable<TResult>>)	Überladen. Gibt eine feststellbare Sequenz zurück, die das Ergebnis des Aufrufs des Selektors für eine verbindungsfähige Observable-Sequenz ist, die ein einzelnes Abonnement für die zugrunde liegende Sequenz freigibt. (Definiert durch Observable.)
	Veröffentlichen<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, T)	Überladen. Gibt eine verbindungsfähige Observable-Sequenz zurück, die ein einzelnes Abonnement für die zugrunde liegende Sequenz gemeinsam verwendet und mit initialValue beginnt. (Definiert durch Observable.)
	PublishLast<T>()	Überladen. Gibt eine feststellbare Sequenz zurück, die ein einzelnes Abonnement für die zugrunde liegende Sequenz verwendet, die nur die letzte Benachrichtigung enthält. (Definiert durch Observable.)
	PublishLast<T, TResult>(Func<IObservable<T>, IObservable<TResult>>)	Überladen. Gibt eine feststellbare Sequenz zurück, die das Ergebnis des Aufrufs des Selektors für eine feststellbare Sequenz ist, die ein einzelnes Abonnement für die zugrunde liegende Sequenz freigibt, die nur die letzte Benachrichtigung enthält. (Definiert durch Observable.)
	RefCount<TSource->	Gibt eine observable Sequenz zurück, die mit der Quelle verbunden bleibt, solange mindestens ein Abonnement für die observable Sequenz vorhanden ist. (Definiert durch Observable.)
	<T->() wiederholen	Überladen. Wiederholt die observable Sequenz auf unbestimmte Zeit. (Definiert durch Observable.)
	<T->(Int32)- wiederholen	Überladen. Wiederholt die observable Sequenz auf unbestimmte Zeit. (Definiert durch Observable.)
	Wiedergabe<T>()	Überladen. Gibt eine feststellbare Sequenz zurück, die ein einzelnes Abonnement für die zugrunde liegende Sequenz verwendet, die alle Benachrichtigungen wiedergibt. (Definiert durch Observable.)
	<T>(TimeSpan)	Überladen. Gibt eine verbindungsfähige feststellbare Sequenz zurück, die ein einzelnes Abonnement für die zugrunde liegende Sequenz verwendet, in der alle Benachrichtigungen im Fenster wiedergegeben werden. (Definiert durch Observable.)
	Wiedergabe<T>(Int32)	Überladen. Gibt eine verbindungsfähige feststellbare Sequenz zurück, die ein einzelnes Abonnement für die zugrunde liegende Sequenz zurückgibt, in der pufferSize-Benachrichtigungen wiedergegeben werden. (Definiert durch Observable.)
	Wiedergabe<T>(IScheduler)	Überladen. Gibt eine feststellbare Sequenz zurück, die ein einzelnes Abonnement für die zugrunde liegende Sequenz verwendet, die alle Benachrichtigungen wiedergibt. (Definiert durch Observable.)
	Wiedergabe<T>(TimeSpan, IScheduler)	Überladen. Gibt eine verbindungsfähige feststellbare Sequenz zurück, die ein einzelnes Abonnement für die zugrunde liegende Sequenz verwendet, in der alle Benachrichtigungen im Fenster wiedergegeben werden. (Definiert durch Observable.)
	Wiedergabe<T>(Int32, IScheduler)	Überladen. Gibt eine verbindungsfähige feststellbare Sequenz zurück, die ein einzelnes Abonnement für die zugrunde liegende Sequenz zurückgibt, in der pufferSize-Benachrichtigungen wiedergegeben werden. (Definiert durch Observable.)
	Wiedergabe<T>(Int32, TimeSpan)	Überladen. Gibt eine verbindungsfähige Observable-Sequenz zurück, die ein einzelnes Abonnement für die zugrunde liegende Sequenz zurückgibt, in der Benachrichtigungen im Fenster puffern. (Definiert durch Observable.)
	Wiedergabe<T>(Int32, TimeSpan, IScheduler)	Überladen. Gibt eine verbindungsfähige Observable-Sequenz zurück, die ein einzelnes Abonnement für die zugrunde liegende Sequenz zurückgibt, in der Benachrichtigungen im Fenster puffern. (Definiert durch Observable.)
	Wiedergabe<T, TResult>(Func<IObservable<T>, IObservable<TResult>>)	Überladen. Gibt eine feststellbare Sequenz zurück, die das Ergebnis des Aufrufs des Selektors für eine feststellbare Sequenz ist, die ein einzelnes Abonnement für die zugrunde liegende Sequenz gemeinsam verwendet und mit dem Anfangswert beginnt. (Definiert durch Observable.)
	Wiedergabe<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, IScheduler)	Überladen. Gibt eine feststellbare Sequenz zurück, die das Ergebnis des Aufrufs des Selektors für eine feststellbare Sequenz ist, die ein einzelnes Abonnement für die zugrunde liegende Sequenz freigibt, in der alle Benachrichtigungen wiedergegeben werden. (Definiert durch Observable.)
	Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, TimeSpan)	Überladen. Gibt eine feststellbare Sequenz zurück, die das Ergebnis des Aufrufs des Selektors für eine verbindungsfähige Observable-Sequenz ist, die ein einzelnes Abonnement für die zugrunde liegende Sequenz freigibt, die alle Benachrichtigungen im Fenster wiedergibt. (Definiert durch Observable.)
	Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32)	Überladen. Gibt eine feststellbare Sequenz zurück, die das Ergebnis des Aufrufs des Selektors für eine verbindungsfähige Observable-Sequenz ist, die ein einzelnes Abonnement für die zugrunde liegende sequenzbasierte Wiedergabe von BufferSize-Benachrichtigungen freigibt. (Definiert durch Observable.)
	Wiedergabe<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, TimeSpan, IScheduler)	Überladen. Gibt eine feststellbare Sequenz zurück, die das Ergebnis des Aufrufs des Selektors für eine verbindungsfähige Observable-Sequenz ist, die ein einzelnes Abonnement für die zugrunde liegende Sequenz freigibt, die alle Benachrichtigungen im Fenster wiedergibt. (Definiert durch Observable.)
	Wiedergabe<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32, IScheduler)	Überladen. Gibt eine feststellbare Sequenz zurück, die das Ergebnis des Aufrufs des Selektors für eine verbindungsfähige Observable-Sequenz ist, die ein einzelnes Abonnement für die zugrunde liegende sequenzbasierte Wiedergabe von BufferSize-Benachrichtigungen freigibt. (Definiert durch Observable.)
	Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32, TimeSpan)	Überladen. Gibt eine feststellbare Sequenz zurück, die das Ergebnis des Aufrufs des Selektors für eine verbindungsfähige Observable-Sequenz ist, die ein einzelnes Abonnement für die zugrunde liegende Sequenz zum Wiedergeben von PufferNize-Benachrichtigungen innerhalb des Fensters freigibt. (Definiert durch Observable.)
	Wiedergabe<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32, TimeSpan, IScheduler)	Überladen. Gibt eine feststellbare Sequenz zurück, die das Ergebnis des Aufrufs des Selektors für eine verbindungsfähige Observable-Sequenz ist, die ein einzelnes Abonnement für die zugrunde liegende Sequenz zum Wiedergeben von PufferNize-Benachrichtigungen innerhalb des Fensters freigibt. (Definiert durch Observable.)
	Wiederholen<T->()	Überladen. Wiederholt die observable Quellsequenz, bis sie erfolgreich beendet wird. (Definiert durch Observable.)
	<T->(Int32)- wiederholen	Überladen. Wiederholt die observable Quellsequenz, bis sie erfolgreich beendet wird. (Definiert durch Observable.)
	Beispiel<T>(TimeSpan)	Überladen. Gibt die Observable-Sequenz in jedem Intervall an. (Definiert durch Observable.)
	Beispiel<T>(TimeSpan, IScheduler)	Überladen. Gibt die Observable-Sequenz in jedem Intervall mit der angegebenen Quelle, dem angegebenen Intervall und dem Zeitplan an. (Definiert durch Observable.)
	Beispiel<T, TSample>(IObservable<TSample>)	Überladen. Gibt die feststellbare Sequenz bei Sampling-Ticks mit der angegebenen Quelle und dem Sampler ab. (Definiert durch Observable.)
	Scan<T>(Func<T, T, T>)	Überladen. Wendet eine Akkumulatorfunktion über eine feststellbare Sequenz an und gibt jedes Zwischenergebnis mit der angegebenen Quelle und dem Akkumulator zurück. (Definiert durch Observable.)
	Scan<T, TAccumulate>(TAccumulate, Func<TAccumulate, T, TAccumulate>)	Überladen. Wendet eine Akkumulatorfunktion auf eine feststellbare Sequenz an und gibt jedes Zwischenergebnis mit der angegebenen Quelle, dem Saatgut und dem Akkumulator zurück. (Definiert durch Observable.)
	Auswählen<T, TResult>(Func<T, TResult>)	Überladen. Projiziert jedes Element einer observablen Sequenz in ein neues Formular mit der angegebenen Quelle und Auswahl. (Definiert durch Observable.)
	<T, TResult>auswählen (Func<T, Int32, TResult>)	Überladen. Projiziert jedes Element einer feststellbaren Sequenz in ein neues Formular, indem er den Index des Elements mit der angegebenen Quelle und Auswahl einbezieht. (Definiert durch Observable.)
	SelectMany<T, TOther>(IObservable<TOther>)	Überladen. Projiziert jedes Element einer observierbaren Sequenz auf eine feststellbare Sequenz und flacht die resultierenden observierbaren Sequenzen in eine feststellbare Sequenz. (Definiert durch Observable.)
	SelectMany<T, TResult>(Func<T, IObservable<TResult>>)	Überladen. Projiziert jedes Element einer observierbaren Sequenz auf eine feststellbare Sequenz und flacht die resultierenden observierbaren Sequenzen in eine feststellbare Sequenz. (Definiert durch Observable.)
	SelectMany<T, TResult>(Func<T, IEnumerable<TResult>>)	Überladen. Projiziert jedes Element einer observierbaren Sequenz auf eine feststellbare Sequenz und flacht die resultierenden observierbaren Sequenzen in eine feststellbare Sequenz. (Definiert durch Observable.)
	SelectMany<T, TResult>(Func<T, IObservable<TResult>>, Func<Exception, IObservable<TResult>>, Func<IObservable<TResult>>)	Überladen. Projiziert jedes Element einer observierbaren Sequenz auf eine feststellbare Sequenz und flacht die resultierenden observierbaren Sequenzen in eine feststellbare Sequenz. (Definiert durch Observable.)
	SelectMany<T, TCollection, TResult>(Func<T, IEnumerable<TCollection>>, Func<T, TCollection, TResult>)	Überladen. Projiziert jedes Element einer observierbaren Sequenz auf eine feststellbare Sequenz und flacht die resultierenden observierbaren Sequenzen in eine feststellbare Sequenz. (Definiert durch Observable.)
	SelectMany<T, TCollection, TResult>(Func<T, IObservable<TCollection>>, Func<T, TCollection, TResult>)	Überladen. Projiziert jedes Element einer observierbaren Sequenz auf eine feststellbare Sequenz und flacht die resultierenden observierbaren Sequenzen in eine feststellbare Sequenz. (Definiert durch Observable.)
	SequenceEqual<T>(IObservable<T>)	Überladen. Bestimmt, ob zwei Sequenzen gleich sind, indem die Elemente paarweise verglichen werden. (Definiert durch Observable.)
	SequenceEqual<T>(IObservable<T>, IEqualityComparer<T>)	Überladen. Bestimmt, ob zwei Sequenzen gleich sind, indem die Elemente mit einem angegebenen Gleichheitsabgleich verglichen werden. (Definiert durch Observable.)
	single<T>()	Überladen. Gibt das einzige Element einer observablen Sequenz zurück und löst eine Ausnahme aus, wenn nicht genau ein Element in der observablen Sequenz vorhanden ist. (Definiert durch Observable.)
	Single<T>(Func<T, boolean>)	Überladen. Gibt das einzige Element einer observierbaren Sequenz zurück, das dem Prädikat entspricht, und löst eine Ausnahme aus, wenn es nicht genau ein Element in der observablen Sequenz gibt. (Definiert durch Observable.)
	SingleOrDefault<T>()	Überladen. Gibt das einzige Element einer observablen Sequenz oder einen Standardwert zurück, wenn die observable Sequenz leer ist. (Definiert durch Observable.)
	SingleOrDefault<T>(Func<T, boolean>)	Überladen. Gibt das einzige Element einer feststellbaren Sequenz zurück, das mit dem Prädikat übereinstimmt, oder einen Standardwert, wenn kein Wert gefunden wird. (Definiert durch Observable.)
	<T-> überspringen	Umgeht eine angegebene Anzahl von Werten in einer observablen Sequenz und gibt dann die verbleibenden Werte zurück. (Definiert durch Observable.)
	SkipLast<T->	Umgeht eine angegebene Anzahl von Elementen am Ende einer observierbaren Sequenz. (Definiert durch Observable.)
	SkipUntil<T, TOther>	Gibt die Werte aus der Quellbeobachtungssequenz nur zurück, nachdem die andere observable Sequenz einen Wert erzeugt. (Definiert durch Observable.)
	SkipWhile<T>(Func<T, boolean>)	Überladen. Umgeht Werte in einer observierbaren Sequenz, solange eine angegebene Bedingung wahr ist, und gibt dann die verbleibenden Werte zurück. (Definiert durch Observable.)
	SkipWhile<T>(Func<T, Int32, Boolean>)	Überladen. Umgeht Werte in einer observierbaren Sequenz, solange eine angegebene Bedingung wahr ist, und gibt dann die verbleibenden Werte zurück. (Definiert durch Observable.)
	StartWith<T>T[])	Überladen. Stellt eine Abfolge von Werten einer feststellbaren Sequenz mit der angegebenen Quelle und den angegebenen Werten voran. (Definiert durch Observable.)
	StartWith<T>(IScheduler, T[])	Überladen. Stellt eine Abfolge von Werten einer feststellbaren Sequenz mit der angegebenen Quelle, dem Angegebenen Zeitplan und den Werten voran. (Definiert durch Observable.)
	Abonnieren<T>()	Überladen. Wertet die observable Sequenz mit einer angegebenen Quelle aus. (Definiert durch ObservableExtensions.)
	Abonnieren<T>(Aktion<T>)	Überladen. Abonniert einen Elementhandler für eine observable Sequenz. (Definiert durch ObservableExtensions.)
	Abonnieren<T>(Aktion<T>, Aktion<Ausnahme>)	Überladen. Abonniert einen Elementhandler und einen Ausnahmehandler für eine observable Sequenz. (Definiert durch ObservableExtensions.)
	Abonnieren<T>(Aktion<T>, Aktion)	Überladen. Abonniert einen Elementhandler und einen Abschlusshandler für eine observable Sequenz. (Definiert durch ObservableExtensions.)
	Abonnieren<T>(Aktion<T>, Aktion<Ausnahme>, Aktion)	Überladen. Abonniert einen Elementhandler, einen Ausnahmehandler und einen Abschlusshandler für eine observable Sequenz. (Definiert durch ObservableExtensions.)
	SubscribeOn<T>(SynchronizationContext)	Überladen. Asynchron abonniert und gekündigt Beobachter für den angegebenen Synchronisierungskontext. (Definiert durch Observable.)
	SubscribeOn<T>(Steuerelement)	Überladen. (Definiert durch ControlObservable.)
	SubscribeOn<T>(Dispatcher)	Überladen. (Definiert durch DispatcherObservable.)
	SubscribeOn<T>(DispatcherScheduler)	Überladen. (Definiert durch DispatcherObservable.)
	SubscribeOn<T>(IScheduler)	Überladen. Asynchron abonniert und gekündigt Beobachter am angegebenen Zeitplan. (Definiert durch Observable.)
	SubscribeOnDispatcher<T>	(Definiert durch DispatcherObservable.)
	Synchronisieren<T->()	Überladen. Synchronisiert die observable Sequenz. (Definiert durch Observable.)
	synchronisieren<T>(Objekt)	Überladen. Synchronisiert die observable Sequenz. (Definiert durch Observable.)
	<T->	Gibt eine angegebene Anzahl zusammenhängender Werte vom Anfang einer observablen Sequenz zurück. (Definiert durch Observable.)
	TakeLast<T->	Gibt eine angegebene Anzahl zusammenhängender Elemente vom Ende einer observierbaren Sequenz zurück. (Definiert durch Observable.)
	TakeUntil<T, TOther>	Gibt die Werte aus der Observable-Quellsequenz zurück, bis die andere observable Sequenz einen Wert erzeugt. (Definiert durch Observable.)
	TakeWhile<T>(Func<T, boolean>)	Überladen. Gibt Werte aus einer feststellbaren Sequenz zurück, solange eine angegebene Bedingung wahr ist, und überspringt dann die verbleibenden Werte. (Definiert durch Observable.)
	TakeWhile<T>(Func<T, Int32, Boolean>)	Überladen. Gibt Werte aus einer feststellbaren Sequenz zurück, solange eine angegebene Bedingung wahr ist, und überspringt dann die verbleibenden Werte. (Definiert durch Observable.)
	Dann<T, TResult>	Übereinstimmungen, wenn die Observable-Sequenz einen verfügbaren Wert aufweist und den Wert projektiert. (Definiert durch Observable.)
	Drosselung<T>(TimeSpan)	Überladen. Ignoriert die Werte aus einer feststellbaren Sequenz, auf die ein anderer Wert vor Fälligkeitszeit mit der angegebenen Quelle und dueTime folgt. (Definiert durch Observable.)
	Drosselung<T>(TimeSpan, IScheduler)	Überladen. Ignoriert die Werte aus einer feststellbaren Sequenz, auf die ein anderer Wert vor Fälligkeitszeit mit der angegebenen Quelle, dueTime und Scheduler folgt. (Definiert durch Observable.)
	TimeInterval<T>()	Überladen. Zeichnet das Zeitintervall zwischen aufeinander folgenden Werten in einer observierbaren Sequenz mit der angegebenen Quelle auf. (Definiert durch Observable.)
	timeInterval<T>(IScheduler)	Überladen. Zeichnet das Zeitintervall zwischen aufeinander folgenden Werten in einer observierbaren Sequenz mit der angegebenen Quelle und dem Zeitplan auf. (Definiert durch Observable.)
	Timeout<T>(TimeSpan)	Überladen. Gibt entweder die observable Sequenz oder eine TimeoutException zurück, wenn DueTime verstrichen ist. (Definiert durch Observable.)
	Timeout<T>(DateTimeOffset)	Überladen. Gibt entweder die observable Sequenz oder eine TimeoutException zurück, wenn DueTime verstrichen ist. (Definiert durch Observable.)
	Timeout<T>(TimeSpan, IObservable<T>)	Überladen. Gibt die observable Quellsequenz oder die andere feststellbare Sequenz zurück, wenn DueTime verstrichen ist. (Definiert durch Observable.)
	Timeout<T>(DateTimeOffset, IObservable<T>)	Überladen. Gibt entweder die observable Sequenz oder eine TimeoutException zurück, wenn DueTime verstrichen ist. (Definiert durch Observable.)
	Timeout<T>(TimeSpan, IScheduler)	Überladen. Gibt entweder die observable Sequenz oder eine TimeoutException zurück, wenn DueTime verstrichen ist. (Definiert durch Observable.)
	Timeout-<T>(DateTimeOffset, IScheduler)	Überladen. Gibt entweder die observable Sequenz oder eine TimeoutException zurück, wenn DueTime verstrichen ist. (Definiert durch Observable.)
	Timeout<T>(TimeSpan, IObservable<T>, IScheduler)	Überladen. Gibt die observable Quellsequenz oder die andere feststellbare Sequenz zurück, wenn DueTime verstrichen ist. (Definiert durch Observable.)
	Timeout<T>(DateTimeOffset, IObservable<T>, IScheduler)	Überladen. Gibt die observable Quellsequenz oder die andere feststellbare Sequenz zurück, wenn DueTime verstrichen ist. (Definiert durch Observable.)
	Timestamp<T>()	Überladen. Zeichnet den Zeitstempel für jeden Wert in einer observablen Sequenz mit der angegebenen Quelle auf. (Definiert durch Observable.)
	<T>(IScheduler)	Überladen. Zeichnet den Zeitstempel für jeden Wert in einer observierbaren Sequenz mit der angegebenen Quelle und dem angegebenen Zeitplan auf. (Definiert durch Observable.)
	ToArray-<T->	Erstellt ein Array aus einer observablen Sequenz. (Definiert durch Observable.)
	ToDictionary<T, TKey>(Func<T, TKey>)	Überladen. Erstellt ein Wörterbuch aus einer observierbaren Sequenz gemäß einer angegebenen Schlüsselauswahlfunktion. (Definiert durch Observable.)
	ToDictionary<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	Überladen. Erstellt ein Wörterbuch aus einer feststellbaren Sequenz gemäß einer angegebenen Schlüsselauswahlfunktion und einem Vergleichsmodul. (Definiert durch Observable.)
	ToDictionary<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>)	Überladen. Erstellt ein Wörterbuch aus einer feststellbaren Sequenz gemäß einer angegebenen Schlüsselmarkierfunktion und einer Elementauswahlfunktion. (Definiert durch Observable.)
	ToDictionary<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>)	Überladen. Erstellt ein Wörterbuch aus einer feststellbaren Sequenz gemäß einer angegebenen Schlüsselauswahlfunktion, einem Vergleichsmodul und einer Elementauswahlfunktion. (Definiert durch Observable.)
	toEnumerable<T>	Wandelt eine feststellbare Sequenz in eine aufzählbare Sequenz um. (Definiert durch Observable.)
	ToEvent-<T->	Macht eine observable Sequenz als Objekt mit einem .NET-Ereignis mit einer angegebenen Quelle verfügbar. (Definiert durch Observable.)
	ToList-<T->	Erstellt eine Liste aus einer observablen Sequenz. (Definiert durch Observable.)
	ToLookup<T, TKey>(Func<T, TKey>)	Überladen. Erstellt einen Nachschlagevorgang aus einer feststellbaren Sequenz gemäß einer angegebenen Tastenauswahlfunktion. (Definiert durch Observable.)
	ToLookup<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	Überladen. Erstellt einen Nachschlagevorgang aus einer observierbaren Sequenz gemäß einer angegebenen Tastenauswahlfunktion und einem Vergleichsmodul. (Definiert durch Observable.)
	ToLookup<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>)	Überladen. Erstellt einen Nachschlagevorgang aus einer feststellbaren Sequenz gemäß einer angegebenen Schlüsselmarkierfunktion und einer Elementauswahlfunktion. (Definiert durch Observable.)
	ToLookup<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>)	Überladen. Erstellt einen Nachschlagevorgang aus einer feststellbaren Sequenz gemäß einer angegebenen Schlüsselmarkierfunktion, einem Vergleichsmodul und einer Elementauswahlfunktion. (Definiert durch Observable.)
	toTask<T>()	Überladen. Gibt einen Vorgang zurück, der den letzten Wert der observablen Sequenz enthält. (Definiert durch TaskObservableExtensions.)
	toTask<T>(Object)	Überladen. Gibt einen Vorgang zurück, der den letzten Wert der observablen Sequenz enthält. (Definiert durch TaskObservableExtensions.)
	toTask<T>(CancellationToken)	Überladen. Gibt einen Vorgang zurück, der den letzten Wert der observablen Sequenz enthält. (Definiert durch TaskObservableExtensions.)
	toTask<T>(CancellationToken, Object)	Überladen. Gibt einen Vorgang zurück, der den letzten Wert der observablen Sequenz enthält. (Definiert durch TaskObservableExtensions.)
	Wo<T>(Func<T, boolesche>)	Überladen. Filtert die Elemente einer feststellbaren Sequenz basierend auf einem Prädikat. (Definiert durch Observable.)
	Where<T>(Func<T, Int32, Boolean>)	Überladen. Filtert die Elemente einer feststellbaren Sequenz basierend auf einem Prädikat, indem der Index des Elements einbezogen wird. (Definiert durch Observable.)
	Window<T>(Int32)	Überladen. Projiziert jedes Element einer observierbaren Sequenz in aufeinander folgende nicht überlappende Fenster, die basierend auf Elementanzahlsinformationen erzeugt werden. (Definiert durch Observable.)
	< >(TimeSpan)	Überladen. Projiziert jedes Element einer observierbaren Sequenz in aufeinander folgende nicht überlappende Fenster, die basierend auf Zeitangaben erzeugt werden. (Definiert durch Observable.)
	Window<T>(Int32, Int32)	Überladen. Projiziert jedes Element einer observierbaren Sequenz in null oder mehr Fenster, die basierend auf Elementanzahlsinformationen erzeugt werden. (Definiert durch Observable.)
	Window<T>(TimeSpan, IScheduler)	Überladen. Projiziert jedes Element einer observierbaren Sequenz in aufeinander folgende nicht überlappende Fenster, die basierend auf Zeitangaben erzeugt werden. (Definiert durch Observable.)
	Window<T>(TimeSpan, TimeSpan)	Überladen. Projiziert jedes Element einer feststellbaren Sequenz in null oder mehr Fenster, die basierend auf Zeitangaben erzeugt werden. (Definiert durch Observable.)
	<T>(TimeSpan, Int32)	Überladen. Projiziert jedes Element einer observierbaren Sequenz in ein Fenster, das abgeschlossen wird, wenn es voll ist oder eine bestimmte Zeitspanne verstrichen ist. (Definiert durch Observable.)
	Window<T>(TimeSpan, TimeSpan, IScheduler)	Überladen. Projiziert jedes Element einer feststellbaren Sequenz in null oder mehr Fenster, die basierend auf Zeitangaben erzeugt werden. (Definiert durch Observable.)
	Window<T>(TimeSpan, Int32, IScheduler)	Überladen. Projiziert jedes Element einer observierbaren Sequenz in ein Fenster, das abgeschlossen wird, wenn es voll ist oder eine bestimmte Zeitspanne verstrichen ist. (Definiert durch Observable.)
	Window<T, TWindowClosing>(Func<IObservable<TWindowClosing>>)	Überladen. Projiziert jedes Element einer observierbaren Sequenz in aufeinander folgende nicht überlappende Fenster. (Definiert durch Observable.)
	Window<T, TWindowOpening, TWindowClosing>(IObservable<TWindowOpening>, Func<TWindowOpening, IObservable<TWindowClosing>>)	Überladen. Projiziert jedes Element einer feststellbaren Sequenz in null oder mehr Fenster. (Definiert durch Observable.)
	Zip<T, TSecond, TResult>(IObservable<TSecond>, Func<T, TSecond, TResult>)	Überladen. Führt zwei feststellbare Sequenzen in einer feststellbaren Sequenz zusammen, indem sie ihre Elemente in paarweiser Weise kombinieren. (Definiert durch Observable.)
	Zip<T, TSecond, TResult>(IEnumerable<TSecond>, Func<T, TSecond, TResult>)	Überladen. Führt eine observable Sequenz und eine aufzählbare Sequenz mit einer observierbaren Sequenz mithilfe der Selektorfunktion zusammen. (Definiert durch Observable.)

Nach oben

Bemerkungen

Kalte Observables beginnen mit dem Abonnement, d. h., die observable Sequenz beginnt nur, Werte an die Beobachter zu pushen, wenn Subscribe aufgerufen wird. Werte werden auch nicht für Abonnenten freigegeben. Dies unterscheidet sich von heißen Observables wie Mausverschiebungsereignissen oder Aktienticker, die bereits Werte erzeugen, noch bevor ein Abonnement aktiv ist. Wenn ein Beobachter eine heiße observable Sequenz abonniert, erhält er den aktuellen Wert im Datenstrom. Die heiße Observable-Sequenz wird für alle Abonnenten freigegeben, und jeder Abonnent wird den nächsten Wert in der Sequenz pusht. Selbst wenn niemand einen bestimmten Aktienticker abonniert hat, wird der Ticker seinen Wert basierend auf der Marktbewegung weiter aktualisieren. Wenn ein Abonnent Interesse an diesem Ticker registriert, erhält er automatisch den neuesten Tick.

Beispiele

Im folgenden Beispiel konvertieren wir eine kalte observable Sequenzquelle mithilfe des Publish-Operators in eine heiße Quelle, die einen IConnectableObservable-<T-> Instanz zurückgibt, die wir heißen. Der Veröffentlichungsoperator bietet einen Mechanismus zum Freigeben von Abonnements, indem ein einzelnes Abonnement an mehrere Abonnenten übertragen wird. Hot fungiert als Proxy und abonniert die Quelle und empfängt dann Werte aus der Quelle, pusht sie an seine eigenen Abonnenten. Um ein Abonnement für die Sicherungsquelle einzurichten und mit dem Empfangen von Werten zu beginnen, verwenden wir die IConnectableObservable.Connect()-Methode. Da IConnectableObservable IObservable erbt, können wir subscribe to subscribe to this hot sequence auch vor dem Start der Ausführung verwenden. Beachten Sie, dass im Beispiel die Hotsequenz beim Abonnieren von Subscription1 nicht gestartet wurde. Daher wird kein Wert an den Abonnenten übertragen. Nach dem Aufrufen von Connect werden die Werte dann an "subscription1" übertragen. Nach einer Verzögerung von 3 Sekunden abonniert Subscription2 hot und beginnt, die Werte sofort von der aktuellen Position (3 in diesem Fall) bis zum Ende zu erhalten. Die Ausgabe sieht wie folgt aus:

Current Time: 6/1/2011 3:38:49 PM

Current Time after 1st subscription: 6/1/2011 3:38:49 PM

Current Time after Connect: 6/1/2011 3:38:52 PM

Observer 1: OnNext: 0

Observer 1: OnNext: 1

Current Time just before 2nd subscription: 6/1/2011 3:38:55 PM 

Observer 1: OnNext: 2

Observer 1: OnNext: 3

Observer 2: OnNext: 3

Observer 1: OnNext: 4

Observer 2: OnNext: 4

       
Console.WriteLine("Current Time: " + DateTime.Now);
var source = Observable.Interval(TimeSpan.FromSeconds(1));   //creates a sequence

IConnectableObservable<long> hot = Observable.Publish<long>(source);  // convert the sequence into a hot sequence

IDisposable subscription1 = hot.Subscribe(     // no value is pushed to 1st subscription at this point
                            x => Console.WriteLine("Observer 1: OnNext: {0}", x),
                            ex => Console.WriteLine("Observer 1: OnError: {0}", ex.Message),
                            () => Console.WriteLine("Observer 1: OnCompleted"));
Console.WriteLine("Current Time after 1st subscription: " + DateTime.Now);
Thread.Sleep(3000);  //idle for 3 seconds
hot.Connect();       // hot is connected to source and starts pushing value to subscribers 
Console.WriteLine("Current Time after Connect: " + DateTime.Now);
Thread.Sleep(3000);  //idle for 3 seconds
Console.WriteLine("Current Time just before 2nd subscription: " + DateTime.Now);
IDisposable subscription2 = hot.Subscribe(     // value will immediately be pushed to 2nd subscription
                            x => Console.WriteLine("Observer 2: OnNext: {0}", x),
                            ex => Console.WriteLine("Observer 2: OnError: {0}", ex.Message),
                            () => Console.WriteLine("Observer 2: OnCompleted"));
Console.ReadKey();

Siehe auch

Referenz

System.Reactive.Subjects Namespace