C#
Version 3.0 Specification
September 2005
Notice
© 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.
Table of Contents
目录
26. Overview of C# 3.0 （C# 3.0 概述）............................................................................................ 5
26.1 Implicitly typed local variables 隐型局部变量(Implicity typed local variables)...................................... 5
26.2 Extension methods 扩展方法............................................................................................................ 6
26.2.1 Declaring extension methods 声明扩展方法................................................................................ 6
26.2.2 Importing extension methods 导入扩展方法................................................................................ 7
26.2.3 Extension method invocations 扩展方法的调用........................................................................... 7
26.3 Lambda expressions Lambda表达式................................................................................................. 8
26.3.1 Lambda expression conversions Lambda 表达式转换................................................................ 10
26.3.2 Type inference 类型推导......................................................................................................... 11
26.3.3 Overload resolution 重载决议................................................................................................... 13
26.4 Object and collection initializers 对象和集合的初始化器................................................................. 14
26.4.1 Object initializers 对象初始化器............................................................................................... 14
26.4.2 Collection initializers 集合初始化器.......................................................................................... 16
26.5 Anonymous types 匿名类型............................................................................................................ 17
26.6 Implicitly typed arrays 隐型数组(Implicitly typed arrays).................................................................. 18
26.7 Query expressions 查询表达式....................................................................................................... 19
26.7.1 Query expression translation 查询表达式的转换....................................................................... 20
26.7.1.1 where clauses where子句................................................................................................... 21
26.7.1.2 select clauses select 子句................................................................................................... 21
26.7.1.3 group clauses group子句..................................................................................................... 21
26.7.1.4 orderby clauses orderby 子句.............................................................................................. 22
26.7.1.5 Multiple generators 多重产生器(generator) ....................................................................... 22
26.7.1.6 into clauses info 子句.......................................................................................................... 23
26.7.2 The query expression pattern 查询表达式模式.......................................................................... 23
26.7.3 Formal translation rules 正式的转换规则.................................................................................. 24
26.8 Expression trees 表达式树............................................................................................................ 26
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.
· 扩展方法，使得使用附加(additional)的方法扩展已存在的类型和构造类型成为可能。
· Lambda expressions, an evolution of anonymous methods that provides improved type inference and conversions to both delegate types and expression trees.
· Lambda 表达式，是匿名方法的演进，可提供改良的类型推导和到dalegate类型和表达式树的转换。
· Object initializers, which ease construction and initialization of objects.
· 对象初始化器，简化了对象的构造和初始化。
· Anonymous types, which are tuple types automatically inferred and created from object initializers.
· 匿名类型，是从对象初始化器自动推导和创建的元组(tuple)类型。
· Implicitly typed arrays, a form of array creation and initialization that infers the element type of the array from an array initializer.
· 隐型数组，数组创建和初始化的形式，它从数组初始化器推导出数组的元素类型。
· Query expressions, which provide a language integrated syntax for queries that is similar to relational and hierarchical query languages such as SQL and XQuery.
· 查询表达式，为类似于关系型和层次化查询语言（比如SQL和XQuery）提供一个语言集成(intergrated)的语法。
· Expression trees, which permit lambda expressions to be represented as data (expression trees) instead of as code (delegates).
· 表达式树，允许lambda表达式表示为数据(表达式树)而不是代码(delegate)。
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)。
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<int,Order>();
var s = "Hello";
var d = 1.0;
var numbers = new int[] {1, 2, 3};
var orders = new Dictionary<int,Order>();
The implicitly typed local variable declarations above are precisely equivalent to the following explicitly typed declarations:
上面的隐型局部变量声明精确地等同于下面的显型(explicitly typed)声明：
int i = 5;
string s = "Hello";
double d = 1.0;
int[] numbers = new int[] {1, 2, 3};
Dictionary<int,Order> orders = new Dictionary<int,Order>();
string s = "Hello";
double d = 1.0;
int[] numbers = new int[] {1, 2, 3};
Dictionary<int,Order> orders = new Dictionary<int,Order>();
A local variable declarator in an implicitly typed local variable declaration is subject to the following restrictions:
隐型局部变量声明中的局部变量声明符(declarator)遵从下面这些约束：
· The declarator must include an initializer.
· 声明符必须包含初始化器。
· The initializer must be an expression. The initializer cannot be an object or collection initializer (§26.4) by itself, but it can be a new expression that includes an object or collection initializer.
· 初始化器必须是一个表达式。初始化器不能是一个自身的对象或者集合初始化器(26.4)，但是它可以是包含一个对象或集合初始化器的一个new表达式。
· The compile-time type of the initializer expression cannot be the null type.
· 初始化器表达式的编译期类型不可以是空(null)类型。
· If the local variable declaration includes multiple declarators, the initializers must all have the same compile-time type.
· 如果局部变量声明包含了多个声明符，这些声明符必须具备同样的编译期类型。
The following are examples of incorrect implicitly typed local variable declarations:
下面是一些不正确的隐型局部变量声明的例子：
var x; // Error, no initializer to infer type from
var y = {1, 2, 3}; // Error, collection initializer not permitted
var z = null; // Error, null type not permitted
var y = {1, 2, 3}; // Error, collection initializer not permitted
var z = null; // Error, null type not permitted
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.
因为向后兼容的原因，当局部变量声明指定var作为类型，而范围域中又存在叫var的类型，则这个声明会推导为那个叫var的类型；然后，会产生一个关注含糊性(ambiguity)的警告，因为叫var的类型违反了既定的类名首字母大写的约定，这个情形也未必会出现。(译者：视编译器实现而定)
The for-initializer of a for statement (§8.8.3) and the resource-acquisition of a using statement (§8.13) can be an implicitly typed local variable declaration. Likewise, the iteration variable of a foreach statement (§8.8.4) may be declared as an implicitly typed local variable, in which case the type of the iteration variable is inferred to be the element type of the collection being enumerated. In the example
for表达式(§8.8.3)的for初始化器(for-initializer) 和using表达式的资源获取(resource-acquisition)可以作为一个隐型局部变量声明。同样，foreach表达式(§8.8.4)的迭代变量可以声明为一个隐型局部变量，这种情况下，（隐型局部变量的）类型推导为正被枚举(enumerated)的集合的元素的类型。例子：
int[] numbers = { 1, 3, 5, 7, 9 };
foreach (var n in numbers) Console.WriteLine(n);
foreach (var n in numbers) Console.WriteLine(n);
the type of n is inferred to be int, the element type of numbers.
n的类型推导为numbers的元素类型int。
Extension methods are static methods that can be invoked using instance method syntax. In effect, extension methods make it possible to extend existing types and constructed types with additional methods.
扩展方法是可以通过使用实例方法语法调用的静态方法。效果上，扩展方法使得用附加的方法扩展已存在类型和构造类型成为可能。
Note
Extension methods are less discoverable and more limited in functionality than instance methods. For those reasons, it is recommended that extension methods be used sparingly and only in situations where instance methods are not feasible or possible.
Extension members of other kinds, such as properties, events, and operators, are being considered but are currently not supported.
注意
扩展方法不容易被发现并且在功能上比实例方法更受限。由于这些原因，推荐保守地使用和仅在实例方法不可行或不可能的情况下使用。
其它种类的扩展方法，比如属性、事件和操作符，正在被考虑当中，但是当前并不被支持。
Extension methods are declared by specifying the keyword this as a modifier on the first parameter of the methods. Extension methods can only be declared in static classes. The following is an example of a static class that declares two extension methods:
扩展方法是通过指定关键字this修饰方法的第一个参数而声明的。扩展方法仅可声明在静态类中。下面是声明了两个扩展方法的静态类的例子：
namespace Acme.Utilities
{
public static class Extensions
{
public static int ToInt32(this string s) {
return Int32.Parse(s);
}
{
public static class Extensions
{
public static int ToInt32(this string s) {
return Int32.Parse(s);
}
public static T[] Slice<T>(this T[] source, int index, int count) {
if (index < 0 || count < 0 || source.Length – index < count)
throw new ArgumentException();
T[] result = new T[count];
Array.Copy(source, index, result, 0, count);
return result;
}
}
}
if (index < 0 || count < 0 || source.Length – index < count)
throw new ArgumentException();
T[] result = new T[count];
Array.Copy(source, index, result, 0, count);
return result;
}
}
}
Extension methods have all the capabilities of regular static methods. In addition, once imported, extension methods can be invoked using instance method syntax.
扩展方法具备所有常规静态方法的所有能力。另外，一旦被导入，扩展方法可以使用实例方法语法调用之。
Extension methods are imported through using-namespace-directives (§9.3.2). In addition to importing the types contained in a namespace, a using-namespace-directive imports all extension methods in all static classes in the namespace. In effect, imported extension methods appear as additional methods on the types that are given by their first parameter and have lower precedence than regular instance methods. For example, when the Acme.Utilities namespace from the example above is imported with the using-namespace-directive
扩展方法用using-namespace-directives (§9.3.2)导入。除了导入包含在名字空间中的类型外，using-namespace-directives 也导入了名字空间中所有静态类中的所有扩展方法。实际上，被导入的扩展方法作为被修饰的第一个参数类型上的附加方法出现，并且相比常规实例方法具有较低的优先权。比如，当使用using-namespace-directive导入上个例子中Acme.Utilities 名字空间：
using Acme.Utilities;
it becomes possible to invoke the extension methods in the static class Extensions using instance method syntax:
它使得可以在静态类Extension上使用实例方法语法调用扩展方法：
string s = "1234";
int i = s.ToInt32(); // Same as Extensions.ToInt32(s)
int i = s.ToInt32(); // Same as Extensions.ToInt32(s)
int[] digits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int[] a = digits.Slice(4, 3); // Same as Extensions.Slice(digits, 4, 3)
int[] a = digits.Slice(4, 3); // Same as Extensions.Slice(digits, 4, 3)
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:
如果调用的正常处理过程发现没有适用的实例方法（特别地，如果这个调用的候选方法集是空的），就会试图处理扩展方法调用的构造。方法调用会首先被分别重写称如下之一：
identifier ( expr )
identifier ( expr , args )
identifier < typeargs > ( expr )
identifier < typeargs > ( expr , args )
The rewritten form is then processed as a static method invocation, except for the way in which identifier is resolved: Starting with the closest enclosing namespace declaration, continuing with each enclosing namespace declaration, and ending with the containing compilation unit, successive attempts are made to process the rewritten method invocation with a method group consisting of all accessible extension methods with the name given by identifier imported by the namespace declaration’s using-namespace-directives. The first method group that yields a non-empty set of candidate methods is the one chosen for the rewritten method invocation. If all attempts yield empty sets of candidate methods, a compile-time error occurs.
重写后的形式然后被作为静态方法调用处理，除非标识符identifier决议为：以最靠近的封闭名字空间声明开始，以每个封闭名字空间声明继续，并以包含的编译单元结束，持续地试图用组成所有可访问的，由using-namespace-directives导入的，指明为 identifier名字的扩展方法处理重写的方法调用。第一个产生非空候选方法集的方法组(method group)就成为被选中的重写的方法调用。如果所有的努力都只产生空的候选集，则发生编译期错误。
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 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) { }
}
{
public void F(int i) { }
}
class C
{
public void F(object obj) { }
}
{
public void F(object obj) { }
}
class X
{
static void Test(A a, B b, C c) {
a.F(1); // E.F(object, int)
a.F("hello"); // E.F(object, string)
{
static void Test(A a, B b, C c) {
a.F(1); // E.F(object, int)
a.F("hello"); // E.F(object, string)
b.F(1); // B.F(int)
b.F("hello"); // E.F(object, string)
b.F("hello"); // E.F(object, string)
c.F(1); // C.F(object)
c.F("hello"); // C.F(object)
}
}
c.F("hello"); // C.F(object)
}
}
In the example, B’s method takes precedence over the first extension method, and C’s method takes precedence over both extension methods.
例子中，B的方法优先于第一个扩展方法，C的方法优先于两个扩展方法。
26.3 Lambda expressions Lambda表达式
C# 2.0 introduces anonymous methods, which allow code blocks to be written “in-line” where delegate values are expected. While anonymous methods provide much of the expressive power of functional programming languages, the anonymous method syntax is rather verbose and imperative in nature. Lambda expressions provide a more concise, functional syntax for writing anonymous methods.
C# 2.0 引入了匿名方法，它允许在delegate值(delegate value) (译者:delegate对象)被需要的地方以内联(in-line)方式写一个代码块。当匿名方法提供了大量函数式编程语言(或泛函编程)(functional programming)的表达力时，实质上，匿名方法的语法是相当烦琐和带有强制性的。Lambda表达式提供了一个更加简练的函数式语法来写匿名方法。
A lambda expression is written as a parameter list, followed by the => token, followed by an expression or a statement block.
Lambda表达式写成一个后面紧跟 => 标记的参数列表，=>之后是一个表达式或表语句块。
expression:
assignment
non-assignment-expression
assignment
non-assignment-expression
non-assignment-expression:
conditional-expression
lambda-expression
query-expression
conditional-expression
lambda-expression
query-expression
lambda-expression:
( lambda-parameter-listopt ) => lambda-expression-body
implicitly-typed-lambda-parameter => lambda-expression-body
( lambda-parameter-listopt ) => lambda-expression-body
implicitly-typed-lambda-parameter => lambda-expression-body
lambda-parameter-list:
explicitly-typed-lambda-parameter-list
implicitly-typed-lambda-parameter-list
explicitly-typed-lambda-parameter-list
implicitly-typed-lambda-parameter-list
explicitly-typed-lambda-parameter-list
explicitly-typed-lambda-parameter
explicitly-typed-lambda-parameter-list , explicitly-typed-lambda-parameter
explicitly-typed-lambda-parameter
explicitly-typed-lambda-parameter-list , explicitly-typed-lambda-parameter
explicitly-typed-lambda-parameter:
parameter-modifieropt type identifier
parameter-modifieropt type identifier
implicitly-typed-lambda-parameter-list
implicitly-typed-lambda-parameter
implicitly-typed-lambda-parameter-list , implicitly-typed-lambda-parameter
implicitly-typed-lambda-parameter
implicitly-typed-lambda-parameter-list , implicitly-typed-lambda-parameter
implicitly-typed-lambda-parameter:
identifier
identifier
lambda-expression-body:
expression
block
expression
block
The parameters of a lambda expression can be explicitly or implicitly typed. In an explicitly typed parameter list, the type of each parameter is explicitly stated. In an implicitly typed parameter list, the types of the parameters are inferred from the context in which the lambda expression occurs—specifically, when the lambda expression is converted to a compatible delegate type, that delegate type provides the parameter types (§26.3.1).
Lambda表达式的参数可以是显型和隐型的。在显型参数列表中，每个参数的类型是显式指定的。在隐型参数列表中，参数的类型由lambda表达式出现的语境推导——特定地，当lambda表达式被转型到一个兼容的delegate类型时，delegate类型提供参数的类型(§26.3.1)。
In a lambda expression with a single, implicitly typed parameter, the parentheses may be omitted from the parameter list. In other words, a lambda expression of the form
在有单一的隐型参数的lambda表达式中，圆括号可以从参数列表中省略。换句话说，如下形式的lambda表达式
( param ) => expr
can be abbreviated to
可以被简写成
param => expr
Some examples of lambda expressions follow below:
下面是一些lambda表达式的例子：
x => x + 1 // Implicitly typed, expression body
x => { return x + 1; } // Implicitly typed, statement body
(int x) => x + 1 // Explicitly typed, expression body
(int x) => { return x + 1; } // Explicitly typed, statement body
(x, y) => x * y // Multiple parameters
() => Console.WriteLine() // No parameters
In general, the specification of anonymous methods, provided in §21 of the C# 2.0 Specification, also applies to lambda expressions. Lambda expressions are a functional superset of anonymous methods, providing the following additional functionality:
通常，C# 2.0规范§21中提供的匿名方法规范，也应用上了lambda表达式。Lambda表达式是匿名方法的泛函超集，它提供了如下附加功能：
· Lambda expressions permit parameter types to be omitted and inferred whereas anonymous methods require parameter types to be explicitly stated.
· Lambda表达式允许参数类型被省略掉和被推导，尽管匿名方法要求显式指定参数类型。
· The body of a lambda expression can be an expression or a statement block whereas the body of an anonymous method can only be a statement block.
· Lambda表达式体可以是一个表达式或者语句块，尽管匿名方法体可以是一个语句块。
· Lambda expressions passed as arguments participate in type argument inference (§26.3.2) and in method overload resolution (§26.3.3).
· Lambda表达式作为参数传递参与类型参数推导(§26.3.2)和重载决议。
· Lambda expressions with an expression body can be converted to expression trees (§26.8).
· 带有表达式体的Lambda表达式可以被转换成表达式树(§26.8)。
Note
The PDC 2005 Technology Preview compiler does not support lambda expressions with a statement block body. In cases where a statement block body is needed, the C# 2.0 anonymous method syntax must be used.
注意
PDC 2005技术预览编译器不支持带有语句体的lambda表达式。在需要语句体的情况下，必须使用C# 2.0匿名方法语法。
26.3.1 Lambda expression conversions Lambda表达式转换
Similar to an anonymous-method-expression, a lambda-expression is classified as a value with special conversion rules. The value does not have a type but can be implicitly converted to a compatible delegate type. Specifically, a delegate type D is compatible with a lambda-expression L provided:
与匿名方法表达式(anonymous-method-expression)类似，lambda表达式是用特