Question

我正在尝试使用表达式树，以便我可以选择使用实体框架映射到DTO，其方式与Include指令在DbSet（实现OData的开放式项目的一部分）上工作的方式非常相似。

下面的代码代表一个测试用例。

Expression<Func<Bar, Bar>> mapBar = b => new Bar { BarInt = b.BarInt, BarString = b.BarString };
Expression<Func<Foo, Foo>> mapFoo = f => new Foo { FooInt = f.FooInt, B = null };

Expression<Func<Foo, Foo>> target = f => new Foo { FooInt = f.FooInt, 
    B = new Bar { 
        BarInt=f.B.BarInt, BarString = f.B.BarString 
    } };

注意Foo.B为null，并插入了mapBar表达式。

我已经使用以下ExpressionVisitor

添加了导航属性

public class UpdateExpressionVisitor : ExpressionVisitor
{
    private readonly ParameterExpression _oldExpr;
    private readonly Expression _newExpr;
    public UpdateExpressionVisitor(ParameterExpression oldExpr, Expression newExpr)
    {
        _oldExpr = oldExpr;
        _newExpr = newExpr;
    }

    protected override MemberAssignment VisitMemberAssignment(MemberAssignment node)
    {
        if (node.Member.Name == _oldExpr.Name)
        {
            return node.Update(_newExpr);
        }
        Console.WriteLine(node);
        return base.VisitMemberAssignment(node);
    }
}

但我无法弄清楚如何改变表达式new Bar { BarInt = b.BarInt,...，成为new Bar { BarInt = f.B.BarInt,...

该函数需要某种ExpressionVisitor，如此

public class MergingVisitor : ExpressionVisitor
{
    private readonly ParameterExpression _oldExpr;
    private readonly ParameterExpression _newProp;
    private readonly ParameterExpression _newParent;
    public MergingVisitor(ParameterExpression oldExpr, ParameterExpression newProp, ParameterExpression newParent)
    {
        _oldExpr = oldExpr;
        _newProp = newProp;
        _newParent = newParent;
    }

    protected override Expression VisitMember(MemberExpression node)
    {
        if (node.Expression == _oldExpr)
        {
            /*!!what to do here!!*/
            var ma = Expression.MakeMemberAccess(_newProp, node.Member);
            return Expression.MakeMemberAccess(_newParent, ma.Member);
        }
        return base.VisitMember(node);
    }

并且它们都需要与

之类的东西链接在一起

public static Expression<Func<T, TMap>> MapNavProperty<T, TMap, U, UMap>(this Expression<Func<T, TMap>> parent, Expression<Func<U, UMap>> nav, string propName)
{
    //concern 1 remap name of prop in nav - not sure if I should do this first
    var parentInitVarName = parent.Parameters[0].Name;
    var parentParam = Expression.Parameter(typeof(T), parentInitVarName);
    var propParam = Expression.Parameter(typeof(U), propName);
    var mergeVisitor = new MergingVisitor(nav.Parameters[0], propParam, parentParam);
    var newNavBody = mergeVisitor.Visit(nav.Body); //as MemberExpression;

    //concern 2 replace given property
    var visitor = new UpdateExpressionVisitor(propParam, nav.Body);

    return (Expression<Func<T, TMap>>)visitor.Visit(parent);
}

虽然目前parentParam将在Expression.MakeMemberAccess函数中失败，因为它是T类型（上例中的Foo），而不是类型U.

如何更改子属性的lamda表达式中的变量名称和类型 - 谢谢。

更新

Svick和Ivan Stoev的答案都是博学的解释，两者都很完美 - （传递）单元测试和两个答案的代码都在on GitHub here。非常感谢你们两个人 - 遗憾的是我无法找到2个答案，所以归结为Eeny，meeny，miny，moe。

Answer 1

var parentParam = Expression.Parameter(typeof(T), parentInitVarName);

这不起作用，表达式中的参数不是通过名称标识，而是通过引用标识。你需要做的就是获取父参数。

var propParam = Expression.Parameter(typeof(U), propName);

这对我没有任何意义。 propName是属性的名称，因此您需要使用它来创建成员访问表达式，而不是参数表达式。

public MergingVisitor(ParameterExpression oldExpr, ParameterExpression newProp, ParameterExpression newParent)

您需要将一个表达式（b）替换为另一个表达式（f.B）。为此，我会创建：

public class ReplaceVisitor : ExpressionVisitor
{
    private readonly Expression _oldExpr;
    private readonly Expression _newExpr;

    public ReplaceVisitor(Expression oldExpr, Expression newExpr)
    {
        _oldExpr = oldExpr;
        _newExpr = newExpr;
    }

    public override Expression Visit(Expression node)
    {
        if (node == _oldExpr)
        {
            return _newExpr;
        }
        return base.Visit(node);
    }
}

public UpdateExpressionVisitor(ParameterExpression oldExpr, Expression newExpr)

将oldExpr作为参数表达式没有任何意义。你需要的只是一个string。

var visitor = new UpdateExpressionVisitor(propParam, nav.Body);

您需要在此处实际使用newNavBody。

整个MapNavProperty()现在看起来像这样：

var parentParam = parent.Parameters.Single();
var propExpression = Expression.Property(parentParam, propName);
var mergeVisitor = new ReplaceVisitor(nav.Parameters.Single(), propExpression);
var newNavBody = mergeVisitor.Visit(nav.Body);

var visitor = new UpdateExpressionVisitor(propName, newNavBody);

return (Expression<Func<T, TMap>>)visitor.Visit(parent);

通过这些更改，您的代码将正常运行。

Answer 2

我个人会使用不同的助手：

（1）替换参数

static Expression ReplaceParameter(this LambdaExpression lambda, Expression target)
{
    return lambda.Body.ReplaceParameter(lambda.Parameters.Single(), target);
}

static Expression ReplaceParameter(this Expression expression, ParameterExpression source, Expression target)
{
    return new ParameterReplacer { Source = source, Target = target }.Visit(expression);
}

class ParameterReplacer : ExpressionVisitor
{
    public ParameterExpression Source;
    public Expression Target;
    protected override Expression VisitParameter(ParameterExpression node)
    {
        return node == Source ? Target : base.VisitParameter(node);
    }
}

（2）替换成员分配值

static Expression ReplaceMemberAssignment(this Expression expression, MemberInfo member, Expression value)
{
    return new MemberAssignmentReplacer { Member = member, Value = value }.Visit(expression);
}

class MemberAssignmentReplacer : ExpressionVisitor
{
    public MemberInfo Member;
    public Expression Value;
    protected override MemberAssignment VisitMemberAssignment(MemberAssignment node)
    {
        return node.Member == Member ? node.Update(Value) : base.VisitMemberAssignment(node);
    }
}

使用这些助手，有问题的功能将是这样的：

public static Expression<Func<T, TMap>> MapNavProperty<T, TMap, U, UMap>(this Expression<Func<T, TMap>> parent, Expression<Func<U, UMap>> nav, string propName)
{
    var parameter = parent.Parameters[0];
    var body = parent.Body.ReplaceMemberAssignment(
        typeof(TMap).GetProperty(propName),
        nav.ReplaceParameter(Expression.Property(parameter, propName))
    );
    return Expression.Lambda<Func<T, TMap>>(body, parameter);
}

将MemberInitExpression分配给属性

更新

2 个答案: