今天看了一下泛型，有点晕…知道了大概！谁难在详细一点谈谈：泛型意义、如何使用、用在哪里？最好写一个很实用有简明的例子。谢谢

烦！（此心情虽然就一个字，却深刻表达了我的感受，可谓言简意赅，一字千金，足可表达我深厚的文学功底和扎实的写作技巧。实在是佩服自己！

泛型的定义
　　泛型的定义主要有以下两种： 　　在程序编码中一些包含类型参数的类型，也就是说泛型的参数只可以代表类，不能代表个别对象。（这是当今较常见的定义）在程序编码中一些包含参数的类。其参数可以代表类或对象等等。（现在人们大多把这称作模板）不论使用哪个定义，泛型的参数在真正使用泛型时都必须作出指明。 　　一些强类型编程语言支援泛型，其主要目的是加强类型安全及减少类转换的次数，但一些支持泛型的编程语言只能达到部份目的。

说穿了泛型就是避免强制类型转换，可以直接用不需要转换来转换去的，把过程减化了也就减少了出错的可能性。
定义：
public class GenericList<T>
{
    public void Add(T input)//T制定成类型参数
    public T Add()//T制定成返回值
}
<T>的T是类型参数，起占位符的作用，编译时被真正类型取代。
使用泛型：
GenericList<int> list1 = new GenericList<int>();
GenericList<string> list2 = new GenericList<string>();
GenericList<类名> list3 = new GenericList<类名>();
GenericList<类名<int>> list4= new GenericList<类名<int>>();

泛型可以定义独立于被包含的类的类型和方法。

优点一：二进制代码重用。
比如：list<T> .NET提供的一个具有Add 之类的集合泛型的类。
list里面的Add（或者其他的所有的）方法是不是相对于你放进去的T，比如list<int> int类型而言，它是独立的呢？
那就是说，我管你放什么数据类型，我就只提供这么些个方法。

优点二：（Add效率高 ）使用泛型可以避免传统集合的装箱和拆箱的操作。
但是使用 泛型就不会了。原因是：泛型的具体数据类型，会在JIT（just in time）编译的类中使用，它不需要在进行装箱和拆箱的操作。

优点三：类型安全，迭代效率高方便（这是我自己加的）
你要知道 在没有泛型之前 传统的集合 参数类型都是Object的 ，
你把参数穿进去，就会把参数由参数类型转化为Object类型。
然后 你又要使用foreach对集合进行迭代，又要把Object对象拆箱成原来的数据类型。
而且 当集合中的数据类型很杂的时候，还会出现 不知道当前对象到底是个什么数据类型的尴尬。
使用泛型就不会出现这样的问题。
比如:List<int> intArr = new List<int>();
    intArr.Add(1);
    intArr.Add("我");//这时编译是不通过的，因为输入的数据类型不是int

还有就是foreach迭代的时候效率比传统集合高 而且还不出出现不知道具体数据类型的尴尬
foreach(int i in intArr)
{
    //我这里直接就申明 int 来接受intArr里的数据是完全可以的，因为它本身就存放的都是int数据类型。
}

要是一般的 集合
比如:ArrayList MyArr -= new ArrayList();
MyArr.Add(1);//放一int  （int  --- object）
MyArr.Add("我");//放一string (string ---  object)
MyArr.Add(new student());//甚至是一个自定义数据类型 (student ----  object)

foreach(var ob in MyArr)
{
   //..在这我就比较尴尬了 ，我不知道迭代到的当前对象到底是个什么数据类型。
}

当然后面还有什么泛型接口，泛型方法，泛型约束 等一堆乱七八糟的东西。不过 你只要弄清楚了泛型的意义，那么后面的都好说了。
希望能帮倒你。

泛型是 C# 2.0 开始引入的一种更加灵活、规范的数据操作机制，看例子：
    class Book{}
    假设有书本对象需要存入集合，再提取出来
    ArrayList list = new ArrayList(); //1、实例化 list 集合对象
    Book b=new Book()//2、实例化一个书本对象
    list.Add(b);                      //3、将书本存入集合
    Book  temp =(Book)list[0];  //4、将书本对象从集合中取出来
    传统的操作方式如上。
    如果，存入的是书本对象，而取出的时候错以为是学生对象，第 4 行代码可能写成：
    Student temp = (Student) list[0];
    在编译时，系统不会发现这个问题，因为存入 list 的对象都会被装箱为 object ，取出的时候由 object 进行拆箱，系统没办法确定数据类型，所以，就算存入和取出的类型不一致，也不会提示错误。编译不出错，运行时肯定要出错了，因为书本对象强制转换为学生，是错误的。
    那如何尽早的进行类型规范和检查呢？这时就要使用泛型。
    List<Book> list = new List<Book>();           //1、实例化只能存放书本对象的集合
    Book b=new Book()//2、实例化一个书本对象
    list.Add(b);                      //3、将书本存入集合
    Book  temp =list[0];  //4、将书本对象从集合中取出来    注意代码的区别：
    第一行：我们没有再使用 ArrayList ，而是使用了 List 泛型集合
            语法：尖括号 < > 中的数据类型是在规范集合只能存入此类型数据。
    第四行：因为定义时有固定的操作类型（），所以，提取 list[0] 肯定是 Student 类型的对象，免去了数据类型转换的麻烦。
    那我们再使用 Student temp = list[0]; 去进行错误类型的提取，程序将在编译时发现数据类型和泛型定义不一致的错误，使我们的程序更安全，更规范，同时，进出 list 集合的数据都有了类型，免去了传统集合进出数据时的装箱和拆箱的操作，提高了数据访问速度。
    泛型可以更规范的定义集合中存储的数据类型，其实可以以一种模板的方式来理解：
    List<Book> list = new List<Book>(); 相当于系统原有 List 集合类型是模板，我们通过模板创建了一种只能操作 Book 类型的集合。那模板的操作方式还有什么用途呢？
    现在我们调用 list.Sort() 方法，对集合当中的书本对象进行排序，因为 Book类型不是系统内置的数据类型，所以排序操作肯定是错误的。那如果需要按照我们的要求进行排序，比如按书本号排序，又该怎么做呢？
    很多集合都需要有排序功能，所以系统有接口 IComparable ，来规范对象排序的操作。既然 IComparable 可以规范各种类型的排序，那就认为是一种模板，同时也就想到了泛型：
    class Student : IComparable<Student> //实现 泛型 比较接口
    {
        private string num;
        public int NUM { get ; set; }  //定义书本号属性
        public int CompareTo(Book other) //以泛型方式声明，所以操作对象也就是 Book
        {
            if(this.Num > other.Num)
                return 1;
            if(this.Num == other.Num)
                return 0;
            return -1;  //大于 等于 小于 对应返回 1 / 0 / -1
        }
    }
    这样操作 Book类后，list.Sort() 功能也就可以通过调用 CompareTo 来对集合里的各个书本对象进行排序了。

1. /// <summary>
   
2.         /// 根据类型得到配置列表
   
3.         /// </summary>
   
4.         /// <param name="paramType"></param>
   
5.         /// <returns></returns>
   
6.         public List<ParamTabInfo> LoadByType(string paramType)
   
7.         {
   
8.             string cmdText = "select ParamID,ParamText,ParamValue from ParamTab where ParamType = @ParamType";
   
9.             List<ParamTabInfo> list = new List<ParamTabInfo>();
   
10. 
    
11.             using (SqlConnection conn = new SqlConnection(Common.DBSettings.TestDBConnText))
    
12.             {
    
13.                 conn.Open();
    
14.                 SqlCommand cmd = new SqlCommand(cmdText, conn);
    
15. 
    
16.                 cmd.Parameters.Add(new SqlParameter("@ParamType", System.Data.SqlDbType.NVarChar, 50));
    
17.                 cmd.Parameters["@ParamType"].Value = paramType;
    
18. 
    
19.                 using (SqlDataReader rdr = cmd.ExecuteReader())
    
20.                 {
    
21.                     while (rdr.Read())
    
22.                     {
    
23.                         ParamTabInfo info = new ParamTabInfo();
    
24.                         info.ParamID = rdr["ParamID"].ToString();
    
25.                         info.ParamText = rdr["ParamText"].ToString();
    
26.                         info.ParamValue = rdr["ParamValue"].ToString();
    
27. 
    
28.                         list.Add(info);
    
29.                     }
    
30.                 }
    
31. 
    
32.             }
    
33. 
    
34.             return list;
    
35.         }

复制代码

如果还不明白，给你说个例子，你肯定会知道什么是泛型，比如你要去黑马上课了，老婆放在家里不放心，你想把她放在一个容器中，假设人都是上帝创造的，那个容器具有神奇的魔力，你把你老婆放进那个容器，老婆就变为最高类上帝（object），你从黑马毕业了回家，从那个容器取出来那个是上帝，你要让他变成你原来的老婆，才可以继续与她生活，在变回去的过程就是强制转换，这样容易出现一个问题，就是可能变不回你原来的老婆。所以就有这样一种东西，那就是泛型，在你把老婆放进容器的时候，在她身上附加上身份识别，不让容器把她转换为最高类上帝，以后你从黑马毕业回来就直接从那容器把你老婆领回家就可以了，不用再转换了。

泛型就是你把一样东西放入容器中，如果你没有为那样东西说明是什么类型的东西，这个容器会认为那是object类型，你再去容器取那样东西时，object你都要强制转换你原来所放的那类型才能使用。而泛型就是在你放那样东西时顺带说明你放的是什么类型的东西，比string类型,那以后你取出来使用就不用转换了直接可以使用。