cláusula "NOT IN" en LINQ to Entidades

Question

¿Hay alguna forma de que pueda crear una cláusula no en la que tendría en SQL Server en Linq para Entidades?

Answer 1

Si está utilizando una colección en memoria como filtro, probablemente sea mejor usar la negación de Contiene(). Tenga en cuenta que esto puede fallar si la lista es demasiado larga, en cuyo caso tendrá que elegir otra estrategia (consulte a continuación el uso de una estrategia para una consulta totalmente orientada a BD).

var exceptionList = new List<string> { "exception1", "exception2" }; 

    var query = myEntities.MyEntity 
         .Select(e => e.Name) 
         .Where(e => !exceptionList.Contains(e.Name)); 

Si está excluyendo basado en otra consulta de base de datos utilizando Except podría ser una mejor elección. (Aquí es un link a las extensiones conjunto admitido en LINQ a Entidades)

var exceptionList = myEntities.MyOtherEntity 
           .Select(e => e.Name); 

    var query = myEntities.MyEntity 
         .Select(e => e.Name) 
         .Except(exceptionList); 

Esto supone una entidad compleja en la que se está excluyendo a algunos que en función alguna propiedad de otra mesa y desea que los nombres de las entidades que no son excluido Si deseaba la entidad completa, tendría que construir las excepciones como instancias de la clase de entidad de modo que satisfaga el operador de igualdad predeterminado (consulte docs).

Answer 2

Probar:

from p in db.Products 
where !theBadCategories.Contains(p.Category) 
select p; 

¿Qué es la consulta SQL que desea traducir en una consulta LINQ?

Answer 3

Tomé una lista y se utiliza,

!MyList.Contains(table.columb.tostring()) 

Nota: Asegúrese de utilizar la lista y no iList

Answer 4

tengo los siguientes métodos de extensión:

public static bool IsIn<T>(this T keyObject, params T[] collection) 
    { 
     return collection.Contains(keyObject); 
    } 

    public static bool IsIn<T>(this T keyObject, IEnumerable<T> collection) 
    { 
     return collection.Contains(keyObject); 
    } 

    public static bool IsNotIn<T>(this T keyObject, params T[] collection) 
    { 
     return keyObject.IsIn(collection) == false; 
    } 

    public static bool IsNotIn<T>(this T keyObject, IEnumerable<T> collection) 
    { 
     return keyObject.IsIn(collection) == false; 
    } 

Uso:

var inclusionList = new List<string> { "inclusion1", "inclusion2" }; 
var query = myEntities.MyEntity 
        .Select(e => e.Name) 
        .Where(e => e.IsIn(inclusionList)); 

var exceptionList = new List<string> { "exception1", "exception2" }; 
var query = myEntities.MyEntity 
        .Select(e => e.Name) 
        .Where(e => e.IsNotIn(exceptionList)); 

Muy útil también cuando se pasa directamente valores:

var query = myEntities.MyEntity 
        .Select(e => e.Name) 
        .Where(e => e.IsIn("inclusion1", "inclusion2")); 

var query = myEntities.MyEntity 
        .Select(e => e.Name) 
        .Where(e => e.IsNotIn("exception1", "exception2")); 

Answer 5

he creado de una manera más similar a la de SQL, creo que es más fácil de entender

var list = (from a in listA.AsEnumerable() 
      join b in listB.AsEnumerable() on a.id equals b.id into ab 
      from c in ab.DefaultIfEmpty() 
      where c != null 
      select new { id = c.id, name = c.nome }).ToList();