《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 >为例：

using System.Collections.Generic;

namespace Generics
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> num = new List<int>();
            num.Add(1);
            num.Add(3);
            int num1 = num[0];
            int num2 = num[1];
        }
    }
}

尖括号中的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>();

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

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

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

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

上述代码运行时，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关键字标记。协变参数只出现的输出位置，比如作为方法的返回类型。

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

逆变量代码： 

using System;
using System.Collections.Generic;

namespace Generics
{
    class Animal{}
    class Dog : Animal{}
    class Program
    {
        public delegate void Feed<in T>(T target);
        static public void FeedAnimal(Animal target)
        {
            Console.WriteLine("Feed Animal");
        }

        static void Main(string[] args)
        {
            //先声明一个T为Animal的委托 
            Feed<Animal> feedAnimalMethod = FeedAnimal;
            //将T为Animal的委托赋值给T为Dog的委托变量，这是合法的，因为在定义泛型委托时有in关键字，如果把in关键字去掉，编译器会认为不合法 
            Feed<Dog> feedDogMethod = feedAnimalMethod;
            feedDogMethod(new Dog());
        }
    }
}

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

协变量代码：

using System;
using System.Collections.Generic;

namespace Generics
{
    class Animal{}
    class Dog : Animal{}
    class Program
    {
        public delegate T Get<out T>();
        static public Dog GetDog()
        {
            return new Dog();
        }

        static void Main(string[] args)
        {
            //先声明一个T为Animal的委托 
            Get<Dog> GetDogMethod = GetDog;
            //并将findDog赋值给findAnimal是合法的，类型T从Dog向Animal转变是协变
            Get<Animal> GetAnimalMethod = GetDogMethod;
            GetAnimalMethod();
            Console.WriteLine(GetAnimalMethod() is Dog);
        }
    }
}

 上述代码：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>：

    class Program
    {
        static void Swap<T>(ref T o1, ref T o2)
        {
            T temp = o1;
            o1 = o2;
            o2 = temp;
        }
       

        static void Main(string[] args)
        {
            int i1 = 1;
            int i2 = 2;
            Swap<int>(ref i1, ref i2);
            string s1 = "a";
            string s2 = "b";
            Swap(ref s1, ref s2); 
        }
    }

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

12.9 可验证性合约束

---

 返回  

12.9.1 主要约束

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

class Constraint1<T> where T : Stream
{
     public void Close(T stream)
     {
         stream.Close();
     }
}

class Program
{
     static void Main(string[] args)
     {
         Constraint1<FileStream> s2 = new Constraint1<FileStream>();
     }
}

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

• class约束：要求指定的类型实参必须是引用类型。Where T:class

        class ConstraintClass<T> where T : class
        {
            void M()
            {
                T temp = null;
            }
        }

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

• Struct 约束：要求指定的类型实参必须是值类型。Where T:struct

        class ConstraintStruct<T> where T : struct
        {
            static T M()
            {
                //允许。因为所有值类型都隐式有一个公共无参构造函数
                return new T();
            }
        }

12.9.2 次要约束

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

• 接口约束：类型实参必须实现了指定的所有接口。
• 类型参数约束：在指定的类型实参之间，存在着一定关系。例如要求存在继承关系

        static void M<TBase,T>(TBase tb, T t) where T : TBase {}
        static void Main(string[] args)
        {
            M<Father,Son>(new Father(), new Son());        //comple pass
            M<Father, Father>(new Father(), new Father()); //comple pass: 
            //Son会隐式转换成Father
            M<Father, Father>(new Son(), new Father());    //comple pass: 
            //GradeSon会隐式转换成Father
            M<Father,Son>(new GradeSun(), new Son());      //comple pass: 

            //comple ERROR: 
            //参数 2: 无法从“Generics.Father”转换为“Generics.Son”
            M<Father, Son>(new GradeSun(), new Father());     

            //虽然(new Son(), new GradeSun())是继承关系，
            //但Complie ERROR:
            //不能将类型“Generics.Father”用作泛型类型或方法“Generics.Program.M<TBase,T>(TBase, T)”中的类型形参“T”。
            //没有从“Generics.Father”到“Generics.Son”的隐式引用转换。
            M<Son, Father>(new Son(), new GradeSun());     
        }

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

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

12.9.3 构造器约束

• 构造器约束要求类型实参必须实现了无参构造器，而且它不支持有参构造器。

    class ClassA { }
    class ClassB
    {
        public ClassB() { }
    }
    class ClassC 
    {
        public ClassC(string str) { }
    }

    class Program
    {
        static T Create<T>()where T:new()
        {
            return new T();
        }

        static void Main(string[] args)
        {
            ClassA a = Create<ClassA>();   //compile pass
            ClassB b = Create<ClassB>();   //compile pass
            ClassC c = Create<ClassC>(""); //Compile ERROR，有参构造器
            int d = Create<int>();  //compile pass, 值类型有默认无参构造器
        }
    }

 

参考

[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