Question

我正在处理与Question 222511类似的问题我需要使用MemberInit表达式，所以我可以将它们添加到构造函数中......我正在尝试实现John Skeet's回答但是我正在运行成为一个巨大的性能差异。以下是一些代码：

// Method A:
// This work good, is fast and returns an un-executed query...
DataContext.LoanNote.Join<LoanNote, Customer, int, LoanNote>(
    DataContext.Customers, loanNote => loanNote.PrimaryCustomerNumber, customer => customer.CustomerNumber,
(LoanNote loanNote, Customer customer) => new LoanNote()
{
    AccountFeeBillAmount = loanNote.AccountFeeBillAmount,
    AccountOpenDate = loanNote.AccountOpenDate,
    // This goes on and on...
    PrimaryCustomer = customer
});

// Method B:
// This on the other hand is a lot slower and I am not sure why...
var resultSelector = BuildJoinResultSelector<LoanNote, Customer, LoanNote("PrimaryCustomer").Compile();

DataContext.LoanNote.Join<LoanNote, Customer, int, LoanNote>(
        DataContext.Customers, loanNote => loanNote.PrimaryCustomerNumber, customer => customer.CustomerNumber, resultSelector);


// The build MemberInitExpression method...
private static Expression<Func<TOuter, TInner, TResult>> BuildJoinResultSelector<TOuter, TInner, TResult>(string propertyName) where TResult : class
        {
            var result = default(Expression<Func<TOuter, TInner, TResult>>);
            var resultType = typeof(TResult);
            var outerType = typeof(TOuter);
            var innerType = typeof(TInner);
            var outer = Expression.Parameter(outerType, "outer");
            var inner = Expression.Parameter(innerType, "inner");
            var bindings = new List<MemberBinding>();

            foreach (var property in resultType.GetProperties())
            {
                if (property.CanRead == false)
                {
                    continue;
                }
                else if (property.CanWrite == false)
                {
                    continue;
                }
                else if (property.Name == propertyName)
                {
                    var condition = Expression.Condition(Expression.Equal(inner, Expression.Constant(null)), Expression.New(innerType), inner);

                    bindings.Add(Expression.Bind(property, condition));
                }
                else
                {
                    bindings.Add(Expression.Bind(property, Expression.Property(outer, property)));
                }
            }

            var memberInit = Expression.MemberInit(Expression.New(resultType), bindings);

            result = Expression.Lambda<Func<TOuter, TInner, TResult>>(memberInit, outer, inner);

            return result;
        }

Answer 1

第二种方法执行速度较慢，因为它使用反射（GetProperties调用）。

如果您多次调用它，可以像这样缓存GetProperties的结果：

static class PropertiesCache<T> { 
    public static readonly PropertyInfo[] Properties = typeof(T).GetProperties();
}

每种类型只会调用GetProperties一次;像这样使用：

foreach (var property in PropertiesCache<TResult>.Properties) {
    if(!property.CanRead || !property.CanWrite) continue;

    //...
}

修改：

您还可以使用LINQ查询替换整个循环，如下所示：

var memberInit = Expression.MemberInit(Expression.New(typeof(TResult)), from property in PropertiesCache<TResult>.Properties where property.CanRead && property.CanWrite select Expression.Bind(property, property.Name == propertyName ? Expression.Coalesce(inner, Expression.New(innerType)) : Expression.Property(outer, property) ) );

与MemberInit Expression的性能差异

1 个答案: