假定有这样一个方法:
public static void Add<T>(T obj, IList<T> list)
{
list.Add(obj);
}
如果想换成这样调用:{
list.Add(obj);
}
Add(Type type, object obj, object list);
通常的方法是这样的:void Add(Type type, object obj, object list)
{
MethodInfo mi = typeof(MyType).GetMethod("Add");
MethodInfo gmi = mi.MakeGenericMethod(type);
gmi.Invoke(new object[] { obj, list });
}
当然,除了性能上的问题,这个方案是完全可行的。但是经过测试,通过这种包装后的耗时比直接的泛型调用相差将近1000倍。因此还需要一些折中一点的方案。为此,我请教了装配脑袋。他给出了一个非常好的方案:{
MethodInfo mi = typeof(MyType).GetMethod("Add");
MethodInfo gmi = mi.MakeGenericMethod(type);
gmi.Invoke(new object[] { obj, list });
}
先定义一个泛型包装委托:
public delegate void GM<T>(T obj, IList<T> list);
然后再定义一个非泛型包装的接口:interface ING
{
void NGM(object obj, object list);
}
然后再实现这个接口,在实现类中直接调用传入的泛型委托:{
void NGM(object obj, object list);
}
public class GClass<T> : ING
{
private GM<T> m_gmd;
public GClass(GM<T> gmd)
{
m_gmd = gmd;
}
INGClass 成员
}
然后就可以非常简单地使用已有的泛型方法来获得一个非泛型接口实现了:{
private GM<T> m_gmd;
public GClass(GM<T> gmd)
{
m_gmd = gmd;
}
INGClass 成员
}
static ING GetNGC(Type genericType, Type methodType, string methodName)
{
MethodInfo mi = methodType.GetMethod(methodName);
MethodInfo gmi = mi.MakeGenericMethod(genericType);
Delegate gmd = Delegate.CreateDelegate(typeof(GM<>).MakeGenericType(genericType), gmi);
return Activator.CreateInstance(typeof(GClass<>).MakeGenericType(genericType), gmd) as ING;
}
通过执行所返回接口的非泛型方法来达到调用泛型方法的目的:{
MethodInfo mi = methodType.GetMethod(methodName);
MethodInfo gmi = mi.MakeGenericMethod(genericType);
Delegate gmd = Delegate.CreateDelegate(typeof(GM<>).MakeGenericType(genericType), gmi);
return Activator.CreateInstance(typeof(GClass<>).MakeGenericType(genericType), gmd) as ING;
}
ING ng = GetNGC(typeof(int), typeof(MyType), "Add");
ng.NGM(i, list);
比对一下,耗时大约是直接泛型调用耗时的三倍。显然这个方案是一个非常实用的方案。归纳一下,一共需要四步:
ng.NGM(i, list);
- 定义泛型委托;
- 定义非泛型接口;
- 实现这个接口;
- 通过泛型委托获取非泛型接口的实现。
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Reflection.Emit;
using System.Text;
namespace GenericMethodTest
{
/// <summary>
/// 接口生成器
/// </summary>
internal static class InterfaceGenerator
{
private static Random _Random = new Random();
private static char GetRandomLetter()
{
int i = (_Random.Next() % 26) + 97;
byte[] b = BitConverter.GetBytes(i);
return BitConverter.ToChar(b, 0);
}
private static string GetRandomString(int n)
{
char[] chars = new char[n];
for (int i = 0; i < n; i++)
{
chars[i] = GetRandomLetter();
}
return new string(chars);
}
private static void LoadArg(ILGenerator gen, int index)
{
switch (index)
{
case 0:
gen.Emit(OpCodes.Ldarg_0);
break;
case 1:
gen.Emit(OpCodes.Ldarg_1);
break;
case 2:
gen.Emit(OpCodes.Ldarg_2);
break;
case 3:
gen.Emit(OpCodes.Ldarg_3);
break;
default:
if (index < 128)
{
gen.Emit(OpCodes.Ldarg_S, index);
}
else
{
gen.Emit(OpCodes.Ldarg, index);
}
break;
}
}
public static T GetInterface<T>(Delegate GM)
{
if (typeof(T).IsInterface)
{
Type delegateType = GM.GetType();
if (delegateType.IsGenericType)
{
if (typeof(MulticastDelegate).IsAssignableFrom(delegateType.GetGenericTypeDefinition()))
{
Type[] genericTypes = delegateType.GetGenericArguments();
if (genericTypes.Length == 1)
{
Type genericType = genericTypes[0];
#if SAVE
string theFilename = "InterfaceGenerator.Attachments.dll";
#endif
AssemblyName aname = new AssemblyName();
aname.Name = string.Format("InterfaceGenerator.Attachments.{0}", GetRandomString(16));
aname.Version = new Version("2.0.0.0");
AssemblyBuilder assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(aname,
#if SAVE
AssemblyBuilderAccess.RunAndSave
#else
AssemblyBuilderAccess.Run
#endif
);
ModuleBuilder module = assembly.DefineDynamicModule(GetRandomString(8)
#if SAVE
, theFilename
#endif
);
TypeBuilder builder = module.DefineType(GetRandomString(16), TypeAttributes.Sealed | TypeAttributes.Class | TypeAttributes.Public);
builder.AddInterfaceImplementation(typeof(T));
// 先定义成员域,用于保存传入的委托。
FieldBuilder field = builder.DefineField(GetRandomString(8), delegateType, FieldAttributes.Private);
// 定义构造器。
ConstructorBuilder ctor = builder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { delegateType });
ILGenerator ctorGen = ctor.GetILGenerator();
ctorGen.Emit(OpCodes.Ldarg_0);
ctorGen.Emit(OpCodes.Call, typeof(object).GetConstructor(new Type[] { }));
ctorGen.Emit(OpCodes.Ldarg_0);
ctorGen.Emit(OpCodes.Ldarg_1);
ctorGen.Emit(OpCodes.Stfld, field);
ctorGen.Emit(OpCodes.Ret);
// 虽然这么写,但事实上接口只有一个方法。
foreach (MethodInfo bmi in typeof(T).GetMethods())
{
ParameterInfo[] paramInfos = bmi.GetParameters();
Type[] argTypes = new Type[paramInfos.Length];
int i = 0;
foreach (ParameterInfo pi in paramInfos)
{
argTypes[i++] = pi.ParameterType;
}
MethodAttributes attributes = MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.ReuseSlot | MethodAttributes.Public;
MethodBuilder method = builder.DefineMethod(bmi.Name, attributes, bmi.ReturnType, argTypes);
builder.DefineMethodOverride(method, bmi);
MethodInfo dmi = delegateType.GetMethod("Invoke");
ILGenerator methodGen = method.GetILGenerator();
bool hasReturn = false;
if (dmi.ReturnType != typeof(void))
{
methodGen.DeclareLocal(dmi.ReturnType);
hasReturn = true;
}
methodGen.Emit(OpCodes.Ldarg_0);
methodGen.Emit(OpCodes.Ldfld, field);
i = 0;
foreach (ParameterInfo pi in dmi.GetParameters())
{
LoadArg(methodGen, i + 1);
if (!pi.ParameterType.IsAssignableFrom(argTypes[i]))
{
if (argTypes[i].IsClass)
{
methodGen.Emit(OpCodes.Castclass, pi.ParameterType);
}
else
{
methodGen.Emit(OpCodes.Unbox, pi.ParameterType);
}
}
i++;
}
methodGen.Emit(OpCodes.Callvirt, dmi);
if (hasReturn)
{
methodGen.Emit(OpCodes.Stloc_0);
methodGen.Emit(OpCodes.Ldloc_0);
}
methodGen.Emit(OpCodes.Ret);
}
Type target = builder.CreateType();
#if SAVE
assembly.Save(theFilename);
#endif
ConstructorInfo ci = target.GetConstructor(new Type[] { delegateType });
return (T) ci.Invoke(new object[] { GM });
}
}
}
}
return default(T);
}
}
}
using System.Collections.Generic;
using System.Reflection;
using System.Reflection.Emit;
using System.Text;
namespace GenericMethodTest
{
/// <summary>
/// 接口生成器
/// </summary>
internal static class InterfaceGenerator
{
private static Random _Random = new Random();
private static char GetRandomLetter()
{
int i = (_Random.Next() % 26) + 97;
byte[] b = BitConverter.GetBytes(i);
return BitConverter.ToChar(b, 0);
}
private static string GetRandomString(int n)
{
char[] chars = new char[n];
for (int i = 0; i < n; i++)
{
chars[i] = GetRandomLetter();
}
return new string(chars);
}
private static void LoadArg(ILGenerator gen, int index)
{
switch (index)
{
case 0:
gen.Emit(OpCodes.Ldarg_0);
break;
case 1:
gen.Emit(OpCodes.Ldarg_1);
break;
case 2:
gen.Emit(OpCodes.Ldarg_2);
break;
case 3:
gen.Emit(OpCodes.Ldarg_3);
break;
default:
if (index < 128)
{
gen.Emit(OpCodes.Ldarg_S, index);
}
else
{
gen.Emit(OpCodes.Ldarg, index);
}
break;
}
}
public static T GetInterface<T>(Delegate GM)
{
if (typeof(T).IsInterface)
{
Type delegateType = GM.GetType();
if (delegateType.IsGenericType)
{
if (typeof(MulticastDelegate).IsAssignableFrom(delegateType.GetGenericTypeDefinition()))
{
Type[] genericTypes = delegateType.GetGenericArguments();
if (genericTypes.Length == 1)
{
Type genericType = genericTypes[0];
#if SAVE
string theFilename = "InterfaceGenerator.Attachments.dll";
#endif
AssemblyName aname = new AssemblyName();
aname.Name = string.Format("InterfaceGenerator.Attachments.{0}", GetRandomString(16));
aname.Version = new Version("2.0.0.0");
AssemblyBuilder assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(aname,
#if SAVE
AssemblyBuilderAccess.RunAndSave
#else
AssemblyBuilderAccess.Run
#endif
);
ModuleBuilder module = assembly.DefineDynamicModule(GetRandomString(8)
#if SAVE
, theFilename
#endif
);
TypeBuilder builder = module.DefineType(GetRandomString(16), TypeAttributes.Sealed | TypeAttributes.Class | TypeAttributes.Public);
builder.AddInterfaceImplementation(typeof(T));
// 先定义成员域,用于保存传入的委托。
FieldBuilder field = builder.DefineField(GetRandomString(8), delegateType, FieldAttributes.Private);
// 定义构造器。
ConstructorBuilder ctor = builder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { delegateType });
ILGenerator ctorGen = ctor.GetILGenerator();
ctorGen.Emit(OpCodes.Ldarg_0);
ctorGen.Emit(OpCodes.Call, typeof(object).GetConstructor(new Type[] { }));
ctorGen.Emit(OpCodes.Ldarg_0);
ctorGen.Emit(OpCodes.Ldarg_1);
ctorGen.Emit(OpCodes.Stfld, field);
ctorGen.Emit(OpCodes.Ret);
// 虽然这么写,但事实上接口只有一个方法。
foreach (MethodInfo bmi in typeof(T).GetMethods())
{
ParameterInfo[] paramInfos = bmi.GetParameters();
Type[] argTypes = new Type[paramInfos.Length];
int i = 0;
foreach (ParameterInfo pi in paramInfos)
{
argTypes[i++] = pi.ParameterType;
}
MethodAttributes attributes = MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.ReuseSlot | MethodAttributes.Public;
MethodBuilder method = builder.DefineMethod(bmi.Name, attributes, bmi.ReturnType, argTypes);
builder.DefineMethodOverride(method, bmi);
MethodInfo dmi = delegateType.GetMethod("Invoke");
ILGenerator methodGen = method.GetILGenerator();
bool hasReturn = false;
if (dmi.ReturnType != typeof(void))
{
methodGen.DeclareLocal(dmi.ReturnType);
hasReturn = true;
}
methodGen.Emit(OpCodes.Ldarg_0);
methodGen.Emit(OpCodes.Ldfld, field);
i = 0;
foreach (ParameterInfo pi in dmi.GetParameters())
{
LoadArg(methodGen, i + 1);
if (!pi.ParameterType.IsAssignableFrom(argTypes[i]))
{
if (argTypes[i].IsClass)
{
methodGen.Emit(OpCodes.Castclass, pi.ParameterType);
}
else
{
methodGen.Emit(OpCodes.Unbox, pi.ParameterType);
}
}
i++;
}
methodGen.Emit(OpCodes.Callvirt, dmi);
if (hasReturn)
{
methodGen.Emit(OpCodes.Stloc_0);
methodGen.Emit(OpCodes.Ldloc_0);
}
methodGen.Emit(OpCodes.Ret);
}
Type target = builder.CreateType();
#if SAVE
assembly.Save(theFilename);
#endif
ConstructorInfo ci = target.GetConstructor(new Type[] { delegateType });
return (T) ci.Invoke(new object[] { GM });
}
}
}
}
return default(T);
}
}
}
结论:
以下是测试代码:
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
namespace GenericMethodTest
{
// 为泛型方法定义的委托
public delegate void GM<T>(T obj, IList<T> list);
// 为非泛型方法定义的接口
public interface ING
{
void NGM(object obj, object list);
}
class Program
{
static void Main(string[] args)
{
List<int> list = new List<int>();
System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
watch.Reset();
watch.Start();
for (int i = 0; i < 1000000; i++)
{
list.Add(i);
}
watch.Stop();
long l1 = watch.ElapsedMilliseconds;
watch.Reset();
watch.Start();
GM<int> gm = new GM<int>(Program.Add);
for (int i = 0; i < 1000000; i++)
{
gm(i, list);
}
watch.Stop();
long l2 = watch.ElapsedMilliseconds;
watch.Reset();
watch.Start();
MethodInfo mi = typeof(Program).GetMethod("Add");
MethodInfo gmi = mi.MakeGenericMethod(typeof(int));
for (int i = 0; i < 1000000; i++)
{
gmi.Invoke(null, new object[] { i, list });
}
watch.Stop();
long l3 = watch.ElapsedMilliseconds;
watch.Reset();
watch.Start();
ING ng1 = GetNGC(typeof(int), typeof(Program), "Add");
for (int i = 0; i < 1000000; i++)
{
ng1.NGM(i, list);
}
watch.Stop();
long l4 = watch.ElapsedMilliseconds;
watch.Reset();
watch.Start();
ING ng2 = InterfaceGenerator.GetInterface<ING>(new GM<int>(Program.Add));
for (int i = 0; i < 1000000; i++)
{
ng2.NGM(i, list);
}
watch.Stop();
long l5 = watch.ElapsedMilliseconds;
Console.WriteLine("{0}\n{1} vs {2} vs {3} vs {4} vs {5}", list.Count, l1, l2, l3, l4, l5);
Console.ReadLine();
}
public static void Add<T>(T obj, IList<T> list)
{
list.Add(obj);
}
static ING GetNGC(Type genericType, Type methodType, string methodName)
{
MethodInfo mi = methodType.GetMethod(methodName);
MethodInfo gmi = mi.MakeGenericMethod(genericType);
Delegate gmd = Delegate.CreateDelegate(typeof(GM<>).MakeGenericType(genericType), gmi);
return Activator.CreateInstance(typeof(GClass<>).MakeGenericType(genericType), gmd) as ING;
}
}
public class GClass<T> : ING
{
private GM<T> m_gmd;
public GClass(GM<T> gmd)
{
m_gmd = gmd;
}
#region INGClass 成员
public void NGM(object obj, object list)
{
m_gmd((T)obj, (IList<T>)list);
}
#endregion
}
}
using System.Collections.Generic;
using System.Reflection;
using System.Text;
namespace GenericMethodTest
{
// 为泛型方法定义的委托
public delegate void GM<T>(T obj, IList<T> list);
// 为非泛型方法定义的接口
public interface ING
{
void NGM(object obj, object list);
}
class Program
{
static void Main(string[] args)
{
List<int> list = new List<int>();
System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
watch.Reset();
watch.Start();
for (int i = 0; i < 1000000; i++)
{
list.Add(i);
}
watch.Stop();
long l1 = watch.ElapsedMilliseconds;
watch.Reset();
watch.Start();
GM<int> gm = new GM<int>(Program.Add);
for (int i = 0; i < 1000000; i++)
{
gm(i, list);
}
watch.Stop();
long l2 = watch.ElapsedMilliseconds;
watch.Reset();
watch.Start();
MethodInfo mi = typeof(Program).GetMethod("Add");
MethodInfo gmi = mi.MakeGenericMethod(typeof(int));
for (int i = 0; i < 1000000; i++)
{
gmi.Invoke(null, new object[] { i, list });
}
watch.Stop();
long l3 = watch.ElapsedMilliseconds;
watch.Reset();
watch.Start();
ING ng1 = GetNGC(typeof(int), typeof(Program), "Add");
for (int i = 0; i < 1000000; i++)
{
ng1.NGM(i, list);
}
watch.Stop();
long l4 = watch.ElapsedMilliseconds;
watch.Reset();
watch.Start();
ING ng2 = InterfaceGenerator.GetInterface<ING>(new GM<int>(Program.Add));
for (int i = 0; i < 1000000; i++)
{
ng2.NGM(i, list);
}
watch.Stop();
long l5 = watch.ElapsedMilliseconds;
Console.WriteLine("{0}\n{1} vs {2} vs {3} vs {4} vs {5}", list.Count, l1, l2, l3, l4, l5);
Console.ReadLine();
}
public static void Add<T>(T obj, IList<T> list)
{
list.Add(obj);
}
static ING GetNGC(Type genericType, Type methodType, string methodName)
{
MethodInfo mi = methodType.GetMethod(methodName);
MethodInfo gmi = mi.MakeGenericMethod(genericType);
Delegate gmd = Delegate.CreateDelegate(typeof(GM<>).MakeGenericType(genericType), gmi);
return Activator.CreateInstance(typeof(GClass<>).MakeGenericType(genericType), gmd) as ING;
}
}
public class GClass<T> : ING
{
private GM<T> m_gmd;
public GClass(GM<T> gmd)
{
m_gmd = gmd;
}
#region INGClass 成员
public void NGM(object obj, object list)
{
m_gmd((T)obj, (IList<T>)list);
}
#endregion
}
}
测试结果:
方案 | 耗时 | 比对 | 其他优点 |
直接调用 | 18 | 1 | 不通用 |
泛型委托包装 | 43 | 2.39 | 不通用 |
反射 | 16538 | 918.78 | 通用,不需额外定义 |
非泛型接口包装 | 60 | 3.33 | 通用,需要额外定义并实现 |
动态生成的非泛型接口包装 | 72 | 4 | 通用,需要额外定义 |