.NET-Generika - Vergleichen Sie zwei Listen und filter: best practice

LINQ-Except-Methode

Wäre dies die sauberste Art und Weise, wie vorgeschlagen, von Maxim und svick erfordert aber eine überschriebene Equals-Methode gleich auf ID oder geben Sie einen comparer (siehe svicks Antwort).

var result = stockPackageList.Except(packageList).ToList();

Ressourcen
Viele LINQ samles finden Sie in der msdn unter http://msdn.microsoft.com/en-us/vcsharp/aa336746

Lasse ich den ersten Teil meiner Antwort verweisen:

Brute-force-Weg:

var result = stockPackageList
              .Where(x => packageList.All(package => x.Id != package.Id))
              .ToList();

sollte den trick tun. Sie müssen nur zu übersetzen, die lambda-syntax vb.net.

Diese Abfrage filtert alle Elemente aus stockPackageList die IDs sind nicht alle Elemente von packageList.

Können Sie umkehren-Abfrage:

var result = stockPackageList
              .Where(x => packageList.Any(package => x.Id == package.Id) == false)
              .ToList();

Den Any Abfrage gibt true zurück, wenn jedes Element in packageList mit einer passenden id. Diese Abfrage sollte etwas schneller laufen, weil es nicht um die traverse der ganzen Sammlung, wie All hat.

Mit Eqality:

Wenn Ihr Paket-Objekt implementiert IEquatable<Package> Sie verkürzen den code unten, um

var result = stockPackageList
              .Where(x => packageList.Contains(x) == false)
              .ToList();

Verwendung einer Hash-Set:

Wenn Sie möchten, verwenden Sie ein hash-set, die Sie tun können

var hash = new HashSet<string>(packageList.Select(x=>x.Id));
var result = stockPackageList.Where(x => hash.Contains(x.Id) == false).ToList();

Dies spart Rechenzeit, wenn die Listen groß geworden, als faester und Ivan Danilov hingewiesen.

Ihre Methode hat die asymptotische Laufzeit von O(m*n), wo m und n sind die Größen Ihrer Sammlungen.

Sollten Sie danach Streben, für O(m lg n). Sie müssen aber natürlich suchen beide Sammlungen, aber Sie können bauen ein hashset von einem von Ihnen in O(n) und führen Sie Abfragen in O(1) im Durchschnitt, so sollten Sie eine Kopie einer Liste in ein hashset und durch die zweite sucht Werte, die in der ehemaligen.

    static void Sort()
    {
        List<Package> a = new List<Package>();
        List<Package> b = new List<Package>();

        Func<Package, int> idExtractor = x => x.ID;

        var hash = new HashSet<Package>(a, new IDComparer<Package, int>(idExtractor));

        a.AddRange(b.Where(x => !hash.Contains(x)));
    }

    class IDComparer<ObjectType, KeyType>
        : IEqualityComparer<ObjectType>
        where KeyType : IComparable
    {
        private Func<ObjectType, KeyType> idExtractor;

        public IDComparer(Func<ObjectType, KeyType> idExtractor)
        {
            this.idExtractor = idExtractor;
        }

        public bool Equals(ObjectType x, ObjectType y)
        {
            return idExtractor(x).Equals(idExtractor(y));
        }

        public int GetHashCode(ObjectType obj)
        {
            return idExtractor(obj).GetHashCode();
        }
    }

var dic = new Dictionary<string, Package>(p1.Count); //capacity here is important
foreach (var p in p1) 
    dic.Add(p.Id, p);
var result = p2.Where(p => !dic.ContainsKey(p.Id)).ToList();

Füllung Wörterbuch fast O(n) durch p1.Zählen. Und jede Suche ist O(1). So haben wir etwas in der Nähe von linearer Komplexität.