Observable.Amb<TSource> , méthode (IObservable<TSource>, IObservable<TSource>)
Propage la séquence observable qui réagit en premier avec les première et deuxième séquences spécifiées.
Espace de noms :System.Reactive.Linq
Assemblée: System.Reactive (en System.Reactive.dll)
Syntaxe
'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.
Paramètres de type
- TSource
Type de la source.
Paramètres
- first
Type : System.IObservable<TSource>
Première séquence observable.
- second
Type : System.IObservable<TSource>
Deuxième séquence observable.
Valeur de retour
Type : System.IObservable<TSource>
Séquence observable qui a répondu en premier à partir de l’ensemble de séquences données.
Remarque sur l'utilisation
En Visual Basic et C#, vous pouvez appeler cette méthode en tant que méthode instance sur n’importe quel objet de type IObservable<TSource>. Lorsque vous utilisez la syntaxe des méthodes d'instance pour appeler cette méthode, omettez le premier paramètre. Pour plus d'informations, consultez ou .
Notes
Le nom de l’opérateur Amb est l’abréviation de « ambigu ». L’opérateur Amb prend au moins deux séquences et retourne la première séquence pour répondre. L’opérateur Amb utilise le traitement parallèle pour détecter la séquence qui génère le premier élément.
Amb peut être appelé en tant que méthode d’extension, comme indiqué dans l’exemple de code de cette rubrique ou en tant que méthode statique. Sur la base de l’exemple de code donné dans cette rubrique, l’extrait de code suivant montre comment appeler Amb une méthode statique.
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 peut également être appelé comme méthode d’extension pour plus de deux séquences. Pour utiliser cette approche, créez une séquence de séquences. L’extrait de code suivant le montre.
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();
}
Exemples
L’exemple suivant illustre l’opérateur Amb en l’appliquant à deux séquences d’entiers. La remise des entiers dans la première séquence est retardée de trois secondes. La remise des entiers dans la deuxième séquence n’est retardée que de deux secondes. Par conséquent, la deuxième séquence répond en premier et est le résultat de l’opérateur Amb comme indiqué.
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();
}
}
}
}
La sortie de l’exemple de code est la suivante.
Press Enter to exit...
4
5
6