Linq查询操作之聚合操作(count,max,min,sum,average,aggregate,longcount)

时间:2022-05-29 22:51:56

  在Linq中有一些这样的操作,根据集合计算某一单一值,比如集合的最大值,最小值,平均值等等。Linq中包含7种操作,这7种操作被称作聚合操作。

1、Count操作,计算序列中元素的个数,或者计算满足一定条件的元素的个数

2、Sum操作,计算序列中所有元素的值的总和

3、Max操作,计算序列中元素的最大值

4、Min操作,计算序列中元素的最小值

5、Average操作,计算序列中所有元素的平均值

6、Aggregate操作,对集合中的元素进行自定义的聚合计算

7、LongCount操作,计算集合中的元素的数量,或者满足一定条件的元素的数量,一般用来计算大型集合中元素的数量

下面我们就来对这些聚合操作来做逐一的分析。

Count操作

  Count操作是用来计算序列中元素的数量或者满足一定条件的元素的数量。Count()方法的原型:    

    public static int Count<TSource>(this IEnumerable<TSource> source);
public static int Count<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);

Count方法有2个原型,第一个只是单独的计算序列中的元素的数量总和,第二个原型有一个委托函数,用来筛选满足一定条件的元素,然后再计算满足条件的数量和。下面我们举个例子来说明:

 1 private void CountQuery()
2 {
3 int[] ints = new int[] { 1,2,3,4,5,6,7 };
4
5
6 var result = ints.Count();
7 var result2 = ints.Count(x => x > 4);
8
9 Response.Write(result + "</br>");
10
11 Response.Write(result2 + "</br>");
12
13 }

这个例子中result是计算ints数组的总数量,result计算的是ints中元素值大于4的元素个数。
看看运行结果:

Linq查询操作之聚合操作(count,max,min,sum,average,aggregate,longcount)

这种求和过程也很简单

Linq查询操作之聚合操作(count,max,min,sum,average,aggregate,longcount)

Sum操作

  Sum操作计算序列中所有元素的和。Sum函数的原型比较多,这里不一一列举。看例子:

 1  private void SumQuery()
2 {
3 int[] ints = new int[] { 1,2,3,4,5,6,7 };
4
5
6 var result = ints.Sum();
7
8
9 Response.Write(result + "</br>");
10
11
12
13 }

看看结果:
Linq查询操作之聚合操作(count,max,min,sum,average,aggregate,longcount)

Max操作

  Max操作来计算序列中元素的最大值。

 1 private void MaxQuery()
2 {
3 int[] ints = new int[] { 1,2,3,4,5,6,7 };
4
5
6 var result = ints.Max();
7
8
9 Response.Write(result + "</br>");
10
11
12
13 }

Linq查询操作之聚合操作(count,max,min,sum,average,aggregate,longcount)

Min操作

  Min操作来计算序列中元素的最小值。

 1 private void MinQuery()
2 {
3 int[] ints = new int[] { 1,2,3,4,5,6,7 };
4
5
6 var result = ints.Min();
7
8
9 Response.Write(result + "</br>");
10
11
12
13 }

Linq查询操作之聚合操作(count,max,min,sum,average,aggregate,longcount)

Average操作

  Average操作是计算序列的所有元素的平均值。

 1 private void AverageQuery()
2 {
3 int[] ints = new int[] { 1,2,3,4,5,6,7 };
4
5
6 var result = ints.Average();
7
8
9 Response.Write(result + "</br>");
10
11
12
13 }

Linq查询操作之聚合操作(count,max,min,sum,average,aggregate,longcount)

Aggregate操作

  Aggregate操作,上面的一些都比较简单,我们重点来分析一下Aggregate操作。Aggregate操作能够对集合中的元素进行自定义的聚合计算。Aggregate()函数有3种原型:

public static TSource Aggregate<TSource>(this IEnumerable<TSource> source, Func<TSource, TSource, TSource> func);
public static TAccumulate Aggregate<TSource, TAccumulate>(this IEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func);
public static TResult Aggregate<TSource, TAccumulate, TResult>(this IEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func, Func<TAccumulate, TResult> resultSelector);

其中source表示数据源,func表示累加器函数,seed表示累加器的初始值,resultSelector表示转换结果函数。

下面我们用一个详细的例子来分累加是如何操作的。

首先我们创建一个整型数组ints,值是0~99.

使用Aggregate计算ints中的素有元素之和。

 1 private void AggregateQuery()
2 {
3 int[] ints = new int[100];
4
5 for (int i = 0; i < 100; i++)
6 {
7 ints[i]=i;
8 }
9
10 var result = ints.Aggregate((a,b) => a+b);
11
12
13 Response.Write(result + "</br>");
14
15
16
17 }

计算结果:
Linq查询操作之聚合操作(count,max,min,sum,average,aggregate,longcount)

我们看第一个原型的累加过程:

Linq查询操作之聚合操作(count,max,min,sum,average,aggregate,longcount)

最终就是通过遍历数据源的每一个元素,根据我们传如的累加函数来累加。比如我们累加函数是求所有元素的和,那么累加函数就是func(a,b){a+b},如果求所有元素的乘积,那么累加函数就是func(a,b){a*b}.

参数a,b的意义:a表示当前元素之前的所有数据根据累加函数求得的值,b就是当前元素。

我们看第二个累加原型:

第二个累加原型有一个累加基数seed,就表示在这个seed基础上进行累加。比如上面我们创建的数组是0~99,累加和是4950.那么我给累加seed这个基数设置为100,那么累加和就是4950+100=5050.

 1         private void AggregateQuery()
2 {
3 int[] ints = new int[100];
4
5 for (int i = 0; i < 100; i++)
6 {
7 ints[i]=i;
8 }
9
10 var result = ints.Aggregate(100,(a,b) => a+b);
11
12
13 Response.Write(result + "</br>");
14
15
16
17 }

看看结果:
Linq查询操作之聚合操作(count,max,min,sum,average,aggregate,longcount)

看源码分析也确实是这样子的:

Linq查询操作之聚合操作(count,max,min,sum,average,aggregate,longcount)

第三个原型又多了一个委托函数,这个委托函数是对累加的结果做进一步处理然后返回处理后的结果。我们先看看源码分析:

Linq查询操作之聚合操作(count,max,min,sum,average,aggregate,longcount)

从累加原型的源码看出,把最终的累加结果又传给resultSelector方法进行进一步处理。

我们看个简单的例子:

 1         private void AggregateQuery()
2 {
3 int[] ints = new int[100];
4
5 for (int i = 0; i < 100; i++)
6 {
7 ints[i]=i;
8 }
9
10 var result = ints.Aggregate(100,(a,b) => a+b,x=>x*-1);
11
12
13 Response.Write(result + "</br>");
14
15
16
17 }

从代码可以看出,我们最终累加的值,然后对它乘以-1返回结果。我们预测应该返回-5050.

看看结果:

Linq查询操作之聚合操作(count,max,min,sum,average,aggregate,longcount)

看来我们经过源码分析,最终得到了验证,我们的分析是正确的。

LongCount操作

  LongCount和Count一样,都是计算序列中元素的数量或者满足一定条件的元素的数量,一般longcount用来计算大型的集合。但是从源代码中我没看到LongCount和Count的计算方法有什么不同,只是计算和的num的声明不同,Count的num声明为int类型,而LongCount的num声明为long类型,数据范围扩大了而已,这里就不再重复讲解了,参考Count即可。