Question

上下文

我正在制作一个Expression解析器，它会接受我的LINQ查询，并将它们转换为特定的字节数组。想想ORM的自定义数据存储，euhm，东西。我会在我的例子中使用SQL来熟悉。

class ExpressionParser<T>
{
    public string ParseWhere(Expression<Func<T, bool>> predicate)
    {
        // Takes an expression, follows the expression tree, building an SQL query.
    }
}

实施例

使用一些虚拟属性来获取示例类FooData：

class FooData
{
    public int Status { get; set; }
    public bool Active { get; set; }
}

var parser = new ExpressionParser<FooData>();
var query = parser.ParseWhere(foo => foo.Active && (foo.Status == 3 || foo.Status == 4));
// Builds "WHERE active AND (status = 3 OR status = 4)"

这很好用，我的解析器遍历表达式树，构建一个WHERE语句，然后返回它。

问题：

现在我看到，例如，Active && (Status == 3 || Status == 4)是一个特殊情况，将在整个项目中使用。所以我很自然地将它提取到计算属性：

class FooData
{
    public int Status { get; set; }
    public bool Active { get; set; }
    public bool IsSpecialThing => Active && (Status == 3 || Status == 4);
}

var query = parser.ParseWhere(foo => foo.IsSpecialThing);

如果要评估表达式，结果将是相同的。但是，这不再起作用了。我得到的不是a full expression tree，而是a tree with one PropertyExpression，而不是告诉我什么。

我尝试将其更改为方法，添加[MethodImpl(MethodImplOptions.AggressiveInlining)]属性，似乎没有任何内容使Expression在我的方法/属性中显示。

问题：

是否有可能让Expression看得更深 - 进入属性getter /方法体？如果不是 - 那么Expression会有替代吗？

如果根本不可能，在这种情况下应该怎么做？它真的很难在项目中复制粘贴数十个（数百？）次查询的长篇部分。

Answer 1

这里的问题是：

public bool IsSpecialThing => Active && (Status == 3 || Status == 4);

等同于：

public bool IsSpecialThing { get { return Active && (Status == 3 || Status == 4); } }

请注意，它们都是编译的方法。您可以看到这一点，因为类型为Func<FooData,bool>，而不是Expression<Func<FooData,bool>>。简答：不，你不能检查它*

如果用这个替换你的类定义：

public class FooData
{
    public int Status { get; set; }
    public bool Active { get; set; }

    public static Expression<Func<FooData, bool>> IsSpecialThing = (foo) => foo.Active && (foo.Status == 3 || foo.Status == 4); 
}

然后您可以按如下方式使用它：

var parser = new ExpressionParser<FooData>();
var query = parser.ParseWhere(FooData.IsSpecialThing);

请注意，这会带来更多困难。我假设你想要写一些类似的东西：

ParseWhere(f => f.IsSpecialThing() && f.SomethingElse)

这里的问题是IsSpecialThing是它自己的lambda函数，它有自己的参数。所以这相当于写作：

ParseWhere(f => (ff => IsSpecialThing(ff)) && f.SomethingElse)

要解决此问题，您需要编写一些帮助方法，让您AND和OR LambdaExpression正确：

public class ParameterRewriter<TArg, TReturn> : ExpressionVisitor
{
    Dictionary<ParameterExpression, ParameterExpression> _mapping;
    public Expression<Func<TArg, TReturn>> Rewrite(Expression<Func<TArg, TReturn>> expr, Dictionary<ParameterExpression, ParameterExpression> mapping)
    {
        _mapping = mapping;
        return (Expression<Func<TArg, TReturn>>)Visit(expr);
    }

    protected override Expression VisitParameter(ParameterExpression p)
    {
        if (_mapping.ContainsKey(p))
            return _mapping[p];
        return p;
    }
}

以上将采用参数之间的映射，并在给定的表达式树中替换它们。

利用它：

public static class ExpressionExtensions
{
    public static Expression<Func<T, bool>> OrElse<T>(this Expression<Func<T, bool>> left, Expression<Func<T, bool>> right)
    {
        var rewrittenRight = RewriteExpression(left, right);

        return Expression.Lambda<Func<T, bool>>(Expression.OrElse(left.Body, rewrittenRight.Body), left.Parameters);
    }

    public static Expression<Func<T, bool>> AndAlso<T>(this Expression<Func<T, bool>> left, Expression<Func<T, bool>> right)
    {
        var rewrittenRight = RewriteExpression(left, right);

        return Expression.Lambda<Func<T, bool>>(Expression.AndAlso(left.Body, rewrittenRight.Body), left.Parameters);
    }

    private static Expression<Func<T, bool>> RewriteExpression<T>(Expression<Func<T, bool>> left, Expression<Func<T, bool>> right)
    {
        var mapping = new Dictionary<ParameterExpression, ParameterExpression>();
        for (var i = 0; i < left.Parameters.Count; i++)
            mapping[right.Parameters[i]] = left.Parameters[i];

        var pr = new ParameterRewriter<T, bool>();
        var rewrittenRight = pr.Rewrite(right, mapping);
        return rewrittenRight;
    }
}

如果你写这个，上面的内容基本上是：

Expression<Func<FooData, bool>> a = f => f.Active;
Expression<Func<FooData, bool>> b = g => g.Status == 5;
Expression<Func<FooData, bool>> c = a.AndAlso(b);

将返回f => f.Active && f.Status == 5（请注意参数g如何替换为f。

全部放在一起：

var parser = new ExpressionParser<FooData>();
var result = parser.ParseWhere(FooData.IsSpecialThing.AndAlso(f => f.Status == 6));

<小时/> ^{*请注意，技术上可能会解析生成的IL，但是你会陷入困境。}

从方法体内获取表达式树

上下文

实施例

问题：

问题：

1 个答案: