本篇继续LINQ Operators的介绍，这里要讨论的是LINQ中的排序和分组功能。LINQ的排序操作符有：OrderBy, OrderByDescending, ThenBy, 和ThenByDescending，他们返回input sequence的排序版本。分组操作符GroupBy把一个平展的输入sequence进行分组存放到输出sequence中。
排序/Ordering
IEnumerable<TSource>→IOrderedEnumerable<TSource>
|
Operator |
说明 |
SQL语义 |
|
OrderBy, ThenBy |
对一个sequence按升序排序 |
ORDER BY ... |
|
OrderByDescending, ThenByDescending |
对一个sequence按降序排序 |
ORDER BY ... DESC |
|
Reverse |
按倒序返回一个sequence |
Exception thrown |
排序操作符以不同顺序返回相同的elements。
OrderBy, OrderByDescending, ThenBy, 和ThenByDescending
OrderBy和OrderByDescending的参数
|
参数 |
类型 |
|
Input sequence |
IEnumerable<TSource> |
|
键选择器/Key selector |
TSource => TKey |
Return type = IOrderedEnumerable<TSource>
ThenBy和ThenByDescending参数
|
参数 |
类型 |
|
Input sequence |
IOrderedEnumerable <TSource> |
|
键选择器/Key selector |
TSource => TKey |
查询表达式语法
orderby expression1 [descending] [, expression2 [descending] ... ]
简介
OrderBy返回input sequence的排序版本，使用键选择器来进行排序比较。请看下面的示例：
string[] names = { "Tom", "Dick", "Harry", "Mary", "Jay" };
//对names sequence按字母顺序排序：
IEnumerable<string> query = names.OrderBy (s => s);
// Result: { "Dick", "Harry", "Jay", "Mary", "Tom" };
//按姓名长度进行排序
IEnumerable<string> query = names.OrderBy (s => s.Length);
// Result: { "Jay", "Tom", "Mary", "Dick", "Harry" };
对于拥有相同排序键值的elements来说，他们的相对位置是不确定的，比如上例按姓名长度排序的查询，Jay和Tom、Mary和Dick，除非我们添加额外的ThenBy运算符：
IEnumerable<string> query = names.OrderBy(s => s.Length).ThenBy(s => s);
// Result: { "Jay", "Tom", "Dick", "Mary", "Harry" };
ThenBy只会对那些在前一次排序中拥有相同键值的elements进行重新排序，我们可以连接任意数量的ThenBy运算符：
// 先按长度排序，然后按第二个字符排序，再按第一个字符排序
IEnumerable<string> query =
names.OrderBy (s => s.Length).ThenBy (s => s[1]).ThenBy (s => s[0]);
// 对应的查询表达式语法为
IEnumerable<string> query =
from s in names
orderby s.Length, s[1], s[0]
select s;
LINQ也提供了OrderByDescending和ThenByDescending运算符，用来按降序排列一个sequence。下面的LINQ-to-db查询获取的purchases先按price降序排列，对于相同的price则按Description字母顺序排列：
var query = dataContext.Purchases.OrderByDescending (p => p.Price)
.ThenBy (p => p.Description);
// 查询表达式语法
var query = from p in dataContext.Purchases
orderby p.Price descending, p.Description
select p;
比较器(Comparers)和排序规则(collations)
对一个本地查询，键选择器对象本身通过其默认的IComparable实现决定了排序算法，我们可以传入一个IComparer对象来重载该排序算法。
// 排序时忽略大小写
names.OrderBy (n => n, StringComparer.CurrentCultureIgnoreCase);
查询表达式语法并不支持传入comparer的做法，LINQ to SQL和EF也没有任何方式来支持此功能。当我们查询一个数据库时，排序算法由排序列的collation（排序规则）决定。如果collation是大小写敏感的，我们可以通过在键选择器上调用ToUpper来获得忽略大小写的排序：
var query = from p in dataContext.Purchases
orderby p.Description.ToUpper()
select p;
IOrderedEnumerable和IOrderedQueryable
排序运算符 返回IEnumerable<T>的一个特殊子类型。Enumerable中的排序运算符返回
IOrderedEnumerable；Queryable中的排序运算符返回IOrderedQueryable。这些子类型允许随后的ThenBy运算符来进一步调整现有的排序，他们中定义的其他成员并没有对用户公开，所以他们看起来就像普通的sequence。仅当我们渐进的创建查询时他们的区别才会显现出来：
IOrderedEnumerable<string> query1 = names.OrderBy(s => s.Length);
IOrderedEnumerable<string> query2 = query1.ThenBy(s => s);
如果我们使用IEnumerable<string>来声明query1，第二行就会编译错误，因为ThenBy需要一个IOrderedEnumerable<string>的输入类型。我们可以通过隐式类型变量来避免这种错误：
var query1 = names.OrderBy(s => s.Length);
var query2 = query1.ThenBy(s => s);
尽管如此，隐式类型有时候也会有其自身的问题，比如下面的查询就不能编译：
var query = names.OrderBy(s => s.Length);
query = query.Where(n => n.Length > 3); // Compile-time error
基于OrderBy的输出类型，编译器推断出query的类型为IOrderedEnumerable<string>。但是下一行中的Where返回一个正常的IEnumerable<string>，所以它已不能重新赋值给query了。我们可以通过显示类型定义或在OrderBy之后调用AsEnumerable()来作为一种变通的方案：
var query = names.OrderBy(s => s.Length).AsEnumerable();
query = query.Where(n => n.Length > 3); // OK
相应的，针对解释查询，我们需要调用AsQueryable。
分组/Grouping
IEnumerable<TSource>→IEnumerable<IGrouping<TSource,TElement>>
|
Operator |
说明 |
SQL语义 |
|
GroupBy |
对一个sequence进行分组 |
GROUP BY |
GroupBy
|
参数 |
类型 |
|
Input sequence |
IEnumerable<TSource> |
|
键选择器/Key selector |
TSource => TKey |
|
元素选择器/Element selector(optional) |
TSource => TElement |
|
比较器/Comparer (optional) |
IEqualityComparer<TKey> |
查询表达式语法
group element-expression by key-expression
简介
GroupBy把一个平展的输入sequence进行分组存放到输出sequence中，比如下面的示例对C: emp目录下的文件按扩展名进行分组：
string[] files = Directory.GetFiles("c:\temp");
IEnumerable<IGrouping<string, string>> query =
files.GroupBy(file => Path.GetExtension(file));
// 使用匿名类型来存储结果
var query2 = files.GroupBy(file => Path.GetExtension(file));
// 遍历结果的方式
foreach (IGrouping<string, string> grouping in query)
{
Console.WriteLine("Extension: " + grouping.Key);
foreach (string filename in grouping)
Console.WriteLine(" - " + filename);
}
// Result:
Extension: .pdf
- chapter03.pdf
- chapter04.pdf
Extension: .doc
- todo.doc
- menu.doc
- Copy of menu.doc
...
Enumerable.GroupBy会读取每一个输入element，把他们存放到一个临时的列表dictionary，所有具有相同key的元素会被存入同一个子列表。然后返回一个分组（grouping）sequence，一个分组是一个带有Key属性的sequence：
public interface IGrouping<TKey, TElement>
: IEnumerable<TElement>, IEnumerable
{
TKey Key { get; } // 一个subsequence共享一个Key属性
}
默认情况下，每个分组里面的element都是没有经过转换的输入element，除非你指定了元素选择器参数。下面就把输入element转换到大写形式：
var query3 = files.GroupBy(
file => Path.GetExtension(file),
file => file.ToUpper());
元素选择器和键值选择器是互相独立的两个概念，上面的例子中，尽管分组中的元素是大写的，但是分组中的Key保持原来的大小写形式：
// Result:
Extension: .pdf
- chapter03.PDF
- chapter04.PDF
Extension: .doc
- todo.DOC
- menu.DOC
- Copy of menu.DOC
...
值得注意的是，分组中的子集合并没有进行排序的功能，他会保持原来的顺序。如果需要对结果排序，我们需要添加OrderBy运算符：
files.GroupBy(file => Path.GetExtension(file), file => file.ToUpper())
.OrderBy(grouping => grouping.Key);
GroupBy的查询表达式语法非常的简单和直接：group element-expression by key-expression
下面使用查询表达式重写上面的例子：
var query =
from file in files
group file.ToUpper() by Path.GetExtension(file);
和select一样，group也会结束一个查询，除非我们增加了一个可以继续查询的子句：
var query =
from file in files
group file.ToUpper() by Path.GetExtension(file) into grouping
orderby grouping.Key
select grouping;
续写查询对于group by运算符来说非常有用，因为我们很可能要对分组进行过滤等操作。
// 只选择元素数量小于3的分组
var query =
from file in files
group file.ToUpper() by Path.GetExtension(file) into grouping
where grouping.Count() < 3
select grouping;
group by之后的where子句相当于SQL中的HAVING，它会应用到整个分组或subsequence，而不是单个元素。
有时候，我们可能仅对分组的汇总感兴趣，所以我们可以丢弃subsequence：
string[] votes = { "Bush", "Gore", "Gore", "Bush", "Bush" };
IEnumerable<string> query = from vote in votes
group vote by vote into g
orderby g.Count() descending
select g.Key;
string winner = query.First(); // Bush
LINQ to SQL和EF中的GroupBy
Grouping在对数据库进行查询时其工作方式是一样的。但是如果设置了关联属性，你会发现group的使用几率不会像标准SQL中那么频繁，因为关联属性已经为我们实现了特定的分组功能。例如，我们想要选择至少有 两个purchases的customers，我们并不需要分组，下面的查询就可以工作得很好：
var query =
from c in dataContext.Customers
where c.Purchases.Count >= 2
select c.Name + " has made " + c.Purchases.Count + " purchases";
下面是一个使用group的例子：
// 对销售额按年份分组
var query = from p in dataContext.Purchases
group p.Price by p.Date.Year into salesByYear
select new {
Year = salesByYear.Key,
TotalValue = salesByYear.Sum()
};
按多键值分组
我们可以按一个复合键值进行分组，方式是使用一个匿名类型来表示这个键值：
// 对purchase按年月分组
var query = from p in dataContext.Purchases
group p by new { Year = p.Date.Year, Month = p.Date.Month };
至此，LINQ Operators我们已经介绍了过滤、数据转换、连接、排序和分组。关于LINQ Operators，在接下来的最后两篇中，会讨论其他还没讲述的运算符，包括：Set、Zip、转换方法、Element运算符、集合方法、量词（Quantifiers）生成方法（Generation Methods）。