c#v2.0 扩展特性 翻译(2)

 1<int> , the just-in-time (JIT) compiler of the .NET Common Language Runtime converts the generic IL and metadata to native code, substituting actual types for type parameters in the process. Subsequent references to that constructed generic type then use the same native code. The process of creating a specific constructed type from a generic type is known as a  **_generic type instantiation_ ** . 
 2
 3当应用程序第一次创建一个新的被构造的泛型，例如  Stack<int> ，  .Net  公共运行时的  JIT  将泛型的中间代码和元数据转化成本地代码，在进程中用真实类型取代类型参数。后来引用已经被构建的泛型就运行本地代码。根据指定的构建类型来创建泛型被称作泛型的实例化。 
 4
 5The .NET Common Language Runtime creates a specialized copy of the native code for each generic type instantiation with a value type, but shares a single copy of the native code for all reference types (since, at the native code level, references are just pointers with the same representation). 
 6
 7.Net  公共语言运行时为每个值类型的泛型创建一个专门的本地代码拷贝。但会为所有引用类型共享一个单独的本地代码拷贝。（因为，在本地代码层次，引用和指针就是同一表示） 
 8
 9###  19.1.2  Constraints 
10
11约束 
12
13Commonly, a generic class will do more than just store data based on a type parameter. Often, the generic class will want to invoke methods on objects whose type is given by a type parameter. For example, an  Add  method in a  Dictionary<k,v> class might need to compare keys using a  CompareTo  method: 
14
15一般来说，一个泛型类不仅可以存储建立在类型参数上的数据，还能做更多。通常，泛型类会尝试调用被指定类型对象上的方法。举例说，在  Dictionary<k,v> 类中一个  Add  方法可能需要通过  CompareTo  方法比较关键字。 
16
17public class Dictionary<k,v>   
18{   
19public void Add(K key, V value)   
20{   
21... 
22
23if (key.CompareTo(x) &lt; 0) {...}  // Error, no CompareTo method   
24...   
25}   
26} 
27
28Since the type argument specified for  K  could be any type, the only members that can be assumed to exist on the  key  parameter are those declared by type  object  , such as  Equals  ,  GetHashCode  , and  ToString  ; a compile-time error therefore occurs in the example above. It is of course possible to cast the  key  parameter to a type that contains a  CompareTo  method. For example, the  key  parameter could be cast to  IComparable  : 
29
30然而类型参数  K  可能是任何类型，被假定存在于  Key  参数的唯一成员变量是那些  object  类型所声明的，比如说  Equal  ，  GetHashCode  和  ToString  ；上面的代码将引发一个编译时错误。当然也可以把  Key 
31
32参数转化成一个包含  CompareTo  方法的类型。例如，  Key  参数可能被转化成支持  IComparable  接口  。 
33
34public class Dictionary<k,v>   
35{   
36public void Add(K key, V value)   
37{   
38... 
39
40if (((IComparable)key).CompareTo(x) &lt; 0) {...}   
41...   
42}   
43} 
44
45While this solution works, it requires a dynamic type check at run-time, which adds overhead. It furthermore defers error reporting to run-time, throwing an  InvalidCastException  if a key doesn’t implement  IComparable  . 
46
47当以上解决方案运行时，加在上面的代码要求进行一个运行时的动态类型检查。而且它在运行时才报告错误，并在当  key  不支持  IComparable  接口时会抛出一个  InvalidCastException. 
48
49To provide stronger compile-time type checking and reduce type casts, C# permits an optional list of  **_constraints_ ** to be supplied for each type parameter. A type parameter constraint specifies a requirement that a type must fulfill in order to be used as an argument for that type parameter. Constraints are declared using the word  where  , followed by the name of a type parameter, followed by a list of class or interface types, or the constructor constraint  new()  . 
50
51为了提供更强的编译时类型检查和减少类型转换，  C#  允许一个可选择的约束列表去提供给每一个类型参数。作为一个类型参数约束的要求，一个类型参数约束指定一个必须完全履行的类型。约束通过关键字  where  声明，后面跟上类型参数的名字，再跟上一串类或接口，或是一个约束构造器  new() 
52
53In order for the  Dictionary<k,v> class to ensure that keys always implement  IComparable  , the class declaration can specify a constraint for the type parameter  K  : 
54
55为了保证  Dictionary<k,v> 类的  Key  支持  IComparable  接口，类的声明指定一个类型参数的约束。 
56
57public class Dictionary<k,v> where K: IComparable   
58{   
59public void Add(K key, V value)   
60{   
61... 
62
63if (key.CompareTo(x) &lt; 0) {...}   
64...   
65}   
66} 
67
68Given this declaration the compiler will ensure that any type argument supplied for  K  is a type that implements  IComparable  . Furthermore, it is no longer necessary to explicitly cast the key parameter to  IComparable  before calling the  CompareTo  method; all members of a type given as a constraint for a type parameter are directly available on values of that type parameter type. 
69
70指定以后，编译器将确保任何提供给  K  的类型参数必须支持  IComparable  接口。而且，在调用  CompareTo  方法前，它不再需要显式的把  Key  参数转化支持  IComparable  接口。被一个类型参数的约束所给定的所有成员在类型值上直接可见  。 
71
72For a given type parameter, it is possible to specify any number of interfaces as constraints, but no more than one class. Each constrained type parameter has a separate  where  clause. In the example below, the type parameter  K  has two interface constraints, while the type parameter  E  has a class constraint and a constructor constraint: 
73
74作为一个给定的类型参数，但对一个类可能会指定任何数量的接口作为约束。每种约束类型参数有一个  Where  子句分隔。在下面的例子里，类型参数  K  有两个接口约束，然而类型参数  E  有一个类约束和一个构建约束。 
75
76public class EntityTable<k,e>   
77where K: IComparable<k>, IPersistable   
78where E: Entity, new()   
79{   
80public void Add(K key, E entity)   
81{   
82... 
83
84if (key.CompareTo(x) &lt; 0) {...}   
85...   
86}   
87} 
88
89The constructor constraint,  new()  , in the example above ensures that a type used as a type argument for  E  has a public, parameterless constructor, and it permits the generic class to use  new  E()  to create instances of that type. 
90
91上面例子中的构建约束  new(),  确保作为类型参数  E  的类型有一个公共的，无参数的构建函数，且它允许泛型类  使用  new E()  去创建该类型的实例。 
92
93Type parameter constrains should be used with care. While they provide stronger compile-time type checking and in some cases improve performance, they also restrict the possible uses of a generic type. For example, a generic class  List<t> might constrain  T  to implement  IComparable  such that the list’s  Sort  method can compare items. However, doing so would preclude use of  List<t> for types that don’t implement  IComparable  , even if the  Sort  method is never actually called in those cases. 
94
95类型参数约束应该小心使用。他们提供更强的编译时类型检查并能在某些例子来提高性能，也能约束泛型的使用可能性。举例说，一个  List<t> 泛型可能会约束  T  实现  IComparable  接口，这样  List  的  Sort  方法就可以比较项目。然而，这将使不支持  IComparable  接口的类型不能使用  List<t>,  即使  Sort  方法没有在案例中被调用。</t></t></t></t></k></k,e></k,v></k,v></k,v></k,v></k,v></k,v></k,v></int></int>