使用Linq to Entities来绕过'Contains()'的限制？

Question

我正在尝试创建一个查询，该查询在where子句中使用id列表，并使用Silverlight ADO.Net数据服务客户端api（因此使用Linq To Entities）。是否有人知道绕过不支持Contains的解决方法？

我想做这样的事情：

List<long?> txnIds = new List<long?>();
// Fill list 

var q = from t in svc.OpenTransaction
        where txnIds.Contains(t.OpenTransactionId)
        select t;

尝试了这个：

var q = from t in svc.OpenTransaction
where txnIds.Any<long>(tt => tt == t.OpenTransactionId)
select t;

但是出现了“不支持‘Any’方法”的错误。

- jbloomer

---

注意：Entity Framework 4（在.NET 4中）有一个“Contains”方法，以防万一有人正在阅读本文并不知道它。我知道OP使用的是EF1（.NET 3.5）。 - DarrellNorton

@Darrell 我刚刚浪费了半个小时，因为我跳过了你的评论。我希望我能让你的评论在屏幕上闪烁和移动。 - Chris

Answer 1

更新: EF ≥ 4 直接支持Contains（请查看Any），所以您不需要任何解决方法。

public static IQueryable<TEntity> WhereIn<TEntity, TValue>
  (
    this ObjectQuery<TEntity> query,
    Expression<Func<TEntity, TValue>> selector,
    IEnumerable<TValue> collection
  )
{
  if (selector == null) throw new ArgumentNullException("selector");
  if (collection == null) throw new ArgumentNullException("collection");
  if (!collection.Any()) 
    return query.Where(t => false);

  ParameterExpression p = selector.Parameters.Single();

  IEnumerable<Expression> equals = collection.Select(value =>
     (Expression)Expression.Equal(selector.Body,
          Expression.Constant(value, typeof(TValue))));

  Expression body = equals.Aggregate((accumulate, equal) =>
      Expression.Or(accumulate, equal));

  return query.Where(Expression.Lambda<Func<TEntity, bool>>(body, p));
}

//Optional - to allow static collection:
public static IQueryable<TEntity> WhereIn<TEntity, TValue>
  (
    this ObjectQuery<TEntity> query,
    Expression<Func<TEntity, TValue>> selector,
    params TValue[] collection
  )
{
  return WhereIn(query, selector, (IEnumerable<TValue>)collection);
}

用法：

public static void Main()
{
  using (MyObjectContext context = new MyObjectContext())
  {
    //Using method 1 - collection provided as collection
    var contacts1 =
      context.Contacts.WhereIn(c => c.Name, GetContactNames());

    //Using method 2 - collection provided statically
    var contacts2 = context.Contacts.WhereIn(c => c.Name,
      "Contact1",
      "Contact2",
      "Contact3",
      "Contact4"
      );
  }
}

- Shimmy Weitzhandler

---

警告：当参数为大型集合（我的是8500个项的int列表）时，会发生堆栈溢出。你可能认为传递这样一个列表很疯狂，但我仍然认为这暴露了这种方法的缺陷。 - dudeNumber4

请纠正我，但这意味着当传递的集合（过滤器）为空集时，它基本上会导致返回所有数据，因为它只返回了查询参数。 我希望它过滤所有值，有什么方法可以做到这一点吗？ - Nap

如果您的意思是当检查集合为空时应该返回无结果，那么在上面的片段中替换 if (!collection.Any()) //action; - 将 action 替换为仅返回所请求类型的空查询以获得最佳性能 - 或者只需删除此行。 - Shimmy Weitzhandler

应该将 return WhereIn(query, selector, collection); 替换为 return WhereIn(query, selector, (IEnumerable<TValue>)collection); 以避免不必要的递归。 - Antoine Aubry

我认为代码中存在一个错误。如果提供的值列表为空，则正确的行为应该是不返回任何结果 - 即/查询中不存在集合中的对象。然而，代码却恰恰相反 - 返回所有值，而不是其中的任何一个。我认为你想要的是 "if (!collection.Any()) return query.Where(e => false)"。 - ShadowChaser

Answer 2

你可以退而求其次手写一些 E-SQL（请注意关键词 "it"）：

return CurrentDataSource.Product.Where("it.ID IN {4,5,6}"); 

以下是我用来从一个集合中生成一些e-sql的代码，结果可能会有所不同：

string[] ids = orders.Select(x=>x.ProductID.ToString()).ToArray();
return CurrentDataSource.Products.Where("it.ID IN {" + string.Join(",", ids) + "}");

- Rob Fonseca-Ensor

---

你有关于“it”的更多信息吗？在MSDN示例中，“it”前缀出现了，但我找不到关于何时/为什么需要“it”的解释。 - Robert Claypool

在Entity Framework动态查询中使用，可以查看http://geekswithblogs.net/thanigai/archive/2009/04/29/dynamic-query-with-entity-framework.aspx，Thanigainathan Siranjeevi在那里进行了解释。 - Shimmy Weitzhandler

Answer 3

来自MSDN：

static Expression<Func<TElement, bool>> BuildContainsExpression<TElement, TValue>(
    Expression<Func<TElement, TValue>> valueSelector, IEnumerable<TValue> values)
{
    if (null == valueSelector) { throw new ArgumentNullException("valueSelector"); }
    if (null == values) { throw new ArgumentNullException("values"); }
    ParameterExpression p = valueSelector.Parameters.Single();

    // p => valueSelector(p) == values[0] || valueSelector(p) == ...
    if (!values.Any())
    {
        return e => false;
    }

    var equals = values.Select(
             value => (Expression)Expression.Equal(valueSelector.Body, Expression.Constant(value, typeof(TValue))));

    var body = equals.Aggregate<Expression>((accumulate, equal) => Expression.Or(accumulate, equal));

    return Expression.Lambda<Func<TElement, bool>>(body, p);
} 

查询变成了：

var query2 = context.Entities.Where(BuildContainsExpression<Entity, int>(e => e.ID, ids));

- jbloomer

---

如果你想做一个“不包含”的操作，只需在BuildContainsExpression方法中进行以下编辑：

• Expression.Equal变为Expression.NotEqual
• Expression.Or变为Expression.And

- Merritt

Answer 4

我不确定Silverlight，但在linq to objects中，我总是使用any()来进行这些查询。

var q = from t in svc.OpenTranaction
        where txnIds.Any(t.OpenTransactionId)
        select t;

- AndreasN

---

任何一个函数不接受序列类型的对象——它要么没有参数（这种情况下它只是“空还是非空”），要么它需要一个谓词。 - Jon Skeet

我非常高兴找到了这个答案：）+1谢谢AndreasN - SDReyes

Answer 5

为了完成记录，这是我最终使用的代码（为了清晰起见省略了错误检查）...

// How the function is called
var q = (from t in svc.OpenTransaction.Expand("Currency,LineItem")
         select t)
         .Where(BuildContainsExpression<OpenTransaction, long>(tt => tt.OpenTransactionId, txnIds));



 // The function to build the contains expression
   static System.Linq.Expressions.Expression<Func<TElement, bool>> BuildContainsExpression<TElement, TValue>(
                System.Linq.Expressions.Expression<Func<TElement, TValue>> valueSelector, 
                IEnumerable<TValue> values)
        {
            if (null == valueSelector) { throw new ArgumentNullException("valueSelector"); }
            if (null == values) { throw new ArgumentNullException("values"); }
            System.Linq.Expressions.ParameterExpression p = valueSelector.Parameters.Single();

            // p => valueSelector(p) == values[0] || valueSelector(p) == ...
            if (!values.Any())
            {
                return e => false;
            }

            var equals = values.Select(value => (System.Linq.Expressions.Expression)System.Linq.Expressions.Expression.Equal(valueSelector.Body, System.Linq.Expressions.Expression.Constant(value, typeof(TValue))));
            var body = equals.Aggregate<System.Linq.Expressions.Expression>((accumulate, equal) => System.Linq.Expressions.Expression.Or(accumulate, equal));
            return System.Linq.Expressions.Expression.Lambda<Func<TElement, bool>>(body, p);
        }

- James Bloomer

Answer 6

我认为在LINQ中使用Join可以解决问题。

虽然我还没有测试过代码，但希望能有所帮助。祝好！:-)

List<long?> txnIds = new List<long?>();
// Fill list 

var q = from t in svc.OpenTransaction
        join tID in txtIds on t equals tID
        select t;

在LINQ中加入：

http://weblogs.asp.net/salimfayad/archive/2008/07/09/linq-to-entities-join-queries.aspx

- Gabriel Chung

Answer 7

除了选择的答案之外。

将Expression.Or替换为Expression.OrElse，以便与Nhibernate一起使用，并修复无法将类型为'NHibernate.Hql.Ast.HqlBitwiseOr'的对象强制转换为类型 'NHibernate.Hql.Ast.HqlBooleanExpression'的异常。

- smg

Answer 8

抱歉，新用户，我本来想在实际答案上发表评论的，但似乎我还不能这样做？

无论如何，关于使用BuildContainsExpression()方法的示例代码的答案，请注意，如果您将该方法用于数据库实体（即不在内存中的对象）并且正在使用IQueryable，则它实际上必须转到数据库，因为它基本上执行了许多SQL“或”条件来检查“where in”子句（使用SQL Profiler运行它以查看）。

这意味着，如果您使用多个BuildContainsExpression()来细化IQueryable，它不会像您期望的那样将其转换为一个在最后运行的SQL语句。

我们的解决方法是使用多个LINQ连接来保持它成为一个SQL调用。

- Shannon

Answer 9

这里有一个示例，我演示了如何使用DataServiceContext编写基于集合的查询： http://blogs.msdn.com/phaniraj/archive/2008/07/17/set-based-operations-in-ado-net-data-services.aspx

- Phani Raj

Answer 10

非常感谢。WhereIn 扩展方法已经足够了。我对它进行了剖析，并生成了与 e-sql 相同的 SQL 命令发送到数据库。

public Estado[] GetSomeOtherMore(int[] values)
{
    var result = _context.Estados.WhereIn(args => args.Id, values) ;
    return result.ToArray();
}

生成了这个：

SELECT 
[Extent1].[intIdFRLEstado] AS [intIdFRLEstado], 
[Extent1].[varDescripcion] AS [varDescripcion]
FROM [dbo].[PVN_FRLEstados] AS [Extent1]
WHERE (2 = [Extent1].[intIdFRLEstado]) OR (4 = [Extent1].[intIdFRLEstado]) OR (8 = [Extent1].[intIdFRLEstado])

- javierlinked