Observable.Aggregate<TSource, TAccumulate> Yöntemi (IObservable<TSource>, TAccumulate, Func<TAccumulate, TSource, TAccumulate>)
Belirtilen çekirdek değerine sahip gözlemlenebilir bir dizi üzerinde bir biriktirici işlevi uygular.
Ad Alanı:System.Reactive.Linq
Derleme: System.Reactive (System.Reactive.dll içinde)
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.
Tür Parametreleri
- Tsource
Kaynak türü.
- Taccumulate
Birikenin türü.
Parametreler
- kaynak
Tür: System.IObservable<TSource>
Üzerinde toplanabilir gözlemlenebilir bir dizi.
- Tohum
Tür: TAccumulate
İlk biriktirici değeri.
- Akümülatör
Tür: System.Func<TAccumulate, TSource, TAccumulate>
Her öğede çağrılacak bir biriktirici işlevi.
Dönüş Değeri
Tür: System.IObservable<TAccumulate>
Son biriktirici değerine sahip tek bir öğe içeren gözlemlenebilir bir dizi.
Kullanım Notu
Visual Basic ve C# içinde bu yöntemi IObservable<TSource> türündeki herhangi bir nesnede örnek yöntemi olarak çağırabilirsiniz. Bu yöntemi çağırmak için örnek yöntemi sözdizimini kullandığınızda, ilk parametreyi yok sayın. Daha fazla bilgi için bkz. veya .
Açıklamalar
Toplama işleci, bir toplama veya birikmiş değer üretmek üzere bir kaynak diziye işlev uygulamak için kullanılır. Diziye uygulanan işlev, biriktirici işlevi olarak adlandırılır. İki parametre gerektirir: bir biriktirici değeri ve biriktirici değeriyle işlenen diziden bir öğe. İlk biriktirici değeri, çekirdek değeri olarak adlandırılır ve toplama işlecine sağlanmalıdır. Biriktirici işlevi, her çağrıldığında yeni biriktirici değerini döndürür. Yeni biriktirici değeri daha sonra sıradaki öğeyi işlemek için biriktirici işlevine bir sonraki çağrıyla birlikte kullanılır. Bu çağrılar sıranın sonuna kadar devam ediyor.
Toplama işleci, işlecine geçirilen tohum değeriyle aynı türde olan gözlemlenebilir bir dizi döndürür. Son toplama değerini almak için toplama işlecinden döndürülen gözlemlenebilir diziye abone olursunuz. Biriktirici işlevi tüm diziye uygulandıktan sonra, son toplama değerini sağlamak için gözlemcinin abonelikte sağlanan OnNext ve OnCompleted işleyicileri çağrılır. Bu işleçle sağlanan örnek koda bakın.
Örnekler
Bu örnek, Console.Readkey() ile çalışma zamanında oluşturulan bir karakter dizesindeki ünlüleri saymak için toplama işlecini kullanmayı gösterir. CountVowels işlevi, biriktirici işlevidir ve dizide karşılaşılan her ünlü öğesinin sayısını artırır.
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;
}
}
}
Aşağıda örnek koddan alınan örnek çıktı verilmiştir.
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...