Clause "NOT IN" dans LINQ to Entities

Question

Est-il possible de créer une clause not in comme dans SQL Server dans Linq to Entities?

Answer 1

Si vous utilisez une collection en mémoire comme filtre, il est probablement préférable d'utiliser la négation de Contains(). Notez que cela peut échouer si la liste est trop longue, auquel cas vous devrez choisir une autre stratégie (voir ci-dessous pour l'utilisation d'une stratégie pour une requête entièrement orientée DB).

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

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

Si vous excluez basé sur une autre requête de base de données en utilisant Except pourrait être un meilleur choix. (Voici un link aux extensions Set pris en charge dans LINQ to Entities)

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

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

Cela suppose une entité complexe dans lequel vous excluez certains d'entre eux selon une propriété d'une autre table et que vous voulez les noms des entités qui ne sont pas exclu. Si vous vouliez l'entité entière, vous devez alors construire les exceptions en tant qu'instances de la classe d'entité de sorte qu'elles satisfassent l'opérateur d'égalité par défaut (voir docs).

Answer 2

Essayez:

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

Quelle est la requête SQL que vous souhaitez traduire dans une requête Linq?

Answer 3

Je pris une liste et utilisé,

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

Remarque: Assurez-vous d'utiliser la liste et non iList

Answer 4

je les méthodes d'extension suivantes:

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

Utilisation:

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

Très utile aussi bien lors du passage des valeurs directement:

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

Je l'ai créé d'une manière plus similaire à SQL, je pense qu'il est plus facile de comprendre

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