本篇继续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
扫一扫
377
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
