从Jamiec的回答中学到了很多。

如果只需要生成CSV字符串，可以尝试此操作。

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

这是一个100万个字符串的测试

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

源代码在这里

聚合主要用于分组或汇总数据。

根据MSDN“聚合函数在序列上应用累加器函数。”

示例1：将数组中的所有数字相加。

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

*重要信息：默认情况下，初始聚合值是集合序列中的1元素。即：总变量初始值默认为1。

变量解释

total：它将保存func返回的合计值（聚合值）。

nextValue：它是数组序列中的下一个值。然后将该值添加到聚合值，即总计。

示例2：添加数组中的所有项。还设置初始累加器值，从10开始添加。

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

参数说明：

第一个参数是初始值（起始值，即种子值），用于开始与数组中的下一个值相加。

第二个参数是一个func，它是一个取2int的func。

1.total：这将与计算后func返回的总和值（聚合值）之前保持相同。

2.nextValue：：它是数组序列中的下一个值。然后将该值添加到聚合值，即总计。

此外，调试此代码将使您更好地了解聚合的工作方式。

一个简短而重要的定义可能是这样的：Linq Aggregate扩展方法允许声明一种应用于列表元素的递归函数，其操作数是两个：按元素在列表中的出现顺序排列的元素，一次一个元素，以及上一次递归迭代的结果，或者如果还没有递归，则什么都没有。

通过这种方式，您可以计算数字的阶乘，或连接字符串。

这是关于在Fluent API（如Linq排序）上使用聚合的说明。

var list = new List<Student>();
var sorted = list
    .OrderBy(s => s.LastName)
    .ThenBy(s => s.FirstName)
    .ThenBy(s => s.Age)
    .ThenBy(s => s.Grading)
    .ThenBy(s => s.TotalCourses);

让我们看看我们想要实现一个接受一组字段的排序函数，这很容易使用Aggregate而不是for循环，如下所示：

public static IOrderedEnumerable<Student> MySort(
    this List<Student> list,
    params Func<Student, object>[] fields)
{
    var firstField = fields.First();
    var otherFields = fields.Skip(1);

    var init = list.OrderBy(firstField);
    return otherFields.Skip(1).Aggregate(init, (resultList, current) => resultList.ThenBy(current));
}

我们可以这样使用：

var sorted = list.MySort(
    s => s.LastName,
    s => s.FirstName,
    s => s.Age,
    s => s.Grading,
    s => s.TotalCourses);

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

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

        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