规范
原文：《C# Version 3.0 Specification》，Microsoft
翻译：lover_P
查询表达式（Query Expression）为查询提供了一种语言集成的语法，这种语法类似于关系和分级查询语言，如SQL和XQuery。
query-expression:
from-clause query-body
from-clause:
from from-generators
from-generators:
from-generator
from-generators , from-generator
from-generator:
identifier in expression
query-body:
from-or-where-clausesopt orderby-caluseopt select-or-group-clause into-clauseopt
from-or-where-clauses:
from-or-where-clause
from-or-where-clauses from-or-where-clause
from-or-where-clause:
from-clause
where-clause
where-clause:
where boolean-expression
orderby-clause:
orderby ordering-clauses
ordering-clauses:
ordering-clause
ordering-clauses , ordering-clause
ordering-clause:
expression ordering-directionopt
ordering-direction:
ascending
descending
select-or-group-clause:
select-clause
group-clause
select-clause:
selelct expression
group-clause:
group expression by expression
into-clause:
into identifier query-body
一个查询表达式以一个from子句开始，以一个select或group子句结束。起始的from子句后可以跟零个或多个from或where子句。每个from子句都是一个生成器，该生成器引入了一个可以覆盖整个序列的迭代变量；而每个where子句都是一个过滤器，该过滤器用于从结果中排出项目。最终的select或group子句根据迭代变量来指定结果的表现形式。select或group子句前面还可以有一个orderby子句，用以指定结果的顺序。最后，可以用一个into子句通过将一个查询的结果作为一个子查询的生成器来“联结”两个查询。
在查询表达式中，具有多个生成器的from子句严格等价于多个顺序的只具有一个生成器的from子句。
7.1 查询表达式的翻译
C# 3.0语言并没有为查询表达式指定确切的执行语义，而是将查询表达式翻译为对附着于查询表达式模式（Query Expression Pattern）的方法的调用。特别地，查询表达式分别被翻译为对名为Where、Select、SelectMany、OrderBy、OrderByDescending、ThenBy、ThenByDescending和GroupBy的方法的调用，这些方法有着预期的签名和返回值类型。这些方法既可以是待查询对象的实例方法，也可以是对象外部的扩展方法。这些方法进行着实际的查询工作。
将查询表达式翻译为方法调用的过程是一个语法映射过程，发生在任何类型绑定或重载抉择的执行之前。翻译的结果可以保证语法正确，但不一定保证产生语义正确的C#代码。在查询表达式翻译之后，产生的方法调用作为一般的方法调用进行处理，这时会依次发现错误，如方法不存在、参数类型错误或对一个范型方法的类型推断失败等。
后面的一系列示例依次演示了查询表达式的翻译。在后面的某一节中给出了翻译规则的正式描述。
7.1.1 where子句
查询表达式中的一个where子句：
from c in customers
where c.City == "London"
select c
将被翻译为对一个Where方法的调用，其参数为合并了迭代变量和where子句中的表达式所得到的拉姆达表达式：
customers.
Where(c => c.City == "London")
7.1.2 select子句
上面的例子演示了选择了最内部的迭代变量的select子句是如何通过翻译为方法调用被消除的。
一个选择了并非最内部的迭代变量的select子句：
from c in customers
where c.City == "Longdon"
select c.Name
将被翻译为一个Select方法调用，其参数是一个拉姆达表达式：
customers.
Where(c => c.City == "London").
Select(c => c.Name)
7.1.3 group子句
一个group子句：
from c in customers
group c.Name by c.Country
将被翻译为对GroupBy方法的调用：
customers.
GroupBy(c => c.Country, c => c.Name)
7.1.4 orderby子句
一个orderby子句：
from c in customers
orderby c.Name
select new { c.Name, c.Phone }
将被翻译为一个对OrderBy方法的调用，或者当指定了descending指示符时，被翻译为一个对OrderByDescending方法的调用：
customers.
OrderBy(c => c.Name).
Select(c => new { c.Name, c.Phone })
另一个orderby子句：
from c in customers
orderby c.Country, c.Balance descending
select new { c.Name, c.Country, c.Balance }
将被翻译为对ThenBy和ThenByDescending方法的调用：
customers.
OrderBy(c => c.Country).
ThenByDescending(c => c.Balance).
Select(c => new { c.Name, c.Country, c.Balance })
7.1.5 多重生成器
多重生成器：
from c in customers
where c.City == "London"
from o in c.Orders
where o.OrderDate.Year == 2005
select new { c.Name, o.OrderID, o.Total }
将被翻译为对所有非最内部生成器的SelectMany方法调用：
customers.
Where(c => c.City == "London").
SelectMany(c =>
c.Orders.
Where(o => o.OrderDate.Year == 2005).
Select(o => new { c.Name, o.OrderID, o.Total })
)
当多重生成器被一个orderby子句合并起来：
from c in customers, o in c.Orders
where o.OrderDate.Year == 2005
orderby o.Total descending
select new { c.Name, o.OrderID, o.Total }
一个附加的Select将被注入，用于收集排序表达式和最终的结果序列。让OrderBy可以操作整个序列是有必要的。OrderBy之后，最终的结果将被提取出来：
customers.
SelectMany(c =>
c.Orders.
Where(o => o.OrderDate.Year == 2005).
Select(o => new { k1 = o.Total, v = new { c.Name, o.OrderID, o.Total } })
).
OrderByDescending(x => x.k1).
Select(x => x.v)
7.1.6 into子句
一个into子句：
from c in customers
group c by c.Country into g
select new { Country = g.Key, CustCount = g.Group.Count() }
是嵌套查询的一种很简单的形式：
from g in
from c in customers
group c by c.Country
select new { Country = g.Key, CustCount = g.Group.Count() }
将被翻译为：
customers.
GroupBy(c => c.Country).
Select(g => new { Country = g.Key, CustCount = g.Group.Count() })
7.2 查询表达式模式
查询表达式模式（Query Expression Pattern）建立了类型可以实现的方法的一套模式，用以支持查询表达式。因为查询表达式会被通过语法映射来翻译为方法调用，因此类型在如何实现其查询表达式模式上尤为灵活。例如，模式的这些方法可以被实现为实例方法或扩展方法，因为两者具有完全一样的调用语法；而方法的参数也可以是委托或表达式树，因为拉姆达表达式可以转换为这两者。
下面给出了支持查询表达式模式的范型类型C<T>的推荐形式。范型类型用于演示参数和结果类型之间正确的关系，也可以将模式实现为非范型类型。
delegate R Func<A, R>(A arg);
class C<T>
{
public C<T> Where(Func<T, bool> predicate);
public C<S> Select<S>(Func<T, S> selector);
public C<S> SelectMany<S>(Func<T, C<S>> selector);
public O<T> OrderBy<K>(Func<T, K> keyExpr);
public O<T> OrderByDescending<K>(Func<T, K> keyExpr);
public C<G<K, T>> GroupBy<K>(Func<T, K> keyExpr);
public C<G<K, E>> GroupBy<K, E>(Func<T, K> keyExpr, Func<T, E> elemExpr);
}
class O<T> : C<T>
{
public O<T> ThenBy<K>(Func<T, K> keySelector);
public O<T> ThenByDescending<K>(Func<T, K> keySelector);
}
class G<K, T>
{
public K Key { get; }
public C<T> Group { get; }
}
上面的方法是用了一个范型委托类型Func<A, R>，也可以使用等价的其他委托或表达式树类型，只要参数和结果类型之间存在正确的关系即可。
注意在推荐的C<T>和O<T>之间的关系中，要保证ThenBy和ThenByDescending方法只能用在OrderBy或OrderByDescending的结果上。同时请注意GroupBy结果的推荐形式，应该是一组具有Key和Group属性的（匿名类型实例）序列。
标准查询运算符（Standard Query Operators，在另外一个规范中描述）提供了查询表达式的一个实现，这个实现可以用于所有实现了System.Collections.Generic.IEnumerable<T>接口的类型。
7.3 正式的翻译规则
对一个查询表达式的处理将重复、依次地应用下列翻译规则。每个翻译都一直应用这些规则直到不再发生任何给定的模式。
注意将会产生对OrderBy和ThenBy的调用的翻译，如果相应的排序子句制定了descending指示符，将产生对OrderByDescending或ThenByDescending的调用。
l 包含了into子句的查询：
q1 into x q2
将被翻译为：
from x in (q1) q2
l 具有多个生成器的from子句：
from g1, g2, ... gn
将被翻译为：
from g1 from g2 ... from gn
l 后面立即跟有where子句的from子句：
from x in e where f
将被翻译为：
from x in (e).Where(x => f)
l 具有多个from子句、一个orderby子句和一个select子句的查询表达式：
from x1 in e1 from x2 in e2 ... orderby k1, k2 ... select v
将被翻译为：
(from x1 in e1 from x2 in e2 ...
select new { K1 = k1, K2 = k2 ..., V = v })
.OrderBy(x => x.K1).ThenBy(x => x.K2)...
.Select(x => x.V)
l 具有多个from子句、一个orderby子句和一个group子句的查询表达式：
from x1 in e1 from x2 in e2 ... orderby k1, k2 ... group v by g
将被翻译为：
(from x1 in e1 from x2 in e2 ...
select new { K1 = k1, K2 = k2 ..., V = v, G = g })
.OrderBy(x => x.K1).ThenBy(x => x.K2) ...
.GroupBy(x => x.G, x => x.V)
l 具有多个from子句和一个select子句的查询表达式：
from x in e from x1 in e1 ... select v
将被翻译为：
(e).SelectMany(x => from x1 in e1 ... select v)
l 具有多个from子句和一个group子句的查询表达式：
from x in e from x1 in e1 ... group v by g
将被翻译为：
(e).SelectMany(x => from x1 in e1 ... group v by g)
l 具有一个from子句、没有orderby子句，并且具有一个select子句的查询表达式：
from x in e select v
将被翻译为：
(e).Select(x => v)
当v就是标识符x时，翻译将被简化为：
(e)
l 具有一个from子句、没有orderby子句，并且具有一个group子句的查询表达式：
from x in e group v by g
将被翻译为
(e).GroupBy(x => g, x => v)
当v就是标识符x时，翻译将被简化为：
(e).GroupBy(x => g)
l 具有一个from子句、一个orderby子句和一个select子句的查询表达式：
from x in e orderby k1, k2 ... select v
将被翻译为：
(e).OrderBy(x => k1).ThenBy(x => k2) ...
.Select(x => v)
当v就是标识符x时，翻译将被简化为：
(e).OrderBy(x => k1).ThenBy(x => k2) ...
l 具有一个from子句、一个orderby子句和一个group子句的查询表达式：
from x in e orderby k1, k2 ... group v by g
将被翻译为：
(e).OrderBy(x => k1).ThenBy(x => k2) ...
.GroupBy(x => g, x => v)
当v就是标识符x时，翻译将被简化为：
(e).OrderBy(x => k1).ThenBy(x => k2) ...
.GroupBy(x => g)