LINQ 表达式。从范围引用的类型的变量“p”，但未定义答案

【问题标题】：LINQ expressions. Variable 'p' of type referenced from scope, but it is not definedLINQ 表达式。从范围引用的类型的变量“p”，但未定义
【发布时间】：2013-03-23 16:37:45
【问题描述】：

我正在使用此代码动态构建 LINQ 查询。它似乎有效，但是当我的搜索中有多个 searchString 时，（所以当添加多个表达式时，我收到以下错误：

从范围引用的类型变量“p”，但未定义**

我想我只能定义 /use p 一次。但是，如果是这样，我需要稍微修改一下我的代码。谁能在这里指出我正确的方向？

    if (searchStrings != null)
    {
        foreach (string searchString in searchStrings)
        {
            Expression<Func<Product, bool>> containsExpression = p => p.Name.Contains(searchString);
            filterExpressions.Add(containsExpression);
        }
    }

    Func<Expression, Expression, BinaryExpression>[] operators = new Func<Expression, Expression, BinaryExpression>[] { Expression.AndAlso };
    Expression<Func<Product, bool>> filters = this.CombinePredicates<Product>(filterExpressions, operators);

    IQueryable<Product> query = cachedProductList.AsQueryable().Where(filters);

    query.Take(itemLimit).ToList();  << **error when the query executes**


    public Expression<Func<T, bool>> CombinePredicates<T>(IList<Expression<Func<T, bool>>> predicateExpressions, Func<Expression, Expression, BinaryExpression> logicalFunction)
    {
        Expression<Func<T, bool>> filter = null;

        if (predicateExpressions.Count > 0)
        {
            Expression<Func<T, bool>> firstPredicate = predicateExpressions[0];
            Expression body = firstPredicate.Body;
            for (int i = 1; i < predicateExpressions.Count; i++)
            {
                body = logicalFunction(body, predicateExpressions[i].Body);
            }
            filter = Expression.Lambda<Func<T, bool>>(body, firstPredicate.Parameters);
        }

        return filter;
    }

【问题讨论】：

我不太明白。您的 CombinePredicates 似乎需要 n 表达式和 n-1 运算符。但是，在您调用它的地方，您有一个长度为1 的运算符数组。如果要加入的谓词超过2，我预计会出现超出数组范围的异常。
我确实看到了，我拿出一些东西让我的例子更紧凑。但我会改变我的问题，使这部分在技术上是正确的。
我更正了那部分。但问题仍然存在。
当您尝试组合 1 个谓词时是否有效（CombinePredicates 中的循环不会执行，该方法应该只返回谓词）？
这是否与以下问题相同：stackoverflow.com/questions/13967523/…

标签： c# linq expression-trees

【解决方案1】：

简化，这里有几行你正在尝试做（我使用字符串而不是 Product 等，但想法是一样的）：

        Expression<Func<string, bool>> c1 = x => x.Contains("111");
        Expression<Func<string, bool>> c2 = y => y.Contains("222");
        var sum = Expression.AndAlso(c1.Body, c2.Body);
        var sumExpr = Expression.Lambda(sum, c1.Parameters);
        sumExpr.Compile(); // exception here

请注意我是如何将你的 foreach 扩展为两个带有 x 和 y 的表达式 - 这正是编译器的样子，它们是 不同的 参数。

换句话说，你正在尝试做这样的事情：

x => x.Contains("...") && y.Contains("...");

编译器想知道那个'y'变量是什么？？

要修复它，我们需要对所有表达式使用完全相同的参数（不仅是名称，还包括引用）。我们可以像这样修复这个简化的代码：

        Expression<Func<string, bool>> c1 = x => x.Contains("111");
        Expression<Func<string, bool>> c2 = y => y.Contains("222");
        var sum = Expression.AndAlso(c1.Body, Expression.Invoke(c2, c1.Parameters[0])); // here is the magic
        var sumExpr = Expression.Lambda(sum, c1.Parameters);
        sumExpr.Compile(); //ok

因此，修复您的原始代码就像：

internal static class Program
{
    public class Product
    {
        public string Name;
    }

    private static void Main(string[] args)
    {
        var searchStrings = new[] { "111", "222" };
        var cachedProductList = new List<Product>
        {
            new Product{Name = "111 should not match"},
            new Product{Name = "222 should not match"},
            new Product{Name = "111 222 should match"},
        };

        var filterExpressions = new List<Expression<Func<Product, bool>>>();
        foreach (string searchString in searchStrings)
        {
            Expression<Func<Product, bool>> containsExpression = x => x.Name.Contains(searchString); // NOT GOOD
            filterExpressions.Add(containsExpression);
        }

        var filters = CombinePredicates<Product>(filterExpressions, Expression.AndAlso);

        var query = cachedProductList.AsQueryable().Where(filters);

        var list = query.Take(10).ToList();
        foreach (var product in list)
        {
            Console.WriteLine(product.Name);
        }
    }

    public static Expression<Func<T, bool>> CombinePredicates<T>(IList<Expression<Func<T, bool>>> predicateExpressions, Func<Expression, Expression, BinaryExpression> logicalFunction)
    {
        Expression<Func<T, bool>> filter = null;

        if (predicateExpressions.Count > 0)
        {
            var firstPredicate = predicateExpressions[0];
            Expression body = firstPredicate.Body;
            for (int i = 1; i < predicateExpressions.Count; i++)
            {
                body = logicalFunction(body, Expression.Invoke(predicateExpressions[i], firstPredicate.Parameters));
            }
            filter = Expression.Lambda<Func<T, bool>>(body, firstPredicate.Parameters);
        }

        return filter;
    }
}

但请注意输出：

222 should not match
111 222 should match

不是你所期望的。这是在 foreach 中使用 searchString 的结果，应该按以下方式重写：

        ...
        foreach (string searchString in searchStrings)
        {
            var name = searchString;
            Expression<Func<Product, bool>> containsExpression = x => x.Name.Contains(name);
            filterExpressions.Add(containsExpression);
        }
        ...

这是输出：

111 222 should match

【讨论】：

感谢您的详细说明。我在这方面做了更多的工作，现在我注意到当我的“cachedProductList”真的来自 HttpContext.Current.Cache 时，我不时会得到从范围引用的类型的变量“x”，但它不是定义。当我不使用缓存时，一切正常。你知道这是为什么吗？
您在缓存中有实际结果（即 ...smthing.ToList()）还是每次都执行的 IEnumerable？看起来你有第二个选择，而你需要第一个..
不，我将完整的产品列表存储在缓存中。之后我想在该列表上执行我的搜索。
这个 'variable blah blah scope' 异常意味着你的 Expression 不能被编译。它与实际列表本身无关，所以我认为列表的缓存不会以某种方式影响它。您需要进一步隔离它，最简单的步骤是在传递给list.Where(expr) 之前将表达式传递给expr.Compile()。这应该有助于了解问题所在
这是我的问题。在不同的位置定义相同的参数，但参数的“名称”不足以使表达式工作，我不得不在任何地方使用相同的 ParameterExpression 实例。 +1

【解决方案2】：

恕我直言，无需列出：

var filterExpressions = new List<Expression<Func<Product, bool>>>()

在访问者类中，您可以轻松地接受以下内容：

public class FilterConverter : IFilterConverterVisitor<Filter> {

    private LambdaExpression ConditionClausePredicate { get; set; }
    private ParameterExpression Parameter { get; set; }

    public void Visit(Filter filter) {

        if (filter == null) {
            return;
        }

        if (this.Parameter == null) {
            this.Parameter = Expression.Parameter(filter.BaseType, "x");
        }

        ConditionClausePredicate = And(filter);
    }

    public Delegate GetConditionClause() {

        if (ConditionClausePredicate != null) {

            return ConditionClausePredicate.Compile();
        }

        return null;
    }

    private LambdaExpression And(Filter filter) {

        if (filter.BaseType == null || string.IsNullOrWhiteSpace(filter.FlattenPropertyName)) {

            //Something is wrong, passing by current filter
            return ConditionClausePredicate;
        }

        var conditionType = filter.GetCondition();
        var propertyExpression = filter.BaseType.GetFlattenPropertyExpression(filter.FlattenPropertyName, this.Parameter);

        switch (conditionType) {

            case FilterCondition.Equal: {

                var matchValue = TypeDescriptor.GetConverter(propertyExpression.ReturnType).ConvertFromString(filter.Match);
                var propertyValue = Expression.Constant(matchValue, propertyExpression.ReturnType);
                var equalExpression = Expression.Equal(propertyExpression.Body, propertyValue);
                if (ConditionClausePredicate == null) {
                    ConditionClausePredicate = Expression.Lambda(equalExpression, this.Parameter);
                } else {
                    ConditionClausePredicate = Expression.Lambda(Expression.And(ConditionClausePredicate.Body, equalExpression), this.Parameter);
                }
                break;
            }
        // and so on...
    }
}

代码不是最优的，我知道，我是一个初学者，还有很多要实现的东西......但是这些东西确实有效。这个想法是每个访问者类都有唯一的 ParameterExpression，然后使用这个参数构造表达式。之后，只需将每个 LambdaExpression 子句的所有表达式连接起来，并在需要时编译为委托。

【讨论】：