本文以实例形式讲述了C#泛型的用法，有助于读者深入理解C#泛型的原理，具体分析如下：
首先需要明白什么时候使用泛型：
当针对不同的数据类型，采用相似的逻辑算法，为了避免重复，可以考虑使用泛型。
一、针对类的泛型
针对不同类型的数组，写一个针对数组的"冒泡排序"。
1.思路
● 针对类的泛型，泛型打在类旁。
● 由于在"冒泡排序"中需要对元素进行比较，所以泛型要约束成实现IComparable接口。
1 class Program
2 {
3 static void Main(string[] args)
4 {
5 SortHelper<int> isorter = new SortHelper<int>();
6 int[] iarray = {8, 7, 1, 2, 12};
7 isorter.BubbleSort(iarray);
8 foreach (int item in iarray)
9 {
10 Console.Write(item+ ", ");
11 }
12 Console.ReadKey();
13 }
14 }
15
16 public class SortHelper<T> where T : IComparable
17 {
18 public void BubbleSort(T[] array)
19 {
20 int length = array.Length;
21 for (int i = 0; i <= length -2; i++)
22 {
23 for (int j = length - 1; j >= 1; j--)
24 {
25 if (array[j].CompareTo(array[j-1]) < 0)
26 {
27 T temp = array[j];
28 array[j] = array[j - 1];
29 array[j - 1] = temp;
30 }
31 }
32 }
33 }
34 }
运行结果如下图所示：
2.关于泛型约束
where T : IComparable 把T约束为实现IComparable接口
where T : class
where T : struct
where T : IComparable, new() 约束泛型必须有构造函数
3.关于冒泡算法
● 之所以for (int i = 0; i <= length -2; i++)，这是边界思维，比如有一个长度为5的数组，如果0号位元素最终调换到4号位，每次调一个位，需要经过4次才能到4号位，即for(int i = 0; i <= 5-2, i++)，i依次为0， 1， 2， 4，期间经历了4次。
● 至于for (int j = length - 1; j >= 1; j--)循环，即遍历从最后一个元素开始到索引为1的元素，每次与前一个位置上的元素比较。
4.关于比较
int类型之所以能比较，是因为int类型也实现了IComparable接口。
byte类型也一样实现了IComparable接口。
二、自定义一个类，使之也能实现冒泡算法
冒泡算法涉及到元素比较，所以自定义类必须实现IComparable接口。
1 class Program
2 {
3 static void Main(string[] args)
4 {
5 Book[] bookArray = new Book[2];
6 Book book1 = new Book(100, "书一");
7 Book book2 = new Book(80, "书二");
8 bookArray[0] = book1;
9 bookArray[1] = book2;
10
11 Console.WriteLine("冒泡之前：");
12 foreach (Book b in bookArray)
13 {
14 Console.WriteLine("书名：{0}，价格：{1}", b.Title, b.Price);
15 }
16
17 SortHelper<Book> sorter = new SortHelper<Book>();
18 sorter.BubbleSort(bookArray);
19 Console.WriteLine("冒泡之后：");
20 foreach (Book b in bookArray)
21 {
22 Console.WriteLine("书名：{0}，价格：{1}", b.Title, b.Price);
23 }
24 Console.ReadKey();
25 }
26 }
27
28 public class SortHelper<T> where T : IComparable
29 {
30 public void BubbleSort(T[] array)
31 {
32 int length = array.Length;
33 for (int i = 0; i <= length -2; i++)
34 {
35 for (int j = length - 1; j >= 1; j--)
36 {
37 if (array[j].CompareTo(array[j-1]) < 0)
38 {
39 T temp = array[j];
40 array[j] = array[j - 1];
41 array[j - 1] = temp;
42 }
43 }
44 }
45 }
46 }
47
48 //自定义类实现IComparable接口
49 public class Book : IComparable
50 {
51 private int price;
52 private string title;
53
54 public Book(){}
55
56 public Book(int price, string title)
57 {
58 this.price = price;
59 this.title = title;
60 }
61
62 public int Price
63 {
64 get { return this.price; }
65 }
66
67 public string Title
68 {
69 get { return this.title; }
70 }
71
72 public int CompareTo(object obj)
73 {
74 Book book = (Book)obj;
75 return this.Price.CompareTo(book.Price);
76 }
77 }
运行结果如下图所示：
三、针对方法的泛型
继续上面的例子，自定义一个类，并定义泛型方法。
1 //方法泛型
2 public class MethodSortHelper
3 {
4 public void BubbleSort<T>(T[] array) where T : IComparable
5 {
6 int length = array.Length;
7 for (int i = 0; i <= length - 2; i++)
8 {
9 for (int j = length - 1; j >= 1; j--)
10 {
11 if (array[j].CompareTo(array[j - 1]) < 0)
12 {
13 T temp = array[j];
14 array[j] = array[j - 1];
15 array[j - 1] = temp;
16 }
17 }
18 }
19 }
20 }
主程序如下：
1 class Program
2 {
3 static void Main(string[] args)
4 {
5 Book[] bookArray = new Book[2];
6 Book book1 = new Book(100, "书一");
7 Book book2 = new Book(80, "书二");
8 bookArray[0] = book1;
9 bookArray[1] = book2;
10
11 Console.WriteLine("冒泡之前：");
12 foreach (Book b in bookArray)
13 {
14 Console.WriteLine("书名：{0}，价格：{1}", b.Title, b.Price);
15 }
16
17 MethodSortHelper sorter = new MethodSortHelper();
18 sorter.BubbleSort<Book>(bookArray);
19 Console.WriteLine("冒泡之后：");
20 foreach (Book b in bookArray)
21 {
22 Console.WriteLine("书名：{0}，价格：{1}", b.Title, b.Price);
23 }
24 Console.ReadKey();
25 }
26 }
运行结果如下图所示：
另外，使用泛型方法的时候，除了按以下：
1 MethodSortHelper sorter = new MethodSortHelper(); 2 sorter.BubbleSort<Book>(bookArray);
还可以这样写：
1 MethodSortHelper sorter = new MethodSortHelper(); 2 sorter.BubbleSort(bookArray);
可见，泛型方法可以根据数组实例隐式推断泛型是否满足条件。
四、泛型的其它优点
1.避免隐式装箱和拆箱
以下包含隐式装箱和拆箱：
1 ArrayList list = new ArrayList();
2 for(int i = 0; i < 3; i++)
3 {
4 list.Add(i); //Add接收的参数类型是引用类型object，这里包含了隐式装箱
5 }
6 for(int i = 0; i < 3; i++)
7 {
8 int value = (int)list[i]; //引用类型强转成值类型，拆箱
9 Console.WriteLine(value);
10 }
使用泛型避免隐式装箱和拆箱：
1 List<int> list = new List<int>();
2 for(int i = 0; i < 3; i++)
3 {
4 list.Add(i);
5 }
6 for(int i = 0; i < 3; i++)
7 {
8 int value = list[i];
9 Console.WriteLine(value);
10 }
2.能在编译期间及时发现错误
不使用泛型，在编译期不会报错的一个例子：
ArrayList list = new ArrayList(); int i = 100; list.Add(i); string value = (string)list[0];
使用泛型，在编译期及时发现错误：
List<int> list = new List<int>(); int i = 100; list.Add(i); string value = (string)list[0];
五、使用泛型的技巧
1.在当前文件中给泛型取别名
using IntList = List<int>; IntList list = new IntList(); list.Add(1);
2.在不同文件中使用泛型别名，定义一个类派生于泛型
public class IntList : List<int>{}