c# - 将多个不同类型的 lambda 表达式组合成一个表达式

Question

我想组合一些分离的 lambda 表达式并构建它们的最终表达式。

示例类：

class Address {
   public string city { get; set; }
   public string country { get; set; }
}
class ClassA {
   public int Id { get; set; }
   public Address address { get; set; }
}
class ClassB {
   public int Id { get; set; }
   public ClassA objectA { get; set; } 
}

每个类都有一个 lambda 表达式：

Expression<Func<ClassA,bool>> classARule = a =>
                     a.Id > 1 && a.address.city == "city1" || a.address.country == "us"

Expression<Func<ClassB,bool>> classBRule = b => b.Id == 100 

因为ClassB有一个属性，ClassA可以创建同时具有这两个条件的表达式。例子 ：

// I want to create this expected object at runtime using classARule and classBRule 
Expression<Func<ClassB,bool>> expected = b =>
     (b.Id == 100) &&
     (b.objectA.Id > 1 && b.objectA.address.city == "city1" || b.objectA.address.country == "us")        

如果我想在运行时生成预期的表达式，我应该以某种方式将a参数转换classARule为b.objectA

问题是我知道如何组合两个表达式，但我不知道如何a用其他对象替换参数。在这种情况下b.objectA

---

更新 - 为了避免更多的混乱

目标是在运行时使用和实现Expression<Func<ClassB,bool>> expected表达classARuleclassBRule

---

标签： c#expressionlambda

Answer 1

幸运的是，我解决了这个问题。如果遇到这样的问题，这里的最终结果是给其他人的。

public static Expression<Func<B, bool>> Combine<B, A>(this Expression<Func<B, bool>> expr1, Expression<Func<A, bool>> expr2, Expression<Func<B, A>> property)
{
    // this is (q) parameter of my property 
    var replaceParameter = property.Parameters[0]; 

    // replacing all (b) parameter with the (q)
    // these two lines converts `b => b.Id == 100` to `q => q.Id == 100` 
    // using ReplaceExpVisitor class
    var leftVisitor = new ReplaceExpVisitor(replaceParameter); 
    var left = leftVisitor.Visit(expr1.Body);

    // the property body is 'q.objectA'
    var replaceBody = property.Body;

    // now i'm replacing every (a) parameter of my second expression to 'q.objectA'
    // these two lines convert this statement:
    //   a.Id > 1 && a.address.city == "city1" || a.address.country == "us"
    // to this :
    //   q.objectA.Id > 1 && q.objectA.address.city == "city1" || q.objectA.address.country == "us"
    var rightVisitor = new ReplaceExpVisitor(replaceBody);
    var right = rightVisitor.Visit(expr2.Body);

    // creating new expression and pass (q) reference to it (replaceParameter).
    return Expression.Lambda<Func<B, bool>>(Expression.AndAlso(left, right), replaceParameter);
}

// this is a simple class to replace all parameters with new expression
private class ReplaceExpVisitor : ExpressionVisitor
{
    private readonly Expression _newval;

    public ReplaceExpVisitor(Expression newval) => _newval = newval;

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

用法 ：

var result = classBRule.Combine(classARule, q => q.objectA);

// or
Expression<Func<ClassB,bool>> result =
          Combine<ClassB, ClassA>(classBRule, classARule, q => q.objectA);

/* 
result is equal to the expected expression in the first example now
result output :

q => 
  ((q.Id == 100) && 
  (((q.objectA.Id > 1) && (q.objectA.address.city == "city1")) || 
  (q.objectA.address.country == "us")))

*/

https://dotnetfiddle.net/KnV3Dz