Solução alternativa 'Contains ()' usando Linq to Entities?

86

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

Eu quero fazer algo assim:

List<long?> txnIds = new List<long?>();
// 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<long>(tt => tt == t.OpenTransactionId)
select t;

Mas obteve "O método 'Qualquer' não é compatível".

James Bloomer
fonte
35
Nota: Entity Framework 4 (no .NET 4) tem um método "Contém", apenas no caso de alguém estar lendo isso e não saber sobre ele. Eu sei que o OP estava usando EF1 (.NET 3.5).
DarrellNorton de
7
@Darrell Acabei de perder meia hora porque pulei seu comentário. Eu gostaria de poder fazer seu comentário piscar e marcar a tela.
Chris Dwyer

Respostas:

97

Atualização: EF ≥ 4 suporta Containsdiretamente (Check-out Any), então você não precisa de nenhuma solução alternativa.

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

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"
      );
  }
}
Shimmy Weitzhandler
fonte
6
Atenção; quando arg é uma coleção grande (o meu era 8500 itens da lista interna), estouro de pilha. Você pode achar que é loucura aprovar tal lista, mas acho que isso expõe uma falha nessa abordagem, no entanto.
dudeNumber4
2
Corrija-me se eu estiver errado. mas isso significa que quando a coleção passada (filtro) é um conjunto vazio, basicamente resultará em todos os dados porque apenas retornou o parâmetro de consulta. Eu esperava filtrar todos os valores. Existe uma maneira de fazer isso?
Soneca de
1
Se você quer dizer que, quando a coleção de verificação está vazia, ela não deve retornar resultados, no trecho acima substitua a if (!collection.Any()) //action;ação - substituir simplesmente retornando uma consulta vazia do tipo solicitado para melhor desempenho - ou apenas remova esta linha.
Shimmy Weitzhandler,
1
retornar WhereIn (consulta, seletor, coleção); deve ser substituído por return WhereIn (query, selector, (IEnumerable <TValue>) collection); para evitar recursão indesejada.
Antoine Aubry
1
Acredito que haja um bug no código. Se a lista de valores fornecida estiver vazia, o comportamento correto deve ser não retornar nenhum resultado - ou seja, / nenhum objeto na consulta existe na coleção. No entanto, o código faz exatamente o oposto - todos os valores são retornados, não nenhum deles. Eu acredito que você quer "if (! Collection.Any ()) return query.Where (e => false)"
ShadowChaser
18

Você pode recorrer à codificação manual de e-sql (observe a palavra-chave "it"):

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

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

string[] ids = orders.Select(x=>x.ProductID.ToString()).ToArray();
return CurrentDataSource.Products.Where("it.ID IN {" + string.Join(",", ids) + "}");
Rob Fonseca-Ensor
fonte
1
Você tem mais informações sobre "isso"? O prefixo "isso" aparece nos exemplos do MSDN, mas em nenhum lugar consigo encontrar uma explicação sobre quando / por que "isso" é necessário.
Robert Claypool
1
Usado na consulta dinâmica do Entity Framework, dê uma olhada em geekswithblogs.net/thanigai/archive/2009/04/29/… , Thanigainathan Siranjeevi explica lá.
Shimmy Weitzhandler
13

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

e a consulta se torna:

var query2 = context.Entities.Where(BuildContainsExpression<Entity, int>(e => e.ID, ids));
James Bloomer
fonte
3
Se você quiser fazer um 'Não contém', basta fazer as seguintes edições no método BuildContainsExpression: - Expression.Equal se torna Expression.NotEqual - Expression.Or se torna Expression.And
Merritt
2

Não tenho certeza sobre Silverligth, mas em linq para objetos eu sempre uso any () para essas consultas.

var q = from t in svc.OpenTranaction
        where txnIds.Any(t.OpenTransactionId)
        select t;
AndreasN
fonte
5
Any não leva um objeto do tipo de sequência - ou não tem parâmetros (nesse caso, é apenas "está vazio ou não") ou leva um predicado.
Jon Skeet
Estou muito feliz por ter encontrado esta resposta:) +1 Obrigado AndreasN
SDReyes
1

Para completar o registro, aqui está o código que finalmente usei (verificação de erros omitida para maior clareza) ...

// 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
fonte
0

Muito obrigado. O método de extensão WhereIn foi suficiente para mim. Fiz o perfil dele e gerei 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])
Jrojo
fonte
0

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

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 Entities do banco de dados (ou seja, não em objetos na memória) e estiver usando IQueryable, ele realmente deve ir para o banco de dados uma vez que basicamente executa muitas condições SQL "ou" 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 que é executada no final conforme o esperado.

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

Shannon
fonte
0

Além da resposta selecionada.

Substitua Expression.Orpor Expression.OrElsepara usar com Nhibernate e corrija a Unable to cast object of type 'NHibernate.Hql.Ast.HqlBitwiseOr' to type 'NHibernate.Hql.Ast.HqlBooleanExpression'exceção.

smg
fonte