Observable.Aggregate<TSource, TAccumulate-Methode> (IObservable<TSource>, TAccumulate, Func<TAccumulate, TSource, TAccumulate>)
Wendet eine Akkumulatorfunktion auf eine beobachtbare Sequenz mit dem angegebenen Startwert an.
Namespace:System.Reactive.Linq
Versammlung: System.Reaktiv (in System.Reactive.dll)
Syntax
'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.
Typparameter
- TSource
Der Quellentyp.
- Taccumulate
Der Typ des Akkumulations.
Parameter
- source
Typ: System.IObservable<TSource>
Eine beobachtbare Sequenz zum Aggregieren.
- seed
Typ: TAccumulate
Der erste Akkumulatorwert.
- Akku
Typ: System.Func<TAccumulate, TSource, TAccumulate>
Eine Akkumulatorfunktion, die für jedes Element aufgerufen werden soll.
Rückgabewert
Typ: System.IObservable<TAccumulate>
Eine beobachtbare Sequenz, die ein einzelnes Element mit dem endgültigen Akkumulatorwert enthält.
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 Aggregatoperator wird verwendet, um eine Funktion auf eine Quellsequenz anzuwenden, um einen aggregierten oder akkumulierten Wert zu erzeugen. Die Funktion, die auf die Sequenz angewendet wird, wird als Akkufunktion bezeichnet. Sie benötigt zwei Parameter: einen Akkumulatorwert und ein Element aus der Sequenz, das mit dem Akkumulatorwert verarbeitet wird. Der anfängliche Akkumulatorwert wird als Seedwert bezeichnet und muss dem Aggregatoperator bereitgestellt werden. Die Akkumulatorfunktion gibt den neuen Akkumulatorwert bei jedem Aufruf zurück. Der neue Akkumulatorwert wird dann mit dem nächsten Aufruf der Akkumulatorfunktion verwendet, um das Element in der Sequenz zu verarbeiten. Diese Aufrufe werden bis zum Ende der Sequenz fortgesetzt.
Der Aggregatoperator gibt eine beobachtbare Sequenz zurück, die vom gleichen Typ ist wie der Startwert, der an den Operator übergeben wird. Um den endgültigen Aggregatwert abzurufen, abonnieren Sie die vom Aggregatoperator zurückgegebene beobachtbare Sequenz. Nachdem die Akkumulatorfunktion auf die gesamte Sequenz angewendet wurde, werden die im Abonnement bereitgestellten OnNext- und OnCompleted-Handler des Beobachters aufgerufen, um den endgültigen Aggregatwert bereitzustellen. Sehen Sie sich den Mit diesem Operator bereitgestellten Beispielcode an.
Beispiele
In diesem Beispiel wird die Verwendung des Aggregatoperators zum Zählen der Vokale in einer Zeichenfolge veranschaulicht, die zur Laufzeit mit Console.Readkey() generiert wurde. Die CountVowels-Funktion ist die Akkumulatorfunktion und erhöht die Anzahl der einzelnen Vokale in der Sequenz.
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;
}
}
}
Hier sehen Sie eine Beispielausgabe aus dem Beispielcode.
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...