Super short
Aggregate는 Haskell / ML / F #에서 접기처럼 작동합니다.

약간 더 긴
.Max (), .Min (), .Sum (), .Average ()는 모든 요소를 ​​순서대로 반복하고 각 집계 함수를 사용하여 집계합니다. .Aggregate ()는 개발자가 시작 상태 (일명 시드)와 집계 함수를 지정할 수 있다는 점에서 일반화 된 집계 자입니다.

나는 당신이 짧은 설명을 요구했다는 것을 알고 있지만 다른 사람들이 짧은 대답을 몇 개 주었을 때 약간 더 긴 것에 관심이 있다고 생각했습니다.

코드가있는 긴 버전 foreach를 사용하고 .Aggregate를 사용하여 한 번 샘플 표준 편차
를 구현하는 방법을 보여줄 수있는 한 가지 방법이 있습니다 . 참고 : 나는 여기서 성능 우선 순위를 정하지 않았으므로 불필요하게 colleciton을 여러 번 반복합니다.

먼저 이차 거리의 합을 만드는 데 사용되는 도우미 함수 :

static double SumOfQuadraticDistance (double average, int value, double state)
{
    var diff = (value - average);
    return state + diff * diff;
}

그런 다음 ForEach를 사용하여 표준 편차를 샘플링하십시오.

static double SampleStandardDeviation_ForEach (
    this IEnumerable<int> ints)
{
    var length = ints.Count ();
    if (length < 2)
    {
        return 0.0;
    }

    const double seed = 0.0;
    var average = ints.Average ();

    var state = seed;
    foreach (var value in ints)
    {
        state = SumOfQuadraticDistance (average, value, state);
    }
    var sumOfQuadraticDistance = state;

    return Math.Sqrt (sumOfQuadraticDistance / (length - 1));
}

그런 다음 .Aggregate를 사용하여 한 번 :

static double SampleStandardDeviation_Aggregate (
    this IEnumerable<int> ints)
{
    var length = ints.Count ();
    if (length < 2)
    {
        return 0.0;
    }

    const double seed = 0.0;
    var average = ints.Average ();

    var sumOfQuadraticDistance = ints
        .Aggregate (
            seed,
            (state, value) => SumOfQuadraticDistance (average, value, state)
            );

    return Math.Sqrt (sumOfQuadraticDistance / (length - 1));
}

sumOfQuadraticDistance가 계산되는 방식을 제외하고 이러한 함수는 동일합니다.

var state = seed;
foreach (var value in ints)
{
    state = SumOfQuadraticDistance (average, value, state);
}
var sumOfQuadraticDistance = state;

대:

var sumOfQuadraticDistance = ints
    .Aggregate (
        seed,
        (state, value) => SumOfQuadraticDistance (average, value, state)
        );

따라서 .Aggregate 가하는 것은이 집계 자 패턴을 캡슐화하고 .Aggregate의 구현이 다음과 같이 보일 것으로 기대합니다.

public static TAggregate Aggregate<TAggregate, TValue> (
    this IEnumerable<TValue> values,
    TAggregate seed,
    Func<TAggregate, TValue, TAggregate> aggregator
    )
{
    var state = seed;

    foreach (var value in values)
    {
        state = aggregator (state, value);
    }

    return state;
}

표준 편차 함수를 사용하면 다음과 같습니다.

var ints = new[] {3, 1, 4, 1, 5, 9, 2, 6, 5, 4};
var average = ints.Average ();
var sampleStandardDeviation = ints.SampleStandardDeviation_Aggregate ();
var sampleStandardDeviation2 = ints.SampleStandardDeviation_ForEach ();

Console.WriteLine (average);
Console.WriteLine (sampleStandardDeviation);
Console.WriteLine (sampleStandardDeviation2);

이모

그렇다면 .Aggregate는 가독성에 도움이됩니까? 일반적으로 나는 .LINQ를 좋아합니다. 완전성 때문에 집계가 Linq에 있어야하지만 개인적으로 그렇게 확신하지는 않습니다. 집계는 잘 작성된 foreach에 비해 가독성을 추가합니다.

답변

A Aggregate<A>(IEnumerable<A> a, Func<A, A, A> f)

new[]{1,2,3,4}.Aggregate((x, y) => x + y);  // 10

B Aggregate<A, B>(IEnumerable<A> a, B bIn, Func<B, A, B> f)

var hayStack = new[] {"straw", "needle", "straw", "straw", "needle"};
var nNeedles = hayStack.Aggregate(0, (n, e) => e == "needle" ? n+1 : n);  // 2

C Aggregate<A,B,C>(IEnumerable<A> a, B bIn, Func<B,A,B> f, Func<B,C> f2)

int[] numbers = new int[] { 1,2,3,4,5 };
int aggregatedValue = numbers.Aggregate((total, nextValue) => total + nextValue);

int[] numbers = new int[] { 1,2,3,4,5 };
int aggregatedValue = numbers.Aggregate(10, (total, nextValue) => total + nextValue);

var csv3 = string.Join(",",chars);

0.28 seconds = Aggregate w/ String Builder 
0.30 seconds = String.Join 

var transformationPipeLine = new List<Func<string, string>>();
transformationPipeLine.Add((input) => input.Trim());
transformationPipeLine.Add((input) => input.Substring(1));
transformationPipeLine.Add((input) => input.Substring(0, input.Length - 1));
transformationPipeLine.Add((input) => input.ToUpper());

var text = "    cat   ";
var output = transformationPipeLine.Aggregate(text, (input, transform)=> transform(input));
Console.WriteLine(output);