26.7 Query expressions查询表达式

Query expressions provide a language integrated syntax for queries that is similar to relational and hierarchical query languages such as SQL and XQuery.

查询表达式为查询提供了一个类似于关系和分层的查询语言(如SQL和XQuery)的语言集成(译者: intergrated或译“整合”)语法。

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-clauseopt 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:
select expression
group-clause:
group expression by expression
into-clause:
into identifier query-body

A query-expression is classified as a non-assignment-expression, the definition of which occurs in §26.3.

查询表达式作为非赋值（non-assignment-expression）表达式分类，其定义出现在§26.3。

A query expression begins with a from clause and ends with either a select or group clause. The initial from clause can be followed by zero or more from or where clauses. Each from clause is a generator that introduces an iteration variable ranging over a sequence, and each where clause is a filter that excludes items from the result. The final select or group clause specfies the shape of the result in terms of the iteration variable(s). The select or group clause may be preceded by an orderby clause that specifies an ordering for the result. Finally, an into clause can be used to “splice” queries by treating the results of one query as a generator in a subsequent query.

查询表达式以from开始，结束于 select或group子句。开头的from子句可以跟随0个或者更多个from或where子句。每个from子句都是一个产生器，它引入了一个迭代变量在序列上搜索；每个where子句是一个过滤器，它从结果中排除一些项。最后的select或group子句指定了依据迭代变量得出的结果的外形 (shape)。Select或group子句前面可有一个orderby子句，它指明返回结果的顺序。最后into子句可以通过把一条查询语句的结果作为产生器插进子序列查询中的方式来拼接查询。

In a query expression, a from clause with multiple generators is exactly equivalent to multiple consecutive from clauses with a single generator.

在查询表达式中，多个产生器的from子句正好等价于多个连续的带有单个产生器的from子句。

*******************************************************************************************************************
26.2.3 Extension method invocations扩展方法调用
The detailed rules for extension method invocation are described in the following. In a method invocation (§7.5.5.1) of one of the forms
扩展方法调用的详细规则表述如下。以如下调用形式之一：
expr . identifier ( )
expr . identifier ( args )
expr . identifier < typeargs > ( )
expr . identifier < typeargs > ( args )

if the normal processing of the invocation finds no applicable instance methods (specifically, if the set of candidate methods for the invocation is empty), an attempt is made to process the construct as an extension method invocation. The method invocation is first rewritten to one of the following, respectively:

The preceeding rules mean that instance methods take precedence over extension methods, and extension methods imported in inner namespace declarations take precedence over extension methods imported in outer namespace declarations. For example:
前面的规则标表明实例方法优先于扩展方法，并且导入进内层名字空间中的扩展方法优先于导入进外层名字空间中的扩展方法。例如：
using N1;
namespace N1
{
public static class E
{
public static void F(this object obj, int i) { }
public static void F(this object obj, string s) { }
}
}
class A { }
class B
{
public void F(int i) { }
}

26.1 Implicitly typed local variables隐型局部变量
In an implicitly typed local variable declaration, the type of the local variable being declared is inferred from the expression used to initialize the variable. When a local variable declaration specifies var as the type and no type named var is in scope, the declaration is an implicitly typed local variable declaration. For example:
在隐型局部变量声明中，正被声明的局部变量的类型从初始化这个变量的表达式推导得来。当局部变量声明指明var作为类型，并且该范围域(scope)中没有var名称的类型存在，这个声明就称为隐型局部声明。例如：
var i = 5;
var s = "Hello";
var d = 1.0;
var numbers = new int[] {1, 2, 3};
var orders = new Dictionary();

The implicitly typed local variable declarations above are precisely equivalent to the following explicitly typed declarations:

For reasons of backward compatibility, when a local variable declaration specifies var as the type and a type named var is in scope, the declaration refers to that type; however,a warning is generated to call attention to the ambiguity. Since a type named var violates the established convention of starting type names with an upper case letter, this situation is unlikely to occur.

2005 Microsoft Corporation. All rights reserved.
Microsoft, Windows, Visual Basic, Visual C#, and Visual C++ are either registered trademarks or trademarks of Microsoft Corporation in the U.S.A. and/or other countries/regions.
Other product and company names mentioned herein may be the trademarks of their respective owners.[/quote]

Table of Contents 目录
26. Overview of C# 3.0 （C# 3.0 概述）
26.1 Implicitly typed local variables 隐型局部变量(Implicity typed local variables)
26.2 Extension methods 扩展方法
26.2.1 Declaring extension methods 声明扩展方法
26.2.2 Importing extension methods 导入扩展方法
26.2.3 Extension method invocations 扩展方法的调用
26.3 Lambda expressions Lambda表达式
26.3.1 Lambda expression conversions Lambda 表达式转换
26.3.2 Type inference 类型推导
26.3.3 Overload resolution 重载决议
26.4 Object and collection initializers 对象和集合的初始化器
26.4.1 Object initializers 对象初始化器
26.4.2 Collection initializers 集合初始化器

26.5 Anonymous types 匿名类

26.6 Implicitly typed arrays 隐型数组(Implicitly typed arrays)
26.7 Query expressions 查询表达式
26.7.1 Query expression translation 查询表达式的转换
26.7.1.1 where clauses where子句
26.7.1.2 select clauses select 子句

26.7.1.3 group clauses group子句
26.7.1.4 orderby clauses orderby 子句
26.7.1.5 Multiple generators 多重产生器(generator)
26.7.1.6 into clauses info 子句
26.7.2 The query expression pattern 查询表达式模式
26.7.3 Formal translation rules 正式的转换规则
26.8 Expression trees 表达式树

 ******************************************************************************************

26. Overview of C# 3.0 (C# 3.0概述)
C# 3.0 (“C# orcas”) introduces several language extensions that build on C# 2.0 to support the creation and use of higher order, functional style class libraries. The extensions enable construction of compositional APIs that have equal expressive power of query languages in domains such as relational databases and XML. The extensions include:
C# 3.0 (“C# 魔兽(Orcas)”) 引入了几个构建在C# 2.0上的语言扩展，用来支持创建和使用更高级的函数式(functional或译：泛函)类库。

这些扩展允许组合(compositional) APIs的构造，这些APIs与关系数据库和XML等领域中的查询语言具有同等的表达力。

· Implicitly typed local variables, which permit the type of local variables to be inferred from the expressions used to initialize them.
· 隐型局部变量，允许局部变量的类型从初始化它们的表达式推导而来。

· Extension methods, which make it possible to extend existing types and constructed types with additional methods.
·

This document is a technical overview of those features. The document makes reference to the C# Language Specification 1.2 (§1 through §18) and the C# Language Specification 2.0 (§19 through §25), both of which are available on the C# Language Home Page (http://msdn.microsoft.com/vcsharp/language).
本文档是这些特征的技术概述。文档引用了C#语言规范1.2（§1-§18）和C#语言规范2.0（§19-§25），这两个规范都在C#语言主页上(http://msdn.microsoft.com/vcsharp/language)。

首先先COPY一下游戏规则：

一、被點到名字得要就是把所有的问题像我一样回答出来发一篇日志在自己的页面上。所有的问题都要答。写一篇我这样的日志。最后提一个自己的问题。再点出另外八个人继续回答～～～列出其他8個需要回答問題的人的名字，還要到這8個人的博客裏留言通知對方——你被點名了，被點名者不得拒絕回答問題。

二、這8个人要在自己的博客裏注明是從哪裏接到的，並且再想一個問題傳給其他8個人，讓遊戲繼續下去，不得回傳。被點到名字的人將會得到大家的祝福，並且所有美好的願望都會在不久的將來實現。

离去