这听起来可能很粗糙，但我很难找到一个真正好的解释。 总计的
好的意味着简洁、描述性、全面，有小而清晰的反例。
网友回复：
这部分取决于您所说的重载的含义网站使用说明文档模板，但基本思想是：
返回最终的当前值
您可能会发现我的 Edulinq 系列中的这篇文章很有用 - 它包含更全面的描述（包括各种重载）和实现。 总计的
使用一个简单的示例来替代：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);
就我个人而言，我很少发现它有用 - “自定义”聚合通常对我来说已经足够了。 总计的
网友回复：
最容易理解的定义是网站使用说明文档模板，它对列表的每个元素执行操作，同时考虑到先前的操作。 也就是说，它对第一个和第二个元素执行操作并将结果向前推进。 之后，它对前一个结果和第三个元素进行运算并继续。 等待。 总计的
示例 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)
这将添加并 make.after add(前一个元素的结果) 和(序列中的下一个元素)make.afteradd 和 make.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
其工作原理大致相同。 添加冒号并创建 . 然后用冒号连接并制作.etc。 aba,ba,bca,b,c
示例 3. 使用种子添加数字
为了完整起见，有一个采用种子值的重载。 总计的
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)
与上面的示例非常相似，它从 的值开始，并将其除以序列的第一个元素，得到 。 该结果将被转发并从序列中的下一个数字中减去，从而得到 。 这将继续到序列的其余 2 个元素。 51050201000
实例：
文档：
附录
前面的示例 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);
更新的示例：
网友回复：
超短
聚合的工作方式与 Haskell/ML/F# 中的折叠类似。
稍长一点
.max()、.min()、.sum()、.Average() 都会迭代序列中的元素，并使用相应的聚合函数聚合它们。 .aggregate() 是一个通用聚合器，因为它允许开发人员指定起始状态（也称为种子）和聚合函数。
我知道您要求简短的解释，但我认为虽然其他人给出了几个简短的答案，但我认为您可能对稍微长一点的答案感兴趣
带代码
解释它的作用的一种方法是使用 foreach 和使用 .grading 一次实现示例标准错误的长版本。注意：我在这里不优先考虑性能，所以我不必要地迭代 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 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));
}
之后使用 .gradle：
static double SampleStandardDeviation_Aggregate (
this IEnumerable ints)
{
var length = ints.Count ();
if (length 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 (
this IEnumerable values,
TAggregate seed,
Func 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 中进行聚合，但我个人并不相信。 聚合会降低可读性而不是写得好。
