一、泛型的作用
泛型是.net中十分常见的一种特性。它是在.net 2.0的时候加入。那为什么要在.net 2.0的时候加入泛型这个特性呢？我们首先来看一段代码。
using System;
namespace 泛型
{
class Program
{
static void Main(string[] args)
{
int iParameter = 1;
string sParameter = "hello world";
DateTime dtParameter = DateTime.Now;
Console.WriteLine("***************************最开始的写法*********************************");
CommonMethod.ShowInt(iParameter);
CommonMethod.ShowString(sParameter);
CommonMethod.ShowDateTime(dtParameter);
Console.ReadLine();
}
}
}
using System;
using System.Collections.Generic;
using System.Text;
namespace 泛型
{
public class CommonMethod
{
public static void ShowInt(int iParameter)
{
Console.WriteLine(string.Format("这个方法是：{0}，它的参数是{1}，参数的类型是{2}", typeof(CommonMethod), iParameter.ToString(), iParameter.GetType().ToString()));
}
public static void ShowString(string sParameter)
{
Console.WriteLine(string.Format("这个方法是：{0}，它的参数是{1}，参数的类型是{2}", typeof(CommonMethod), sParameter.ToString(), sParameter.GetType().ToString()));
}
public static void ShowDateTime(DateTime dtParameter)
{
Console.WriteLine(string.Format("这个方法是：{0}，它的参数是{1}，参数的类型是{2}",typeof(CommonMethod), dtParameter.ToString(), dtParameter.GetType().ToString()));
}
}
}
通过代码可以理解，我们只是要根据不同的类型，输出相同的内容。因为.net 1.0的时候没有泛型的概念，那么我们最简单的做法就是有多少类型，我们就写多少个方法，进行输出。
这样就会造成一些问题：
1、代码量大。.net有那么多类型，每一个类型都写一个方法，那么代码势必会很长。
2、不利于代码维护。当需要对输出内容进行修改时，则每一个方法都需要进行修改。这就是一种灾难。
那么有没有方法解决这些问题呢？
在.net 1.0的时候，我们可以通过这种方式进行解决。先上代码：
using System;
namespace 泛型
{
class Program
{
static void Main(string[] args)
{
int iParameter = 1;
string sParameter = "hello world";
DateTime dtParameter = DateTime.Now;
Object oParameter = "Object";
Console.WriteLine("***************************.net 1.0 最开始的写法*********************************");
CommonMethod.ShowInt(iParameter);
CommonMethod.ShowString(sParameter);
CommonMethod.ShowDateTime(dtParameter);
Console.WriteLine("***************************.net 1.0 优化的写法*********************************");
CommonMethod.ShowObject(iParameter);
CommonMethod.ShowObject(sParameter);
CommonMethod.ShowObject(dtParameter);
CommonMethod.ShowObject(oParameter);
Console.ReadLine();
}
}
}
using System;
using System.Collections.Generic;
using System.Text;
namespace 泛型
{
public class CommonMethod
{
public static void ShowInt(int iParameter)
{
Console.WriteLine(string.Format("这个方法是：{0}，它的参数是{1}，参数的类型是{2}", typeof(CommonMethod), iParameter.ToString(), iParameter.GetType().ToString()));
}
public static void ShowString(string sParameter)
{
Console.WriteLine(string.Format("这个方法是：{0}，它的参数是{1}，参数的类型是{2}", typeof(CommonMethod), sParameter.ToString(), sParameter.GetType().ToString()));
}
public static void ShowDateTime(DateTime dtParameter)
{
Console.WriteLine(string.Format("这个方法是：{0}，它的参数是{1}，参数的类型是{2}",typeof(CommonMethod), dtParameter.ToString(), dtParameter.GetType().ToString()));
}
public static void ShowObject(Object oParameter)
{
Console.WriteLine(string.Format("这个方法是：{0}，它的参数是{1}，参数的类型是{2}",typeof(CommonMethod), oParameter.ToString(), oParameter.GetType().ToString()));
}
}
}
代码中添加了ShowObject方法，参数传递Object类型，然后所有的类型都调用这个方法。那么结果呢？
运行结果是正常的。那么为什么可以这样？
1、任何父类出现的地方都可以用子类代替。
2、Object是一切类型的父类
感觉可以使用这个方法解决之前不同类型，输出相同内容的问题了。为什么后来又出现了泛型呢？
因为使用Object的方法，有两个问题：
1、装箱和拆箱的性能损耗。object是引用类型，当传递值类型时，需要转换成引用类型。
传入一个Int值（栈）需要把值从栈Copy堆里面
2、类型安全问题。当你需要传递一个int类型时，你传递了一个String类型。编译是能通过的，只有等到运行时才会报错。这是不安全的。
总结起来在.net 1.0的时代，主要有几个问题：
1、代码重复比较严重。不同的类型需要写不同的方法，造成代码冗余严重。
2、使用Object参数的形式能解决代码冗余的问题，但是性能上付出了代价。
3、使用Object参数的形式，参数类型是不安全的。任何类型的参数都能传递到方法里。
所以，为了解决这些问题，在.net 2.0的时候就引入了泛型这个特性。
还是一样，先上代码：
using System;
namespace 泛型
{
class Program
{
static void Main(string[] args)
{
int iParameter = 1;
string sParameter = "hello world";
DateTime dtParameter = DateTime.Now;
Object oParameter = "Object";
Console.WriteLine("***************************.net 1.0 最开始的写法*********************************");
CommonMethod.ShowInt(iParameter);
CommonMethod.ShowString(sParameter);
CommonMethod.ShowDateTime(dtParameter);
Console.WriteLine("***************************.net 1.0 优化的写法*********************************");
CommonMethod.ShowObject(iParameter);
CommonMethod.ShowObject(sParameter);
CommonMethod.ShowObject(dtParameter);
CommonMethod.ShowObject(oParameter);
Console.WriteLine("***************************.net 泛型*********************************");
CommonMethod.Show<int>(iParameter);
CommonMethod.Show<string>(sParameter);
CommonMethod.Show<DateTime>(dtParameter);
CommonMethod.Show<Object>(oParameter);
Console.ReadLine();
}
}
}
using System;
using System.Collections.Generic;
using System.Text;
namespace 泛型
{
public class CommonMethod
{
public static void ShowInt(int iParameter)
{
Console.WriteLine(string.Format("这个方法是：{0}，它的参数是{1}，参数的类型是{2}", typeof(CommonMethod), iParameter.ToString(), iParameter.GetType().ToString()));
}
public static void ShowString(string sParameter)
{
Console.WriteLine(string.Format("这个方法是：{0}，它的参数是{1}，参数的类型是{2}", typeof(CommonMethod), sParameter.ToString(), sParameter.GetType().ToString()));
}
public static void ShowDateTime(DateTime dtParameter)
{
Console.WriteLine(string.Format("这个方法是：{0}，它的参数是{1}，参数的类型是{2}", typeof(CommonMethod), dtParameter.ToString(), dtParameter.GetType().ToString()));
}
public static void ShowObject(Object oParameter)
{
Console.WriteLine(string.Format("这个方法是：{0}，它的参数是{1}，参数的类型是{2}", typeof(CommonMethod), oParameter.ToString(), oParameter.GetType().ToString()));
}
public static void Show<T>(T tParameter)
{
Console.WriteLine(string.Format("这个方法是：{0}，它的参数是{1}，参数的类型是{2}", typeof(CommonMethod), tParameter.ToString(), tParameter.GetType().ToString()));
}
}
}
注意里面Show的方法，这个就是泛型方法的定义。那么运行结果呢？请看图：
可以看到是没有问题的。
泛型的作用是什么？我用一句话概括就是不同类型的参数进行相同的操作时，你就可以考虑使用泛型。
二、泛型的定义
public static void Show<T>(T tParameter)
{
Console.WriteLine(string.Format("这个方法是：{0}，它的参数是{1}，参数的类型是{2}", typeof(CommonMethod), tParameter.ToString(), tParameter.GetType().ToString()));
}
泛型方法与一般方法的区别在方法名后有一对<>。其中T表示的是一个占位符，意思是我这里会指定一个类型，但是我现在不知道，我把位置给占着。等要使用到这个方法时，我在指定类型。其采用的思想延迟思想。
其中占位符可以是一个，也可以是多个。比如Show<T,N,M,Two>都行。但是请注意，这里的占位符不能是关键词。比如class,static等。
三、泛型有没有解决问题？
第一个问题，代码冗余，这个比较明显，在main方法里面都调用了一个方法，代码简洁不少。
第二个性能问题，那我们就写一个测试代码。
首先添加一个类Monitor。代码如下:
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
namespace 泛型
{
public class Monitor
{
public static void Show()
{
Console.WriteLine("****************Monitor******************");
{
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("一般方法耗时={0}毫秒,Object方法耗时={1}毫秒,泛型方法耗时={2}毫秒" , commonSecond, objectSecond, genericSecond);
}
}
#region PrivateMethod
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
}
#endregion
}
}
main方法：
using System;
namespace 泛型
{
class Program
{
static void Main(string[] args)
{
for (int i = 0; i < 5; i++)
{
Monitor.Show();
}
Console.ReadLine();
}
}
}
Monitor类中定义了ShowInt,ShowObject,Show三类方法，每个方法内都是空的，没有做任何操作。然后在Show方法中，调用ShowInt,ShowObject,Show各100000000次，通过Stopwatch计时器计算每个方法执行10000000次所需要的时间（毫秒）。
Main方法中，为了比较全面的看到时间，我这里调用了5次Show方法。结果如图：
明显的能看出，Object方法耗时最长，一般方法的耗时和泛型的耗时基本相差无几。
所以在性能上的问题，我们也能得到了解决。
第三个问题：类型安全问题。
当我们使用泛型方法时，在调用的适合就需要指定类型。
int iValue = 12345;
string sValue=”Hello World”;
Show(iValue)
这样是可以成功的，但是如果我们写成这样：
Show(sValue)
则编译不通过，从一定程度上解决了类型安全的问题。
四、泛型缓存
为什么泛型的效率这么高呢？这里面涉及到泛型缓存的概念。
类中的静态类型无论实例化多少次，在内存中只会有一个。静态构造函数只会执行一次。在泛型类中，T类型不同，每个不同的T类型，都会产生一个不同的副本，所以会产生不同的静态属性、不同的静态构造函数。简单的说就是不同类型的T会生成相同的副本，而相同类型的T会只用同一个副本。
请看下面的例子：
GenericCache类：
using System;
using System.Collections.Generic;
using System.Text;
namespace 泛型
{
public class GenericCache<T>
{
static GenericCache()
{
Console.WriteLine("这是 GenericCache 静态构造函数");
_TypeTime = string.Format("{0}_{1}", typeof(T).FullName, DateTime.Now.ToString("yyyyMMddHHmmss.fff"));
}
private static string _TypeTime = "";
public static string GetCache()
{
return _TypeTime;
}
}
}
GenericCacheTest类：
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
namespace 泛型
{
public class GenericCacheTest
{
public static void Show()
{
for (int i = 0; i < 5; i++)
{
Console.WriteLine("这是第{0}次执行......", (i + 1).ToString());
Console.WriteLine(GenericCache<int>.GetCache());
Thread.Sleep(100);
Console.WriteLine(GenericCache<long>.GetCache());
Thread.Sleep(100);
Console.WriteLine(GenericCache<DateTime>.GetCache());
Thread.Sleep(100);
Console.WriteLine(GenericCache<string>.GetCache());
Thread.Sleep(100);
Console.WriteLine(GenericCache<GenericCacheTest>.GetCache());
Thread.Sleep(100);
}
}
}
}
main方法：
using System;
namespace 泛型
{
class Program
{
static void Main(string[] args)
{
GenericCacheTest.Show();
Console.ReadLine();
}
}
}
运行后结果为：
观察结果可以看到，5次执行相同类型的时间都是一致的。并且从第二次开始，执行时并没有进入构造函数。利用泛型的这一个特性，可以实现缓存。
注意：只能为不同的类型缓存一次。泛型缓存比字典缓存效率高。泛型缓存不能主动释放
扫一扫
1446
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
