除了这里已经给出的所有好答案之外，我还用它来引导一个项目完成一系列转换步骤。

如果转换被实现为Func＜T，T＞，则可以将多个转换添加到List＜Func＜T，T＞中，并使用Aggregate遍历T的每个步骤。

更具体的例子

您需要获取一个字符串值，并通过一系列可以通过编程构建的文本转换对其进行遍历。

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

这将创建一系列转换：删除前导和尾随空格->删除第一个字符->删除最后一个字符->转换为大写。可以根据需要添加、删除或重新排序此链中的步骤，以创建所需的任何类型的转换管道。

这个特定管道的最终结果是“猫”变成了“A”。

一旦你意识到T可以是任何东西，它就会变得非常强大。这可以用于图像转换，如过滤器，使用BitMap作为示例；

用于对多维整数数组中的列求和的聚合

        int[][] nonMagicSquare =
        {
            new int[] {  3,  1,  7,  8 },
            new int[] {  2,  4, 16,  5 },
            new int[] { 11,  6, 12, 15 },
            new int[] {  9, 13, 10, 14 }
        };

        IEnumerable<int> rowSums = nonMagicSquare
            .Select(row => row.Sum());
        IEnumerable<int> colSums = nonMagicSquare
            .Aggregate(
                (priorSums, currentRow) =>
                    priorSums.Select((priorSum, index) => priorSum + currentRow[index]).ToArray()
                );

在Aggregate函数中使用带索引的Select对匹配的列求和并返回新的Array；{ 3 + 2 = 5, 1 + 4 = 5, 7 + 16 = 23, 8 + 5 = 13 }.

        Console.WriteLine("rowSums: " + string.Join(", ", rowSums)); // rowSums: 19, 27, 44, 46
        Console.WriteLine("colSums: " + string.Join(", ", colSums)); // colSums: 25, 24, 45, 42

但是，由于累积类型（int）与源类型（bool）不同，因此计算布尔数组中的true数更为困难；这里需要种子以使用第二过载。

        bool[][] booleanTable =
        {
            new bool[] { true, true, true, false },
            new bool[] { false, false, false, true },
            new bool[] { true, false, false, true },
            new bool[] { true, true, false, false }
        };

        IEnumerable<int> rowCounts = booleanTable
            .Select(row => row.Select(value => value ? 1 : 0).Sum());
        IEnumerable<int> seed = new int[booleanTable.First().Length];
        IEnumerable<int> colCounts = booleanTable
            .Aggregate(seed,
                (priorSums, currentRow) =>
                    priorSums.Select((priorSum, index) => priorSum + (currentRow[index] ? 1 : 0)).ToArray()
                );

        Console.WriteLine("rowCounts: " + string.Join(", ", rowCounts)); // rowCounts: 3, 1, 2, 2
        Console.WriteLine("colCounts: " + string.Join(", ", colCounts)); // colCounts: 3, 2, 1, 2

这在一定程度上取决于你所说的过载，但基本的想法是：

以种子作为“当前值”开始重复序列。对于序列中的每个值：应用用户指定的函数将（currentValue，sequenceValue）转换为（nextValue）设置当前值=下一个值返回最终currentValue

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

一个简单的例子是使用聚合作为计数的替代：

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

就我个人而言，我很少发现聚合有用——“定制”的聚合方法通常对我来说足够好。

除了这里已经给出的所有好答案之外，我还用它来引导一个项目完成一系列转换步骤。

如果转换被实现为Func＜T，T＞，则可以将多个转换添加到List＜Func＜T，T＞中，并使用Aggregate遍历T的每个步骤。

更具体的例子

您需要获取一个字符串值，并通过一系列可以通过编程构建的文本转换对其进行遍历。

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

这将创建一系列转换：删除前导和尾随空格->删除第一个字符->删除最后一个字符->转换为大写。可以根据需要添加、删除或重新排序此链中的步骤，以创建所需的任何类型的转换管道。

这个特定管道的最终结果是“猫”变成了“A”。

一旦你意识到T可以是任何东西，它就会变得非常强大。这可以用于图像转换，如过滤器，使用BitMap作为示例；

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)

这将1和2相加为3。然后将3（上一个元素的结果）和3（顺序中的下一个元素）相加，得到6。然后将6和4相加为10。

示例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

这是以大致相同的方式工作的。将a、a、逗号和b连接起来形成a、b。然后用逗号和c连接a、b，形成a、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)

与上述示例非常相似，这从值5开始，并将其与序列10的第一个元素相乘，结果为50。该结果被进位并乘以序列20中的下一个数字，得到1000的结果。这将继续通过序列的其余2个元素。

现场示例：http://rextester.com/ZXZ64749文件：http://msdn.microsoft.com/en-us/library/bb548651.aspx

补遗

上面的示例2使用字符串串联来创建一个由逗号分隔的值列表。这是一种简单的方式来解释Aggregate的用法，而Aggregate正是这个答案的意图。但是，如果使用此技术实际创建大量逗号分隔的数据，则更适合使用StringBuilder，并且这与使用种子重载初始化StringBuilder的Aggregate完全兼容。

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

释义

聚合方法是泛型集合的扩展方法。聚合方法将函数应用于集合的每个项。不仅应用函数，还将其结果作为下一次迭代的初始值。因此，我们将从集合中获得计算值（最小值、最大值、平均值或其他统计值）。

因此，聚合方法是递归函数的一种安全实现形式。

安全，因为递归将在集合的每个项上迭代，我们无法通过错误的退出条件获得任何无限循环暂停。递归，因为当前函数的结果用作下一个函数调用的参数。

语法：

collection.Aggregate(seed, func, resultSelector);

seed—默认初始值；func-我们的递归函数。它可以是lambda表达式、Func委托或函数类型T F（T result，T nextValue）；resultSelector-它可以是一个函数，如func或一个表达式，用于计算、转换、更改和转换最终结果。

工作原理：

var nums = new[]{1, 2};
var result = nums.Aggregate(1, (result, n) => result + n); //result = (1 + 1) + 2 = 4
var result2 = nums.Aggregate(0, (result, n) => result + n, response => (decimal)response/2.0); //result2 = ((0 + 1) + 2)*1.0/2.0 = 3*1.0/2.0 = 3.0/2.0 = 1.5

实际用途：

从数字n中查找阶乘：

int n = 7;
var numbers = Enumerable.Range(1, n);
var factorial = numbers.Aggregate((result, x) => result * x);

其执行与该功能相同的操作：

public static int Factorial(int n)
{
   if (n < 1) return 1;

   return n * Factorial(n - 1);
}

Aggregate（）是最强大的LINQ扩展方法之一，如Select（）和Where（）。我们可以使用它来替换Sum（）、Min（）。Max（）、Avg（）功能，或通过实现添加上下文来更改它：

    var numbers = new[]{3, 2, 6, 4, 9, 5, 7};
    var avg = numbers.Aggregate(0.0, (result, x) => result + x, response => (double)response/(double)numbers.Count());
    var min = numbers.Aggregate((result, x) => (result < x)? result: x);

扩展方法的更复杂用法：

    var path = @“c:\path-to-folder”;

    string[] txtFiles = Directory.GetFiles(path).Where(f => f.EndsWith(“.txt”)).ToArray<string>();
    var output = txtFiles.Select(f => File.ReadAllText(f, Encoding.Default)).Aggregate<string>((result, content) => result + content);

    File.WriteAllText(path + “summary.txt”, output, Encoding.Default);

    Console.WriteLine(“Text files merged into: {0}”, output); //or other log info