第十二章 泛型
2014-06-15
初识泛型[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 }
![](https://i-blog.csdnimg.cn/blog_migrate/a1d40ca6abf99bcd059336fa96c22aa0.png)
尖括号中的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 }
![](https://i-blog.csdnimg.cn/blog_migrate/5e66c9605cf0be389b94b23a5d40976b.png)
注意:类型推断时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