C#泛型（一）

简介:

　　先看看泛型的概念--“通过参数化类型来实现在同一份代码上操作多种数据类型。利用“参数化类型”将类型抽象化，从而实现灵活的复用”。

　　很多初学者在刚开始接触泛型的时候会比较难理解 “泛型” 在这里先把 “泛型”当作一个形容词 这样比较方便理解 因为很多东西都可以是泛型的 比如--

“泛型的类” ，“泛型的方法”，“泛型的接口”，“泛型的委托” 等...很多时候我们使用泛型可以极大减少代码重复使程序更加清爽，也可以避免不必要的‘装箱’ ‘拆箱’过程。

<泛型的引入|为什么要有泛型？>

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

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

1.普通的写法：

-输入多个 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使用泛型（泛型类）：

我们自然而然的会这样想了如果可以把方法中的 参数类型 用一个 ”占位符“ 表示 每次 传入 什么类型 他就变成什么类型，这样就可以将这个方法当成一个模板用了（有点像Web编程中在Html中使用占位符）。

这里我们用 “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);
            }
        }

aaarticlea/png;base64,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" alt="" />

*泛型与集合类型(ArrayList)

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

下面我们来看一个例子

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 然后用 开始和结束DateTime.Now 来获取消耗的时间：

  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);

aaarticlea/png;base64,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" alt="" />

*泛型与集合类型(ArrayList)

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

下面我们来看一个例子

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 然后用 开始和结束DateTime.Now 来获取消耗的时间：

       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);

aaarticlea/png;base64,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" alt="" />

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);

aaarticlea/png;base64,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" alt="" />

总结：

看到这里相信大家明白为什么要引入泛型了吧，通过使用泛型-

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

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

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