Observable.Aggregate<TSource, TAccumulate> Method (IObservable<TSource>, TAccumulate, Func<TAccumulate, TSource, TAccumulate>)
Применяет функцию аккумуляторов к наблюдаемой последовательности с указанным начальным значением.
Пространство имен:System.Reactive.Linq
Сборки: System.Reactive (в System.Reactive.dll)
Синтаксис
'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.
Параметры типа
- TSource
Тип источника.
- TAccumulate
Тип аккумулировать.
Параметры
- source
Тип: System.IObservable<TSource>
Наблюдаемая последовательность для агрегирования.
- seed
Тип: TAccumulate
Начальное агрегатное значение.
- Аккумулятор
Тип: System.Func<TAccumulate, TSource, TAccumulate>
Агрегатная функция, вызываемая для каждого элемента.
Возвращаемое значение
Тип: System.IObservable<TAccumulate>
Наблюдаемая последовательность, содержащая один элемент с окончательным значением аккумулятора.
Примечание об использовании
В Visual Basic и C# этот метод можно вызвать как метод экземпляра для любого объекта типа IObservable<TSource>. При вызове метода для экземпляра следует опускать первый параметр. Дополнительные сведения см. в разделе или .
Комментарии
Агрегатный оператор используется для применения функции в исходной последовательности для получения агрегатного или накопленных значений. Функция, применяемая в последовательности, называется функцией аккумуляторов. Для этого требуется два параметра: значение аккумулятора и элемент из последовательности, которая обрабатывается с помощью значения аккумулятора. Начальное значение аккумулятора называется начальным значением и должно быть предоставлено оператору агрегата. Функция аккумуляторов возвращает новое значение аккумулятора при каждом вызове. Затем новое значение аккумулятора используется при следующем вызове функции аккумуляторов для обработки элемента в последовательности. Эти вызовы продолжаются до конца последовательности.
Агрегатный оператор возвращает наблюдаемую последовательность, которая имеет тот же тип, что и начальное значение, передаваемое в оператор . Чтобы получить окончательное агрегатное значение, необходимо подписаться на наблюдаемую последовательность, возвращаемую оператором агрегата. После применения функции аккумуляторов во всей последовательности вызываются обработчики OnNext и OnCompleted наблюдателя, предоставленные в подписке, для предоставления итогового статистического значения. См. пример кода, предоставленный с этим оператором.
Примеры
В этом примере демонстрируется использование агрегатного оператора для подсчета гласных в строке символов, созданных во время выполнения с помощью Console.Readkey(). Функция CountVowels — это функция аккумуляторов, и она увеличивает количество всех гласных, встречающихся в последовательности.
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;
}
}
}
Ниже приведен пример выходных данных из примера кода.
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...