Gibt es in .NET eine Möglichkeit zu prüfen, ob Liste a alle Elemente in Liste b enthält?

Question

Ich habe die folgende Methode:

namespace ListHelper
{
    public class ListHelper<T>
    {
        public static bool ContainsAllItems(List<T> a, List<T> b)
        {
            return b.TrueForAll(delegate(T t)
            {
                return a.Contains(t);
            });
        }
    }
}

Deren Zweck ist es, festzustellen, ob eine Liste alle Elemente einer anderen Liste enthält. Es würde mir scheinen, dass so etwas in .NET bereits gebaut werden würde, ist das der Fall und bin ich doppelte Funktionalität?

Bearbeiten: Ich entschuldige mich dafür, dass ich nicht im Voraus angegeben habe, dass ich diesen Code auf Mono Version 2.4.2 verwende.

Answer 1

Wenn Sie .NET 3.5 verwenden, ist es einfach:

public class ListHelper
{
    public static bool ContainsAllItems(List a, List b)
    {
        return !b.Except(a).Any();
    }
}

Dies überprüft, ob es Elemente in b gibt, die nicht in a sind - und kehrt dann das Ergebnis um.

Beachten Sie, dass es etwas konventioneller wäre, die Methode generisch zu machen anstatt die Klasse, und es keinen Grund gibt, List anstelle von IEnumerable zu benötigen - daher wäre dies wahrscheinlich bevorzugt:

public static class LinqExtras // Oder ähnliches
{
    public static bool ContainsAllItems(this IEnumerable a, IEnumerable b)
    {
        return !b.Except(a).Any();
    }
}

Answer 2

Enthalten in .NET 4: Enumerable.All

public static bool ContainsAll<T>(IEnumerable<T> source, IEnumerable<T> values)
{
    return values.All(value => source.Contains(value));
}

Answer 3

Nur zum Spaß, @JonSkeets Antwort als Erweiterungsmethode:

/// 
/// Enthält eine Liste alle Werte einer anderen Liste?
/// 
/// Benötigt .NET 3.5 oder höher. Quelle:  https://stackoverflow.com/a/1520664/1037948 
/// Listentyp
/// die größere Liste, die überprüft wird
/// die Liste, nach der in der enthaltenden Liste gesucht wird
/// true, wenn alles vorhanden ist
public static bool ContainsAll(this IEnumerable containingList, IEnumerable lookupList) {
    return ! lookupList.Except(containingList).Any();
}

Answer 4

Ich kenne einen Weg, um LinQ-Methoden zu verwenden. Es ist etwas seltsam zu lesen, funktioniert aber ziemlich gut

var motherList = new List { "Hallo", "Welt", "Benutzer" };
var sonList = new List { "Hallo", "Benutzer" };

Sie möchten überprüfen, ob sonList vollständig in motherList enthalten ist

Um dies zu tun:

sonList.All(str => moterList.Any(word => word == str));

// Wörtlich gelesen würde es heißen "Für jedes Element in sonList
// testen, ob es in motherList enthalten ist

Bitte probieren Sie es aus und sehen Sie, ob es auch dort funktioniert. Hoffe es hilft ;-)

Answer 5

Sie könnten auch einen anderen Weg nutzen. Überschreiben Sie equals und nutzen Sie dies

public bool ContainsAll(List a,List check)
{
   List l = new List(check);
   foreach(T _t in a)
   {
      if(check.Contains(t))
      {
         check.Remove(t);
         if(check.Count == 0)
         {
            return true;
         }
      }
      return false;
   }
}