可重复使用的表达式[重复项]

Question

此问题已经在这里有了答案：

Convert Linq expression “obj => obj.Prop” into “parent => parent.obj.Prop”（1个答案）

关闭52分钟前。

给出带有Where子句的查询

CollectionA.Where(a => a.Prop1 == val1 && a.Prop2 == val2)

和另一个具有类似Where子句但属性通过引用链接的查询。

CollectionB.Where(b => b.Reference.Prop1 == val1 && b.Reference.Prop2 == val2)

对于功能，它确实起作用：

        Func<A, bool> f1 = a => a.Prop1 == val1 && a.Prop2 == val2;
        Func<B, bool> g1 = b => f1(b.Reference);

对于表达式，这不起作用：

        Expression<Func<A, bool>> f2 = a => a.Prop1 == val1 && a.Prop2 == val2;
        Expression<Func<B, bool>> g2 = b => f2(b.Reference); // <-- Method name expected.

我想使用规范在查询中重用表达式。

喜欢这个：

Specification specification = new Specification(val1, val2)

CollectionA.Where(specification.ToExpression());

CollectionB.Where(specification.ToExpression(x => x.Reference));:


public class Specification 
{
    private readonly int val1;
    private readonly long val2;

    public Specification(int val1, long val2)
    {
        this.val1 = val1;
        this.val2 = val2;
    }

    public Expression<Func<A, bool>> ToExpression()
    {
        return x => x.Prop1 == val1 && x.Prop2 == val2;
    }

    public Expression<Func<B, bool>> ToExpression<B>(Expression<Func<B, A>> navigate)
    {
        // ?
    }
}

如何实施此方法？

[另外，我希望这不仅适用于二进制'and'表达式，而且适用于任何表达式（即，任何组合深度和参数类型）。 （例如a => a.Prop1 == val1 && a.Prop2.Prop2a == val2a && a.Prop2.Prop2a == val2a），但基本上它只是实现我尝试使用上述函数g2执行的操作。

Answer 1

您不能直接调用其他表达式f2(b.Reference)。创建一个编译并调用f2的表达式将是徒劳的。

您实际上想要做的是compose

表达式。制作一个新表达式，该表达式表示一个链接到另一个表达式。您缺少的表达式实际上只是从A中获得B的参数选择器，如下所示：b => b.Reference;

这里有一个方便的Compose方法（类似于this one），用于将它们链接在一起。

class A
{
    public int Prop1 = 1;
    public int Prop2 = 2;
}
class B
{
    public A Reference;
}

class Program
{
    static Expression<Func<A, C>> Compose<A, B, C>(
        Expression<Func<A, B>> fAB, Expression<Func<B, C>> fBC)
    {
        var arg = Expression.Parameter(typeof(A));
        return Expression.Lambda<Func<A, C>>(
            Expression.Invoke(fBC, Expression.Invoke(fAB, arg)), arg);
    }

    static void Main(string[] args)
    {
        int val1 = 1;
        int val2 = 2;

        Func<A, bool> f1 = a => a.Prop1 == val1 && a.Prop2 == val2;
        Func<B, bool> g1 = b => f1(b.Reference);

        Expression<Func<A, bool>> f2 = a => a.Prop1 == val1 && a.Prop2 == val2;
        Expression<Func<B, A>> argSelect = b => b.Reference;
        var g2 = Compose<B, A, bool>(argSelect, f2);    

        A objA = new A();
        B objB = new B() { Reference = objA };
        var g2Compiled = g2.Compile();
        Console.WriteLine(g2Compiled.Invoke(objB));

        // Demonstrate that it's connected to our local variable
        val2 = 3;
        Console.WriteLine(g2Compiled.Invoke(objB));
    }
}