泛型

概念

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

泛型的由来

现在需要我们来实现一个冒泡排序算法，那么不用泛型我们是怎么做呢？

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

现在我们把程序补充完整，运行看一下效果：

SortHelper sortHelper = new SortHelper();
int[] array = { 1, 5, 9, 23, 6, 2 };
sortHelper.BubbleSort(array);
foreach (int i in array)
{
     Console.Write("{0} ", i);
}
Console.ReadKey();

运行结果：

而现在呢，我们又有一个新的需求，需要对一个byte类型的数组进行排序，但是我们上面的排序算法只能接受Int类型的数组，那我们怎么办？
话说最简单的方法就是将上面的方法复制一遍，将类型改为byte。

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

现在功能是实现了，但是这是我们想要的代码吗？如果我们还要对char类型等其他类型的数组进行排序呢？我们继续复制粘贴代码吗？那这样我们就需要思考一个更佳的解决方案了。
现在我们重新思考我们的实现过程，我们会发现这些方法的实现过程除了类型不同，代码几乎完全一样。

public void BubbleSort(int[] array)
public void BubbleSort(byte[] array)

那我们该怎么办呢？
如果我们用一个类型参数T来代替int[]、byte[],其中类型参数T可以代表任何类型，那么这三个方法之间的差异是不是就被屏蔽掉了?

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

但是问题又出现了，那么怎么知道T究竟是具体的哪个类型呢？
在.NET中，提供了专门的语法来传递T类型参数，其中一种就是定义类型的时候传递，此时，类型也就变成了泛型类。

public class SortHelper1<T>
    {
        public void BubbleSort(T[] array)
        {
            //方法的实现
        }
    }

在类名称的后面加了一个尖括号，使用这个尖括号来传递类型参数。下面我们看看究竟如何使用泛型。当我们需要对一个int类型的数组排序时：

//int类型
SortHelper1<int> sortHelper = new SortHelper1<int>();
int[] array = { 1, 5, 9, 23, 6, 2 };
sortHelper1.BubbleSort(array);
      foreach (int i in array)
      {
         Console.Write("{0} ", i);
      }
Console.ReadKey();

运行结果：

当我们需要为byte类型的数组进行排序时：

//byte类型
SortHelper1<byte> sortHelper1 = new SortHelper1<byte>();
byte[] array = { 1, 5, 9, 23, 6, 2 };
sortHelper1.BubbleSort(array);
foreach (int i in array)
{
    Console.Write("{0} ", i);
}
Console.ReadKey();

运行结果：

现在我们可以看到，通过使用泛型，极大地减少了重复代码，是程序更加清爽。

类型参数约束

看到上面代码变的这么简洁，而且功能也实现了，终于可以休息一下了，可是娜娜又想到了这样一个问题：假设我们自己定义了一个类型（Book），这个类里面有两个字段：一个是int类型的Price，代表书的价格；一个是string类型的Title，代表书的标题

public class Book
    {
        private int price;
        private string title;

        public Book() { }

        public Book(int price, string title) {
            this.price = price;
            this.title = title;
        }

        public int Price { get { return this.price; } }
        public string Title { get { return this.title; } }

        public int CompareTo(object obj) {
            Book book2 = (Book)obj;
            return this.Price.CompareTo(book2.Price);
        }
    }

现在，创建一个Book类型的数组，仿照上面的泛型类来进行排序

 SortHelper1<Book> sortHelper1 = new SortHelper1<Book>();
 Book[] bookarray = new Book[2];
 Book book1 = new Book(30, "安全信息资源管理");
 Book book2 = new Book(20, "计算机网络");
 bookarray[0] = book1;
 bookarray[1] = book2;
 sortHelper1.BubbleSort(bookarray);
 foreach (Book b in bookarray)
 {
       Console.WriteLine("price:{0}", b.Price);
       Console.WriteLine("titel:{0}", b.Title);
 }