将多个不同类型的 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")        

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

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

---

更新 - 避免更多混乱

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

---

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

Answer 2

您需要编译表达式：

class Address
{
    public string city { get; set; }
    public string country { get; set; }
}

class ObjectA
{
    public int Id { get; set; }
    public Address address { get; set; }
}

class ObjectB
{
    public int Id { get; set; }
    public ObjectA objectA { get; set; }
}


Expression<Func<ObjectB, bool>> expected = b =>
    (b.Id == 100) &&
    (b.objectA.Id > 1 && b.objectA.address.city == "City1" || b.objectA.address.country == "US");

// Compile the Expression
var expectedItems = expected.Compile();

List<ObjectB> objBs = new List<ObjectB>();

var address = new Address();
var objA = new ObjectA();
var objB = new ObjectB();
address.city = "City1";
address.country = "US";
objA.Id = 1;
objB.Id = 100;
objA.address = address;
objB.objectA = objA;
objBs.Add(objB);

address = new Address();
objA = new ObjectA();
objB = new ObjectB();
address.city = "City2";
address.country = "US";
objA.Id = 3;
objB.Id = 100;
objA.address = address;
objB.objectA = objA;
objBs.Add(objB);

// Use expectedItems
var result = objBs.FirstOrDefault(b => expectedItems(b));