LINQ表达式.变量& # 39;p # 39;从作用域引用的类型，但未定义

简化，这里有几行你正在尝试做(我使用字符串代替产品等，但想法是一样的):

        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'变量是什么??

要解决这个问题，我们需要对所有表达式使用完全相同的形参(不仅是name，还有reference)。我们可以像这样修改这段简化的代码:

        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

恕我冒昧，不需要列清单:

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...
    }
}

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