Używanie LINQ do obiektów do znajdowania elementów w jednej kolekcji, które nie pasują do innej

Question

Chcę znaleźć wszystkie elementy w jednej kolekcji, które nie pasują do innej kolekcji. Kolekcje nie są tego samego typu; Chcę napisać wyrażenie lambda, aby określić równość.

LINQPad przykładem tego, co próbuję zrobić:

void Main() 
{ 
    var employees = new[] 
    { 
     new Employee { Id = 20, Name = "Bob" }, 
     new Employee { Id = 10, Name = "Bill" }, 
     new Employee { Id = 30, Name = "Frank" } 
    }; 

    var managers = new[] 
    { 
     new Manager { EmployeeId = 20 }, 
     new Manager { EmployeeId = 30 } 
    }; 

    var nonManagers = 
    from employee in employees 
    where !(managers.Any(x => x.EmployeeId == employee.Id)) 
    select employee; 

    nonManagers.Dump(); 

    // Based on cdonner's answer: 

    var nonManagers2 = 
    from employee in employees 
    join manager in managers 
     on employee.Id equals manager.EmployeeId 
    into tempManagers 
    from manager in tempManagers.DefaultIfEmpty() 
    where manager == null 
    select employee; 

    nonManagers2.Dump(); 

    // Based on Richard Hein's answer: 

    var nonManagers3 = 
    employees.Except(
     from employee in employees 
     join manager in managers 
      on employee.Id equals manager.EmployeeId 
     select employee); 

    nonManagers3.Dump(); 
} 

public class Employee 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 
} 

public class Manager 
{ 
    public int EmployeeId { get; set; } 
} 

Powyższe prace i powróci Pracownik Bill (# 10). Nie wygląda jednak elegancko i może być nieskuteczne przy większych kolekcjach. W SQL prawdopodobnie wykonałbym LEFT JOIN i znalazłem przedmioty, w których drugi identyfikator był NULL. Jaka jest najlepsza praktyka w LINQ?

EDYCJA: Zaktualizowano, aby zapobiec rozwiązaniom zależnym od Id równego indeksu.

EDYCJA: Dodano rozwiązanie cdonnera - czy ktoś ma coś prostszego?

EDYCJA: Dodano wariant odpowiedzi Richarda Heina, mojego obecnego faworyta. Dziękuję wszystkim za doskonałe odpowiedzi!

Answer 1

To jest prawie taki sam, jak kilka innych przykładów, ale mniej kodu:

employees.Except(employees.Join(managers, e => e.Id, m => m.EmployeeId, (e, m) => e)); 

To nie jest prostsze niż employees.Where (e => managers.Any (m! => m.EmployeeId == e.Id)) lub oryginalnej składni.

Answer 2

/// <summary> 
    /// This method returns items in a set that are not in 
    /// another set of a different type 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    /// <typeparam name="TOther"></typeparam> 
    /// <typeparam name="TKey"></typeparam> 
    /// <param name="items"></param> 
    /// <param name="other"></param> 
    /// <param name="getItemKey"></param> 
    /// <param name="getOtherKey"></param> 
    /// <returns></returns> 
    public static IEnumerable<T> Except<T, TOther, TKey>(
              this IEnumerable<T> items, 
              IEnumerable<TOther> other, 
              Func<T, TKey> getItemKey, 
              Func<TOther, TKey> getOtherKey) 
    { 
     return from item in items 
       join otherItem in other on getItemKey(item) 
       equals getOtherKey(otherItem) into tempItems 
       from temp in tempItems.DefaultIfEmpty() 
       where ReferenceEquals(null, temp) || temp.Equals(default(TOther)) 
       select item; 
    } 

Nie pamiętam, gdzie znalazłem tę metodę.

Answer 3

Spójrz na funkcję Except() LINQ. Robi dokładnie to, czego potrzebujesz.

Answer 4

var nonmanagers = employees.Select(e => e.Id) 
    .Except(managers.Select(m => m.EmployeeId)) 
    .Select(id => employees.Single(e => e.Id == id)); 

Answer 5

 
     var nonManagers = (from e1 in employees 
          select e1).Except(
            from m in managers 
            from e2 in employees 
            where m.EmployeeId == e2.Id 
            select e2); 

Answer 6

Trochę się spóźniam (wiem).

Szukałem tego samego problemu i rozważałem HashSet z powodu różnych wskazówek dotyczących wydajności w tym kierunku inc. @ Skeet na Intersection of multiple lists with IEnumerable.Intersect() - i poprosił wokół mojego biura i konsensus było to, że HashSet byłoby szybciej i bardziej czytelne:

HashSet<int> managerIds = new HashSet<int>(managers.Select(x => x.EmployeeId)); 
nonManagers4 = employees.Where(x => !managerIds.Contains(x.Id)).ToList(); 

Potem zaproponowano mi jeszcze szybsze rozwiązanie przy użyciu rodzimych tablice do stworzenia nieco maska-owski rozwiązanie typu (Składnia w macierzystych zapytaniach tablicowych zniechęciłaby mnie do korzystania z nich, z wyjątkiem ekstremalnych przyczyn wydajności).

Aby dać tę odpowiedź za małą wiarę po strasznie długo mam rozszerzonego programu LINQPad i danych z synchronizacją, dzięki czemu można porównać to, co jest teraz sześć opcji:

void Main() 
{ 
    var employees = new[] 
    { 
     new Employee { Id = 20, Name = "Bob" }, 
     new Employee { Id = 10, Name = "Kirk NM" }, 
     new Employee { Id = 48, Name = "Rick NM" }, 
     new Employee { Id = 42, Name = "Dick" }, 
     new Employee { Id = 43, Name = "Harry" }, 
     new Employee { Id = 44, Name = "Joe" }, 
     new Employee { Id = 45, Name = "Steve NM" }, 
     new Employee { Id = 46, Name = "Jim NM" }, 
     new Employee { Id = 30, Name = "Frank"}, 
     new Employee { Id = 47, Name = "Dave NM" }, 
     new Employee { Id = 49, Name = "Alex NM" }, 
     new Employee { Id = 50, Name = "Phil NM" }, 
     new Employee { Id = 51, Name = "Ed NM" }, 
     new Employee { Id = 52, Name = "Ollie NM" }, 
     new Employee { Id = 41, Name = "Bill" }, 
     new Employee { Id = 53, Name = "John NM" }, 
     new Employee { Id = 54, Name = "Simon NM" } 
    }; 

    var managers = new[] 
    { 
     new Manager { EmployeeId = 20 }, 
     new Manager { EmployeeId = 30 }, 
     new Manager { EmployeeId = 41 }, 
     new Manager { EmployeeId = 42 }, 
     new Manager { EmployeeId = 43 }, 
     new Manager { EmployeeId = 44 } 
    }; 

    System.Diagnostics.Stopwatch watch1 = new System.Diagnostics.Stopwatch(); 

    int max = 1000000; 

    watch1.Start(); 
    List<Employee> nonManagers1 = new List<Employee>(); 
    foreach (var item in Enumerable.Range(1,max)) 
    { 
     nonManagers1 = (from employee in employees where !(managers.Any(x => x.EmployeeId == employee.Id)) select employee).ToList(); 

    } 
    nonManagers1.Dump(); 
    watch1.Stop(); 
    Console.WriteLine("Any: " + watch1.ElapsedMilliseconds); 

    watch1.Restart();  
    List<Employee> nonManagers2 = new List<Employee>(); 
    foreach (var item in Enumerable.Range(1,max)) 
    { 
     nonManagers2 = 
     (from employee in employees 
     join manager in managers 
      on employee.Id equals manager.EmployeeId 
     into tempManagers 
     from manager in tempManagers.DefaultIfEmpty() 
     where manager == null 
     select employee).ToList(); 
    } 
    nonManagers2.Dump(); 
    watch1.Stop(); 
    Console.WriteLine("temp table: " + watch1.ElapsedMilliseconds); 

    watch1.Restart();  
    List<Employee> nonManagers3 = new List<Employee>(); 
    foreach (var item in Enumerable.Range(1,max)) 
    { 
     nonManagers3 = employees.Except(employees.Join(managers, e => e.Id, m => m.EmployeeId, (e, m) => e)).ToList(); 
    } 
    nonManagers3.Dump(); 
    watch1.Stop(); 
    Console.WriteLine("Except: " + watch1.ElapsedMilliseconds); 

    watch1.Restart();  
    List<Employee> nonManagers4 = new List<Employee>(); 
    foreach (var item in Enumerable.Range(1,max)) 
    { 
     HashSet<int> managerIds = new HashSet<int>(managers.Select(x => x.EmployeeId)); 
     nonManagers4 = employees.Where(x => !managerIds.Contains(x.Id)).ToList(); 

    } 
    nonManagers4.Dump(); 
    watch1.Stop(); 
    Console.WriteLine("HashSet: " + watch1.ElapsedMilliseconds); 

     watch1.Restart(); 
     List<Employee> nonManagers5 = new List<Employee>(); 
     foreach (var item in Enumerable.Range(1, max)) 
     { 
        bool[] test = new bool[managers.Max(x => x.EmployeeId) + 1]; 
        foreach (var manager in managers) 
        { 
         test[manager.EmployeeId] = true; 
        } 

        nonManagers5 = employees.Where(x => x.Id > test.Length - 1 || !test[x.Id]).ToList(); 


     } 
     nonManagers5.Dump(); 
     watch1.Stop(); 
     Console.WriteLine("Native array call: " + watch1.ElapsedMilliseconds); 

     watch1.Restart(); 
     List<Employee> nonManagers6 = new List<Employee>(); 
     foreach (var item in Enumerable.Range(1, max)) 
     { 
        bool[] test = new bool[managers.Max(x => x.EmployeeId) + 1]; 
        foreach (var manager in managers) 
        { 
         test[manager.EmployeeId] = true; 
        } 

        nonManagers6 = employees.Where(x => x.Id > test.Length - 1 || !test[x.Id]).ToList(); 
     } 
     nonManagers6.Dump(); 
     watch1.Stop(); 
     Console.WriteLine("Native array call 2: " + watch1.ElapsedMilliseconds); 
} 

public class Employee 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 
} 

public class Manager 
{ 
    public int EmployeeId { get; set; } 
} 

Answer 7

Jest lepiej, jeśli w lewo przyłączyć element i filtr z warunkiem zerowym

var finalcertificates = (from globCert in resultCertificate 
             join toExcludeCert in certificatesToExclude 
              on globCert.CertificateId equals toExcludeCert.CertificateId into certs 
             from toExcludeCert in certs.DefaultIfEmpty() 
             where toExcludeCert == null 
             select globCert).Union(currentCertificate).Distinct().OrderBy(cert => cert.CertificateName); 

Answer 8

Menedżerowie to także pracownicy! Zatem klasa Manager powinna być podklasą klasy Employee (lub, jeśli tego nie lubisz, powinny one obie podklasy z klasy nadrzędnej lub utworzyć klasę NonManager).

Wtedy problem jest tak proste, jak wdrożenie interfejsu IEquatable na Employee nadrzędnej (dla GetHashCode prostu zwrócić EmployeeID), a następnie przy użyciu tego kodu:

var nonManagerEmployees = employeeList.Except(managerList);