这听起来可能很蹩脚,但我还没能找到一个对聚合的真正好的解释。

好的意思是简短、描述性、全面,并有一个小而清晰的例子。


当前回答

每个人都给出了自己的解释。我的解释是这样的。

聚合方法将函数应用于集合的每个项。例如,让我们使用集合{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; }

其他回答

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

根据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::它是数组序列中的下一个值。然后将该值添加到聚合值,即总计。

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

释义

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

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

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

语法:

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

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

以种子作为“当前值”开始重复序列。对于序列中的每个值:应用用户指定的函数将(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);

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

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

这是关于在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);