Linq to Entities-Cláusula SQL "IN"

Esto debería ser suficiente para tu propósito. Compara dos colecciones y comprueba si una colección tiene los valores que coinciden con los de la otra colección

fea_Features.Where(s => selectedFeatures.Contains(s.feaId))

Si está utilizando VS2008/. net 3.5, consulte el consejo #8 de Alex James: http://blogs.msdn.com/alexj/archive/2009/03/26/tip-8-writing-where-in-style-queries-using-linq-to-entities.aspx

De lo contrario solo use el array.Contiene(someEntity.Miembro) método.

Iré por la Unión Interior en este contexto. Si hubiera utilizado contiene, iteraría 6 veces a pesar del hecho de que solo hay una coincidencia.

var desiredNames = new[] { "Pankaj", "Garg" }; 

var people = new[]  
{  
    new { FirstName="Pankaj", Surname="Garg" },  
    new { FirstName="Marc", Surname="Gravell" },  
    new { FirstName="Jeff", Surname="Atwood" }  
}; 

var records = (from p in people join filtered in desiredNames on p.FirstName equals filtered  select p.FirstName).ToList(); 

Desventajas de Contiene

Supongamos que tengo dos objetos de lista.

List 1      List 2
  1           12
  2            7
  3            8
  4           98
  5            9
  6           10
  7            6

Usando Contains, buscará cada elemento de la Lista 1 en la Lista 2, lo que significa que la iteración ocurrirá 49 veces.!!

Esta podría ser la forma en la que puede usar directamente los métodos de extensión LINQ para verificar la cláusula in

var result = _db.Companies.Where(c => _db.CurrentSessionVariableDetails.Select(s => s.CompanyId).Contains(c.Id)).ToList();

También intenté trabajar con un SQL-IN-like thing - consultando contra un Entity Data Model. Mi enfoque es un constructor de cadenas para componer una expresión OR grande. Eso es terriblemente feo, pero me temo que es la única manera de ir ahora mismo.

Ahora bien, eso se ve así:

Queue<Guid> productIds = new Queue<Guid>(Products.Select(p => p.Key));
if(productIds.Count > 0)
{
    StringBuilder sb = new StringBuilder();
    sb.AppendFormat("{0}.ProductId = Guid\'{1}\'", entities.Products.Name, productIds.Dequeue());
    while(productIds.Count > 0)
    {
        sb.AppendFormat(" OR {0}.ProductId = Guid\'{1}\'",
          entities.Products.Name, productIds.Dequeue());
    }
}

Trabajando con GUID en este contexto: Como puedes ver arriba, siempre hay la palabra "GUID" antes del GUID ifself en los fragmentos de cadena de consulta. Si no agrega esto, ObjectQuery<T>.Where lanza el siguiente excepción:

Los tipos de argumento 'Edm.Guid' y Edm.String ' son incompatibles para esto operación., casi igual expresión, línea 6, columna 14.

Encontrado esto en los foros de MSDN, podría ser útil tener en cuenta.

Matthias

... esperamos la próxima versión de. NET y Entity Framework, cuando todo mejore. :)

Un método alternativo a la respuesta de BenAlabaster

En primer lugar, puede reescribir la consulta de esta manera:

var matches = from Users in people
        where Users.User_Rights == "Admin" ||
              Users.User_Rights == "Users" || 
              Users.User_Rights == "Limited"
        select Users;

Ciertamente esto es más 'verboso' y un dolor de escribir, pero funciona de todos modos.

Así que si tuviéramos algún método de utilidad que hiciera fácil crear este tipo de expresiones LINQ estaríamos en el negocio.

Con un método de utilidad en su lugar se puede escribir algo como esto:

var matches = ctx.People.Where(
        BuildOrExpression<People, string>(
           p => p.User_Rights, names
        )
);

Esto construye una expresión que tiene el mismo efecto as:

var matches = from p in ctx.People
        where names.Contains(p.User_Rights)
        select p;

Pero lo que es más importante en realidad funciona contra.NET 3.5 SP1.

Aquí está la función de fontanería que hace esto posible:

public static Expression<Func<TElement, bool>> BuildOrExpression<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();

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

No voy a tratar de explicar este método, aparte de decir que esencialmente construye una expresión de predicado para todos los valores utilizando el valueSelector (es decir, p => p. User_Rights) y ORs esos predicados juntos para crear una expresión para el predicado completo

Fuente: http://blogs.msdn.com/b/alexj/archive/2009/03/26/tip-8-writing-where-in-style-queries-using-linq-to-entities.aspx

En Serio? Ustedes nunca han usado

where (t.MyTableId == 1 || t.MyTableId == 2 || t.MyTableId == 3)