为什么要用到泛型类、泛型方法

 从开发第一个系统，一直在使用泛型。那么为什么要使用泛型呢？或者说泛型有什么好处。

   先来看官方的的解释：

    

    泛型类和泛型方法同时具备可重用性、类型安全和效率，这是非泛型类和非泛型方法无法具备的。 泛型通常用与集合以及作用于集合的方法一起使用。 .NET Framework 2.0 版类库提供一个新的命名空间 System.Collections.Generic，其中包含几个新的基于泛型的集合类。 建议面向 .NET Framework 2.0 及更高版本的所有应用程序都使用新的泛型集合类，而不要使用旧的非泛型集合类如 ArrayList。 有关更多信息，请参见 .NET Framework 类库中的泛型。

   首先第一句话，就清晰的告诉大家了，使用泛型就是这么好，重用，类型安全，效率。那么泛型为什么就有这么些好处了呢。

可重用性：

现在我们要返回两个信息，一种是字符串类型的信息，一种是数值类型的信息。

不使用泛型的话我们可以这么做，直接添加两个方法，一个返回字符串，另一个返回数值类型 。

[csharp]  view plain  copy

1. public string getString(string stringMessage)  
2.         {  
3.             return stringMessage;  
4.         }  
5.   
6.         public int getIng(int intMessage)  
7.         {  
8.             return intMessage;  
9.         }

而使用泛型的话：只需要一个方法，很简单T就是我们泛型

[csharp]  view plain  copy

1. public T getWord<T>(T t)  
2.         {  
3.             return t;  
4.         }

当然了，有些人说了字符串和数值可以相互转换，一个方法也可以，拜托了，这只是个例子，平常使用的话，泛型多用于IList。而且强制转换容易出运行时的问题。好的，问题来了，强制转换，说到强制转换，可以可以说下List，这就说到接下来的泛型的两个优点：类型安全和高效率。

    类型安全：

    List里面可以添加各种数据类型，它可以说是个异类集合。但是它容易数据类型转换时的运行时错误，也就是说类型不安全。

这得说到List的实现方式了。在List中可以放各种各样的数据类型，不论你push中的元素是什么东东，统统的变为Object类型。而且值类型向Object转换时，还得采取装箱操作，拿出来还得拆箱操作，很容易出现InvalidCastException异常，这有说到了程序员的习惯，对于获取的数据，判null的操作是很必要的。

引用类型向Object的转换应该不用什么消耗资源的操作。毕竟所有的对象都继承Object类型嘛。这一点小编还不太了解呢。这点还望大家都多多指点。

但是如果list中的对象不是某个子类对象的实例，那么强制类型转换就会出现错误，类型安全就会出现问题了。看下面的一段代码，某个程序员一不小心写成了Message类的强制转换。这就出问题了呀

[csharp]  view plain  copy

1. class Program  
2.     {  
3.         static void Main(string[] args)  
4.         {  
5.            System.Collections.ArrayList list = new System.Collections.ArrayList();  
6.            PersonModel person = new PersonModel();  
7.             person.Age = 23;  
8.             person.Name ="张三";  
9.             list.Add(person);  
10.             PersonModel pserson2 = new PersonModel();  
11.             if(list[0].GetType() == typeof(PersonModel)){  
12.                //某个程序员，一不小心写成了Message类的强制转换  
13.                 Message message = (Message)list[0];  
14.             }  
15.   
16.            
17.             Console.WriteLine(pserson2);  
18.   
19.             Console.Read();  
20.   
21.         }  
22.   
23.     }  
24.     class PersonModel  
25.     {  
26.         string name;  
27.   
28.         public string Name  
29.         {  
30.             get { return name; }  
31.             set { name = value; }  
32.         }  
33.         int age;  
34.   
35.         public int Age  
36.         {  
37.             get { return age; }  
38.             set { age = value; }  
39.         }  
40.         public override string ToString()  
41.         {  
42.             return this.name + "," + this.age;  
43.         }  
44.     }  
45.     class MessageModel  
46.     {  
47.     }

而泛型呢，泛型解决了类型转换的根本问题，第一它用不着类型的强制转换。第二泛型集合一旦声明了是何种数据类型的集合，就不再允许其他类型加进去List。最后一旦出现类型转换的错误时，无需运行，编译就通不过。

看下面的使用泛型强制PersonModel的泛型集合，在编译时就提示错误

[csharp]  view plain  copy

1. List<PersonModel> personList = new List<PersonModel>();  
2.             personList.Add(person);  
3.             Message message2 =(Message)personList[0]; //提示错误，类型转换通不过

高效率

    最后还有效率的问题。

    很简单，泛型集合一旦声明了是何种数据类型的集合，就只能添加何种数据类型。添加去也不会转换成Object，它是运行时动态的获取类型参数。也就是说没有装箱和拆箱这些操作。减少了处理器的资源浪费。

总结：泛型是一种思想，也是一种技术，动态的获取参数类型，让编程更加的灵活。那么问题来了，怎么实现动态的获取参数类型呢？毫无疑问，使用反射。