如何转换表达式树？

Question

更新：

我会尝试解释我的意思。 有 2 个不同类（MyClass1 和 MyClass2）和将 class1 转换为 class2 的方法：

class MyClass1
  {
        //...Some fields and properties
 }

  class MyClass2
   {
        //...Some fields and properties
  }

public MyClass2 Convert(MyClass1 class1)
{
//.....
return class2Object;
}

有 2 种不同的方法：

   void method1(Expression<Func<MyClass1, bool>> where, //other parameters)
    {
        //some operations
        //...............

        //need to call method2(Expression<Func<MyClass2, bool>>)
        //   BUT! How do I convert Expression<Func<MyClass1, bool>> 
        //   to Expression<Func<MyClass2, bool>>
    }

    void method2(Expression<Func<MyClass2, bool>> where, //other parameters)
    {
        //some operations
    }

如何转换 Expression<功能< MyClass1，布尔>>>到表达式<功能< MyClass2，布尔> >

Answer 1

让我猜猜您在问什么：您的 MyClass1 和 MyClass2 看起来相同（它们都有一个 int field1 和一个 string field2）。现在您有一个 Expression>，类似于：

Expression<Func<MyClass1, bool>> exp1 = x => x.field1 == 100; // x is MyClass1

您想要另一个表达式，它看起来相同，但它用于 MyClass2 ：

Expression<Func<MyClass2, bool>> exp2 = x => x.field1 == 100; // x is MyClass2

如果这就是您所问的问题，这是我的答案：

要获取 MyClass2 的表达式，您需要替换 exp1 中的所有 x ，因为 exp1 中的所有 x 都是 MyClass1 类型。 ExpressionVisitor 正是您想要的。

class MyExpressionVisitor : ExpressionVisitor
{
    public ParameterExpression NewParameterExp { get; private set; }

    public MyExpressionVisitor(ParameterExpression newParameterExp)
    {
        NewParameterExp = newParameterExp;
    }

    protected override Expression VisitParameter(ParameterExpression node)
    {
        return NewParameterExp;
    }

    protected override Expression VisitMember(MemberExpression node)
    {
        if (node.Member.DeclaringType == typeof(MyClass1))
            return Expression.MakeMemberAccess(this.Visit(node.Expression), 
               typeof(MyClass2).GetMember(node.Member.Name).FirstOrDefault());
        return base.VisitMember(node);
    }
}

访问者将遍历（称为“访问”）整个表达式，访问所有节点。当涉及到 ParameterExpression 节点时，我们更改该节点（因为它是 MyClass1，所以我们将其更改为 MyClass2，请参阅 VisitParameter 方法）。我们需要改变的另一件事是，当访问者来到像x.field1这样的节点时，它访问的是MyClass1中的field1，我们也需要修改它（参见VisitMember ）。遍历整个exp1后，我们得到一个全新的exp2，替换了一些节点，这就是我们想要的。

Expression<Func<MyClass1, bool>> exp1 = x => x.field1 == 100;

var visitor = new MyExpressionVisitor(Expression.Parameter(typeof(MyClass2), 
                        exp1.Parameters[0].Name));

var exp2 = Expression.Lambda<Func<MyClass2, bool>>
                (visitor.Visit(exp1.Body), visitor.NewParameterExp);

//the following is for testing
var data = new MyClass2();
Console.WriteLine(exp2.Compile()(data));  //False
data.field1 = 100;
Console.WriteLine(exp2.Compile()(data));   //True

Answer 2

表达式树是不可变的，因此要做到这一点，您需要遍历整个树，重建它并用等效项替换该类型的任何使用 - 通常通过编写“访问者”。当遇到 MemberExpression 或 MethodCallExpression 时，您将检查成员的声明类型 - 如果它是您不想要的类型，请重新创建它（Expression.PropertyOrField 在这里很有用）。

请注意，您不能仅在使用它的地方执行此操作；整棵树必须重新生成。我现在不在电脑前，但如果你愿意的话我可以稍后做一个例子；如果您需要此示例，请发表评论。

请注意，由于 int/long 和 char/string 不匹配，这有点复杂。

Answer 3

public CategoryViewModel GetSingle( Expression<Func<CategoryViewModel, bool>> where)
        {
            Expression<Func<DAL.EntityModels.Category, CategoryViewModel>> converter =
                c => ToBll(c);

            var param = Expression.Parameter(typeof(DAL.EntityModels.Category), "category");
            var body = Expression.Invoke(where, Expression.Invoke(converter, param));
            var lambda = Expression.Lambda<Func<DAL.EntityModels.Category, bool>>(body, param);

            return  (CategoryViewModel )_categoryRepository.GetSingle(lambda);

        }

//..............
public T GetSingle(Expression<Func<T, bool>> where)
        {
            return this.ObjectSet.Where(where).FirstOrDefault<T>();
        }

Answer 4

您可以将第一个表达式编译为委托，然后使用
NJection.LambdaConverter 将其转换是一个将委托转换为表达式树的库。