C#秘密武器之泛型

一、简介:

　　很多初学者在刚开始接触泛型的时候会比较难理解泛型，在这里先把 “泛型”当作一个形容词，这样就方便理解了，因为很多东西都可以是泛型的！比如：“泛型的类”，“泛型的方法”，“泛型的接口”，“泛型的委托” 等，很多时候我们使用泛型可以极大减少代码重复，使程序更加清爽，也可以避免不必要的‘装箱’和‘拆箱’过程。

为什么要有泛型？

　　我们常常会遇到这样的情况：为了实现某一个功能，我们一开始把方法写好，但后来我们发现同样的功能需要我们再写一次，但是这次方法的参数类型和上次不一样了，这个时候按照敏捷软件开发的思想，不要过早的进行抽象和应对变化，当变化第一次出现时，使用最快的方法解决它，但变化第二次出现时，再进行更好的架构设计，这样的目的是为了避免过度设计，因为有可能第二次变化永远也不会出现。考虑到功能一样，我们通常会直接复制原方法的代码，然后修改一下参数类型即可快速解决。这样做确实没错，但是有时候不仅出现了第二次变化 ，还出现了第三次...或者是更多次变化，继续使用CV大法修改方法的签名将会导致大量重复代码的出现，于是我们就会想，要是存在一个可以传递任何数据类型的方法那该多好，即把这个方法的实现当成模板，把方法的签名抽象出来，于是我们引入了泛型。

下面我们来看一下具体的例子：

1.1 使用CV大法

输入多个 int类型，进行冒泡排序让它们依次重小到大输出，代码如下：

    public class SortHelper
    {
        public void BubbleSort(int[] arr)
        {
            int length = arr.Length;
            for (int i = 0; i < length-1; i++)
            {
                for (int j = 0; j < length-1-i; j++)
                {
                    if (arr[j]>arr[j+1])
                    {
                        int temp=arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
        }
    }

 测试:

static void Main(string[] args)
        {
            SortHelper sorter = new SortHelper();
            int[] a = { 4,5,1,3,2,8,5,0,2};
            sorter.BubbleSort(a);
　　　　　　//输出省略
}

 输出为:0,1,2,2,3,4,5,5,8

输入多个 Byte类型，进行冒泡排序让它们依次重小到大输出，代码如下：

这个时候我只要复制一下原来的方法改一下签名就可以了

    public class SortHelper
    {
        public void BubbleSort(byte[] arr)
        {
            int length = arr.Length;
            for (int i = 0; i < length-1; i++)
            {
                for (int j = 0; j < length-1-i; j++)
                {
                    if (arr[j]>arr[j+1])
                    {
                        byte temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
        }
    }

 这样做虽然可以，但是以后若要处理N次各种其它数据类时就要大量重复复制，严重影响代码的简洁度，而且当功能要扩展时，每个方法都要修改，维护起来非常不方便。

 1.2 使用泛型

我们自然而然的会这样想了：如果可以把方法中的参数类型用一个 ”占位符“表示每次传入什么类型它就变成什么类型，这样就可以将这个方法当成一个模板用了。

这里我们用 “T” 来代表这个特殊的参数类型，于是代码就变成了这样：

    public class SortHelper
    {
        public void BubbleSort(T[] arr)
        {
            int length = arr.Length;
            for (int i = 0; i < length-1; i++)
            {
                for (int j = 0; j < length-1-i; j++)
                {
                    if (arr[j]>arr[j+1])
                    {
                        T temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
        }
    }

 这里 T 代表 ”类型的类型“ 和 int ，string ...等数据类型相似，T 就是类型本身。让人兴奋的是真的有像 “T” 这样的特别存在，在.NET中叫做类型参数. 

下面我们看看规范的代码：这里我们把BubbleSort定义成泛型类，定义泛型类的一种方法是在类后面加上“<T>” 

    //定义泛型类SortHelper 这里“where T:IComparable” 是给类型参数T一个限制 -- 参数类型必须实现IComparable接口，否则无法通过编译
    public class SortHelper<T> where T:IComparable
    {
        public void BubbleSort(T[] arr)
        {
            int length = arr.Length;
            for (int i = 0; i < length-1; i++)
            {
                for (int j = 0; j < length-1-i; j++)
                {
                    if (arr[j].CompareTo(arr[j+1])>0)
                    {
                        T temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
        }
    }

 测试:

        static void Main(string[] args)
        {
            SortHelper<byte> sorter = new SortHelper<byte>();
            byte[] a = { 4,5,1,3,2,8,5,0,2};

            sorter.BubbleSort(a);

            SortHelper<int> sorter1 = new SortHelper<int>();
            int[] b = { 4, 5, 1, 3, 2, 8, 5, 0, 2 };
            sorter1.BubbleSort(b);
　　　　　　　//输出省略
        }

 输出为:
0,1,2,2,3,4,5,5,8

0,1,2,2,3,4,5,5,8

输入多个自定义类型的实例，进行冒泡排序让它们依次从小到大输出，下面我们来模拟一下宠物店卖的猫，按价格排序：

猫类：

    public class cat:IComparable
    {
        public string name;
        public int price;

        public int CompareTo(object obj)
        {
            cat catT = (cat)obj;
            return this.price.CompareTo(catT.price);
        }

        public cat(string name, int price)
        {
            this.price = price;
            this.name = name;
        }
    }

 测试:

        static void Main(string[] args)
        {
            SortHelper<cat> sorter2 = new SortHelper<cat>();
            cat cat1=new cat("猫1",1000);
            cat cat2=new cat("猫2",1400);
            cat cat3=new cat("猫3",400);
            cat[] c = { cat1, cat2, cat3 };

            sorter2.BubbleSort(c);
            //输出
            for (int i = 0; i < c.Length; i++)
            {
                Console.WriteLine("Name:"+c[i].name+" Price:"+c[i].price);
            }
        }    

 结果如图:

二、泛型与集合类型

 通过泛型可以大大提高集合类型的的性能恶化安全性。

2.1 非泛型的集合类

先是往集合里存放3个数据 ：

            ArrayList list = new ArrayList();
            int listSize = 3;

            for (int i = 0; i < listSize; i++)
            {
                list.Add(i);
            }

            for (int i = 0; i < listSize; i++)
            {
                int value = (int)list[i];
                Console.WriteLine(value);
            }

 测试：

输出

0

1

2

这样子写虽然能运行通过，但是在这里 list每次调用Add方法时就做了一次 ” 装箱 “ 操作，接着每次取数据时对list的元素进行一次强制转换 (int)list[i]，同时也做了一次 “ 拆箱 ”操作，这两个操作对.NET来说是比较耗时的，当操作的次数越多效果就越明显。

 2.2 下面我们将 listSize 设置成 1000000 ，看看消耗的时间

            ArrayList list = new ArrayList();
            int listSize = 1000000;
            long StarTime = DateTime.Now.Ticks;
            for (int i = 0; i < listSize; i++)
            {
                list.Add(i);
            }

            for (int i = 0; i < listSize; i++)
            {
                int value = (int)list[i];
            }
            long EndTime = DateTime.Now.Ticks;

            Console.WriteLine("使用ArrayList，耗时:{0} Ticks", EndTime - StarTime);

 测试：

结果

 2.3  使用泛型集合类型（泛型数组）

            List<int> list = new List<int>();
            int listSize = 1000000;
            long StarTime = DateTime.Now.Ticks;
            for (int i = 0; i < listSize; i++)
            {
                list.Add(i);
            }

            for (int i = 0; i < listSize; i++)
            {
                int value =list[i];
            }
            long EndTime = DateTime.Now.Ticks;

            Console.WriteLine("使用List<int>，耗时:{0} Ticks", EndTime - StarTime);

 测试：

 比较上述2次执行的结果我们会发现，使用 ArrayList 的耗时是使用 List<int> 的2倍多 ，随着次数的增大差距会越来越明显！

 总结：

1.可以避免同种功能代码的大幅度重复出现，使我们的代码更加简洁、可读性更高

2.方便扩展维护，灵活度高

3.避免隐式的装箱拆箱，提高程序运行速度

三、泛型方法与泛型接口

 3.1 泛型方法

上面说到用一个泛型类 SortHelper 来做一个冒泡排序的处理，现在回顾一下之前的代码：

    public class SortHelper<T> where T:IComparable
    {
        public void BubbleSort(T[] arr)
        {
            int length = arr.Length;
            for (int i = 0; i < length-1; i++)
            {
                for (int j = 0; j < length-1-i; j++)
                {
                    if (arr[j].CompareTo(arr[j+1])>0)
                    {
                        T temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
        }
    }

 这里我们为了调用 BubbleSort，而将参数T传递给类 SortHelper，假如 SortHelper 类中，除了 BubbleSort 方法之外，还有其它的没有使用到参数T的方法 比如：

    public class SortHelper<T> where T:IComparable
    {
        public void BubbleSort(T[] arr)
        {
                //省略
        }
        
        public void OtherMethod1()
        {
                //省略
        }
        //此处省略N个OtherMethod
    }

 这里有 N 个 OtherMethod方法。

 测试调用 OtherMethod1： 

        static void Main(string[] args)
        {
            SortHelper<int> UserOtherMethod = new SortHelper<int>();
            UserOtherMethod.OtherMethod1();
        }

 在实例化 UserOtherMethod 对象时，必须给 SortHelper 传一个类型参数，这里是 int  。显然这种情况下，我们仅仅是为了 BubbleSort 方法能够正常使用而定义泛型类，但是却强迫调用 SortHelper 类其它方法的实例也传递这样一个参数，很明显这是没必要的，于是这个时候 ’泛型方法‘ 就出现了 ，修改代码如下：

    public class SortHelper2
    {
        public void BubbleSort<T>(T[] arr) where T:IComparable
        {
            int length = arr.Length;
            for (int i = 0; i < length - 1; i++)
            {
                for (int j = 0; j < length - 1 - i; j++)
                {
                    if (arr[j].CompareTo(arr[j + 1]) > 0)
                    {
                        T temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
        }
    }

 总结：

 泛型方法和普通方法没多大区别，仅仅在方法名后面加了“<T>”， 接着是括号里面的参数，最后是限定语句。

 上述的这种情况，我们通过使用泛型方法，就可以避免每次使用泛型类传参了。

 3.2  泛型接口

 回顾前面我们自己写了一个 “cat” 类，并调用了一个接口“IComparable” ，代码如下：

    public class cat:IComparable
    {
        public string name;
        public int price;

        public int CompareTo(object obj)
 　　　　{

　　　　　　cat catT = (cat)obj;
　　　　　　return this.price.CompareTo(catT.price);
 　　　　}

　　　　　public cat(string name, int price)
        {
            this.price = price;
            this.name = name;
        }
    }

 这里粉红色标记的部分我们实现了 “IComparable” 接口的 “CompareTo” 方法，这里没有进行装箱和拆箱。因为cat是引用类型，而且“ return this.price.CompareTo(catT.price) ”这里调用的是 price (int型) 的 ComparaTo 方法，右键对int转到定义查看代码。这里可以清楚的看到int类型实现了 IComparable 与 IComparable<int> 这两个接口，也就是说它分别实现了这两个接口的 ComparaTo() 方法,那这里又是调用哪个接口的 ComparaTo() 方法呢？

 实际上这里传过来的参数是int型，那么优先调用的是 ComparaTo(int value) 方法，这样就避免了不必要的拆装箱了。

     上图中是.NET 中 int 类型实现 IComparable 接口的 ComparaTo(object value) 方法，不难看出“红箭头”标记部分是执行装箱拆箱操作的过程。

     下图是 int类型实现泛型版本的 IComparable<int> 的 ComparaTo(int value) 方法，如果对2种方法进行大量重复操作，不难发现使用泛型接口实现的方法性能比较好。

 总结：

 程序设计中应该尽量避免装箱和拆箱操作，为了避免多次装箱拆箱造成的性能影响 ，通过上面的例子我们可以知道使用泛型接口可以有效的避免这个问题：使用 IComparable<T> 而不使用 IComparable，这样可以避免值类型的装箱和取消装箱操作。

四、 泛型的协变和逆变以及常用的接口IEnumerable 及其泛型版的IEnumerable<out T>

 4.1 泛型的协变与逆变|泛型修饰符‘out’与‘in’

       首先这2个拗口的名词先不用去管它，先知道协变和逆变主要是用在泛型的接口和委托上就可以了，下面我们通过一个例子来看看。在这之前我们插点别的东西，我们知道接口是可以体现多态的，当然接口体现的多态注重的功能上的多态，这和抽象类不同，抽象类更注重的是建立在血缘关系上的多态。

知道接口是可以体现多态的之后，我们来看看一个相关的例子：鸟和飞机都会飞，把飞定义成一个借口，在定义2个类

    public interface IFlyable
    {
        void fly();
    }
    class Bird:IFlyable
    {
        public void fly()
        {
            Console.WriteLine("鸟儿飞！");
        }
    }
    class Plane:IFlyable
    {
        public void fly()
        {
            Console.WriteLine("飞机飞！");
        }
    }

 下面看看接口体现的多态性:

            IFlyable ifly; 
            
            ifly = new Bird();
            ifly.fly();

            ifly = new Plane();
            ifly.fly();

运行结果:

鸟儿飞！

飞机飞！

 了解了接口的多态性后我们再来看一个例子：

这里定义了2个类 Animal 和 Cat （Cat继承了Animal）

    public class Animal
    {
    }

    public class Cat:Animal
    {
    }

 继续往下看：

Cat cat = new Cat();

 下面这句代码，cat向animal转，子类向父类转换，这时cat会隐式转换为animal 我们说“儿子像父亲” 这是完全可以理解的

Animal animal = cat;

 但是 说”父亲像儿子“ 这是说不过去的 ，但是有的时候如果儿子坑爹，强制转换了一下还是可以的

cat = (Cat)animal;

 (协变)

            List<Cat> catArray = new List<Cat>();
            List<Animal> animalArray = catArray;

如果是上面说的类，这样写是可以的，但是这里是会报错的  如图

继续往下看 这样写却可以

            IEnumerable<Cat> lCat = new List<Cat>();
            IEnumerable<Animal> lAnimal = lCat;

对 IEnumerable<Cat> 转到定义 如图 我们发现这里多了一个 “out” 关键字

概念引入：

       对于泛型类型参数，out 关键字指定该类型参数是协变的。 可以在泛型接口和委托中使用 out 关键字。“协变”是指能够使用与原始指定的派生类型相比，派生程度更大的类型。对于 “协变”， 笔者是这样理解的：就是”说的通变化“ ，就像 “儿子像父亲一样”（假定父亲派生程度0那么儿子的派生程度就是1了，所以父亲可以使用派生程度更大的儿子）

 (逆变)

我们知道IComparable<T>接口中，T的修饰符是‘in’，下面我们修改一下上面的代码演示一下 ：

    class Cat : Animal, IComparable<Cat>
    {
        //仅演示
        public int CompareTo(Cat other)
        {
            return 1;
        }
    }

    class Animal : IComparable<Animal>
    {
        //仅演示
        public int CompareTo(Animal other)
        {
            return 1;
        }
    }

 这里Cat和Animal都实现了IComparable<T>接口，然后我们这样写

            IComparable<Cat> ICat = new Cat();
            IComparable<Animal> IAnimal = new Animal();
            ICat = IAnimal;

代码中ICat（高派生程度）使用 IAnimal(低派生程度) “父亲像儿子” 和上面的例子完全相反。

概念引入：

       对于泛型类型参数，in 关键字指定该类型参数是逆变的。 可以在泛型接口和委托中使用 in 关键字。“逆变”则是指能够使用派生程度更小的类型。对于 “逆变” 笔者的理解则是： “坑爹儿子” 反过来硬说 “父亲像儿子”， 这是 “说不过去的” ，只是利用了强硬的手段。

 在了解了上面的内容后，我们来看看“out” 与 “in” 关键字的特性

IEnumerable<T>接口的IEnumerator<T> GetEnumerator()方法返回了一个迭代器 ，不难发现T如果用 out 标记，则T代表了输出，也就说只能作为结果返回。

IComparable<T>接口的CompareTo(T other)方法传入了一个T类型的Other参数，不难发现T如果用 in 标记，则T代表了输入，也就是它只能作为参数传入。

下面我们演示一个例子

将动物会叫这功能，定义成一个泛型借口用 out 修饰

这里会出现一个错误

把第二个带参数的setSound方法，去掉后编译可以正常通过

下面我们把 out 改成 in

这里会出现一个错误

把第一个setSound方法，去掉后编译可以正常通过，或者把第一个方法的返回值，改成其它非T类型，编译也可通过

这个演示充分说明了：out 修饰 T 则 T只能作为结果输出而不能作为参数  ； in 修饰 T 则 T只能作为参数而不能作为结果返回；

 4.2  IEnumerable接口及其泛型版

为什么要用IEnumerable接口? 下面我们通过一个例子看看：

    //定义Person类
    public class Person
    {
        public Person(string _name)
        {
            this.name = _name;
        }

        public string name;
    }

    //定义People类
    public class People
    {
        private Person[] _people;

        public People(Person[] pArray)
        {
            //实例化数组 用于存Person实例
            _people = new Person[pArray.Length];

            for (int i = 0; i < pArray.Length; i++)
            {
                _people[i] = pArray[i];
            }
        }
    }

上面的代码我们定义了一个 Person 类和一个 People 类，显然 People是用来存放多个Person实例的集合，下面我们尝试用 Foreach 遍历集合的每个元素输出:

        static void Main(string[] args)
        {
            Person[] personArray = new Person[3]{
            new Person("Keiling1"),
            new Person("Keiling2"),
            new Person("Keiling3"),
            };

            People people = new People(personArray);
            foreach (Person item in people)
            {
                Console.WriteLine(item.name);
            }
        }

这里编译不能通过，出现了一个错误

GetEnumerator:是IEnumerable接口中的一个方法,它返回一个 IEnumerator（迭代器）,如下图 

IEnumerator内部规定了，实现一个迭代器的所有基本方法，包括 如下图

为了在foreach中使用 People的实例， 我们给People实现IEnumerable接口，代码如下：

    public class People:IEnumerable
    {
        private Person[] _people;

        public People(Person[] pArray)
        {
            //实例化数组 用于存Person实例
            _people = new Person[pArray.Length];

            for (int i = 0; i < pArray.Length; i++)
            {
                _people[i] = pArray[i];
            }
        }

////IEnumerable和IEnumerator通过IEnumerable的GetEnumerator()方法建立了连接，可以通过IEnumerable的GetEnumerator()得到IEnumerator对象。
        IEnumerator IEnumerable.GetEnumerator()
        {
            return (IEnumerator)GetEnumerator();
        }

        public PeopleEnum GetEnumerator()
        {
            return new PeopleEnum(_people);
        }
    }

    public class PeopleEnum:IEnumerator
    {
        public Person[] _people;

        public PeopleEnum(Person [] pArray)
        {
            _people = pArray;
        }
        //游标
        int position = -1;

        //是否可以往下 移
        public bool MoveNext()
        {
            position++;
            return (position < _people.Length);
        }

        //集合的所有元素取完了之后 重置position
        public void Reset()
        {
            position = -1;
        }

        //实现 IEnumerator的 Current方法 返回当前所指的Person对象
        object IEnumerator.Current
        {
            get
            {
                return Current;
            }
        }

        //Current是返回Person类实例的只读方法
        public Person Current
        {
            get
            {
                try
                {
                    return _people[position];
                }
                catch (IndexOutOfRangeException)
                {
                    throw new InvalidOperationException();
                }
            }
        }
    }

测试运行：

        static void Main(string[] args)
        {
            Person[] personArray = new Person[3]{
            new Person("Keiling1"),
            new Person("Keiling2"),
            new Person("Keiling3"),
            };

            People people = new People(personArray);
            foreach (Person item in people)
            {
                Console.WriteLine(item.name);
            }
        }

结果：

总结:

1.一个集合要支持foreach方式的遍历，必须实现IEnumerable接口，描述这类实现了该接口的对象，我们叫它‘序列’。

比如 List<T> 支持 foreach 遍历 是因为它实现了IEnumerable接口和其泛型版，如图--

 

2. IEnumerator对象具体实现了迭代器（通过MoveNext()，Reset()，Current）。

3. 从这两个接口的用词选择上，也可以看出其不同：IEnumerable是一个声明式的接口，声明实现该接口的class是“可枚举（enumerable）”的，但并没有说明如何实现迭代器，而IEnumerator是一个实现式的接口，IEnumerator对象就是一个迭代器。 

 关于IEnumerable<T>我们来了解一下它的代码:

 

4.由于IEnumerable<T>继承了IEnumerable接口，所以要实现IEnumerator<T> ，还需要实现IEnumerator接口，由于和泛型版本的方法同名，所以该方法的实现需要使用显式接口实现。这里就不继续介绍它的具体实现了，和IEnumerator基本一致，这里就不详述了，读者可以自己动手写一下。

 

ps 了解IEnumerable和IEnumerable<T>对理解LINQ是有很大帮助的。