LINQ之路15:LINQ Operators之元素运算符、集合方法、量词方法(转http://www.cnblogs.com/lifepoem/archive/2011/11/28/2265837.html)

Coordinator
Dec 3, 2011 at 11:02 AM

本篇继续LINQ Operators的介绍,包括元素运算符/Element Operators、集合方法/Aggregation、量词/Quantifiers Methods。元素运算符从一个sequence当中获取单个元素;集合方法对sequence进行统计/汇总并返回当个标量值;量词方法用于判断sequence是否满足特定条件并返回bool值。

元素运算符/Element Operators

IEnumerable<TSource>→TSource

Operator

说明

SQL语义

First,

FirstOrDefault

返回sequence中(可选满足某个条件)的第一个元素

SELECT TOP 1 ... ORDER BY ...

Last,

LastOrDefault

返回sequence中(可选满足某个条件)的最后一个元素

SELECT   TOP 1 ... ORDER BY ... DESC

Single, SingleOrDefault

相当于First/FirstOrDefault,但是如果不止一个匹配元素则抛出异常

 

ElementAt, ElementAtOrDefault

返回特定位置上的元素

Exception   thrown

DefaultIfEmpty

如何sequence没有元素则返回null或default(TSource)

OUTER JOIN

以 “OrDefault”结束的方法在输入sequence为空或没有匹配的元素时返回default(TSource),而不是抛出异常。default(TSource)对于引用类型的元素来说等于null,对于值类型元素则通常等于0。

First, Last, and Single

参数

类型

源sequence

IEnumerable<TSource>

条件(可选)

TSource => bool

下面的例子示范了First和Last的方法:

            int[] numbers = { 1, 2, 3, 4, 5 };
int first = numbers.First(); // 1
int last = numbers.Last(); // 5
int firstEven = numbers.First(n => n % 2 == 0); // 2
int lastEven = numbers.Last(n => n % 2 == 0); // 4

下面的例子对First和FirstOrDefault进行了对比:

            int firstBigError = numbers.First(n => n > 10); // Exception
int firstBigNumber = numbers.FirstOrDefault(n => n > 10); // 0

对于Single运算符来说,必须只能有且仅有一个匹配元素,否则将会抛出异常;SingleOrDefault可以有一个或零个匹配元素:

            int onlyDivBy3 = numbers.Single(n => n % 3 == 0);           // 3
int divBy2Err = numbers.Single(n => n % 2 == 0); // Error: 2 & 4 match
int singleError = numbers.Single(n => n > 10); // Error
int noMatches = numbers.SingleOrDefault(n => n > 10); // 0
int divBy2Error = numbers.SingleOrDefault(n => n % 2 == 0); // Error

Single是上面这个家族中最“严格”的元素运算符,而FirstOrDefault和LastOrDefault则是最宽松的。

在LINQ to SQL和EF,Single经常用来在一个表中根据主键获取一行数据:

            Customer cust = dataContext.Customers.Single(c => c.ID == 3);

 

ElementAt

参数

类型

源sequence

IEnumerable<TSource>

待返回元素的索引

int

ElementAt获取sequence中特定位置上的元素:

            int[] numbers = { 1, 2, 3, 4, 5 };
int third = numbers.ElementAt(2); // 3
int tenthError = numbers.ElementAt(9); // Exception
int tenth = numbers.ElementAtOrDefault(9); // 0

 

DefaultIfEmpty

DefaultIfEmpty把一个空sequence转换为null/default()。它用来书写平展的outer join,请参考:LINQ之路12:LINQ Operators之数据转换(Projecting)中的SelectMany中的Outer joins一节。

 

集合方法/Aggregation Methods

IEnumerable<TSource>→ scalar

Operator

说明

SQL语义

Count, LongCount

返回输入sequence中的元素个数,可以指定某个条件

COUNT (...)

Min, Max

返回输入sequence中的最小/最大元素

MIN   (...), MAX (...)

Sum, Average

对sequence中的元素求和或平均值

SUM (...), AVG (...)

Aggregate

执行定制的计算

抛出异常

Count 和LongCount

参数

类型

源sequence

IEnumerable<TSource>

条件(可选)

TSource => bool

Count简单地遍历某个sequence,返回其元素个数:

            int fullCount = new int[] { 5, 6, 7 }.Count();  // 3

Enumerable.Count的内部实现会判断输入sequence是否实现了ICollection<T>接口,如果是,则调用ICollection<T>.Count,否则遍历sequence中的每个元素并进行计数。

我们可以选择提供一个条件:

            int digitCount = "pa55w0rd".Count(c => char.IsDigit(c));    // 3

LongCount的功能与Count一样,但是返回64-bit整数,这样就允许遍历元素超过32-bit整数范围的sequence。

Min 和Max

参数

类型

源sequence

IEnumerable<TSource>

结果选择器(可选)

TSource => TResult

Min和Max返回输入sequence中的最小/最大元素:

            int[] numbers = { 28, 32, 14 };
int smallest = numbers.Min(); // 14;
int largest = numbers.Max(); // 32;

如果我们提供了选择器表达式,每个元素都会先进行数据转换:

            int smallest = numbers.Max(n => n % 10);  // 8;

如果元素本质上不支持比较,那么选择器表达式就是必须的。换句话说,如果他们没有实现IComparable<T>:

            Purchase runtimeError = dataContext.Purchases.Min(); // Error
decimal? lowestPrice = dataContext.Purchases.Min(p => p.Price); // OK

选择器表达式不只是决定了元素的比较方式,而且决定了最终的结果。上面使用p => p.Price的示例中,最终结果是一个decimal数值,而不是purchase对象。如果要想得到最便宜的purchase,我们需要一个子查询:

            Purchase cheapest = dataContext.Purchases
.Where(p => p.Price == dataContext.Purchases.Min(p2 => p2.Price))
.FirstOrDefault();

当然上面这个例子中,我们也可以不使用Min,而用OrderBy来获得相同的结果。

Sum和Average

参数

类型

源sequence

IEnumerable<TSource>

结果选择器(可选)

TSource => TResult

Sum和 Average的使用方式和Min/Max类似,他们用于对sequence中的元素求和或平均值:

            decimal[] numbers = { 3, 4, 8 };
decimal sumTotal = numbers.Sum(); // 15
decimal average = numbers.Average(); // 5

下面的查询返回names数组中每个字符串的总长度:

            string[] names = { "Tom", "Dick", "Harry", "Mary", "Jay" };
int combinedLength = names.Sum(s => s.Length); // 19

Sum和Average对他们操作的元素类型相当严格,他们可以操作下面这些数值类型(int, long, float, double, decimal, 和他们的可空版本)。而Min和Max可以直接操作任何实现了IComparable<T>的对象,如string。并且, Average总是参照下表返回decimal或者double类型的结果:

选择器类型

结果类型

decimal

decimal

int, long, float, double

double

这意味着下面的查询无法编译 (“cannot convert double to int”):

            // cannot convert double to int
int avg = new int[] { 3, 4 }.Average();
// But this will compile:
double avg2 = new int[] { 3, 4 }.Average(); // 3.5

为了防止丢失数据精度,Average隐式地把输入数值转换到更宽的数据类型。

当查询数据库时,Sum和Average会被翻译到标准的SQL 集合运算符。下面的查询返回purchase平均值超过500的Customers:

            var query = from c in dataContext.Customers
where c.Purchases.Average (p => p.Price) > 500
select c.Name;

 

Aggregate

Aggregate允许我们使用定制的算法来完成不常见的汇总/计算。Aggregate在LINQ to SQL和Entity Framework中不被支持,并且它的使用方法有些特殊。下面的示例用Aggregate完成了Sum的功能:

            int[] numbers = { 2, 3, 4 };
int sum = numbers.Aggregate(0, (total, n) => total + n); // 9

Aggregate的第一个参数是算法的种子,即初始值。第二个参数是一个表达式,用来针对每个元素更新计算数值。我们可以选择提供第三个参数来对最终结果进行数据转换。

Aggregate可以解决的很多问题同样可以使用foreach循环(更熟悉的语法形式)来完成。使用Aggregate的优势是对于复杂的计算,我们可以使用PLINQ自动实现平行的计算任务。

不带种子的集合计算

当调用Aggregate时,我们可以省略种子值,这时第一个元素会隐式成为种子值,并且集合计算从第二个元素继续下去。

            // 省去种子参数调用Aggregate
int[] numbers = { 1, 2, 3 };
int sum = numbers.Aggregate ((total, n) => total + n); // 6

这个例子完成和上面例子同样的功能(求和),但是实际上我们完成了两个不同的计算。前一个例子,我们计算0+1+2+3;现在我们计算的是1+2+3。我们可以使用乘法来更好的展示他们之间的区别:

            int[] numbers = { 1, 2, 3 };
int x = numbers.Aggregate(0, (prod, n) => prod * n); // 0*1*2*3 = 0
int y = numbers.Aggregate((prod, n) => prod * n); // 1*2*3 = 6

 

量词/Quantifiers

IEnumerable<TSource>→bool

Operator

说明

SQL语义

Contains

如果输入sequence包含给定的element则返回true

WHERE ... IN (...)

Any

如果任意一个元素满足给定条件则返回true

WHERE   ... IN (...)

All

如果所有元素都满足给定条件则返回true

WHERE (...)

SequenceEqual

如果第二个sequence和输入sequence拥有相同的elements则返回true

 

Contains 和Any

Contains方法接受一个TSource类型参数;Any可选地接受一个条件表达式。

如果输入sequence包含给定的element,Contains返回true:

            bool hasAThree = new int[] { 2, 3, 4 }.Contains(3); // true;

如果任意一个元素满足给定条件,Any返回true。我们可以使用Any来重写上面的查询:

            bool hasAThree = new int[] { 2, 3, 4 }.Any(n => n == 3); // true;

Any可以完成Contains可以完成的任何事情,也能完成Contains不能完成的事情:

            bool hasABigNumber = new int[] { 2, 3, 4 }.Any(n => n > 10); // false;

如果调用Any时省略了条件表达式,则只要sequence中含有元素就返回true,下面使用另一种方式完成了上面查询的功能:

            bool hasABigNumber = new int[] { 2, 3, 4 }.Where(n => n > 10).Any();

Any在我们使用子查询时非常有用,并且经常用在数据库查询中,比如:

            var query =
from c in dataContext.Customers
where c.Purchases.Any(p => p.Price > 1000)
select c;

 

All 和SequenceEqual

如果所有的元素都符合给定条件,则All返回true。下面的查询返回所有purchases都小于100的customers:

            var query =
dataContext.Customers.Where(c => c.Purchases.All(p => p.Price < 100));

SequenceEqual比较两个sequence。如果他们拥有相同的元素,且相同的顺序,则返回true:

            int[] numbers1 = { 2, 3, 4 };
int[] numbers2 = { 2, 3, 4 };
int[] numbers3 = { 3, 2, 4 };

Console.WriteLine(numbers1.SequenceEqual(numbers2)); // True
Console.WriteLine(numbers1.SequenceEqual(numbers3)); // False

 

分类: LINQ
标签