泛型

.Net自从2.0版本开始就支持泛型。使用泛型类型可以最大限度地重用代码、保护类型的安全以及提高性能。

性能

            var list = new ArrayList();
            list.Add(20);//装箱--将值类型转换为引用类型

            int num = (int)list[0];//拆箱--将引用类型转换为值类型

            foreach (int i in list)//拆箱
            {
                Console.WriteLine(i);
            }

ArrayList存储对象，所以Add方法会进行装箱操作，当读取ArrayList中的值时，需要将其转换为int类型，需要进行拆箱操作。装箱、拆箱操作很容易使用，但是性能损失较大，特别是遍历许多项时。

此时，我们可以使用List<T>泛型类来减少装箱和拆箱操作，类型参数T定义为int类型

            var list = new List<int>();
            list.Add(20);//不进行装箱操作

            int num = list[0];//不进行拆箱操作

            foreach (int i in list)//不进行拆箱操作
            {
                Console.WriteLine(i);
            }

类型安全

            var list = new ArrayList();
            list.Add(20);
            list.Add("abc");
            foreach (int i in list)//集合中并非所有元素都可以强制转化为int类型，会出现一个运行异常
            {
                Console.WriteLine(i);
            }

泛型类List<T>中，参数类型T可以定义允许使用的数据类型

            var list = new List<int>();//参数类型T设置为int类型，只允许对int类型的数值进行操作
            list.Add(20);
            list.Add("abc");//传入参数数据类型与设置的参数类型不符，会导致错误

代码复用性

我们看如下代码，为了实现对不同数据类型的数组进行遍历，我们需要为每种类型都编写一个方法：

    class Generic
    {
        public void Main()
        {
            int[] arr_int = { 1, 2, 3 };
            string[] arr_string = { "abc", "123" };
            char[] arr_char = { 'a', 'b', 'c' };
            PrintArray(arr_int);
            PrintArray(arr_string);
            PrintArray(arr_char);

            Console.ReadKey();
        }
        //遍历int类型的数组
        void PrintArray(int[] arr)
        {
            foreach (int i in arr)
            {
                Console.WriteLine(i);
            }
        }
        //遍历string类型的数组
        void PrintArray(string[] arr)
        {
            foreach (string str in arr)
            {
                Console.WriteLine(str);
            }
        }
        //遍历char类型的数组
        void PrintArray(char[] arr)
        {
            foreach (char ch in arr)
            {
                Console.WriteLine(ch);
            }
        }
    }

但是如果我们使用泛型的话，代码就简单多了

    class Generic
    {
        public void Main()
        {
            int[] arr_int = { 1, 2, 3 };
            string[] arr_string = { "abc", "123" };
            char[] arr_char = { 'a', 'b', 'c' };
            //完整的写法
            PrintArray<int>(arr_int);
            PrintArray<string>(arr_string);
            PrintArray<char>(arr_char);
            //简便写法
            PrintArray(arr_int);
            PrintArray(arr_string);
            PrintArray(arr_char);

            Console.ReadKey();
        }
        //遍历数组
        void PrintArray<T>(T[] arr)
        {
            foreach (T item in arr)
            {
                Console.WriteLine(item);
            }
        }
    }

命名约定

如果在程序中使用了泛型，遵循泛型的命名规则可以帮助我们区分泛型类型和非泛型类型。

泛型类型的命名规则：

• 泛型类型的名称用字母T作为前缀；

    class TClassName<T>
    {
        //...
    }

• 如果没有特殊的要求，泛型类型允许用任意的类型代替，并且只使用了一个泛型类型，就可以用T作为泛型类型的名称；
• 如果泛型类型有特定的要求的（例如，他必须实现一个接口或派生自基类），或者使用了两个或多个泛型类型，就应该为泛型类型使用描述性的名称

    class TClassName<TParam1, Tparam2>
    {
        //...
    }

泛型类的默认值

我们看下边的代码，我们需要将变量value进行初始化，要求如果value是引用类型就初始化为null，如果value是值类型就初始化为0；但是泛型中并不能确定T的类型是值类型或是引用类型，那我们要如何进行初始化呢？为了解决这个问题，我们可以是会用default关键字。default关键字会根据T的类型进行初始化，如果T为引用类型就将其设置为null，如果T为值类型就将其设置为0。

        public T Test<T>()
        {
            T value = default(T);
            //..Do Something
            return value;
        }

 约束

约束	说明
where T:struct	指定类型T必须是值类型
where T:class	指定类型T必须是引用类型
where T:IFoo	指定类型T必须实现接口IFoo
where T:Foo	指定类型T必须派生自基类Foo
where T:new()	构造函数约束，指定类型T必须有一个默认的无参构造函数（构造函数只能对无参的构造函数进行约束）
where T1:T2	类型T1派生自泛型类型T2