LINQ聚合算法解释

Question

这可能听起来很蹩脚，但我还没有找到对Aggregate真正好的解释。

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

Answer 1

聚合主要用于对数据进行分组或求和。

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

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

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

*重要提示：默认情况下，初始聚合值是集合序列中的第 1 个元素。
即：total变量初始值默认为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，它是一个需要 2 个 int 的 func。

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

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

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

Answer 2

除了这里已经提供的所有精彩答案之外，我还使用它来引导项目完成一系列转换步骤。

如果转换作为 Func 实现，您可以将多个转换添加到 List> 并使用 聚合以遍历T的实例完成每个步骤。

更具体的示例

您想要获取一个string 值，并让它完成一系列可以通过编程方式构建的文本转换。

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

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

此特定管道的最终结果是 " cat " 变为 "A"。

---

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

Answer 3

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

如果唯一需要生成 CSV 字符串，你可以尝试这个。

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

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

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

源代码位于 此处

Answer 4

定义

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

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

安全，因为递归会迭代集合中的每一项，而我们无法得到任何无穷大由于错误的退出条件而导致循环暂停。 递归，因为当前函数的结果被用作下一个函数调用的参数。

语法：

collection.Aggregate(seed, func, resultSelector);

• seed - 默认初始值；
• func - 我们的递归函数。它可以是 lambda 表达式、Func 委托或函数类型 TF(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

实际使用：

1. 从数字 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);
}

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

3. 扩展方法的更复杂用法：

    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

Answer 5

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

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

Answer 6

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

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

在聚合函数中使用带索引的 Select 对匹配的列求和并返回一个新数组； { 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

但是计算布尔数组中 true 的数量更加困难，因为累积类型 (int) 与源类型 (bool) 不同；这里需要一个种子才能使用第二个重载。

        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

Answer 7

大家都给出了自己的解释。我的解释是这样的。

聚合方法将函数应用于集合的每个项目。例如，让我们有集合 { 6, 2, 8, 3 } 和函数 Add (operator +) 它执行 (((6+2)+8)+3) 并返回 19

var numbers = new List<int> { 6, 2, 8, 3 };
int sum = numbers.Aggregate(func: (result, item) => result + item);
// sum: (((6+2)+8)+3) = 19

在这个例子中，传递了命名方法 Add而不是 lambda 表达式。

var numbers = new List<int> { 6, 2, 8, 3 };
int sum = numbers.Aggregate(func: Add);
// sum: (((6+2)+8)+3) = 19

private static int Add(int x, int y) { return x + y; }

Answer 8

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

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

Answer 9

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 逗号和 b 连接起来形成 a,b。然后将 a,b 与逗号和 c 连接起来，形成 a,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)

与上面的示例非常相似，它以值 5 开头，并将其乘以序列 10 的第一个元素，得到结果 50 。该结果被结转并乘以序列 20 中的下一个数字，得到结果 1000。这将继续到序列的剩余 2 个元素。

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

---

附录

上面的示例 2 使用字符串连接来创建以逗号分隔的值列表。这是解释聚合的使用的一种简单方法，这也是这个答案的目的。但是，如果使用此技术实际创建大量逗号分隔的数据，那么使用 StringBuilder 会更合适，并且这与使用 Aggregate 完全兼容用于启动 StringBuilder 的种子重载。

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

Answer 10

它部分取决于您所讨论的重载，但基本思想是：

• 以种子作为“当前值”开始
• 迭代序列。对于序列中的每个值：
  • 应用用户指定的函数将 (currentValue,equenceValue) 转换为 (nextValue)
  • 设置currentValue = nextValue
• 返回最终的 < code>currentValue

您可能会找到 我的 Edulinq 系列中的聚合帖子很有用 - 它包含更详细的描述（包括各种重载）和实现。

一个简单的示例是使用 Aggregate 作为 Count 的替代方案：

// 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有用 - “定制”聚合方法通常对我来说足够好了。

Answer 11

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

稍长
.Max()、.Min()、.Sum()、.Average() 都会迭代序列中的元素，并使用各自的聚合函数聚合它们。 .Aggregate() 是通用聚合器，它允许开发人员指定开始状态（也称为种子）和聚合函数。

我知道您要求简短的解释，但我认为其他人给出了一些简短的答案，我认为您可能会对稍长的答案感兴趣

带有代码的长版本
说明它的作用的一种方法是展示如何在使用 foreach 和使用 .Aggregate 时实现示例标准差。 注意：我在这里没有优先考虑性能，因此我不必要地对集合进行多次迭代

首先使用一个辅助函数来创建二次距离之和：

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，因为我认为 .Where、.Select、.OrderBy 等对可读性有很大帮助（如果您避免内联分层 .Selects）。出于完整性原因，Aggregate 必须位于 Linq 中，但我个人不太相信 .Aggregate 与编写良好的 foreach 相比增加了可读性。

Answer 12

一张图胜过一千个字

提醒：
Func 是一个具有两个 X 和 Y 类型输入的函数，返回 类型的结果R.

Enumerable.Aggregate 具有三个重载：

重载 1：

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

示例：

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

这种重载很简单，但有以下限制：

• 序列必须至少包含一个元素，
  否则该函数将抛出InvalidOperationException。
• 元素和结果必须属于同一类型。

---

重载 2：

B Aggregate<A, B>(this 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

这种重载更为通用：

• 必须提供种子值 (bIn)。
• 集合可以为空，
  在这种情况下，该函数将产生种子值作为结果。
• 元素和结果可以有不同的类型。

---

重载 3：

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

在我看来，第三个重载并不是很有用。
通过使用重载 2，后跟一个转换其结果的函数，可以更简洁地编写相同的内容。

插图改编自这篇优秀的博文。