《C# in Depth：深入理解C#》读书笔记 - 泛型

最新推荐文章于 2018-10-29 09:41:38 发布

装逼是种天赋@#E@$

最新推荐文章于 2018-10-29 09:41:38 发布

阅读量1.3k

点赞数

分类专栏： C# 深入装逼

C# 深入装逼专栏收录该内容

26 篇文章 3 订阅

订阅专栏

理解C#泛型

在C# 2.0中引入了泛型，泛型的出现解决了编码中的很多问题。相信大家一定经常用到"System.Collections.Generic"命名空间中的泛型集合类（"Generic"就是泛型的意思）。在C# 1.0中，我们还在使用"System.Collections"命名空间中的非泛型集合类，那么看看我们在没有泛型的时候遇到的问题。

问题1：强制类型转换

ArrayList stuList = new ArrayList();
Student wilber = new Student { Name = "Wilber", Age = 27, Gender = "Male" };
stuList.Add(wilber);
Student stu = (Student)stuList[0];
stuList.Add(10);

在使用非泛型集合ArrayList时，所有的对象都是以object类型加入ArrayList，当对象从ArrayList取出的时候也是object类型，这时我们就需要进行强制类型转换，如果转换不当，就会得到一个运行时的错误；即使我们向ArrayList添加不同类型的对象时，也不会报错（例如上面向stuList中加入了一个int值）。

问题2：装箱和拆箱

在上面的例子中，如果我们使用ArrayList存放一组值类型的数据（例如一组int值），存入时，每个值类型的数据都要进行装箱为object类型；取出时，每个object类型的数据又要进行拆箱操作。

可以看到，在使用非泛型集合的时候，用户需要自己进行类型转换，并且可能遇到运行时的类型转换异常；同时，对于值类型的操作，非泛型集合会有装箱和拆箱带来的效率问题。

泛型的出现

对于上面的问题，我们可以使用C# 2.0中的泛型集合。

这样一来，我们就通过类型参数（例子中的Student）来限制List可以包含的实例类型，从而避免的强制类型转换。

同时，通过类型参数，编译器可以进行类型检查，当试图往List中存入一个与类型参数不匹配的对象的时候，编译器就是给出错误提示。

List<Student> stuList = new List<Student>();
Student wilber = new Student { Name = "Wilber", Age = 27, Gender = "Male" };
stuList.Add(wilber);
Student stu = stuList[0];
stuList.Add(10);

泛型中的术语

下面我们看看泛型中的一些概念和术语。

泛型有两种表现形式：泛型类型（包括类、接口、委托和结构，没有泛型枚举）和泛型方法。在泛型类型和泛型方法中都会有类型参数，当通过泛型类型实例化对象或者对泛型方法调用的时候，都需要使用一个真实的类型来代替类型参数。

类型参数是真实类型的占位符，在泛型声明过程中，所有的类型参数放在一对间括号中（<>），通过逗号分隔。

泛型类型

根据类型参数不同的指定类型实参的情况，泛型类型可以分为：

如果没有为类型参数提供类型实参，那么声明的就是一个未绑定泛型类型（unbound generic）
如果指定了类型实参，该类型就称为 已构造类型（constructed type），然而已构造类型又可以是开放类型或封闭类型的
- 包含类型参数的类型就是开放类型（open type）（所有的未绑定的泛型类型都属于开放类型的），
- 每个类型参数都指定了类型实参就是封闭类型（closed type）

类型是对象的蓝图，我们可以通过类型来实例化对象；那么对于泛型来说，未绑定泛型类型是以构造泛型类型的蓝图，已构造泛型类型又是实际对象的蓝图。

下图就是一个简单的例子，Dictionary<TKey, TValue>就是一个泛型类型（未绑定泛型类型，开放类型）；通过制定类型参数，可以得到不同的封闭类型；通过不同的封闭类型有可以构造不同的实例。

泛型方法

我们都已经习惯了方法的参数和返回值拥有固定的类型，这里就看看“参数化”的方法。对于泛型方法，可以理解为拥有类型参数的方法。

对于上面例子中Dictionary<TKey, TValue>这个泛型类型，有很多方法可以使用，例如：

void Add(TKey, key, TValue value)
bool ContainsValue(TValue value)
bool ContainsKey(TKey key)

注意，这些方法中没有一个是真正的泛型方法，他们只是使用了泛型类型的类型参数。

真正的泛型方法应该拥有自己的类型参数，当我们使用泛型方法的时候，要给泛型方法的类新参数指定类型实参，接下来看一个泛型方法的例子。

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("The bigger one is {0}", GetBiggerOne<int>(3,9));
        Console.WriteLine("The bigger one is {0}", GetBiggerOne<string>("Hello", "World"));

        Console.Read();
    }

    public static T GetBiggerOne<T>(T itemOne, T itemTwo) where T : IComparable
    {
        if (itemOne.CompareTo(itemTwo) > 0)
        {
            return itemOne;
        }
        return itemTwo;
    }
}

在上面的例子中，我们使用泛型方法来实现一个两个元素比较的例子，我们看到方法"GetBiggerOne"拥有自己的类型参数，当我们看到一个泛型方法时，可以一步步用真实的类型替换泛型方法中的类型参数，这样就会简化我们的分析。

对于泛型的类型约束，将在下面一篇文章介绍。

泛型的优点

根据上面的分析，可以看到泛型有一些的优点：

代码重用
- 泛型提供的代码的重用，确切的说应该是 "逻辑和算法的重用"。从前面的泛型方法例子可以看到，通过泛型可以避免为每种特定的类型实现一个比较方法。
类型安全
- 泛型类型保证了类型安全，可以在编译期就发现类型不匹配的问题，而不是等到运行时
效率
- 避免值类型的装箱和拆箱引起的效率问题（后面会简单介绍为什么泛型可以避免装箱和拆箱）

总结

泛型的出现，给我们带来了很多好处，泛型实现了类型和方法的"参数化"。

基于泛型，我们可以实现代码重用，并且泛型为我们提供了类型安全检查。对于值类型的操作，通过泛型可以避免装箱和拆箱带来的性能损失。

同样C# 2.0 以后，就建议只在代码中使用支持泛型的集合类了（System.Collections.Generic）。

泛型中的类型约束和类型推断

前一篇文章介绍了泛型的基本概念。在本文中，我们看一下泛型中两个很重要的特性：类型约束和类型推断。

类型约束

相信你还记得前面一篇文章中的泛型方法，在这个泛型方法中，我们就使用了类型约束。

类型约束（type constraint）进一步控制了可指定的类型实参，当我们创建自己的泛型类型或者泛型方法的时候，类型约束是很有用的。

回到前一篇例子中的泛型方法，这个泛型方法就要求可指定的类型实参必须实现了IComparable接口。

为什么会有这个约束呢？原因很简单，因为我们在泛型方法的实现中直接调用T类型的"CompareTo"方法。所以，我们需要通过一个约束来保证T类型都有"CompareTo"方法，也就是说我们要指定的类型实参T要实现IComparable接口。

public static T GetBiggerOne<T>(T itemOne, T itemTwo) where T : IComparable
{
    if (itemOne.CompareTo(itemTwo) > 0)
    {
        return itemOne;
    }
    return itemTwo;
}

经过上面的解释，大家肯定对约束有了简单的认识。

在类型约束中，有四种约束可供使用，他们的语法都是基本相同的，约束要放到泛型类型或泛型方法的末尾，并由上下文关键字where来引入。同时，约束也可以按照一定的规则组合在一起使用。

下面我们就分别看看可供我们使用的四种类型约束。

引用类型约束

引用类型表示为T : class，用于确保指定的类型实参都是引用类型（任何类，接口，数组或委托，以及已知为引用类型的另一个类型参数）。

如果使用引用类型约束，那么它必须是为类型参数指定的第一个约束。

一个简单的示例，例如对于下面的声明：

struct RefSample<T> where T : class { }

有效的封闭类型：

RefSample<string>
RefSample<IDisposable>

无效的封闭类型：

RefSample<int>
RefSample<double>

值类型约束

跟引用类型约束形式类似，值类型约束表示为T : struct，用于确保指定的类型实参都是值类型。

同样，如果使用值类型约束，那么它必须是为类型参数指定的第一个约束。

例如对于下面的声明：

class ValSample<T> where T : struct { }

有效的封闭类型：

ValSample <int>

无效的封闭类型：

ValSample <string>

构造函数类型约束

构造函数类型约束表示为T : new()，用于确保所有的类型参数有一个无参数的构造函数，这个构造函数可用于创建类型的实例。这适用于：所有值类型；所有非静态、非抽象、没有显示声明的构造函数的类；显示声明了一个公共无参构造函数的所有非抽象类。

如果使用构造函数类型约束，那么它必须是为类型参数指定的最后一个约束。

下面用一个例子进行简单的说明：

public T CreateInstance<T>() where T : new()
{
    return new T();
}

这次例子中是一个泛型方法，约束我们指定的类型实参必须拥有无参数的构造函数，在这种情况下，这个泛型方法就可以返回该类型的一个实例。

所有下面都是有效的调用：

CreateInstance<int>()
CreateInstance<object>()

注意，在C#中，所有的值类型都有一个默认的无参数构造函数，所以当我们使用一些组合约束的时候，C#编译器就会报出一个错误，因为这样的指定是多余的，所有值类型都隐式提供一个无参公共构造函数。

public T CreateInstance<T>() where T: struct, new()

转换类型约束

转型类型约束允许我们指定另一个类型，类型实参必须可以通过一致性、引用或装箱转换隐式的转换为改类型。

根据上面的描述，可以看到转换类型约束可以有以下一些表示：

T : <基类名>，类型参数必须是指定的基类或派生自指定的基类
T : <接口名>，类型参数必须是指定的接口或实现指定的接口；可以指定多个接口约束；约束接口也可以是泛型的
T : U，用于指定T的类型实参必须是用于指定U的类型实参或者派生自用于指定U的类型实参

下面看几个例子：

class Sample<T> where T: Stream

有效：Sample<Stream>

无效：Sample<string>

class Sample<T> where T: IDisposable

有效：Sample<SqlConnection >

无效：Sample<StringBuilder>

class Sample<T,U> where T: U

有效：Sample<Stream,IDispsable>

无效：LSample<string,IDisposable>

组合约束

组合约束就是将前面提到的多种约束集合起来使用。

对于一个类型参数，我们可以使用where关键字进行多个约束；对于不同的类型参数，可以有不同的约束，它们分别由单独的where关键字引入。

在组合约束中，有很多组合情况是无效的，下面看一下例子：

class Sample<T> where T: class, struct
- 没有任何类型即时引用类型又是值类型的，所以这样的组合是无效的
class Sample<T> where T: Stream, class
- 引用类型约束应该为第一个约束，所以这样的组合无效的（同样，如果使用值类型约束，也必须是第一个）
class Sample<T> where T: new(), Stream
- 构造函数约束必须放在最后面，所以这样的组合无效的
class Sample<T> where T: IDisposable, Stream
- 如果存在多个转换类型约束，并且其中一个为类，那么它应该出现在接口的前面
class Sample<T> where T: XmlReader, IComparable, IComparable
- 对于转换类型约束，同一个接口不能出现多次
class Sample<T,U> where T: struct where U:class, T
- 类型形参"T"具有"struct"约束，因此"T"不能用作"U"的约束
class Sample<T,U> where T:Stream, U:IDisposable
- 不同的类型参数可以有不同的约束，它们必须分别由单独的where关键字引入

类型推断

在调用泛型方法的时候，我们都需要通过"<>"来指定类型实参，就会显得代码比较复杂、冗余。其实，根据方法调用时传递的实参类型，可以比较容易的推断出泛型方法的类型参数应该是什么。

所以，编译器就添加了一些"智能"，帮我们推断泛型方法的类型参数，这样我们在方法调用的时候就可以不用显示的声明类型实参。

注意，类型推断只适用于泛型方法。

看一个简单的类型推断的例子：

class Program
{
    static void Main(string[] args)
    {
        //Console.WriteLine("The bigger one is {0}", GetBiggerOne<int>(3, 9));
        //Console.WriteLine("The bigger one is {0}", GetBiggerOne<string>("Hello", "World"));
        //让编译器进行类型推断
        Console.WriteLine("The bigger one is {0}", GetBiggerOne(3, 9));
        Console.WriteLine("The bigger one is {0}", GetBiggerOne("Hello", "World"));

        Console.Read();
    }

    public static T GetBiggerOne<T>(T itemOne, T itemTwo) where T : IComparable
    {
        if (itemOne.CompareTo(itemTwo) > 0)
        {
            return itemOne;
        }
        return itemTwo;
    }
}

总结

本文中介绍了泛型中的类型约束和类型推断特性。

在我们使用自定义的泛型类型和泛型方法的时候，如果我们已经发现需要进行一些约束，最好就是直接在声明泛型类型和方法的时候把约束加上。同时应该注意组合约束中的一系列无效的约束组合。

对于类型推断，这个特性只适合泛型方法，可以简化我们调用泛型方法时显示的声明类型实参。

深入理解C#泛型

前面两篇文章介绍了C#泛型的基本知识和特性，下面我们看看泛型是怎么工作的，了解一下泛型内部机制。

泛型内部机制

泛型拥有类型参数，通过类型参数可以提供"参数化"的类型，事实上，泛型类型的"类型参数"变成了泛型类型的元数据，"运行时"在需要的时候会利用他们构造恰当的类型，通过这些类型，我们有可以实例化不同类型的对象。也就是说，未绑定泛型类型是以构造泛型类型的蓝图，已构造泛型类型又是实际对象的蓝图。

分析泛型IL代码

下面看一个例子，在这个例子中定义了一个用于比较的泛型类和一个比较int的非泛型类：

namespace GenericTest
{
    class CompareUtil<T> where T: IComparable
    {
        public T ItemOne { get; set; }
        public T ItemTwo { get; set; }

        public CompareUtil(T itemOne, T itemTwo)
        {
            this.ItemOne = itemOne;
            this.ItemTwo = itemTwo;
        }

        public T GetBiggerOne()
        {
            if (ItemOne.CompareTo(ItemTwo) > 0)
            {
                return ItemOne;
            }
            return ItemTwo;
        }
    }

    class IntCompareUtil
    {
        public int ItemOne { get; set; }
        public int ItemTwo { get; set; }

        public IntCompareUtil(int itemOne, int itemTwo)
        {
            this.ItemOne = itemOne;
            this.ItemTwo = itemTwo;
        }

        public int GetBiggerOne()
        {
            if (ItemOne.CompareTo(ItemTwo) > 0)
            {
                return ItemOne;
            }
            return ItemTwo;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            CompareUtil<int> compareInt = new CompareUtil<int>(3, 6);
            int bigInt = compareInt.GetBiggerOne();

            IntCompareUtil intCompareUtil = new IntCompareUtil(4, 7);
            int big = intCompareUtil.GetBiggerOne();

            Console.Read();
        }
    }
}

首先，通过ILSpy查看一下泛型类"CompareUtil<T>"的IL代码（只列出了一部分IL代码）

.class private auto ansi beforefieldinit GenericTest.CompareUtil`1<([mscorlib]System.IComparable) T>
    extends [mscorlib]System.Object
{
……
.method public hidebysig specialname rtspecialname 
        instance void .ctor (
            !T itemOne,
            !T itemTwo
        ) cil managed 
    {……}
    ……
    // Properties
    .property instance !T ItemOne()
    {
        .get instance !0 GenericTest.CompareUtil`1::get_ItemOne()
        .set instance void GenericTest.CompareUtil`1::set_ItemOne(!0)
    }
    .property instance !T ItemTwo()
    {
        .get instance !0 GenericTest.CompareUtil`1::get_ItemTwo()
        .set instance void GenericTest.CompareUtil`1::set_ItemTwo(!0)
    }

} // end of class GenericTest.CompareUtil`1

大家可以查看非泛型类"IntCompareUtil"的IL代码，你会发现泛型类的IL代码跟非泛型类的IL代码基本一致，只是泛型类的IL代码中多了一些类型参数元数据。

下面看看泛型类IL代码中的几个特殊点：

GenericTest.CompareUtil`1<([mscorlib]System.IComparable) T>
- `1表示元数，也就是类型参数的数量
- <([mscorlib]System.IComparable) T>就是我们加在泛型类型上的类型约束
!T和!0
- !T就是类型参数的占位符
- !0代表第一个类型参数（当泛型的元数为2时，!1就代表第二个类型参数）

同时，大家也可以比较一下泛型类和非泛型类的实例构造IL代码

IL_0003: newobj instance void class GenericTest.CompareUtil`1<int32>::.ctor(!0, !0)

IL_0012: newobj instance void GenericTest.IntCompareUtil::.ctor(int32, int32)

泛型机制

根据上面的分析可以得到， C#泛型能力有CLR在运行时支持，编译器在处理泛型的时候做了两件事情：

当编译器遇到"CompareUtil<T>"这种泛型代码时，编译器会把泛型代码编译为IL代码和元数据时，采用特殊的占位符来表示类型参数
而真正的泛型实例化工作以"on-demand"的方式，也就是说当编译器遇到"CompareUtil<int> compareInt"指定类型实参的代码时，根据类型实参JIT将泛型类型的IL转换成本机代码，这个本地代码中已经使用了实际的数据类型，等同于用实际类型声明的类

值类型和引用类型的实例化

JIT为所有类型参数为"引用类型"的泛型类型产生同一份本机代码，之所以能这么做，是由于所有的引用具有相同的大小。

但是如果类型参数为"值类型"，对每一个不同的"值类型"，JIT将为其产生一份独立的本机代码。

至于说为什么使用泛型类可以避免值类型的装箱和拆箱操作：

List<int> intList = new List<int>();

相信大家看到下面的IL代码就明白了，在泛型类中，都是通过类型参数直接使用值类型。

// Fields
.field private !T[] _items

对泛型类型使用typeof

在C#中，我们经常使用typeof操作符来获得一个System.Type对象的引用。

对于泛型类型，我们也可以通过两种方式使用typeof：

获取泛型类型定义（未绑定泛型类型）
- 为了获取泛型类型的定义，只需要提供声明的类型名称，删除所有的类型参数，但保留逗号
获取特定的已构造类型（也就是获取封闭类型的类型引用）
- 只需要指定类型实参

下面看一个简单的例子，

static void DemonstrateTypeOf<T>()
{
    Console.WriteLine(typeof(T));

    Console.WriteLine(typeof(List<>));
    Console.WriteLine(typeof(Dictionary<,>));

    Console.WriteLine(typeof(List<T>));
    Console.WriteLine(typeof(Dictionary<string, T>));

    Console.WriteLine(typeof(List<long>));
    Console.WriteLine(typeof(Dictionary<string, int>));
}

函数的输出如下：

System.Double
System.Collections.Generic.List`1[T]
System.Collections.Generic.Dictionary`2[TKey,TValue]
System.Collections.Generic.List`1[System.Double]
System.Collections.Generic.Dictionary`2[System.String,System.Double]
System.Collections.Generic.List`1[System.Int64]
System.Collections.Generic.Dictionary`2[System.String,System.Int32]

通过输出的结果，我们也可以看到每个泛型的元数，以及泛型类型（未绑定泛型类型和封闭类型）的类型。

静态字段和静态构造函数

泛型中的静态字段

在C#中，类的静态成员变量在不同的类实例间是共享的，并且可以通过类名访问。C# 2.0中引入了泛型，导致静态成员变量的机制出现了一些变化：静态成员变量在相同封闭类型间共享，不同的封闭类型间不共享。这也非常容易理解，因为不同的封闭类型虽然有相同的类名称，但由于分别传入了不同的数据类型，他们是完全不同的类型。

看一个简单的例子：

namespace GenericTest
{
    class TypeWithField<T>
    {
        public static string field;
        public static void PrintField()
        {
            Console.WriteLine(field);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            TypeWithField<int>.field = "Int Field";
            TypeWithField<string>.field = "String Field";

            TypeWithField<int>.PrintField();
            TypeWithField<string>.PrintField();

            Console.Read();
        }
    }
}