在表达式中使用函数？

Question

背景

我有一个测试通过但在管道中发生错误的示例，我不知道为什么。我想弄清楚发生了什么，但我是表达式构造的新手，不想做任何假设。

这是一种搜索过滤机制。它使用 ServiceStack 的 PredicateBuilder 实现。我基本上有一个我传入的值列表，我希望它构造一个表达式树。我之前只使用Func<T<bool>> 完成了此操作，但意识到我需要使用Expression<Func<T<bool>>> 结束。无赖。

目标

从可重复使用的搜索过滤器类型构建的搜索过滤器，它由Funcs 和Expressions 构建而成，允许我从对象传递字段名称以及我应该匹配并结束的值我们可以运行 Where() 声明的东西。

代码/问题

我正在尝试的通用“可空布尔”过滤器——设置可接受的项目并返回一个用于帮助过滤的函数：

public class NullableBoolFilter : IGenericSearchFilter<bool?>
{
    public Func<bool?, bool> GetFilterFunc(string valuesToProcess)
    {
        var acceptableValues = new List<bool?>();

        if (string.IsNullOrWhiteSpace(valuesToProcess))
        {
            // all values acceptable
            acceptableValues = new List<bool?>{true, false, null};
        }
        else
        {
            if (!valuesToProcess.Contains("0") && !valuesToProcess.Contains("1"))
            {
                throw new ArgumentException("Invalid Nullable boolean filter attribute specified");
            }
            if (valuesToProcess.Contains("0"))
            {
                acceptableValues.Add(false);

            }
            if (valuesToProcess.Contains("1"))
            {
                acceptableValues.Add(true);
            }
        }

        Func<bool?, bool> returnFunc = delegate(bool? item) { return acceptableValues.Any(x=>x == item); };
        return returnFunc;
    }
}

然后我有另一个过滤器，它继承自 NullableBoolFilter 并尝试使用 Func：

public class ClaimsReportIsMDLFilter : NullableBoolFilter, ISearchFilter<vSEARCH_ClaimsReport>
{
    public Expression<Func<vSEARCH_ClaimsReport, bool>> GetExpression(string valuesToProcess)
    {
        var theFunc = base.GetFilterFunc(valuesToProcess);

        Expression<Func<vSEARCH_ClaimsReport, bool>> mdlMatches = item => theFunc(item.IsMDL);

        var predicate = PredicateBuilder.False<vSEARCH_ClaimsReport>();
        predicate = predicate.Or(mdlMatches);

        return predicate;

    }
}

以下测试通过：

public class ClaimsReportIsMDLFilterTests
{
    // ReSharper disable InconsistentNaming
    private readonly vSEARCH_ClaimsReport ItemWithMDL = new vSEARCH_ClaimsReport { IsMDL = true };
    private readonly vSEARCH_ClaimsReport ItemWithoutMDL = new vSEARCH_ClaimsReport { IsMDL = false };
    private readonly vSEARCH_ClaimsReport ItemWithNullMDL = new vSEARCH_ClaimsReport { IsMDL = null };
    // ReSharper restore InconsistentNaming

    [Fact]
    public void WithSearchValueOf1_HidesNonMDLAndNull()
    {

        var sut = this.GetCompiledExpressionForValues("1");

        sut.Invoke(ItemWithMDL).Should().BeTrue();
        sut.Invoke(ItemWithoutMDL).Should().BeFalse();
        sut.Invoke(ItemWithNullMDL).Should().BeFalse();

    }

    private Func<vSEARCH_ClaimsReport, bool> GetCompiledExpressionForValues(string searchValue)
    {
        return new ClaimsReportIsMDLFilter().GetExpression(searchValue).Compile();
    }

}

问题

当我实际尝试运行它时，我收到错误：

从范围“”引用的“vSEARCH_ClaimsReport”类型的变量“参数”，但未定义

这对我来说是有道理的——在评估它时，我没有真正的对象可以传递给Func。但是，我很困惑为什么我的测试可能会通过，但这并没有在实际使用中。

问题

• 为什么我的测试可能通过但我仍然收到此错误？
• 我应该如何着手解决这个问题？
• 有没有一种远程简单的方法可以将Func 转换为Expression，我可以将字段传递到其中？
• 我是否需要放弃通用过滤器的想法并让每个类根据传入的输入手动将表达式添加到PredicateBuilder？这是可行的，但似乎可以进一步减少工作量。

Answer 1

为什么我的测试会通过 [...]

因为您的测试只是将表达式编译成它所代表的代码并调用它。它不需要实际解析表达式树并查看它所代表的代码在做什么，它只是运行它并确保输出正确。

为什么 [...] 我仍然会收到此错误？

因为当您实际使用它时，它不仅仅是执行代码；而是执行代码。相反，它正在查看表达式树以尝试确定代码在做什么以便可以将其转换为其他内容，而不是使其可以作为 C# 代码运行。

您的表达式除了调用委托外什么都不做。遍历表达式树的人无法看到委托内部并知道它在做什么。知道您正在调用另一种方法并不是可以翻译成另一种语言的。

我应该如何开始尝试解决这个问题？

您需要从一开始就生成一个Expression，而不是生成一个Func，然后再创建一个调用它的Expression。

有没有一种远程简单的方法来获取该 Func 并将其转换为我可以将字段传递到的表达式？

没有。您需要提取函数的 IL 代码，将其反编译为 C# 代码，然后构建 Expression 对象来表示该代码。这几乎不会发生。

---

你几乎需要让GetFilterFunc 返回一个Expression，才能让它工作。幸运的是，考虑到你所拥有的，这很容易做到。您只需更改方法签名并将最后两行替换为以下内容：

return item => acceptableValues.Any(x => x == item);

然后瞧。 lambda 可以根据上下文编译成 Expression 对象，而不是委托，因此如果方法的返回类型是 Expression<Func<bool?,bool>>，这就是您将得到的。

现在，在GetExpression 中使用它。首先，PredicateBuilder 并没有真正做任何事情。在表达式中添加 OR FALSE 不会改变任何意义。这一切都可以过去。剩下的就是使用Expression<Func<bool?,bool>> 并通过拉出一个布尔属性将其更改为Expression<Func<vSEARCH_ClaimsReport, bool>>。要做到这一点，表达式的工作量要比委托多一点。我们需要做更多的工作来组合它们，而不是仅仅调用表达式。我们将要编写一个方法来执行此操作：

public static Expression<Func<TFirstParam, TResult>>
    Compose<TFirstParam, TIntermediate, TResult>(
    this Expression<Func<TFirstParam, TIntermediate>> first,
    Expression<Func<TIntermediate, TResult>> second)
{
    var param = Expression.Parameter(typeof(TFirstParam), "param");

    var newFirst = first.Body.Replace(first.Parameters[0], param);
    var newSecond = second.Body.Replace(second.Parameters[0], newFirst);

    return Expression.Lambda<Func<TFirstParam, TResult>>(newSecond, param);
}

这依赖于使用以下方法将一个表达式的所有实例替换为另一个：

public static Expression Replace(this Expression expression,
    Expression searchEx, Expression replaceEx)
{
    return new ReplaceVisitor(searchEx, replaceEx).Visit(expression);
}

internal class ReplaceVisitor : ExpressionVisitor
{
    private readonly Expression from, to;
    public ReplaceVisitor(Expression from, Expression to)
    {
        this.from = from;
        this.to = to;
    }
    public override Expression Visit(Expression node)
    {
        return node == from ? to : base.Visit(node);
    }
}

这样做是用第一个表达式的主体替换第二个表达式参数的所有实例，有效地将该表达式内联到第二个。剩下的就是简单地用一个新的单个参数替换所有参数并将其包装回一个 lambda。

既然我们有了，我们的方法就很简单了：

public Expression<Func<vSEARCH_ClaimsReport, bool>> GetExpression(
    string valuesToProcess)
{
    Expression<Func<vSEARCH_ClaimsReport, bool?>> selector = 
        item => item.IsMDL;
    return selector.Compose(base.GetFilterFunc(valuesToProcess));
}