Observable.Aggregate<TSource, TAccumulate> , méthode (IObservable<TSource>, TAccumulate, Func<TAccumulate, TSource, TAccumulate>)
Applique une fonction d’accumulateur sur une séquence observable avec la valeur de départ spécifiée.
Namespace:System.Reactive.Linq
Assemblée: System.Reactive (en System.Reactive.dll)
Syntaxe
'Declaration
<ExtensionAttribute> _
Public Shared Function Aggregate(Of TSource, TAccumulate) ( _
source As IObservable(Of TSource), _
seed As TAccumulate, _
accumulator As Func(Of TAccumulate, TSource, TAccumulate) _
) As IObservable(Of TAccumulate)
'Usage
Dim source As IObservable(Of TSource)
Dim seed As TAccumulate
Dim accumulator As Func(Of TAccumulate, TSource, TAccumulate)
Dim returnValue As IObservable(Of TAccumulate)
returnValue = source.Aggregate(seed, _
accumulator)
public static IObservable<TAccumulate> Aggregate<TSource, TAccumulate>(
this IObservable<TSource> source,
TAccumulate seed,
Func<TAccumulate, TSource, TAccumulate> accumulator
)
[ExtensionAttribute]
public:
generic<typename TSource, typename TAccumulate>
static IObservable<TAccumulate>^ Aggregate(
IObservable<TSource>^ source,
TAccumulate seed,
Func<TAccumulate, TSource, TAccumulate>^ accumulator
)
static member Aggregate :
source:IObservable<'TSource> *
seed:'TAccumulate *
accumulator:Func<'TAccumulate, 'TSource, 'TAccumulate> -> IObservable<'TAccumulate>
JScript does not support generic types and methods.
Paramètres de type
- TSource
Type de la source.
- Aaccumuler
Type d’accumulation.
Paramètres
- source
Type : System.IObservable<TSource>
Séquence observable à agréger.
- seed
Type : TAccumulate
Valeur d'accumulation initiale.
- Accumulateur
Type : System.Func<TAccumulate, TSource, TAccumulate>
Fonction d'accumulation à appeler sur chaque élément.
Valeur de retour
Type : System.IObservable<TAccumulate>
Séquence observable contenant un élément unique avec la valeur d’accumulateur finale.
Remarque sur l'utilisation
Dans 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
L’opérateur d’agrégation est utilisé pour appliquer une fonction à une séquence source afin de produire une valeur agrégée ou cumulée. La fonction appliquée dans la séquence est appelée fonction d’accumulateur. Elle nécessite deux paramètres : une valeur d’accumulateur et un élément de la séquence qui est traité avec la valeur de l’accumulateur. La valeur de l’accumulateur initial est appelée valeur de départ et doit être fournie à l’opérateur d’agrégation. La fonction accumulateur retourne la nouvelle valeur d’accumulateur chaque fois qu’elle est appelée. La nouvelle valeur de l’accumulateur est ensuite utilisée avec l’appel suivant à la fonction d’accumulateur pour traiter l’élément dans la séquence. Ces appels se poursuivent jusqu’à la fin de la séquence.
L’opérateur d’agrégation retourne une séquence observable qui est du même type que la valeur de départ qui est passée à l’opérateur. Pour obtenir la valeur d’agrégation finale, vous vous abonnez à la séquence observable retournée par l’opérateur d’agrégation. Une fois la fonction d’accumulateur appliquée sur l’ensemble de la séquence, les gestionnaires OnNext et OnCompleted de l’observateur fournis dans l’abonnement sont appelés pour fournir la valeur d’agrégation finale. Consultez l’exemple de code fourni avec cet opérateur.
Exemples
Cet exemple illustre l’utilisation de l’opérateur d’agrégation pour compter les voyelles dans une chaîne de caractères générée au moment de l’exécution avec Console.Readkey(). La fonction CountVowels est la fonction d’accumulateur et incrémente le nombre de chaque voyelle rencontrée dans la séquence.
using System;
using System.Reactive.Linq;
namespace Example
{
class Program
{
enum Vowels : int
{
A, E, I, O, U
};
static void Main()
{
//****************************************************************************************//
//*** Create an observable sequence of char from console input until enter is pressed. ***//
//****************************************************************************************//
IObservable<char> xs = Observable.Create<char>(observer =>
{
bool bContinue = true;
while (bContinue)
{
ConsoleKeyInfo keyInfo = Console.ReadKey(true);
if (keyInfo.Key != ConsoleKey.Enter)
{
Console.Write(keyInfo.KeyChar);
observer.OnNext(keyInfo.KeyChar);
}
else
{
observer.OnCompleted();
Console.WriteLine("\n");
bContinue = false;
}
}
return (() => { });
});
//***************************************************************************************//
//*** ***//
//*** The "Aggregate" operator causes the accumulator function, "CountVowels", to be ***//
//*** called for each character in the sequence. ***//
//*** ***//
//*** The seed value is the integer array which will hold a count of each of the five ***//
//*** vowels encountered. It is passed as a parameter to Aggregate. ***//
//*** The seed value will be passed to CountVowels and processed with the first item ***//
//*** in the sequence. ***//
//*** ***//
//*** The return value from "CountVowels" is the same type as the seed parameter. ***//
//*** That return value is subsequently passed into each call to the accumulator with ***//
//*** its corresponding character from the sequence. ***//
// ***//
//*** The event handler, "OnNext", is not called until the accumulator function has ***//
//*** been executed across the entire sequence. ***//
//*** ***//
//***************************************************************************************//
Console.WriteLine("\nEnter a sequence of characters followed by the ENTER key.\n" +
"The example code will count the vowels you enter\n");
using (IDisposable handle = xs.Aggregate(new int[5], CountVowels).Subscribe(OnNext))
{
Console.WriteLine("\nPress ENTER to exit...");
Console.ReadLine();
}
}
//*********************************************************************************************************//
//*** ***//
//*** The Event handler, "OnNext" is called when the event stream that Aggregate is processing ***//
//** completes. ***//
//*** ***//
//*** The final accumulator value is passed to the handler. In this example, it is the array containing ***//
//*** final count of each vowel encountered. ***//
//*** ***//
//*********************************************************************************************************//
static void OnNext(int[] state)
{
Console.WriteLine("Vowel Final Count = A:{0}, E:{1}, I:{2}, O:{3}, U:{4}\n",
state[(int)Vowels.A],
state[(int)Vowels.E],
state[(int)Vowels.I],
state[(int)Vowels.O],
state[(int)Vowels.U]);
}
//*********************************************************************************************************//
//*** ***//
//*** CountVowels will be called for each character event in the event stream. ***//
//*** ***//
//*** The int array, "state", is used as the accumulator. It holds a count for each vowel. ***//
//*** ***//
//*** CountVowels simply looks at the character "ch" to see if it is a vowel and increments that vowel ***//
//*** count in the array. ***//
//*** ***//
//*********************************************************************************************************//
static int[] CountVowels(int[] state, char ch)
{
char lch = char.ToLower(ch);
switch (lch)
{
case 'a': state[(int)Vowels.A]++;
break;
case 'e': state[(int)Vowels.E]++;
break;
case 'i': state[(int)Vowels.I]++;
break;
case 'o': state[(int)Vowels.O]++;
break;
case 'u': state[(int)Vowels.U]++;
break;
};
return state;
}
}
}
Voici un exemple de sortie de l’exemple de code.
Enter a sequence of characters followed by the ENTER key.
The example code will count the vowels you enter
This is a sequence of char I am generating from Console.ReadKey()
Vowel Final Count = A:5, E:8, I:4, O:4, U:1
Press ENTER to exit...