Observable.Amb<TSource-Methode> (IObservable<TSource>, IObservable<TSource>)
Gibt die beobachtbare Sequenz weiter, die zuerst mit der angegebenen ersten und zweiten Sequenz reagiert.
Namespace:System.Reactive.Linq
Versammlung: System.Reaktiv (in System.Reactive.dll)
Syntax
'Declaration
<ExtensionAttribute> _
Public Shared Function Amb(Of TSource) ( _
first As IObservable(Of TSource), _
second As IObservable(Of TSource) _
) As IObservable(Of TSource)
'Usage
Dim first As IObservable(Of TSource)
Dim second As IObservable(Of TSource)
Dim returnValue As IObservable(Of TSource)
returnValue = first.Amb(second)
public static IObservable<TSource> Amb<TSource>(
this IObservable<TSource> first,
IObservable<TSource> second
)
[ExtensionAttribute]
public:
generic<typename TSource>
static IObservable<TSource>^ Amb(
IObservable<TSource>^ first,
IObservable<TSource>^ second
)
static member Amb :
first:IObservable<'TSource> *
second:IObservable<'TSource> -> IObservable<'TSource>
JScript does not support generic types and methods.
Typparameter
- TSource
Der Quellentyp.
Parameter
- first
Typ: System.IObservable<TSource>
Die erste beobachtbare Sequenz.
- second
Typ: System.IObservable<TSource>
Die zweite beobachtbare Sequenz.
Rückgabewert
Typ: System.IObservable<TSource>
Die beobachtbare Sequenz, die zuerst aus dem Satz der angegebenen Sequenzen reagierte.
Hinweis zur Verwendung
In Visual Basic und C# können Sie diese Methode als instance-Methode für jedes Objekt vom Typ IObservable<TSource> aufrufen. Bei Verwendung der Syntax für Instanzenmethoden lassen Sie den ersten Parameter aus. Weitere Informationen finden Sie unter oder .
Bemerkungen
Der Name des Amb-Operators steht für "mehrdeutig". Der Amb-Operator nimmt zwei oder mehr Sequenzen an und gibt die erste Sequenz zurück, um zu reagieren. Der Amb-Operator verwendet die parallele Verarbeitung, um zu erkennen, welche Sequenz das erste Element ergibt.
Amb kann als Erweiterungsmethode aufgerufen werden, wie im Codebeispiel in diesem Thema gezeigt, oder es kann als statische Methode aufgerufen werden. Basierend auf dem in diesem Thema beschriebenen Codebeispiel veranschaulicht der folgende Codeausschnitt, wie Amb eine statische Methode aufgerufen wird.
int[] sequence1 = { 1, 2, 3 };
int[] sequence2 = { 4, 5, 6 };
int[] sequence3 = { 7, 8, 9 };
//*** The first item in the sequence1 event stream is delayed by 3 seconds. ***//
IObservable<int> firstSource = sequence1.ToObservable().Delay(TimeSpan.FromSeconds(3));
//*** The first event in the sequence2 event stream is only delayed by 2 seconds. ***//
IObservable<int> secondSource = sequence2.ToObservable().Delay(TimeSpan.FromSeconds(2));
//*** The first event in the sequence3 event stream is only delayed by 1 second. ***//
IObservable<int> thirdSource = sequence3.ToObservable().Delay(TimeSpan.FromSeconds(1));
//*****************************************************************************************//
//*** ***//
//*** The Amb operator will simply return the observable sequence which responds first. ***//
//*** The other sequence will be ignored. ***//
//*** ***//
//*** In this example "thirdSource", which contains sequence3, will respond before ***//
//*** "firstSource" and "secondSource". So "thirdSource" will be the observable ***//
//*** sequence returned from the Amb operator. It will be subscribed to and written ***//
//*** to the console. ***//
//*** ***//
//*****************************************************************************************//
//*** The static method allows the Amb operator to process more than two sequences ***//
using (IDisposable handle = Observable.Amb(firstSource, secondSource, thirdSource).Subscribe(value => Console.WriteLine(value)))
{
Console.WriteLine("\nPress ENTER to exit...\n");
Console.ReadLine();
}
Amb kann auch als Erweiterungsmethode für mehr als zwei Sequenzen aufgerufen werden. Um diesen Ansatz zu verwenden, erstellen Sie eine Sequenz von Sequenzen. Der folgende Codeausschnitt veranschaulicht dies.
int[] sequence1 = { 1, 2, 3 };
int[] sequence2 = { 4, 5, 6 };
int[] sequence3 = { 7, 8, 9 };
//*** The first item in the sequence1 event stream is delayed by 3 seconds. ***//
IObservable<int> firstSource = sequence1.ToObservable().Delay(TimeSpan.FromSeconds(3));
//*** The first event in the sequence2 event stream is only delayed by 2 seconds. ***//
IObservable<int> secondSource = sequence2.ToObservable().Delay(TimeSpan.FromSeconds(2));
//*** The first event in the sequence3 event stream is only delayed by 1 second. ***//
IObservable<int> thirdSource = sequence3.ToObservable().Delay(TimeSpan.FromSeconds(1));
//*****************************************************************************************//
//*** ***//
//*** The Amb operator will simply return the observable sequence which responds first. ***//
//*** The other sequence will be ignored. ***//
//*** ***//
//*** In this example "thirdSource", which contains sequence3, will respond before ***//
//*** "firstSource" and "secondSource". So "thirdSource" will be the observable ***//
//*** sequence returned from the Amb operator. It will be subscribed to and written ***//
//*** to the console. ***//
//*** ***//
//*****************************************************************************************//
//*** Call the extension method on a sequence of any number of sequences. ***//
IObservable<int>[] sources = new[] { firstSource, secondSource, thirdSource };
using(IDisposable handle = sources.Amb().Subscribe(value => Console.WriteLine(value)))
{
Console.WriteLine("\nPress ENTER to exit...\n");
Console.ReadLine();
}
Beispiele
Im folgenden Beispiel wird der Amb-Operator veranschaulicht, indem er ihn mit zwei Sequenzen ganzer Zahlen anwendet. Die Übermittlung der ganzen Zahlen in der ersten Sequenz verzögert sich um drei Sekunden. Die Übermittlung der ganzen Zahlen in der zweiten Sequenz wird nur um zwei Sekunden verzögert. Die zweite Sequenz reagiert also zuerst und ist das Ergebnis des Amb-Operators, wie gezeigt.
using System;
using System.Reactive.Linq;
namespace Example
{
class Program
{
static void Main()
{
int[] sequence1 = { 1, 2, 3 };
int[] sequence2 = { 4, 5, 6 };
//*** The first event in observable sequence1 is delayed by 3 seconds. ***//
IObservable<int> firstSource = sequence1.ToObservable().Delay(TimeSpan.FromSeconds(3));
//*** The first event in observable sequence2 is only delayed by 2 seconds. ***//
IObservable<int> secondSource = sequence2.ToObservable().Delay(TimeSpan.FromSeconds(2));
//*****************************************************************************************//
//*** ***//
//*** The Amb operator will simply return the observable sequence which responds first. ***//
//*** The other sequence will be ignored. ***//
//*** ***//
//*** In this example "secondSource", which contains sequence2, will respond before ***//
//*** "firstSource". So "secondSource" will be the observable sequence returned from ***//
//*** the Amb operator. ***//
//*** ***//
//*****************************************************************************************//
using (IDisposable handle = firstSource.Amb(secondSource).Subscribe(value => Console.WriteLine(value)))
{
Console.WriteLine("Press Enter to exit...\n");
Console.ReadLine();
}
}
}
}
Die Ausgabe des Beispielcodes lautet wie folgt.
Press Enter to exit...
4
5
6