使用ExpressionTree將MemberAcces創建為複雜類型

Question

使用ExpressionTree將MemberAcces創建為複雜類型

c# expression expression-trees lambda linq

題

我想動態創建一個MemberAcess Expression到更深層次然後1（遞歸）：

public class Job
{
    public string Name { get; set; }
    public int Salary { get; set; }
}
public class Employee
{
    public string Name { get; set; }
    public Job Job { get; set; }
}

我想為Employee中的每個屬性和Employee的複雜成員中的每個屬性動態創建MemberAccesExpressions列表，結果應該是這樣的：

MemberAccesExpression[] {
    { e => e.Name },
    { e => e.Job.Name },
    { e => e.Job.Name }
}

這是我得到的偽代碼：

List list = new List();
public Expression<Func<TModel, dynamic>> CreateME<TModel>(TModel model)
{
        var type = typeof (TModel);
        var properties = type.GetProperties();
        foreach (var prop in properties)
        {
            // I want to ignore collections
            if (typeof(ICollection).IsAssignableFrom(prop.PropertyType)) continue;

            // Recall for complex property
            if (prop.PropertyType.Namespace != "System")
            {
                // CreateME(model, ) // THIS IS WHEN I DON'T KNOW WHAT TO DO
                continue;
            }

            var param = Expression.Parameter(type, "x");
            var memberAccess = Expression.PropertyOrField(param, prop.Name);
            list.Add(Expression.Lambda<Func<TModel, dynamic>>(memberAccess, param));
        }
}

我如何使這成為一個遞歸方法？我想添加一個名為（TModel模型，Expression> baseMemberAccess = null）的可選參數，並且如果它不為null，則以某種方式將成員表達式連接到baseMemberAccess。

PS是否有更好的方法來確定Type是否不是原子類型（prop.PropertyType.Namespace！=“System”）？（不是int，float，string等......）

亞當，感謝任何幫助

嘗試更簡單地編輯它的編輯：

如果我想創建一個成員訪問Employee.Name的表達式樹，這就是我所做的：

        var param = Expression.Parameter(type, "x");
        var memberAccess = Expression.PropertyOrField(param, memberName);
        return Expression.Lambda<Func<TModel, TMember>>(memberAccess, param);

對Employee.Job.Salary的成員訪問權限相當於什麼？

Adam Tal

在 Stack Overflow 上查看更多

Adam Mills · Accepted Answer · 6/22/2012 7:34:59 PM

public IEnumerable<Expression<Func<TModel, dynamic>>> CreateME<TModel>()
    {
        var stack = new Stack<StackItem>();
        var type = typeof(TModel);
        var parameterExpression = Expression.Parameter(type, "x");
        stack.Push(new StackItem(typeof(TModel), parameterExpression));

        while (stack.Count > 0)
        {
            var currentItem = stack.Pop();
            var properties = currentItem.PropertyType.GetProperties();
            foreach (var property in properties)
            {
                if (IsComplexProperty(property))
                    stack.Push(new StackItem(property.PropertyType, Expression.PropertyOrField(currentItem.AccessChainExpression, property.Name)));
                else
                {
                    yield return GetSimplePropertyExpression<TModel>(parameterExpression, currentItem.AccessChainExpression, property.Name);
                }
            }
        }


    }

    private static Expression<Func<TModel, dynamic>> GetSimplePropertyExpression<TModel>(ParameterExpression lhs, Expression accessChain, string propertyName)
    {
        var memberAccess = Expression.Convert(Expression.PropertyOrField(accessChain, propertyName), typeof(object));
        return Expression.Lambda<Func<TModel, dynamic>>(memberAccess, lhs);
    }

    private static bool IsComplexProperty(PropertyInfo p)
    {
        return !typeof (ICollection).IsAssignableFrom(p.PropertyType) && p.PropertyType.Namespace != "System";
    }


    class StackItem
    {
        public StackItem(Type propertyType, Expression accessChainExpression)
        {
            PropertyType = propertyType;
            AccessChainExpression = accessChainExpression;
        }

        public Type PropertyType { get; private set; }
        public Expression AccessChainExpression { get; private set; }
    }

我相信它可以改進，但這應該工作。

使用ExpressionTree將MemberAcces創建為複雜類型

題

Fastest Entity Framework Extensions

一般承認的答案

Performance

Expression Evaluator