C#泛型类，有多少个类？
C# 泛型有多少个类？
有这样一个需求：通过反射获取类类型中指定名字的方法信息，实现如下，
public class NormalClass {
public MethodInfo GetMethodInfo(Type classType, string methodName) {
MethodInfo methodInfo;
methodInfo = classType.GetMethod(methodName, BindingFlags .Public | BindingFlags .Instance);
return methodInfo;
}
}
这个需求看起来很简单，但是调用的地方和传的 classType 是相当的多，于是考虑到缓存，创建一个全局字典，用于存储类的方法信息，GetMethodInfo() 方法从类字典中试着获取类对应的方法列表，如果不存在，则创建方法列表并加到字曲中供下次获取，这样就不用相同类每次都创建，起到缓存作用。现在的实现看起来如下，
public class NormalClass {
private static object __lockObject = new object ();
private static Dictionary <Type , List <MethodInfo >> __typeList = new Dictionary <Type , List <MethodInfo >>();
private List <MethodInfo > _methodList;
public NormalClass(Type classType) {
lock (__lockObject) {
if (!__typeList.TryGetValue(classType, out _methodList)) {
lock (__lockObject) {
_methodList = new List <MethodInfo >();
__typeList.Add(classType, _methodList);
MethodInfo [] methodInfos = classType.GetMethods(BindingFlags .Instance | BindingFlags .Public);
foreach (MethodInfo methodInfo in methodInfos) {
_methodList.Add(methodInfo);
}
}
}
}
}
public MethodInfo GetMethodInfo(string methodName) {
foreach (MethodInfo methodInfo in _methodList) {
if (methodInfo.Name.Equals(methodName)){
return methodInfo;
}
}
return null ;
}
}
好了，功能实现了，编写调用语句，
NormalClass normalClass1 = new NormalClass (typeof (TestClass1 ));
MethodInfo methodInfo = normalClass1.GetMethodInfo("TestMethod" );
调用也OK ，一切正常，需求完成。这时，另外一个人用泛型方式实现了另一个类，新类看起来如下，
public class GeneralizationClass <T> where T : class {
private static object __lockObject = new object ();
private static Dictionary <Type , List <MethodInfo >> __typeList = new Dictionary <Type , List <MethodInfo >>();
private List <MethodInfo > _methodList;
public GeneralizationClass() {
lock (__lockObject) {
Type classType = typeof (T);
if (!__typeList.TryGetValue(classType, out _methodList)) {
lock (__lockObject) {
_methodList = new List <MethodInfo >();
__typeList.Add(classType, _methodList);
MethodInfo [] methodInfos = classType.GetMethods(BindingFlags .Instance | BindingFlags .Public);
foreach (MethodInfo methodInfo in methodInfos) {
_methodList.Add(methodInfo);
}
}
}
}
}
public MethodInfo GetMethodInfo(string methodName) {
foreach (MethodInfo methodInfo in _methodList) {
if (methodInfo.Name.Equals(methodName)){
return methodInfo;
}
}
return null ;
}
}
用泛型实现的类也能做相同的事情，看起来好象没什么问题，运行也正常，调用语句象下面这样，
GeneralizationClass <TestClass1 > genClass1 = new GeneralizationClass <TestClass1 >();
MethodInfo methodInfo = genClass1.GetMethodInfo("TestMethod" );
但是，用泛型实现的类，存在一个很大的问题，就是如果指派给泛型类的类类型不同，则泛型对象的类型是不同的，就如下面语句，typeEqual 变量的值为 false ，
GeneralizationClass <TestClass1 > genClass1 = new GeneralizationClass <TestClass1 >();
GeneralizationClass <TestClass2 > genClass2 = new GeneralizationClass <TestClass2 >();
bool typeEqual = genClass1.GetType() == genClass2.GetType();
这就是说，指派给泛型类的类类型有多少个，则就有多少个不同的类型，而泛型类内部的缓存字典，也会不同，因为是完全不同的类了。
现在才进入要表达的主题 J
为了验证上面的观点，我们分别在普通类和泛型类上增加一个静态属性，用于获取多次调用后，字典中的 Type 数，实现如下，
public static int TypeCount{
get {
return __typeList.Count;
}
}
然后，我们编写下面的语句进行测试，测试结果在每条语句的注释中，
private void button1_Click(object sender, EventArgs e) {
NormalClass normalClass1;
NormalClass normalClass2;
NormalClass normalClass3;
NormalClass normalClass4;
int typeCount;
normalClass1 = new NormalClass (typeof (TestClass1 ));
typeCount = NormalClass .TypeCount; // typeCount == 1
normalClass2 = new NormalClass (typeof (TestClass2 ));
typeCount = NormalClass .TypeCount; // typeCount == 2
normalClass1 = new NormalClass (typeof (TestClass1 ));
typeCount = NormalClass .TypeCount; // typeCount == 2
normalClass3 = new NormalClass (typeof (TestClass3 ));
typeCount = NormalClass .TypeCount; // typeCount == 3
normalClass4 = new NormalClass (typeof (TestClass4 ));
typeCount = NormalClass .TypeCount; // typeCount == 4
normalClass1 = new NormalClass (typeof (TestClass1 ));
typeCount = NormalClass .TypeCount; // typeCount == 4
normalClass3 = new NormalClass (typeof (TestClass3 ));
typeCount = NormalClass .TypeCount; // typeCount == 4
// 对比类类型是否相等
bool typeEqual;
typeEqual = normalClass1.GetType() == normalClass2.GetType(); // typeEqual == true
typeEqual = normalClass1.GetType() == normalClass3.GetType(); // typeEqual == true
typeEqual = normalClass1.GetType() == normalClass4.GetType(); // typeEqual == true
typeEqual = normalClass2.GetType() == normalClass3.GetType(); // typeEqual == true
}
private void button2_Click(object sender, EventArgs e) {
GeneralizationClass <TestClass1 > genClass1;
GeneralizationClass <TestClass2 > genClass2;
GeneralizationClass <TestClass3 > genClass3;
GeneralizationClass <TestClass4 > genClass4;
int typeCount;
genClass1 = new GeneralizationClass <TestClass1 >();
typeCount = GeneralizationClass <TestClass1 >.TypeCount; // typeCount == 1
genClass2 = new GeneralizationClass <TestClass2 >();
typeCount = GeneralizationClass <TestClass2 >.TypeCount; // typeCount == 1
genClass1 = new GeneralizationClass <TestClass1 >();
typeCount = GeneralizationClass <TestClass1 >.TypeCount; // typeCount == 1
genClass3 = new GeneralizationClass <TestClass3 >();
typeCount = GeneralizationClass <TestClass3 >.TypeCount; // typeCount == 1
genClass4 = new GeneralizationClass <TestClass4 >();
typeCount = GeneralizationClass <TestClass4 >.TypeCount; // typeCount == 1
genClass1 = new GeneralizationClass <TestClass1 >();
typeCount = GeneralizationClass <TestClass1 >.TypeCount; // typeCount == 1
genClass3 = new GeneralizationClass <TestClass3 >();
typeCount = GeneralizationClass <TestClass3 >.TypeCount; // typeCount == 1
// 对比类类型是否相等
bool typeEqual;
typeEqual = genClass1.GetType() == genClass2.GetType(); // typeEqual == false
typeEqual = genClass1.GetType() == genClass3.GetType(); // typeEqual == false
typeEqual = genClass1.GetType() == genClass4.GetType(); // typeEqual == false
typeEqual = genClass2.GetType() == genClass3.GetType(); // typeEqual == false
}
}
通过上面的测试语句，相信大家已经明白。