.Net泛型类的学习总结

.Net泛型类的学习首先我们来看看什么是.Net泛型类？带有“类型参数”的类称为“泛型类”。那么如果使用.Net泛型类，则可为每个这样的参数提供“类型变量”，从而从.Net泛型类生成一个“构造类”。之后可以声明类型为构造类的变量，创建构造类的实例，并将它分配给该变量。除类以外，您还可以定义和使用泛型结构、接口、过程和委托。下面我们就来看看.net泛型类的一些声明和以及.Net泛型类创建的实例情况。

创新互联公司是专业的网站建设公司,提供网站建设,网站制作,网站设计等网站开发一体化解决方案;包括H5网站设计,微信小程序,网站定制,企业网站建设,电子商务商城网站建设,自适应网站建设,建网站,PHP网站建设,软件开发，软文推广，网站营销。欢迎做网站的企业前来合作洽谈,创新互联公司将竭诚为您服务!

.Net泛型类声明

泛型类声明是一种类的声明，它需要提供类型实参才能构成实际类型。

类声明可以有选择地定义类型形参：

 
 
 
    
  
  
  
  1. class-declaration: 
    2. 
  
  
  
  2. attributesopt   
    3. 
  
  
  
  3.  class-modifiersopt   
    4. 
  
  
  
  4.  class   identifier   
    5. 
  
  
  
  5.  type-parameter-listopt   
    6. 
  
  
  
  6.  class-baseopt 
    7. 
  
  
  
  7. type-parameter-constraints-clausesopt  
    8. 
  
  
  
  8.   class-body   ;opt
    9.

只有提供了一个 type-parameter-list，才可以为这个类声明提供 type-parameter-constraints-clauses。

提供了 type-parameter-list 的类声明是一个泛型类声明。此外，任何嵌套在泛型类声明或泛型结构声明中的类本身就是一个泛型类声明，因为必须为包含类型提供类型形参才能创建构造类型。

除了明确指出的地方外，泛型类声明与非泛型类声明遵循相同的规则。泛型类声明可嵌套在非泛型类声明中。

使用构造类型 (constructed type)引用泛型类。给定下面的泛型类声明

 
 
 
    
  
  
  
  1. class List﹤T﹥ {}
    2.

List﹤T﹥、List﹤int﹥ 和 List﹤List﹤string﹥﹥ 就是其构造类型的一些示例。使用一个或多个类型形参的构造类型（例如 List﹤T﹥）称为开放构造类型 (open constructed type)。不使用类型形参的构造类型（例如 List﹤int﹥）称为封闭构造类型 (closed constructed type)。

泛型类型可根据类型形参的数目进行“重载”；这就是说，同一命名空间或外层类型声明中的两个类型声明可以使用相同标识符，只要这两个声明具有不同数目的类型形参即可。

 
 
 
    
  
  
  
  1. class C {} 
    2. 
  
  
  
  2. 
  
  
  
  3. class C﹤V﹥ {} 
    4. 
  
  
  
  4. 
  
  
  
  5. struct C﹤U,V﹥ {} // Error, C with two type parameters defined twice 
    6. 
  
  
  
  6. 
  
  
  
  7. class C﹤A,B﹥ {}  // Error, C with two type parameters defined twice 
    8.

类型名称解析、简单名称解析和成员访问、过程中使用的类型查找规则均会考虑类型形参的数目。

泛型类声明的基接口必须满足唯一性规则。

.Net泛型类之类型形参

类型形参可在类声明中提供。每个类型形参都是一个简单标识符，代表一个为创建构造类型而提供的类型实参的占位符。类型形参是将来提供的类型的形式占位符。而类型实参是在创建构造类型时替换类型形参的实际类型。

 
 
 
    
  
  
  
  1. type-parameter-list: 
    2. 
  
  
  
  2. ﹤   type-parameters   ﹥ 
    3. 
  
  
  
  3. 
  
  
  
  4. type-parameters: 
    5. 
  
  
  
  5. attributesopt   type-parameter 
    6. 
  
  
  
  6. type-parameters   ,   attributesopt   type-parameter 
    7. 
  
  
  
  7. 
  
  
  
  8. type-parameter: 
    9. 
  
  
  
  9. identifier 
    10.

类声明中的每个类型形参在该类的声明空间中定义一个名称。因此，它不能与另一个类型形参或该类中声明的成员具有相同的名称。类型形参不能与类型本身具有相同的名称。

类上的类型形参的作用域包括 class-base、type-parameter-constraints-clauses 和 class-body。与类的成员不同，此作用域不会扩展到派生类。在其作用域中，类型形参可用作类型。

 
 
 
    
  
  
  
  1. type: 
    2. 
  
  
  
  2. value-type 
    3. 
  
  
  
  3. reference-type 
    4. 
  
  
  
  4. type-parameter
    5.

由于类型形参可使用许多不同的实际类型实参进行实例化，因此类型形参具有与其他类型稍微不同的操作和限制。这包括：

·不能直接使用类型形参声明基类或接口

·类型形参上的成员查找规则取决于应用到该类型形参的约束（如果有）。

·类型形参的可用转换取决于应用到该类型形参的约束（如果有）。

·如果事先不知道由类型形参给出的类型是引用类型不能将标识null 转换为该类型。不过，可以改为使用默认值表达式。此外，具有由类型形参给出的类型的值可以使用 == 和 != 与null 进行比较，除非该类型形参具有值类型约束。

·仅当类型形参受 constructor-constraint 或值类型约束的约束时，才能将 new 表达式与类型形参联合使用。

·不能在属性中的任何位置上使用类型形参。

·不能在成员访问或类型名称中使用类型形参标识静态成员或嵌套类型。

·在不安全代码中，类型形参不能用作 unmanaged-type。

作为类型，类型形参纯粹是一个编译时构造。在运行时，每个类型形参都绑定到一个运行时类型，运行时类型是通过向泛型类型声明提供类型实参来指定的。因此，使用类型形参声明的变量的类型在运行时将是封闭构造类型。涉及类型形参的所有语句和表达式的运行时执行都使用作为该形参的类型实参提供的实际类型。

.Net泛型类之实例类型

每个类声明都有一个关联的构造类型，即实例类型 (instance type)。对于泛型类声明，实例类型是通过从该类型声明创建构造类型来构成的，所提供的每个类型实参替换对应的类型形参。由于实例类型使用类型形参，因此只能在类型形参的作用域中使用该实例类型；也就是在类声明的内部。对于在类声明中编写的代码，实例类型为 this 的类型。对于非泛型类，实例类型就是所声明的类。下面显示几个类声明以及它们的实例类型：

 
 
 
    
  
  
  
  1. class A﹤T﹥   // instance type: A﹤T﹥ 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3. class B {}    // instance type: A﹤T﹥.B 
    4. 
  
  
  
  4. 
  
  
  
  5. class C﹤U﹥ {}// instance type: A﹤T﹥.C﹤U﹥ 
    6. 
  
  
  
  6. } 
    7. 
  
  
  
  7. 
  
  
  
  8. class D {}   // instance type: D 
    9.

.Net泛型类之基规范

类声明中指定的基类可以是构造类类型。基类本身不能是类型形参，但在其作用域中可以包含类型形参。

 
 
 
    
  
  
  
  1. class Extend﹤V﹥: V {}   
    2. 
  
  
  
  2. 
  
  
  
  3.  // Error, type parameter used as base class 
    4.

泛型类声明不能使用 System.Attribute 作为直接或间接基类。

类声明中指定的基接口可以是构造接口类型。基接口本身不能是类型形参，但在其作用域中可以包含类型形参。下面的代码演示类实现和扩展构造类型的方法：

 
 
 
    
  
  
  
  1. class C﹤U,V﹥ {} 
    2. 
  
  
  
  2. 
  
  
  
  3. interface I1﹤V﹥ {} 
    4. 
  
  
  
  4. 
  
  
  
  5. class D: C﹤string,int﹥, I1﹤string﹥ {} 
    6. 
  
  
  
  6. 
  
  
  
  7. class E﹤T﹥: C﹤int,T﹥, I1﹤T﹥ {} 
    8.

泛型类声明的基接口必须满足唯一性规则。

如果类中的方法重写或实现基类或接口中的方法，则必须为特定类型提供相应的方法。下面的代码演示如何重写和实现方法。对此做了进一步的解释。

 
 
 
    
  
  
  
  1. class C﹤U,V﹥  
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3. public virtual void M1(U x, List﹤V﹥ y) {} 
    4. 
  
  
  
  4. } 
    5. 
  
  
  
  5. 
  
  
  
  6. interface I1﹤V﹥  
    7. 
  
  
  
  7. { 
    8. 
  
  
  
  8. V M2(V); 
    9. 
  
  
  
  9. } 
    10. 
  
  
  
  10. 
  
  
  
  11. class D: C﹤string,int﹥, I1﹤string﹥  
    12. 
  
  
  
  12. { 
    13. 
  
  
  
  13. public override void M1(string x, List﹤int﹥ y) {} 
    14. 
  
  
  
  14. 
  
  
  
  15. public string M2(string x) {} 
    16. 
  
  
  
  16. } 
    17.

#p#

.Net泛型类的成员

泛型类的所有成员都可以直接或作为构造类型的一部分使用任何包容类 (enclosing class) 中的类型形参。当在运行时使用特定的封闭构造类型时，所出现的每个类型形参都被替换成为该构造类型提供的实际类型实参。例如：

 
 
 
    
  
  
  
  1. class C﹤V﹥ 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3. public V f1; 
    4. 
  
  
  
  4. public C﹤V﹥ f2 = null; 
    5. 
  
  
  
  5. 
  
  
  
  6. public C(V x) { 
    7. 
  
  
  
  7. this.f1 = x; 
    8. 
  
  
  
  8. this.f2 = this; 
    9. 
  
  
  
  9. } 
    10. 
  
  
  
  10. } 
    11. 
  
  
  
  11. 
  
  
  
  12. class Application 
    13. 
  
  
  
  13. { 
    14. 
  
  
  
  14. static void Main() { 
    15. 
  
  
  
  15. C﹤int﹥ x1 = new C﹤int﹥(1); 
    16. 
  
  
  
  16. Console.WriteLine(x1.f1);  // Prints 1 
    17. 
  
  
  
  17. 
  
  
  
  18. C﹤double﹥ x2 = new C﹤double﹥(3.1415); 
    19. 
  
  
  
  19. Console.WriteLine(x2.f1);  // Prints 3.1415 
    20. 
  
  
  
  20. } 
    21. 
  
  
  
  21. } 
    22.

在实例函数成员中，类型 this 是包含这些成员的声明的实例类型。

除了使用类型形参作为类型以外，泛型类声明中的成员与非泛型类的成员遵循相同的规则。下面几小节将讨论适用于特定种类的成员的附加规则。

.Net泛型类中的静态字段

泛型类声明中的静态变量在相同封闭构造类型的所有实例之间共享，但是不会在不同封闭构造类型的实例之间共享。不管静态变量的类型是否涉及任何类型形参，这些规则都适用。

例如：

 
 
 
    
  
  
  
  1. class C﹤V﹥ 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3. static int count = 0; 
    4. 
  
  
  
  4. 
  
  
  
  5. public C() { 
    6. 
  
  
  
  6. count++; 
    7. 
  
  
  
  7. } 
    8. 
  
  
  
  8. 
  
  
  
  9. public static int Count { 
    10. 
  
  
  
  10. get { return count; } 
    11. 
  
  
  
  11. } 
    12. 
  
  
  
  12. } 
    13. 
  
  
  
  13. 
  
  
  
  14. class Application 
    15. 
  
  
  
  15. { 
    16. 
  
  
  
  16. static void Main() { 
    17. 
  
  
  
  17. C﹤int﹥ x1 = new C﹤int﹥(); 
    18. 
  
  
  
  18. Console.WriteLine(C﹤int﹥.Count);  // Prints 1 
    19. 
  
  
  
  19. 
  
  
  
  20. C﹤double﹥ x2 = new C﹤double﹥(); 
    21. 
  
  
  
  21. Console.WriteLine(C﹤int﹥.Count);  // Prints 1 
    22. 
  
  
  
  22. 
  
  
  
  23. C﹤int﹥ x3 = new C﹤int﹥(); 
    24. 
  
  
  
  24. Console.WriteLine(C﹤int﹥.Count);  // Prints 2 
    25. 
  
  
  
  25. } 
    26. 
  
  
  
  26. } 
    27.

.Net泛型类中的静态构造函数

泛型类中的静态构造函数用于初始化静态字段，并为从该泛型类声明创建的每个不同封闭构造类型执行其他初始化操作。泛型类型声明的类型形参处于作用域中，并且可在静态构造函数的函数体中使用。

新的封闭构造类类型在***次发生下列任一情况时进行初始化：

·创建该封闭构造类型的实例。

·引用该封闭构造类型的任何静态成员。

为了初始化新的封闭构造类类型，需要先为该特定的封闭构造类型创建一组新的静态字段。将其中的每个静态字段初始化为默认值。下一步，为这些静态字段执行静态字段初始值设定项。***，执行静态构造函数。

由于静态构造函数只为每个封闭构造类类型执行一次，因此对于无法通过约束在编译时进行检查的类型形参来说，此处是进行运行时检查的方便位置。例如，下面的类型使用静态构造函数检查类型实参是否为一个枚举：

 
 
 
    
  
  
  
  1. class Gen﹤T﹥ where T: struct
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3. static Gen() { 
    4. 
  
  
  
  4. if (!typeof(T).IsEnum) { 
    5. 
  
  
  
  5.    throw new ArgumentException("T must be an enum"); 
    6. 
  
  
  
  6. } 
    7. 
  
  
  
  7. } 
    8. 
  
  
  
  8. }
    9.

.Net泛型类之访问受保护成员

在泛型类声明中，通过从该泛型类构造的任何类类型的实例，可以对继承的受保护实例成员进行访问。具体而言，指定的用于访问 protected 和 protected internal 实例成员的规则通过下面针对泛型的规则进行了扩充：

在泛型类 G 中，如果 E 的类型是从 G 构造的类类型或从 G 构造的类类型继承的类类型，则使用 E.M 形式的 primary-expression 访问继承的受保护实例成员 M 是允许的。

在下面的示例中

 
 
 
    
  
  
  
  1. class C﹤T﹥ 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3. protected T x; 
    4. 
  
  
  
  4. } 
    5. 
  
  
  
  5. 
  
  
  
  6. class D﹤T﹥: C﹤T﹥ 
    7. 
  
  
  
  7. { 
    8. 
  
  
  
  8. static void F() { 
    9. 
  
  
  
  9. D﹤T﹥ dt = new D﹤T﹥(); 
    10. 
  
  
  
  10. D﹤int﹥ di = new D﹤int﹥(); 
    11. 
  
  
  
  11. D﹤string﹥ ds = new D﹤string﹥(); 
    12. 
  
  
  
  12. dt.x = default(T); 
    13. 
  
  
  
  13. di.x = 123; 
    14. 
  
  
  
  14. ds.x = "test"; 
    15. 
  
  
  
  15. } 
    16. 
  
  
  
  16. } 
    17.

对 x 的三个赋值是允许的，因为它们全都通过从该泛型类型构造的类类型的实例进行。

.Net泛型类中的重载

泛型类声明中的方法、构造函数、索引器和运算符可以被重载。虽然声明的签名必须唯一，但是在替换类型实参时可能会导致出现完全相同的签名。在这样的情况下，重载解析的附加规则将挑选最明确的
成员。

下面的示例根据此规则演示有效和无效的重载：

 
 
 
    
  
  
  
  1. interface I1﹤T﹥ {} 
    2. 
  
  
  
  2. 
  
  
  
  3. interface I2﹤T﹥ {} 
    4. 
  
  
  
  4. 
  
  
  
  5. class G1﹤U﹥ 
    6. 
  
  
  
  6. { 
    7. 
  
  
  
  7. int F1(U u); // Overload resulotion for G﹤int﹥.F1 
    8. 
  
  
  
  8. int F1(int i);   // will pick non-generic 
    9. 
  
  
  
  9. 
  
  
  
  10. void F2(I1﹤U﹥ a); // Valid overload 
    11. 
  
  
  
  11. void F2(I2﹤U﹥ a); 
    12. 
  
  
  
  12. } 
    13. 
  
  
  
  13. 
  
  
  
  14. class G2﹤U,V﹥ 
    15. 
  
  
  
  15. { 
    16. 
  
  
  
  16. void F3(U u, V v);// Valid, but overload resolution for 
    17. 
  
  
  
  17. void F3(V v, U u);// G2﹤int,int﹥.F3 will fail 
    18. 
  
  
  
  18. 
  
  
  
  19. void F4(U u, I1﹤V﹥ v); // Valid, but overload resolution for   
    20. 
  
  
  
  20.    void F4(I1﹤V﹥ v, U u);// G2﹤I1﹤int﹥,int﹥.F4 will fail 
    21. 
  
  
  
  21. 
  
  
  
  22. void F5(U u1, I1﹤V﹥ v2); // Valid overload 
    23. 
  
  
  
  23. void F5(V v1, U u2); 
    24. 
  
  
  
  24. 
  
  
  
  25. void F6(ref U u); // valid overload 
    26. 
  
  
  
  26. void F6(out V v); 
    27. 
  
  
  
  27. } 
    28.

形参数组方法和类型形参

可以在形参数组的类型中使用类型形参。例如，给定下面的声明

 
 
 
    
  
  
  
  1. class C﹤V﹥ 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3. static void F(int x, int y, params V[] args); 
    4. 
  
  
  
  4. }
    5.

对该方法的如下展开形式的调用：

 
 
 
    
  
  
  
  1. C﹤int﹥.F(10, 20); 
    2. 
  
  
  
  2. C﹤object﹥.F(10, 20, 30, 40); 
    3. 
  
  
  
  3. C﹤string﹥.F(10, 20, "hello", "goodbye");
    4.

完全对应于：

 
 
 
    
  
  
  
  1. C﹤int﹥.F(10, 20, new int[] {}); 
    2. 
  
  
  
  2. C﹤object﹥.F(10, 20, new object[] {30, 40}); 
    3. 
  
  
  
  3. C﹤string﹥.F(10, 20, new string[] {"hello", "goodbye"} );
    4.

.Net泛型类之重写和泛型类

和往常一样，泛型类中的函数成员可以重写基类中的函数成员。在确定被重写的基成员时，必须通过替换类型实参来确定基类的成员。一旦确定了基类的成员，重写规则就与非泛型类
相同。

下面的示例演示重写规则如何在存在泛型的情况下起作用：

 
 
 
    
  
  
  
  1. abstract class C﹤T﹥ 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3. public virtual T F() {} 
    4. 
  
  
  
  4. 
  
  
  
  5. public virtual C﹤T﹥ G() {} 
    6. 
  
  
  
  6. 
  
  
  
  7. public virtual void H(C﹤T﹥ x) {} 
    8. 
  
  
  
  8. } 
    9. 
  
  
  
  9. 
  
  
  
  10. class D: C﹤string﹥ 
    11. 
  
  
  
  11. { 
    12. 
  
  
  
  12. public override string F() {}    // Ok 
    13. 
  
  
  
  13. 
  
  
  
  14. public override C﹤string﹥ G() {} // Ok 
    15. 
  
  
  
  15. 
  
  
  
  16. public override void H(C﹤T﹥ x) {} // Error, should be C﹤string﹥ 
    17. 
  
  
  
  17. } 
    18. 
  
  
  
  18. 
  
  
  
  19. class E﹤T,U﹥: C﹤U﹥ 
    20. 
  
  
  
  20. { 
    21. 
  
  
  
  21. public override U F() {}// Ok 
    22. 
  
  
  
  22. 
  
  
  
  23. public override C﹤U﹥ G() {}  // Ok 
    24. 
  
  
  
  24. 
  
  
  
  25. public override void H(C﹤T﹥ x) {} // Error, should be C﹤U﹥ 
    26. 
  
  
  
  26. } 
    27.

.Net泛型类中的运算符

泛型类声明可以定义运算符，所遵循的规则与非泛型类声明相同。运算符声明中使用类声明的实例类型的方式必须与运算符的正常使用规则类似，具体如下：

·一元运算符必须以该实例类型的单个参数为操作对象。一元的 ++ 和 -- 运算符必须返回该实例类型或从该实例类型派生的类型。

·二元运算符的参数中必须至少有一个属于该实例类型。

·转换运算符的形参类型或返回类型必须属于该实例类型。

下面演示泛型类中的有效运算符声明的一些示例：

 
 
 
    
  
  
  
  1. class X﹤T﹥ 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3. public static X﹤T﹥ operator ++(X﹤T﹥ operand) {} 
    4. 
  
  
  
  4. 
  
  
  
  5. public static int operator *(X﹤T﹥ op1, int op2) {} 
    6. 
  
  
  
  6. 
  
  
  
  7. public static explicit operator X﹤T﹥(T value) {} 
    8. 
  
  
  
  8. } 
    9.

对于从源类型 S 转换到目标类型 T 的转换运算符，在应用指定的规则时，与 S 或 T 关联的任何类型形参都被视为与其他类型没有继承关系的唯一类型，并忽略对那些类型形参的所有约束。

在下面的示例中

 
 
 
    
  
  
  
  1. class C﹤T﹥ {} 
    2. 
  
  
  
  2. 
  
  
  
  3. class D﹤T﹥: C﹤T﹥ 
    4. 
  
  
  
  4. { 
    5. 
  
  
  
  5. public static implicit operator C﹤int﹥(D﹤T﹥ value) {}  // Ok 
    6. 
  
  
  
  6. 
  
  
  
  7. public static implicit operator C﹤string﹥(D﹤T﹥ value) {} // Ok 
    8. 
  
  
  
  8. 
  
  
  
  9. public static implicit operator C﹤T﹥(D﹤T﹥ value) {} // Error 
    10. 
  
  
  
  10. } 
    11.

前两个运算符声明是允许的，T 和 int 以及 string 分别被视为没有关系的唯一类型。但是，第三个运算符是错误的，因为 C﹤T﹥ 是 D﹤T﹥ 的基类。

对于某些类型实参，可以声明这样的运算符，即这些运算符指定了已经作为预定义转换而存在的转换。在下面的示例中

 
 
 
    
  
  
  
  1. struct Convertible﹤T﹥ 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3. public static implicit operator Convertible﹤T﹥(T value) {} 
    4. 
  
  
  
  4. 
  
  
  
  5. public static explicit operator T(Convertible﹤T﹥ value) {} 
    6. 
  
  
  
  6. } 
    7.

当把类型 object 指定为 T 的类型实参时，第二个运算符将声明一个已经存在的转换（存在从任何类型到类型 object 的隐式转换，因此也存在显式转换）。

在两个类型之间存在预定义转换的情况下，这些类型之间的任何用户定义的转换将被忽略。具体而言：

·如果存在从类型 S 到类型T 的预定义隐式转换，则从S 到T 的所有用户定义的转换（隐式或显式）将被忽略。

·如果存在从类型S 到类型T 的预定义显式转换，则从 S 到T 的所有用户定义的显式转换将被忽略。但是，仍然会考虑从 S 到 T 的用户定义的隐式转换。

对于除 object 以外的所有类型，上面的 Convertible﹤T﹥ 类型声明的运算符都不会与预定义的转换发生冲突。例如：

 
 
 
    
  
  
  
  1. void F(int i, Convertible﹤int﹥ n) { 
    2. 
  
  
  
  2. i = n; // Error 
    3. 
  
  
  
  3. i = (int)n;    // User-defined explicit conversion 
    4. 
  
  
  
  4. n = i; // User-defined implicit conversion 
    5. 
  
  
  
  5. n = (Convertible﹤int﹥)i;    // User-defined implicit conversion 
    6. 
  
  
  
  6. }
    7.

但是对于类型 object，除了下面这个特例之外，预定义的转换将在其他所有情况下隐藏用户定义的
转换：

 
 
 
    
  
  
  
  1. void F(object o, Convertible﹤object﹥ n) { 
    2. 
  
  
  
  2. o = n; // Pre-defined boxing conversion 
    3. 
  
  
  
  3. o = (object)n; // Pre-defined boxing conversion 
    4. 
  
  
  
  4. n = o; // User-defined implicit conversion 
    5. 
  
  
  
  5. n = (Convertible﹤object﹥)o; // Pre-defined unboxing conversion 
    6. 
  
  
  
  6. }
    7.

.Net泛型类中的嵌套类型

泛型类声明可以包含嵌套的类型声明。包容类的类型形参可以在嵌套类型中使用。嵌套类型声明可以包含仅适用于该嵌套类型的附加类型形参。

泛型类声明中包含的每个类型声明都隐式地是泛型类型声明。在编写对嵌套在泛型类型中的类型的引用时，必须指定其包容构造类型（包括其类型实参）。但是可在外层类中不加限定地使用嵌套类型；在构造嵌套类型时可以隐式地使用外层类的实例类型。下面的示例演示三种不同的引用从 Inner 创建的构造类型的正确方法；前两种方法是等效的：

 
 
 
    
  
  
  
  1. class Outer﹤T﹥ 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3.    class Inner﹤U﹥ 
    4. 
  
  
  
  4. { 
    5. 
  
  
  
  5. public static void F(T t, U u) {} 
    6. 
  
  
  
  6. } 
    7. 
  
  
  
  7. 
  
  
  
  8. static void F(T t) { 
    9. 
  
  
  
  9. Outer﹤T﹥.Inner﹤string﹥.F(t, "abc");  // These two statements have 
    10. 
  
  
  
  10. Inner﹤string﹥.F(t, "abc"); // the same effect 
    11. 
  
  
  
  11. 
  
  
  
  12. Outer﹤int﹥.Inner﹤string﹥.F(3, "abc");  // This type is different 
    13. 
  
  
  
  13. 
  
  
  
  14. Outer.Inner﹤string﹥.F(t, "abc");// Error, Outer needs type arg 
    15. 
  
  
  
  15. } 
    16. 
  
  
  
  16. } 
    17.

嵌套类型中的类型形参可以隐藏外层类型中声明的成员或类型形参，但这是一种不好的编程风格：

 
 
 
    
  
  
  
  1. class Outer﹤T﹥ 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3. class Inner﹤T﹥  // Valid, hides Outer’s T 
    4. 
  
  
  
  4. { 
    5. 
  
  
  
  5. public T t;  // Refers to Inner’s T 
    6. 
  
  
  
  6. } 
    7. 
  
  
  
  7. } 
    8. 
  
  
  
  8.

.Net泛型类的声明以及使用中会碰到的一些概念及应用的基本内容就向你介绍到这里，希望对你了解和学习.Net泛型类有所帮助。

当前名称：.Net泛型类的学习总结
URL链接：http://www.mswzjz.com/qtweb/news32/184532.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

外贸建站知识

分类信息网

成都电信服务器托管　　 　绵阳网站建设　　 　网站建设公司　　 　邛崃网站建设　　 　成都服务器托管　　 　整合营销　　 　成都定制网站　　 　宜宾网站建设　　 　成都微信小程序开发　　 　成都包装盒设计　　 　成都网站制作　　 　南充服务器托管　　 　手机网站建设套餐　　 　江油做网站　　 　成都棕树机房　　 　雪茄烟　　 　公路钻孔机　　 　IDC机房托管　　 　关键词优化　　 　电商网站建设方案