.Net-泛型的应用（Generic）

1.发现问题：泛型引入之前对于同一个方法传递不同参数的处理

这里举个例子：

public class CommonMethod
{
	/// <summary>
	/// 打印个int值
	/// </summary>
	/// <param name="sParameter"></param>
	public static void ShowInt(int iParameter)
	{
	    Console.WriteLine("This is {0},parameter={1},type={2}",
	        typeof(CommonMethod).Name, iParameter.GetType().Name, iParameter);
	}
	
	/// <summary>
	/// 打印个string值
	/// </summary>
	/// <param name="sParameter"></param>
	public static void ShowString(string sParameter)
	{
	    Console.WriteLine("This is {0},parameter={1},type={2}",
	        typeof(CommonMethod).Name, sParameter.GetType().Name, sParameter);
	}
	
	/// <summary>
	/// 打印个DateTime值
	/// </summary>
	/// <param name="oParameter"></param>
	public static void ShowDateTime(DateTime dtParameter)
	{
	    Console.WriteLine("This is {0},parameter={1},type={2}",
	        typeof(CommonMethod).Name, dtParameter.GetType().Name, dtParameter);
	}
}

然后在调用的时候：

// 直接调用传递Int的方法
CommonMethod.ShowInt(1);
// 直接调用传递String的方法
CommonMethod.ShowString("11");

结果如图所示：

从上面的结果中我们可以看出这三个方法，除了传入的参数不同外，其里面实现的功能都是一样的。在1.0版的时候，还没有泛型这个概念，那么怎么办呢。相信很多人会想到了OOP(面向对象编程)三大特性之一的继承，我们知道，C#语言中，object是所有类型的基类，将上面的代码进行以下优化：

/// <summary>
/// 打印个object值
/// 1 object类型是一切类型的父类
/// 2 通过继承，子类拥有父类的一切属性和行为；任何父类出现的地方，都可以用子类来代替 
/// object引用类型  加入传个值类型int  会有装箱拆箱  性能损失
/// 类型不安全
/// </summary>
/// <param name="oParameter"></param>
public static void ShowObject(object oParameter)
{
    Console.WriteLine("This is {0},parameter={1},type={2}",
        typeof(CommonMethod), oParameter.GetType().Name, oParameter);
}

然后再次调用新方法：

// object的方法可以传递上述的几个类型，因为：
// 1 object类型是一切类型的父类
// 2 通过继承，子类拥有父类的一切属性和行为；任何父类出现的地方，都可以用子类来代替
// 但是object是引用类型（存在堆中），这里如果是使用object方法传入int类型的话
// int类型是值类型（存在栈中）,object 方法在处理时需要先将int类型数据从栈中复制到堆中处理，称之为装箱
// 在方法使用的时候，还需要拆箱为int类型，这两个过程都消耗性能，所以2.0之后引入了泛型的概念
CommonMethod.ShowObject(22);
CommonMethod.ShowObject("222");
CommonMethod.ShowObject(DateTime.Now);

结果如图所示：

从上面的结果中我们可以看出，使用Object类型达到了我们的要求，解决了代码的可复用。可能有人会问定义的是object类型的，为什么可以传入int、string等类型呢？原因有二：
1、object类型是一切类型的父类。

2、通过继承，子类拥有父类的一切属性和行为，任何父类出现的地方，都可以用子类来代替。

但是上面object类型的方法又会带来另外一个问题：装箱和拆箱，会损耗程序的性能。

微软在C#2.0的时候推出了泛型，可以很好的解决上面的问题。

2.引入泛型

什么是泛型？

泛型（Generic） 允许您延迟编写类或方法中的编程元素的数据类型的规范，直到实际在程序中使用它的时候。换句话说，泛型允许您编写一个可以与任何数据类型一起工作的类或方法。
泛型是C#2.0推出的新语法，不是语法糖，而是2.0由框架升级提供的功能。

您可以通过数据类型的替代参数编写类或方法的规范。当编译器遇到类的构造函数或方法的函数调用时，它会生成代码来处理指定的数据类型。

泛型的特性？

使用泛型是一种增强程序功能的技术，具体表现在以下几个方面：

1. 它有助于您最大限度地重用代码、保护类型的安全以及提高性能。
2. 您可以创建泛型集合类。.NET 框架类库在 System.Collections.Generic 命名空间中包含了一些新的泛型集合类。您可以使用这些泛型集合类来替代 System.Collections 中的集合类。
3. 您可以创建自己的泛型接口、泛型类、泛型方法、泛型事件和泛型委托。
4. 您可以对泛型类进行约束以访问特定数据类型的方法。
5. 关于泛型数据类型中使用的类型的信息可在运行时通过使用反射获取。

上述讲过使用object来减少代码的重复编写，下面讲一下泛型的使用：

public class GenericMethod
{
    public static void Show<T>(T tParameter)
    {
        Console.WriteLine("This is {0},parameter={1},type={2}", typeof(GenericMethod).Name, tParameter.GetType().Name, tParameter);
    }
}

泛型方法的调用：

GenericMethod.Show<int>(1);
GenericMethod.Show<string>("11");
GenericMethod.Show<DateTime>(DateTime.Now);

结果如图：

这里同样实现了方法的复用，那么这里的泛型同之前讲的object的方法复用有什么不同了？

1. object是利用了继承的特性实现的，但是对于像传递int时存在一个装箱拆箱的操作，存在性能损耗， 装箱操作和拆箱操作是要额外耗费cpu和内存资源的，所以在c# 2.0之后引入了泛型来减少装箱操作和拆箱操作消耗。
2. 泛型是延迟声明的：即定义的时候没有指定具体的参数类型，把参数类型的声明推迟到了调用的时候才指定参数类型。 延迟思想在程序架构设计的时候很受欢迎。例如：分布式缓存队列、EF的延迟加载等等。

泛型原理：控制台程序最终会编译成一个exe程序，exe被点击的时候，会经过JIT(即时编译器)的编译，最终生成二进制代码，才能被计算机执行。泛型加入到语法以后，VS自带的编译器又做了升级，升级之后编译时遇到泛型，会做特殊的处理：生成占位符。再次经过JIT编译的时候，会把上面编译生成的占位符替换成具体的数据类型。

代码打印：

Console.WriteLine(typeof(List<>));// 打印出来的有一个`1,代表占位符，有一个参数
Console.WriteLine(typeof(Dictionary<,>));// 打印出来的有一个`2,代表占位符，有两个参数

结果：

从上面的截图中可以看出：泛型在编译之后会生成占位符。

泛型的性能测试？

举个例子：将普通的int方法，object方法，泛型方法分别执行一亿次，查看执行时间

public static void Show()
{
    Console.WriteLine("将普通的int类型，object类型，泛型的方法分别执行一亿次");
    {
        int iValue = 12345;
        long commonSecond = 0;
        long objectSecond = 0;
        long genericSecond = 0;

        {
            Stopwatch watch = new Stopwatch();
            watch.Start();
            for (int i = 0; i < 100000000; i++)
            {
                ShowInt(iValue);
            }
            watch.Stop();
            commonSecond = watch.ElapsedMilliseconds;
        }
        {
            Stopwatch watch = new Stopwatch();
            watch.Start();
            for (int i = 0; i < 100000000; i++)
            {
                ShowObject(iValue);
            }
            watch.Stop();
            objectSecond = watch.ElapsedMilliseconds;
        }
        {
            Stopwatch watch = new Stopwatch();
            watch.Start();
            for (int i = 0; i < 100000000; i++)
            {
                Show<int>(iValue);
            }
            watch.Stop();
            genericSecond = watch.ElapsedMilliseconds;
        }
        Console.WriteLine("commonSecond={0},objectSecond={1},genericSecond={2}"
            , commonSecond, objectSecond, genericSecond);
    }
}

private static void ShowInt(int iParameter)
{
    //do nothing
}
private static void ShowObject(object oParameter)
{
    //do nothing
}
private static void Show<T>(T tParameter)
{
    //do nothing
}

从结果中可以看出：泛型方法的性能最高，其次是普通方法，object方法的性能最低，因为object存在装拆箱。

除了泛型参数，还有泛型类，泛型接口，泛型委托

泛型约束

在定义泛型类时，可以对客户端代码能够在实例化类时用于类型参数的类型种类施加限制。如果客户端代码尝试使用某个约束所不允许的类型来实例化类，则会产生编译时错误。这些限制称为约束。约束是1.使用 where 上下文关键字指定的。下表列出了六种类型的约束：
where T: struct
2.类型参数必须是值类型。可以指定除 Nullable 以外的任何值类型。有关更多信息，请参见使用可以为 null 的类型（C# 编程指南）。
where T : class
3.类型参数必须是引用类型；这一点也适用于任何类、接口、委托或数组类型。
where T：new()
4.类型参数必须具有无参数的公共构造函数。当与其他约束一起使用时，new() 约束必须最后指定。
where T：<基类名>
5.类型参数必须是指定的基类或派生自指定的基类。
where T：<接口名称>
6.类型参数必须是指定的接口或实现指定的接口。可以指定多个接口约束。约束接口也可以是泛型的。
where T：U
为 T 提供的类型参数必须是为 U 提供的参数或派生自为 U 提供的参数。

使用约束的原因？
如果要检查泛型列表中的某个项以确定它是否有效，或者将它与其他某个项进行比较，则编译器必须在一定程度上保证它需要调用的运算符或方法将受到客户端代码可能指定的任何类型参数的支持。这种保证是通过对泛型类定义应用一个或多个约束获得的。例如，基类约束告诉编译器：仅此类型的对象或从此类型派生的对象才可用作类型参数。一旦编译器有了这个保证，它就能够允许在泛型类中调用该类型的方法。约束是使用上下文关键字 where 应用的。
泛型约束是可以叠加的。

3.为什么说泛型是类型安全的？

举个例子，比如说像 ArrayList，在插入数据的时候，ArrayList胃口很大，什么都能吃，像 int,string…,但是如果到了边里取数据的时候，你想一下，你怎么知道循环的这一个数据是什么类型？当然这里可以对每一个遍历的数据做类型匹配处理，但太麻烦了。

现在的话有了泛型，声明的时候就已经指定了数据类型，如果添加的数据数据类型不对，直接在编译环节就直接会报错 。

4.泛型的好处

1. 类型安全，上面讲过了。
2. 性能提升，如果使用 object 也可以转换，但是存在装箱拆箱，必然就存在内存的分配处理，性能有损耗。
3. 方法复用，那如果说避免装箱拆箱可以分别写方法啊，但是这样太麻烦了。