Utilizzare LINQ per ottenere elementi in un Elenco <>, che non sono in un altro Elenco <>

Suppongo che ci sia una semplice query LINQ per farlo, non sono proprio sicuro di come.

Dato questo codice:

class Program
{
    static void Main(string[] args)
    {
        List<Person> peopleList1 = new List<Person>();
        peopleList1.Add(new Person() { ID = 1 });
        peopleList1.Add(new Person() { ID = 2 });
        peopleList1.Add(new Person() { ID = 3 });

        List<Person> peopleList2 = new List<Person>();
        peopleList2.Add(new Person() { ID = 1 });
        peopleList2.Add(new Person() { ID = 2 });
        peopleList2.Add(new Person() { ID = 3 });
        peopleList2.Add(new Person() { ID = 4 });
        peopleList2.Add(new Person() { ID = 5 });
    }
}

class Person
{
    public int ID { get; set; }
}

Vorrei eseguire una query LINQ per darmi tutte le persone peopleList2che non ci sono peopleList1.

Questo esempio dovrebbe darmi due persone (ID = 4 e ID = 5)

Questo può essere risolto usando la seguente espressione LINQ:

var result = peopleList2.Where(p => !peopleList1.Any(p2 => p2.ID == p.ID));

Un modo alternativo di esprimere questo tramite LINQ, che alcuni sviluppatori trovano più leggibili:

var result = peopleList2.Where(p => peopleList1.All(p2 => p2.ID != p.ID));

Avvertenza: come notato nei commenti, questi approcci richiedono un'operazione O (n * m) . Questo potrebbe andare bene, ma potrebbe introdurre problemi di prestazioni, soprattutto se il set di dati è piuttosto grande. Se ciò non soddisfa i requisiti di prestazione, potrebbe essere necessario valutare altre opzioni. Poiché il requisito dichiarato è per una soluzione in LINQ, tuttavia, tali opzioni non vengono esplorate qui. Come sempre, valuta qualsiasi approccio rispetto ai requisiti di prestazione che il tuo progetto potrebbe avere.

Se si ignora l'uguaglianza delle persone, è possibile utilizzare anche:

peopleList2.Except(peopleList1)

Exceptdovrebbe essere significativamente più veloce della Where(...Any)variante poiché può mettere il secondo elenco in una tabella hash. Where(...Any)ha un runtime di O(peopleList1.Count * peopleList2.Count)mentre le varianti basate su HashSet<T>(quasi) hanno un runtime di O(peopleList1.Count + peopleList2.Count).

Exceptrimuove implicitamente i duplicati. Ciò non dovrebbe influire sul tuo caso, ma potrebbe essere un problema per casi simili.

O se vuoi un codice veloce ma non vuoi sovrascrivere l'uguaglianza:

var excludedIDs = new HashSet<int>(peopleList1.Select(p => p.ID));
var result = peopleList2.Where(p => !excludedIDs.Contains(p.ID));

Questa variante non rimuove i duplicati.

O se lo vuoi senza negazione:

var result = peopleList2.Where(p => peopleList1.All(p2 => p2.ID != p.ID));

Fondamentalmente dice di ottenere tutto da peopleList2 dove tutti gli id ​​in peopleList1 sono diversi da id in peoplesList2.

Solo un approccio leggermente diverso dalla risposta accettata :)

Poiché tutte le soluzioni finora utilizzate hanno utilizzato una sintassi fluida, ecco una soluzione nella sintassi dell'espressione di query, per chi è interessato:

var peopleDifference = 
  from person2 in peopleList2
  where !(
      from person1 in peopleList1 
      select person1.ID
    ).Contains(person2.ID)
  select person2;

Penso che sia abbastanza diverso dalle risposte fornite per essere di interesse per alcuni, anche se molto probabilmente sarebbe non ottimale per gli Elenchi. Ora per le tabelle con ID indicizzati, questa sarebbe sicuramente la strada da percorrere.

Un po 'tardi alla festa, ma una buona soluzione che è anche compatibile con Linq to SQL è:

List<string> list1 = new List<string>() { "1", "2", "3" };
List<string> list2 = new List<string>() { "2", "4" };

List<string> inList1ButNotList2 = (from o in list1
                                   join p in list2 on o equals p into t
                                   from od in t.DefaultIfEmpty()
                                   where od == null
                                   select o).ToList<string>();

List<string> inList2ButNotList1 = (from o in list2
                                   join p in list1 on o equals p into t
                                   from od in t.DefaultIfEmpty()
                                   where od == null
                                   select o).ToList<string>();

List<string> inBoth = (from o in list1
                       join p in list2 on o equals p into t
                       from od in t.DefaultIfEmpty()
                       where od != null
                       select od).ToList<string>();

Complimenti a http://www.dotnet-tricks.com/Tutorial/linq/UXPF181012-SQL-Joins-with-C

La risposta di Klaus è stata fantastica, ma ReSharper ti chiederà di "Semplificare l'espressione LINQ":

var result = peopleList2.Where(p => peopleList1.All(p2 => p2.ID != p.ID));

Questa estensione enumerabile consente di definire un elenco di elementi da escludere e una funzione da utilizzare per trovare la chiave da utilizzare per eseguire il confronto.

public static class EnumerableExtensions
{
    public static IEnumerable<TSource> Exclude<TSource, TKey>(this IEnumerable<TSource> source,
    IEnumerable<TSource> exclude, Func<TSource, TKey> keySelector)
    {
       var excludedSet = new HashSet<TKey>(exclude.Select(keySelector));
       return source.Where(item => !excludedSet.Contains(keySelector(item)));
    }
}

Puoi usarlo in questo modo

list1.Exclude(list2, i => i.ID);

Ecco un esempio funzionante che acquisisce competenze IT che un candidato non ha già.

//Get a list of skills from the Skill table
IEnumerable<Skill> skillenum = skillrepository.Skill;
//Get a list of skills the candidate has                   
IEnumerable<CandSkill> candskillenum = candskillrepository.CandSkill
       .Where(p => p.Candidate_ID == Candidate_ID);             
//Using the enum lists with LINQ filter out the skills not in the candidate skill list
IEnumerable<Skill> skillenumresult = skillenum.Where(p => !candskillenum.Any(p2 => p2.Skill_ID == p.Skill_ID));
//Assign the selectable list to a viewBag
ViewBag.SelSkills = new SelectList(skillenumresult, "Skill_ID", "Skill_Name", 1);

in primo luogo, estrarre gli id ​​dalla raccolta in cui condizione

List<int> indexes_Yes = this.Contenido.Where(x => x.key == 'TEST').Select(x => x.Id).ToList();

in secondo luogo, utilizzare l'estensione "confronta" per selezionare gli ID diversi dalla selezione

List<int> indexes_No = this.Contenido.Where(x => !indexes_Yes.Contains(x.Id)).Select(x => x.Id).ToList();

Ovviamente puoi usare x.key! = "TEST", ma è solo un esempio

Dopo aver scritto un FuncEqualityComparer generico, puoi usarlo ovunque.

peopleList2.Except(peopleList1, new FuncEqualityComparer<Person>((p, q) => p.ID == q.ID));

public class FuncEqualityComparer<T> : IEqualityComparer<T>
{
    private readonly Func<T, T, bool> comparer;
    private readonly Func<T, int> hash;

    public FuncEqualityComparer(Func<T, T, bool> comparer)
    {
        this.comparer = comparer;
        if (typeof(T).GetMethod(nameof(object.GetHashCode)).DeclaringType == typeof(object))
            hash = (_) => 0;
        else
            hash = t => t.GetHashCode(); 
    }

    public bool Equals(T x, T y) => comparer(x, y);
    public int GetHashCode(T obj) => hash(obj);
}