这听起来可能很蹩脚，但我无法找到一个真正好的解释。Aggregate

好意味着简短、描述性、全面性，并附有小而清晰的例子。

网友回答：

这部分取决于您所说的重载，但基本思想是：

• 从种子作为“当前值”开始
• 循环访问序列。对于序列中的每个值：
  • 应用用户指定的函数以转换为(currentValue, sequenceValue)(nextValue)
  • 设置currentValue = nextValue
• 返回最终currentValue

您可能会发现我的 Edulinq 系列中的帖子很有用——它包括更详细的描述（包括各种重载）和实现。Aggregate

一个简单的例子是用作以下的替代：AggregateCount

// 0 is the seed, and for each item, we effectively increment the current value.
// In this case we can ignore "item" itself.
int count = sequence.Aggregate(0, (current, item) => current + 1);

或者也许将字符串序列中的所有字符串长度相加：

int total = sequence.Aggregate(0, (current, item) => current + item.Length);

就我个人而言，我很少觉得有用——“定制”的聚合方法通常对我来说已经足够了。Aggregate

网友回答：

最容易理解的定义是，它对列表的每个元素执行操作，同时考虑到之前的操作。也就是说，它对第一个和第二个元素执行操作并将结果向前推进。然后，它对前一个结果和第三个元素进行操作并继续前进。等。Aggregate

例 1.对数字求和

var nums = new[]{1,2,3,4};
var sum = nums.Aggregate( (a,b) => a + b);
Console.WriteLine(sum); // output: 10 (1+2+3+4)

这将添加并使 .然后添加（上一个元素的结果）和（顺序中的下一个元素）使 .然后添加并制作 .1233366410

例 2.从字符串数组创建 CSV

var chars = new []{"a","b","c", "d"};
var csv = chars.Aggregate( (a,b) => a + ',' + b);
Console.WriteLine(csv); // Output a,b,c,d

这的工作方式大致相同。连接一个逗号并制作 .然后用逗号连接并制作 .等等。aba,ba,bca,b,c

例 3.使用种子将数字相乘

为了完整起见，存在一个重载，其使用种子值。Aggregate

var multipliers = new []{10,20,30,40};
var multiplied = multipliers.Aggregate(5, (a,b) => a * b);
Console.WriteLine(multiplied); //Output 1200000 ((((5*10)*20)*30)*40)

与上述示例非常相似，它以值 of 开头，并将其乘以序列的第一个元素，得到的结果为 。此结果将向前转并乘以序列中的下一个数字，得到的结果为 。这继续通过序列的其余 2 个元素。51050201000

实时示例：http://rextester.com/ZXZ64749
文档：http://msdn.microsoft.com/en-us/library/bb548651.aspx

补遗

上面的示例 2 使用字符串串联来创建以逗号分隔的值列表。这是一种简单的方式来解释这个答案的意图。但是，如果使用这种技术实际创建大量逗号分隔的数据，则使用 ，这将更合适，这与使用种子重载启动 .AggregateStringBuilderAggregateStringBuilder

var chars = new []{"a","b","c", "d"};
var csv = chars.Aggregate(new StringBuilder(), (a,b) => {
    if(a.Length>0)
        a.Append(",");
    a.Append(b);
    return a;
});
Console.WriteLine(csv);

更新的示例：http://rextester.com/YZCVXV6464

网友回答：

超短
聚合的工作方式类似于 Haskell/ML/F# 中的折叠。

稍长
.最大（）， .分钟（）， .总和（）， .Average（） 都迭代序列中的元素，并使用相应的聚合函数聚合它们。.聚合 （） 是通用聚合器，因为它允许开发人员指定开始状态（又名种子）和聚合函数。

我知道你要求一个简短的解释，但我想当其他人给出几个简短的答案时，我想你可能会对一个稍微长一点的答案感兴趣

带有代码
的长版本 说明它做什么的一种方法可以显示您如何实现示例标准偏差一次使用 foreach 和一次使用 .骨料。注意：我在这里没有优先考虑性能，所以我不必要地在 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));
}

然后一旦使用.骨料：

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));
}

请注意，除了如何计算总和二次距离之外，这些函数是相同的：

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)
        );

那又怎样。聚合确实是它封装了这种聚合器模式，我希望实现.聚合将如下所示：

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);

恕我直言

也是如此.聚合帮助可读性？总的来说，我喜欢 LINQ，因为我认为 .哪里。选择。OrderBy 等极大地提高了可读性（如果避免内联分层。选择）。出于完整性原因，聚合必须在 Linq 中，但我个人不太相信.聚合增加了可读性，而不是写得很好。