反射性能 - 创建委托（属性C＃）(Reflection Performance - Create

我在使用反射性能问题。
所以我决定创建我的对象的属性，代表和这么远的：

TestClass cwp = new TestClass();
var propertyInt = typeof(TestClass).GetProperties().Single(obj => obj.Name == "AnyValue");
var access = BuildGetAccessor(propertyInt.GetGetMethod());
var result = access(cwp);

static Func<object, object> BuildGetAccessor(MethodInfo method)
{
    var obj = Expression.Parameter(typeof(object), "o");

    Expression<Func<object, object>> expr =
        Expression.Lambda<Func<object, object>>(
            Expression.Convert(
                Expression.Call(
                    Expression.Convert(obj, method.DeclaringType),
                    method),
                typeof(object)),
            obj);

    return expr.Compile();
}

结果是非常令人满意的，比使用常规方法更快的约30-40倍（ PropertyInfo.GetValue (obj, null); ）

问题是： 怎样才能让一个SetValue一个属性，它的工作方式相同吗？ 遗憾的是没有得到的方式。

我这样做，因为我不能使用方法<T>因为我的应用程序的结构。

Answer 1:

这应该为你工作：

static Action<object, object> BuildSetAccessor(MethodInfo method)
{
    var obj = Expression.Parameter(typeof(object), "o");
    var value = Expression.Parameter(typeof(object));

    Expression<Action<object, object>> expr =
        Expression.Lambda<Action<object, object>>(
            Expression.Call(
                Expression.Convert(obj, method.DeclaringType),
                method,
                Expression.Convert(value, method.GetParameters()[0].ParameterType)),
            obj,
            value);

    return expr.Compile();
}

用法：

var accessor = BuildSetAccessor(typeof(TestClass).GetProperty("MyProperty").GetSetMethod());
var instance = new TestClass();
accessor(instance, "foo");
Console.WriteLine(instance.MyProperty);

随着TestClass ：

public class TestClass 
{
    public string MyProperty { get; set; }
}

打印出来：

FOO

Answer 2:

我想你会用更好CreateDelegate构建如果性能是关键。 既然你知道方法的事先签名，在这里只是GetGetMethod和GetSetMethod的的PropertyInfo ，您可以创建一个委托执行的方法很直接相同的签名。 如果你需要建立一些逻辑（您没有一个方法处理）向与会代表表达会更适合。 我做了不同的路线对这个问题的一些基准测试：

Func<S, T> Getter;
Action<S, T> Setter;
PropertyInfo Property;
public void Initialize(Expression<Func<S, T>> propertySelector)
{
    var body = propertySelector.Body as MemberExpression;
    if (body == null)
        throw new MissingMemberException("something went wrong");

    Property = body.Member as PropertyInfo;



    //approaches:

    //Getter = s => (T)Property.GetValue(s, null);

    //Getter = memberSelector.Compile();

    //ParameterExpression inst = Expression.Parameter(typeof(S));
    //Getter = Expression.Lambda<Func<S, T>>(Expression.Property(inst, Property), inst).Compile();

    //var inst = Expression.Parameter(typeof(S));
    //Getter = Expression.Lambda<Func<S, T>>(Expression.Call(inst, Property.GetGetMethod()), inst).Compile();

    //Getter = (Func<S, T>)Delegate.CreateDelegate(typeof(Func<S, T>), Property.GetGetMethod());



    //Setter = (s, t) => Property.SetValue(s, t, null);

    //var val = Expression.Parameter(typeof(T));
    //var inst = Expression.Parameter(typeof(S));
    //Setter = Expression.Lambda<Action<S, T>>(Expression.Call(inst, Property.GetSetMethod(), val),
    //                                         inst, val).Compile();

    //Setter = (Action<S, T>)Delegate.CreateDelegate(typeof(Action<S, T>), Property.GetSetMethod());
}


//Actual calls (tested under loop):
public T Get(S instance)
{
    //direct invocation:
    //return (T)Property.GetValue(instance, null);

   //calling the delegate:
   //return Getter(instance);
}
public void Set(S instance, T value)
{
    //direct invocation:
    //Property.SetValue(instance, value, null);

   //calling the delegate:
   //Setter(instance, value);
}

结果1000多电话- （获取，设置）：

的GetValue-的SetValue（直接）：3800毫秒，5500毫秒

的GetValue-的SetValue（代表）：3600毫秒，5300毫秒

编译表达式：

  Get: Expression.Property: 280 ms Expression.Call: 280 ms direct compile: 280 ms Set: 300 ms 

创建委托：130毫秒，135毫秒

直接财产电话：70毫秒，70毫秒

我想，你的情况，写：

public static Func<S, T> BuildGetAccessor<S, T>(Expression<Func<S, T>> propertySelector)
{
    return propertySelector.GetPropertyInfo().GetGetMethod().CreateDelegate<Func<S, T>>();
}

public static Action<S, T> BuildSetAccessor<S, T>(Expression<Func<S, T>> propertySelector)
{
    return propertySelector.GetPropertyInfo().GetSetMethod().CreateDelegate<Action<S, T>>();
}

// a generic extension for CreateDelegate
public static T CreateDelegate<T>(this MethodInfo method) where T : class
{
    return Delegate.CreateDelegate(typeof(T), method) as T;
}

public static PropertyInfo GetPropertyInfo<S, T>(this Expression<Func<S, T>> propertySelector)
{
    var body = propertySelector.Body as MemberExpression;
    if (body == null)
        throw new MissingMemberException("something went wrong");

    return body.Member as PropertyInfo;
}

所以，现在给你打电话：

TestClass cwp = new TestClass();
var access = BuildGetAccessor((TestClass t) => t.AnyValue);
var result = access(cwp);

这不是简单的？ 写了一个泛型类在这里处理确切的事情。

Answer 3:

使用动态类型。 他们使用反射引擎盖下，但他们快了很多 。

除此以外...

有与宽容的许可吨自由更快反射库在那里。 我会联系你，但有太多，我不知道这会适合你。 只要搜索CodePlex网站等，当你发现你喜欢的东西，尝试一下。

但是，是的，也许在这之前，觉得如果真的反思就是答案。 经常有其他的解决方案。

编辑：根据要求...

http://geekswithblogs.net/SunnyCoder/archive/2009/06/26/c-4.0-dynamics-vs.-reflection.aspx
http://theburningmonk.com/2010/09/performance-test-dynamic-method-invocation-in-csharp-4/
http://www.mssoftwareconsulting.com/msswc/blog/post/C-40-and-dynamic-performance.aspx

这是常识，据我可以告诉。

文章来源: Reflection Performance - Create Delegate (Properties C#)