《CLR via C#》读书笔记 之 泛型

第十二章 泛型

2014-06-15

初始泛型

12.3 泛型基础结构

  12.3.1 开放类型与封闭类型

  12.3.2 泛型类型和继承

  12.3.3 泛型类型同一性

  12.3.4 代码爆炸

12.6 委托和接口的逆变和协变泛型类型实参

12.7 泛型方法

  12.7.1 泛型方法和类型推断

12.9 可验证性合约束

  12.9.1 主要约束

  12.9.2 次要约束

  12.9.3 构造器约束

参考

 

 

初识泛型[1][2]

 返回 

泛型(generic)是CLR和编程语言提供一种特殊机制，它支持另一种形式的代码重用，即"算法重用"。

简单地说，开发人员先定义好一个算法，比如排序、搜索、交换等。但是定义算法的开发人员并不设定该算法要操作什么数据类型；该算法可广泛地应用于不同类型的对象。然后，另一个开发人员只要指定了算法要操作的具体数据类型，就可以使用这个现成的算法了。

泛型有两种表现形式：泛型类型和泛型方法。

  • 泛型类型：大多数算法都封装在一个类型中，CLR允许创建泛型引用类型和泛型值类型，但不允许创建泛型枚举类型。除此之外，CLR还允许创建泛型接口和泛型委托。
  • 泛型方法：方法偶尔也封装有用的算法，所以CLR允许引用类型、值类型或接口中定义泛型方法。

以最常用的FCL中的泛型List<T >为例：

 1 using System.Collections.Generic;
 2 
 3 namespace Generics
 4 {
 5     class Program
 6     {
 7         static void Main(string[] args)
 8         {
 9             List<int> num = new List<int>();
10             num.Add(1);
11             num.Add(3);
12             int num1 = num[0];
13             int num2 = num[1];
14         }
15     }
16 }

 

尖括号中的T是不确定的数据类型，叫做类型参数(type parameter)，一般规定以字母T开头，可以是TKey, TValue都可以。而调用时指定的具体类型叫做类型实参(type argument)。

类型参数是真实类型的占位符。

 

 

  • 类型名List是以“`”加数字结尾的。数字表示类型的元数，也就是需要指定具体类型的参数个数。
  • 泛型是类型安全的。如果用“num.Add("a");”会发生编译错误；
  • 泛型可以提高算法的可重用性，而且从例子中看出int类型并没有进行装箱拆箱操作，相比将所有类型转换为Object的方式而言，提高了程序的性能。
  • 为泛型变量设置默认值时常使用default关键字进行，T temp=default(T)。如果T为引用类型，则temp为null;如果T为值类型，则temp设为0值. 

12.3 泛型基础结构[2]

 返回  

为了是泛型能够工作，Microsoft必须完成以下工作：

  • 创建新的IL指令，使之能够识别类型实参
  • 修改现有元数据表的格式，以便表示具有泛型参数的类型名称和方法
  • 修改各种编程语言(C#等)，以支持新的语法，允许开发人员定义个引入泛型类型和方法
  • 修改编译器，使之能生成新的IL指令和修改元数据格式
  • 修改JIT编译器，使之能够处理新的、支持类型实参的IL指令，以便生成正确的本地代码
  • 创建新的反射成员，使开发人员能查询类型和成员，以判断它们是否具有泛型参数。另外，还必须定义新的反射成员，使开发人员能在运行时创建泛型类型和方法定义。
  • 修改调试器以以显示和操作泛型类型、成员、字段以及局部变量。
  • 修改VisualStudio 的"智能感知"(IntelliSense)特性。

 

12.3.1 开放类型与封闭类型

开放类型：具有泛型参数的类型是开放类型，如List<T>，CLR不允许构造开放类型的实例；
封闭类型：在实际调用代码时，如果所有类型实参都已经指定了实际数据类型，如List<string>，则该类型为封闭类型。CLR允许构造封闭类型的实例。

12.3.2 泛型类型和继承

泛型类型仍然是类型，所以它能从其他任何类型派生。使用一个泛型类型并指定类型实参时，实际上是在CLR中定义一个新的类型对象，新的类型对象是从派生该泛型类型的那个类型派生的。也就是说，由于List<T>是从Object派生的，那么List<String>和List<Guid>也是从Object派生的。

12.3.3 泛型类型同一性

有的时候，泛型语法会将开发人员搞糊涂，所以有的开发人员定义了一个新的非泛型类类型，它从一个泛型类型派生，并指定了所有的类型实参。例如，为了简化一下代码：

List<DateTime> dt = new List<DateTime>();

一些开发人员可能首先定义下面这样的一个类：

1 internal sealed class DateTimeList ： List<DataTime> 
2 {
3         //这里无需放任何代码！
4 }

然后就比较一下DateTimeList和List<DateTime>的同一性：

1         static void Main(string[] args)
2         {
3             DateTimeList dt = new DateTimeList();
4             Boolean sameType = (typeof(List<DateTime>) == (typeof(DateTimeList))); 
5         }

上述代码运行时，sameType会初始化为false，因为比较的是两个不同类型的对象。

因此，决不要单纯处于增强源代码的易读性类这样定义一个新类。这样会丧失类型同一性(identity)和相等性(equivalence)。也就是说，假如一个方法的原型接受一个DateTimeList，那么不能将一个List<DateTime>传给它。然而，如果方法的原型接受一个List<DateTime>，那么可以将一个DateTimeList传给它，因为DateTimeList是从List<DateTime>派生的。 

12.3.4 代码爆炸

 使用泛型类型参数的一个方法在进行JIT编译时，CLR获取方法的IL，用指定的类型实参进行替换，然后创建恰当的本地代码。然而，这样做有一个缺点：CLR要为每种不同的方法/类型组合生成本地代码。我们将这个现象称为"代码爆炸"。它可能造成引用程序集的显著增大，从而影响性能。
 
CLR内建了一些优化措施，能缓解代码爆炸。首先，假如为一个特定的类型实参调用了一个方法，以后再次使用相同的类型实参来调用这个方法，CLR只会为这个方法/类型组合编译一次。所以，如果一个程序集使用List<DateTime>，一个完全不同的程序集也使用List<DateTime>，CLR只会为List<DateTime>编译一次方法。
 
CLR还提供了一个优化措施，它认为所有引用类型实参都是完全相同的，所以代码能够共享。之所以能这样，是因为所有引用类型的实参或变量时间只是执行堆上的对象的指针，而对象指针全部是以相同的方式操作的。
 
但是，假如某个类型实参是值类型，CLR就必须专门为那个值类型生成本地代码。因为值类型的大小不定。即使类型、大小相同，CLR仍然无法共享代码，可能需要用不同的本地CPU指令操作这些值。

12.6 委托和接口的逆变和协变泛型类型实参

 返回  

委托的每个泛型类型参数都可标记为协变量或者逆变量。泛型类型参数如下：

  • 不变量（invariant）意味着类型参数不能更改。
  • 逆变量（contravariant）意味着泛型参数可以从一个基类更改为该类的派生类。在c#中，用in关键字标记。逆变参数只出现在输入位置，比如作为方法的参数。
  • 协变量（covariant）意味着泛型类型参数可以从一个派生类改为它的基类。在c#中，用out关键字标记。协变参数只出现的输出位置，比如作为方法的返回类型。

协变逆变的问题实际上都源于一个根本的原则： 子类可以向父类隐式转换，但是父类不能向子类隐式转换。

逆变量代码： 

 1 using System;
 2 using System.Collections.Generic;
 3 
 4 namespace Generics
 5 {
 6     class Animal{}
 7     class Dog : Animal{}
 8     class Program
 9     {
10         public delegate void Feed<in T>(T target);
11         static public void FeedAnimal(Animal target)
12         {
13             Console.WriteLine("Feed Animal");
14         }
15 
16         static void Main(string[] args)
17         {
18             //先声明一个T为Animal的委托 
19             Feed<Animal> feedAnimalMethod = FeedAnimal;
20             //将T为Animal的委托赋值给T为Dog的委托变量，这是合法的，因为在定义泛型委托时有in关键字，如果把in关键字去掉，编译器会认为不合法 
21             Feed<Dog> feedDogMethod = feedAnimalMethod;
22             feedDogMethod(new Dog());
23         }
24     }
25 }

上述代码：Feed<in 子> a = Feed<父> b, 该方法的参数是Animal（即父），Dog（即子）可以隐式转换为Animal（即父）。

协变量代码：

 1 using System;
 2 using System.Collections.Generic;
 3 
 4 namespace Generics
 5 {
 6     class Animal{}
 7     class Dog : Animal{}
 8     class Program
 9     {
10         public delegate T Get<out T>();
11         static public Dog GetDog()
12         {
13             return new Dog();
14         }
15 
16         static void Main(string[] args)
17         {
18             //先声明一个T为Animal的委托 
19             Get<Dog> GetDogMethod = GetDog;
20             //并将findDog赋值给findAnimal是合法的，类型T从Dog向Animal转变是协变
21             Get<Animal> GetAnimalMethod = GetDogMethod;
22             GetAnimalMethod();
23             Console.WriteLine(GetAnimalMethod() is Dog);
24         }
25     }
26 }

 上述代码：Get<out 父> a = Get<子>，将返回值Gog（即子）赋给Animal（即父）是隐式转换。

 

 综上所述，虽然协变，逆变形式上不同，但都 遵循一个原则：子类可以向父类隐式转换，但是父类不能向子类隐式转换。

  • 协变：Get<out 父> a = Get<子>
  • 逆变：Feed<in 子> a = Feed<父>

若想了解逆变和协变背景和原理，请参考.NET 4.0中的泛型的协变和逆变

若想了解逆变和协变的使用方法，请参考谈谈.Net中的协变和逆变

12.7 泛型方法

 返回  

12.7.1 泛型方法和类型推断[1]

 为了增强可读性，编译器支持类型推断功能，如下代码 Swap(ref s1, ref s2);，省略<String>：

 1     class Program
 2     {
 3         static void Swap<T>(ref T o1, ref T o2)
 4         {
 5             T temp = o1;
 6             o1 = o2;
 7             o2 = temp;
 8         }
 9        
10 
11         static void Main(string[] args)
12         {
13             int i1 = 1;
14             int i2 = 2;
15             Swap<int>(ref i1, ref i2);
16             string s1 = "a";
17             string s2 = "b";
18             Swap(ref s1, ref s2); 
19         }
20     }

注意：类型推断时C#使用的是变量的数据类型，而不是变量引用的对象的类型，如下图：

12.9 可验证性合约束

 返回  

12.9.1 主要约束

一个类型参数可以指定0或1个主要约束，主要约束可以一个非密封的引用类型，它表示类型实参必须与约束类型相同或者为约束类型的派生类。该引用类型不能为Object, Array, Delegate, MulticastDelegate, ValueType, Enum, Void。

 1 class Constraint1<T> where T : Stream
 2 {
 3      public void Close(T stream)
 4      {
 5          stream.Close();
 6      }
 7 }
 8 
 9 class Program
10 {
11      static void Main(string[] args)
12      {
13          Constraint1<FileStream> s2 = new Constraint1<FileStream>();
14      }
15 }

 

两种特殊的主要约束：class和struct。

  • class约束：要求指定的类型实参必须是引用类型。Where T:class
1         class ConstraintClass<T> where T : class
2         {
3             void M()
4             {
5                 T temp = null;
6             }
7         }

上述代码，将temp设置为T是合法的，因为T是一个引用类型。C在没有约束的情况下，如果T为值类型，是不能赋值为null的，会产生编译错误。

  • Struct 约束：要求指定的类型实参必须是值类型。Where T:struct
1         class ConstraintStruct<T> where T : struct
2         {
3             static T M()
4             {
5                 //允许。因为所有值类型都隐式有一个公共无参构造函数
6                 return new T();
7             }
8         }

12.9.2 次要约束

一个类型参数可以指定0或者多个次要约束。常见的次要约束主要有两种：

  • 接口约束：类型实参必须实现了指定的所有接口。
  • 类型参数约束：在指定的类型实参之间，存在着一定关系。例如要求存在继承关系
 1         static void M<TBase,T>(TBase tb, T t) where T : TBase {}
 2         static void Main(string[] args)
 3         {
 4             M<Father,Son>(new Father(), new Son());        //comple pass
 5             M<Father, Father>(new Father(), new Father()); //comple pass: 
 6             //Son会隐式转换成Father
 7             M<Father, Father>(new Son(), new Father());    //comple pass: 
 8             //GradeSon会隐式转换成Father
 9             M<Father,Son>(new GradeSun(), new Son());      //comple pass: 
10 
11             //comple ERROR: 
12             //参数 2: 无法从“Generics.Father”转换为“Generics.Son”
13             M<Father, Son>(new GradeSun(), new Father());     
14 
15             //虽然(new Son(), new GradeSun())是继承关系，
16             //但Complie ERROR:
17             //不能将类型“Generics.Father”用作泛型类型或方法“Generics.Program.M<TBase,T>(TBase, T)”中的类型形参“T”。
18             //没有从“Generics.Father”到“Generics.Son”的隐式引用转换。
19             M<Son, Father>(new Son(), new GradeSun());     
20         }

从上述代码中，我们可以看到：类型参数约束是约束<,>中两者关系，而非(,)中国两者关系。

另外，13行代码错误的原因是无法将 new Father() 转换为 <Son>

12.9.3 构造器约束

  • 构造器约束要求类型实参必须实现了无参构造器，而且它不支持有参构造器。
 1     class ClassA { }
 2     class ClassB
 3     {
 4         public ClassB() { }
 5     }
 6     class ClassC 
 7     {
 8         public ClassC(string str) { }
 9     }
10 
11     class Program
12     {
13         static T Create<T>()where T:new()
14         {
15             return new T();
16         }
17 
18         static void Main(string[] args)
19         {
20             ClassA a = Create<ClassA>();   //compile pass
21             ClassB b = Create<ClassB>();   //compile pass
22             ClassC c = Create<ClassC>(""); //Compile ERROR，有参构造器
23             int d = Create<int>();  //compile pass, 值类型有默认无参构造器
24         }
25     }

 


 

参考

[1] 跟小静读CLR via C#(16)--泛型 http://www.cnblogs.com/janes/archive/2011/12/21/2295959.html
[2] 《CLR via C#》读书笔记(7) -- 泛型(上) http://www.cnblogs.com/Code-life/archive/2012/12/20/2823520.html

 

posted @ 2014-06-15 21:37  明-Ming  阅读(371)  评论(0)  编辑  收藏  举报