写在前面
1）本篇博客并非原创，而是我针对.NET反射相关知识的总结。本篇内容来源汇总于3篇博客。在后面的介绍中会在开头给出对应的链接，方便读者自行学习。
2）本篇博客主要针对表达式树代码进行详细讲解。
反射优化简介
我们知道反射与直接调用相比性能要慢很多，因此本篇主要针对如何对反射进行优化。 目前最常见的优化反射性能的方法就是采用委托：用委托的方式调用需要反射调用的方法（或者属性、字段）。
那么如何得到委托？ 三种方法：Emit、Delegate.CreateDelegate、ExpressionTree 。下面将分别介绍这3中方法。
Emit创建委托
Emit创建委托，主要靠自己编写IL代码。操作IL代码：难度高，而且不易于阅读。所以我对这种方法并不感冒。下面将直接给出代码，在代码中有对应的注释，各位有兴趣可以研究研究。
public class EmitToReflector
{
public delegate void SetValueDelegate(object target, object arg);
public static SetValueDelegate CreatePropertySetter(PropertyInfo property)
{
//验证
if (property == null)
throw new ArgumentNullException("property");
if (!property.CanWrite)
return null;
MethodInfo setMethod = property.GetSetMethod(true);
//创建一个名为PropertySetter的动态方法，其目的就是生成上面的setMethod
DynamicMethod dm = new DynamicMethod("PropertySetter", null,new Type[] { typeof(object), typeof(object) },property.DeclaringType, true);
//创建一个MSIL生成器，为动态方法生成代码
ILGenerator il = dm.GetILGenerator();
//下面全是操作IL
if (!setMethod.IsStatic)
{
il.Emit(OpCodes.Ldarg_0);
}
il.Emit(OpCodes.Ldarg_1);
EmitCastToReference(il, property.PropertyType);
if (!setMethod.IsStatic && !property.DeclaringType.IsValueType)
{
il.EmitCall(OpCodes.Callvirt, setMethod, null);
}
else
il.EmitCall(OpCodes.Call, setMethod, null);
//方法结束，返回
il.Emit(OpCodes.Ret);
//生成对应的委托
return (SetValueDelegate)dm.CreateDelegate(typeof(SetValueDelegate));
}
private static void EmitCastToReference(ILGenerator il, Type type)
{
if (type.IsValueType)
il.Emit(OpCodes.Unbox_Any, type);
else
il.Emit(OpCodes.Castclass, type);
}
}
运行结果：（测试代码我会在文章末尾给出）
后来我了解到，Emit其强大之处在于：可以动态的生成程序集、方法，然后对其进行调用，实现AOP的编程思想。（这个我没了解过，前文只是抛砖引玉之功用）
原文链接：http://www.cnblogs.com/yingql/archive/2009/03/20/1418007.html
Delegate.CreateDelegate创建委托
Delegate.CreateDelegate()也可以创建委托，但是它有一个缺点，就是只能创建参数是强类型（<T>）委托，而不能创建参数是通用类型（Object）委托。
下面的测试代码，说明了Delegate.CreateDelegate()无法创建参数是通用类型的委托。
Person person = new Person();
PropertyInfo propInfo = typeof(Person).GetProperty("Name");
//只能创建强类型委托
//Action<Person, string> setter = (Action<Person, string>)Delegate.CreateDelegate(
// typeof(Action<Person, string>), null, propInfo.GetSetMethod());
//放开这段代码，你会发现便宜错误
Action<object, object> setter = (Action<object, object>)Delegate.CreateDelegate(
typeof(Action<object, object>), null, propInfo.GetSetMethod());
setter(person, "Test");
Console.WriteLine(person.Name);
针对反射，及程序运行时得到对应的Type（如果知道具体的类型，又何必用反射呢？），然后对其进行操作。所以支持参数是通用类型是必须的。
解决具体类型-》通用类型的转换分以下几个步骤
1.具体类型-》泛型，及Action<Person,string>-》Action<TTarget,TValue>。
public class DelegateToReflector<TTarget, TValue>
{
Action<TTarget, TValue> _setter;
public DelegateToReflector(PropertyInfo propertyInfo)
{
if (propertyInfo == null)
throw new ArgumentNullException("propertyInfo");
if (propertyInfo.CanWrite == false)
throw new NotSupportedException("属性不支持写操作。");
MethodInfo m = propertyInfo.GetSetMethod(true);
_setter = (Action<TTarget, TValue>)Delegate.CreateDelegate(typeof(Action<TTarget, TValue>), null, m);
}
}
2.生成赋值委托时，根据入参的属性（Property），无法直接生成Action<TTarget,TValue>。所以在①中把Action<TTarget,TValue>作为类的一个变量。通过构造函数对其进行赋值。这样在②中可以通过Type.MakeGenericType()获取对应的类型，然后创建对应的实例，从而为Action<TTarget,TValue>赋值。
public class GetterSetterFactory
{
public static object CreatePropertySetterWrapper(PropertyInfo propertyInfo)
{
if (propertyInfo == null)
throw new ArgumentNullException("propertyInfo");
if (propertyInfo.CanWrite == false)
throw new NotSupportedException("属性不支持写操作。");
MethodInfo mi = propertyInfo.GetSetMethod(true);
if (mi.GetParameters().Length > 1)
throw new NotSupportedException("不支持构造索引器属性的委托。");
Type instanceType = typeof(DelegateToReflector<,>).MakeGenericType(propertyInfo.DeclaringType, propertyInfo.PropertyType);
return Activator.CreateInstance(instanceType, propertyInfo);
}
}
3.通过①、②得到可用的Action<TTarget,TValue>（setter）后。下面就是调用。调用将以通用的形式（setter(object,object)）的形式调用。可以定义一个接口
public interface ISetValue
{
void Set(object target, object val);
}
public class DelegateToReflector<TTarget, TValue> : ISetValue
{
//...之前的代码
public void Set(object target, object value)
{
_setter((TTarget)target, (TValue)value);
}
}
public class GetterSetterFactory
{
public static ISetValue CreatePropertySetterWrapper(PropertyInfo propertyInfo)
{
//...之前的代码
return (ISetValue)Activator.CreateInstance(instanceType, propertyInfo);
}
}
4.最后就是测试代码
static void TestDelegateToReflector()
{
int count = 1000000;
Person testObj = new Person();
PropertyInfo propInfo = typeof(Person).GetProperty("Name");
Console.Write("泛型委托花费时间： ");
DelegateToReflector<Person, string> setter3 = new DelegateToReflector<Person, string>(propInfo);
Stopwatch watch4 = Stopwatch.StartNew();
for (int i = 0; i < count; i++)
setter3.Set(testObj, "Test");
watch4.Stop();
Console.WriteLine(watch4.Elapsed.ToString());
Console.Write("通用接口花费时间： ");
var setter4 = GetterSetterFactory.CreatePropertySetterWrapper(propInfo);
Stopwatch watch5 = Stopwatch.StartNew();
for (int i = 0; i < count; i++)
setter4.Set(testObj, "Test");
watch5.Stop();
Console.WriteLine(watch5.Elapsed.ToString());
}
结论：Delegate.CreateDelegate创建委托，代码可读性Emit创建委托好太多，但是实现上有一些绕（由于无法直接映射Action<object,object>，所以需要绕了一个大圈子来解决这个问题），不够直接。
原文链接：http://www.cnblogs.com/fish-li/archive/2013/02/18/2916253.html
表达式树（Expression）创建委托
表达式树创建委托，实现的思路上比Delgate.CreateDelagate直接，代码的实现上也易于阅读。依旧以SetProperty()作为示例，Delegate.CreateDelegate()无法直接创建Action<object,object>，而表达式树可以直接创建Action<object,object>。
public static Action<object, object> InitSetter(PropertyInfo propertyInfo)
{
//((T)instance).Property = ((V)parm)
//定义两个参数：instance（属性的拥有者），parm（要设置的值）
var instance = Expression.Parameter(typeof(object), "instance");
var parm = Expression.Parameter(typeof(object), "parm");
//判断方法是否是静态的，若非静态方法，需要把instance转换为对应的类型
var instanceCast = propertyInfo.GetSetMethod().IsStatic ? null : Expression.Convert(instance, propertyInfo.ReflectedType);
//参数类型转换（(V)parm）
var parmCast = Expression.Convert(parm, propertyInfo.PropertyType);
//((T)instance).Property
var property = Expression.Property(instanceCast, propertyInfo);
//属性赋值操作 ((T)instance).Property = ((V)parm)
var setProperty = Expression.Assign(property, parmCast);
//定义委托
var lambda = Expression.Lambda<Action<object, object>>(setProperty, instance, parm);
//创建委托
return lambda.Compile();
}
说明：
1.Expression有许多静态方法，你需要自行了解。
2.代码已经给出对应的注释，我想不用我多作赘述了。
3.注意这个方法的第一行注释，就是这个方法的实现思路。
4.表达式树需要做对应的类型转换，这点一定要切记。
最后就是测试代码：
static void TestExpressionToReflector()
{
int count = 1000000;
Person testObj = new Person();
PropertyInfo propInfo = typeof(Person).GetProperty("Name");
Console.Write("泛型委托花费时间： ");
DelegateToReflector<Person, string> setter3 = new DelegateToReflector<Person, string>(propInfo);
Stopwatch watch4 = Stopwatch.StartNew();
for (int i = 0; i < count; i++)
setter3.Set(testObj, "Test");
watch4.Stop();
Console.WriteLine(watch4.Elapsed.ToString());
Console.Write("通用接口花费时间： ");
var setter4 = ExpressionToReflector.InitSetter(propInfo);
Stopwatch watch5 = Stopwatch.StartNew();
for (int i = 0; i < count; i++)
setter4(testObj, "Test");
watch5.Stop();
Console.WriteLine(watch5.Elapsed.ToString());
}
原文链接：http://www.cnblogs.com/JeffreyZhao/archive/2008/11/24/1338682.html
结束语：优化反射，一般都是通过创建委托来对其进行优化。三种生成委托的方法，我个人最喜欢表达式树，理由：直接。思路直接，实现直接。其实处理反射，还有一种运行时处理方法---dynamic。最后，感谢大家的耐心阅读。测试代码下载
