在 Linq 的 contains 扩展中使用 Expression<Func<T,X>>。

Question

使用以下示例，我想在我的Contains方法中使用我的Expression，让它通过EF将查询传递到SQL Server。

如何构建这个功能以使其正常工作？

void Main()
{

    IQueryable<Person> qry = GetQueryableItemsFromDB();
    var filtered = qry.Filter(p=>p.CompanyId);

}

public static class Ext
{
    public static IQueryable<T> Filter<T>(this IQueryable<T> items, Expression<Func<T, int>> resolveCompanyIdExpression)
    {      
        IEnumerable<int> validComps = GetCompanyIdsFromDataBase();        
        var exp = Expression.Lambda<Func<T, bool>>(          
            Expression.Call(typeof(Queryable),"Contains", new[] { typeof(Company) },
            Expression.Constant(validComps),
            resolveCompanyIdExpression.Body),
            resolveCompanyIdExpression.Parameters[0]);
        return items.Where(exp);  
    }  

    public static IQueryable<T> Filter<T>(this IQueryable<T> items, Expression<Func<T, IEnumerable<int>>> resolveCompanyIdExpression)
    {      
        IEnumerable<int> validComps = GetCompanyIdsFromDataBase();        
        //No Idea what to do here ?
    }  
}

public class Person
{
    public int CompanyId {get;set;}
}

我知道我可以传递整个条件，但我只想让用户提供如何从相关实体中解析公司。

更新

我决定解析companyId而不是整个公司实体，我可以在内存中获取id列表，如果它是IQueryable或普通数组/IEnumerable我也不介意。

但是我遇到了一些奇怪的错误：

执行 'Extent.Select(o => o).Where(p => (p.Hide = False)).Where(p => (p.Archived = False)).Where(item => System.Int32[].Contains(item.Development.CompanyId))' 期间出现异常。请参阅 InnerException 以获取更多详细信息。

内部异常为

参数表达式无效

更新2

我已编辑代码以反映我真正想要做的事情，但在解决此问题上没有太大进展。

- Richard Friend

---

即使您按照目前的方式使其工作，也会为列表中的每个项目执行单独的往返，因为您的查询基于对象列表。 您需要更改查询以从“validComps”开始，或从数据库获取“IQueryable <T>”并从那里开始。 您还需要将“包含”基于对象的唯一ID而不是整个对象。 - StriplingWarrior

好的，那是我的笔误，应该是 IQueryable<T>。 - Richard Friend

Answer 1

如果我理解正确，您需要的是表达式组合：

public static IQueryable<T> Filter<T>(IQueryable<T> query, Expression<Func<T, int>> getCompanyId) {
    IEnumerable<int> validCompanyIds = GetCompanyIdsFromDatabase();
    Expression<Func<int, bool>> filterByCompanyId = id => validCompanyIds.Contains(id);

    // these generics will actually be inferred, I've just written them to be explicit
    Expression<Func<T, bool>> composed = filterByCompanyId.Compose<T, int, bool>(getCompanyId);
    return query.Where(composed);
}

以下是在表达式上实现Compose()扩展方法的实现：

    /// <summary>
    /// Composes two lambda expressions f(y) and g(x), returning a new expression representing f(g(x)).
    /// This is useful for constructing expressions to pass to functions like Where(). If given x => x.Id and id => ids.Contains(id),
    /// for example, you can create the expression x => ids.Contains(x.Id), which could be passed to Where() for an IQueryable of x's type
    /// </summary>
    /// <typeparam name="TIn">The input of g</typeparam>
    /// <typeparam name="TIntermediate">The output of g and the input of f</typeparam>
    /// <typeparam name="TOut">The output of f</typeparam>
    /// <param name="f">The outer function</param>
    /// <param name="g">The inner function</param>
    /// <returns>A new lambda expression</returns>
    public static Expression<Func<TIn, TOut>> Compose<TIn, TIntermediate, TOut>(this Expression<Func<TIntermediate, TOut>> f, Expression<Func<TIn, TIntermediate>> g)
    {
        // The implementation used here gets around EF's inability to process Invoke expressions. Rather than invoking f with the output of g, we
        // effectively "inline" g by replacing all instances of f's parameter with g's body and creating a new lambda with the rebound body of f and
        // the parameters of g
        var map = f.Parameters.ToDictionary(p => p, p => g.Body);            
        var reboundBody = ParameterRebinder.ReplaceParameters(map, f.Body);
        var lambda = Expression.Lambda<Func<TIn, TOut>>(reboundBody, g.Parameters);
        return lambda;
    }

public class ParameterRebinder : ExpressionVisitor
        { 
            private readonly Dictionary<ParameterExpression, Expression> Map;

            public ParameterRebinder(Dictionary<ParameterExpression, Expression> map)
            {
                this.Map = map ?? new Dictionary<ParameterExpression, Expression>();
            }

            public static Expression ReplaceParameters(Dictionary<ParameterExpression, Expression> map, Expression exp)
            {
                return new ParameterRebinder(map).Visit(exp);
            } 

            protected override Expression VisitParameter(ParameterExpression node)
            {
                Expression replacement;
                if (this.Map.TryGetValue(node, out replacement))
                {
                    return this.Visit(replacement);
                }
                return base.VisitParameter(node);
            }
        }

- ChaseMedallion

Answer 2

尝试使用Expression.Compile()方法：

return items.Where(item => validComps.Contains(resolveCompanyExpression.Compile()(item))).AsQueryable();

- dmg

---

我认为 .Compile 不适用于表达式，对我而言它返回了 Func<T, Company>，在将查询传递到数据库时无法工作。 - Richard Friend

也许这个链接可以帮助你：http://rapidapplicationdevelopment.blogspot.com/2008/03/expression-trees-why-linq-to-sql-is.html - dmg

Answer 3

items 参数不是 IQueryable 吗？如果是，尝试这样：

public static IQueryable<T> FilterByCompany<T>(this IQueryable<T> items, Expression<Func<T, Company>> resolveCompanyExpression)
    where T : EntityBase
{
    IQueryable<Company> validComps = GetCompaniesFromDataBase();

    var exp = Expression.Lambda<Func<T, bool>>(
        Expression.Call(
            typeof(Queryable),
            "Contains",
            new[] { typeof(Company) },
            Expression.Constant(validComps),
            resolveCompanyExpression.Body
        ),
        resolveCompanyExpression.Parameters[0]
    );
    return items.Where(exp);
}

- Balazs Tihanyi

---

在OP的例子中，this是一个List<>。 - Steve Mallory