‘Contains ()’ solução alternativa usando o Linq to Entities?

Eu estou tentando criar uma consulta que usa uma lista de ids na cláusula where, usando a API do cliente do Silverlight ADO.Net Data Services (e, portanto, Linq To Entities). Alguém sabe de uma solução alternativa para contém não sendo suportado?

Eu quero fazer algo assim:

List txnIds = new List(); // Fill list var q = from t in svc.OpenTransaction where txnIds.Contains(t.OpenTransactionId) select t; 

Tentei isso:

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

Mas tenho “O método ‘Qualquer’ não é suportado”.

Atualização: EF ≥ 4 suporta Contains diretamente (Checkout Any ), então você não precisa de nenhuma solução alternativa.

 public static IQueryable WhereIn ( this ObjectQuery query, Expression> selector, IEnumerable 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 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>(body, p)); } //Optional - to allow static collection: public static IQueryable WhereIn ( this ObjectQuery query, Expression> selector, params TValue[] collection ) { return WhereIn(query, selector, (IEnumerable)collection); } 

USO:

 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" ); } } 

Você pode voltar atrás codificando alguns e-sql (observe a palavra-chave “it”):

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

Aqui está o código que eu usei para gerar alguns e-sql de uma coleção, YMMV:

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

Do MSDN :

 static Expression> BuildContainsExpression( Expression> valueSelector, IEnumerable 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((accumulate, equal) => Expression.Or(accumulate, equal)); return Expression.Lambda>(body, p); } 

e a consulta se torna:

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

Eu não tenho certeza sobre Silverligth, mas no linq para objects eu sempre uso any () para essas consultas.

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

Para completar o registro, aqui está o código que eu finalmente usei (verificação de erros omitidos para clareza) …

 // How the function is called var q = (from t in svc.OpenTransaction.Expand("Currency,LineItem") select t) .Where(BuildContainsExpression(tt => tt.OpenTransactionId, txnIds)); // The function to build the contains expression static System.Linq.Expressions.Expression> BuildContainsExpression( System.Linq.Expressions.Expression> valueSelector, IEnumerable 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((accumulate, equal) => System.Linq.Expressions.Expression.Or(accumulate, equal)); return System.Linq.Expressions.Expression.Lambda>(body, p); } 

Aqui está um exemplo em que demonstro como escrever consultas baseadas em conjuntos usando o DataServiceContext: http://blogs.msdn.com/phaniraj/archive/2008/07/17/set-based-operations-in-ado-net-data -services.aspx

Muito obrigado. WhereIn método de extensão foi o suficiente para mim. Eu perfilei e gerou o mesmo comando SQL para o DataBase como e-sql.

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

Gerou isto:

 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]) 

Eu acho que um Join in LINQ pode ser um walkaround.

Eu não testei o código embora. Espero que ajude. Felicidades. 🙂

 List txnIds = new List(); // Fill list var q = from t in svc.OpenTransaction join tID in txtIds on t equals tID select t; 

Junte-se ao LINQ:

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

Desculpe novo usuário, eu teria comentado a resposta real, mas parece que não posso fazer isso ainda?

De qualquer forma, em relação à resposta com código de amostra para BuildContainsExpression (), esteja ciente de que se você usar esse método em Entidades de database (ou seja, objects não em memory) e estiver usando IQueryable, ele realmente terá que ir para o database uma vez que basicamente faz um monte de “ou” condições SQL para verificar a cláusula “where in” (execute-o com o SQL Profiler para ver).

Isso pode significar que, se você estiver refinando um IQueryable com vários BuildContainsExpression (), ele não o transformará em uma instrução SQL executada no final, como esperado.

A solução para nós era usar várias junções LINQ para mantê-lo em uma chamada SQL.

Além da resposta selecionada.

Substitua Expression.Or por Expression.OrElse para usar com Nhibernate e fixe Unable to cast object of type 'NHibernate.Hql.Ast.HqlBitwiseOr' to type 'NHibernate.Hql.Ast.HqlBooleanExpression' exceção Unable to cast object of type 'NHibernate.Hql.Ast.HqlBitwiseOr' to type 'NHibernate.Hql.Ast.HqlBooleanExpression' .