Kann .NET 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); 
      }); 
     } 
    } 
} 

Der Zweck zu bestimmen, ist, wenn eine Liste alle Elemente einer anderen Liste enthält. Es scheint mir, dass sowas schon in .NET eingebaut sein würde, ist das der Fall und verdopple ich die Funktionalität?

Edit: Ich entschuldige mich, dass ich diesen Code nicht auf Mono Version 2.4.2 verwende.

Answer 1

Wenn Sie .NET 3.5, indem es einfach:

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

Diese prüft, ob es irgendwelche Elemente in b die nicht in a - und invertiert dann das Ergebnis.

Beachten Sie, dass es etwas konventionelleren wäre, die Methode Generika anstatt die Klasse zu machen, und es gibt keinen Grund List<T> statt IEnumerable<T> zu verlangen - so würde dies wahrscheinlich bevorzugt werden:

public static class LinqExtras // Or whatever 
{ 
    public static bool ContainsAllItems<T>(IEnumerable<T> a, IEnumerable<T> b) 
    { 
     return !b.Except(a).Any(); 
    } 
} 

Answer 2

Nur zum Spaß, @ JonSkeet des answer als Erweiterung Methode:

/// <summary> 
/// Does a list contain all values of another list? 
/// </summary> 
/// <remarks>Needs .NET 3.5 or greater. Source: https://stackoverflow.com/a/1520664/1037948 </remarks> 
/// <typeparam name="T">list value type</typeparam> 
/// <param name="containingList">the larger list we're checking in</param> 
/// <param name="lookupList">the list to look for in the containing list</param> 
/// <returns>true if it has everything</returns> 
public static bool ContainsAll<T>(this IEnumerable<T> containingList, IEnumerable<T> lookupList) { 
    return ! lookupList.Except(containingList).Any(); 
} 

Answer 3

Sie könnten auch eine andere Art und Weise nutzen. Außer Kraft setzen gleich und verwenden diese

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

Answer 4

Eingeschlossen in .NET 4: Enumerable.All

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