.NET ha un modo per verificare se l'Elenco a contiene tutti gli elementi in Elenco b?

Question

Ho il seguente metodo:

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); 
      }); 
     } 
    } 
} 

Lo scopo è quello di determinare se un elenco contiene tutti gli elementi di un altro elenco. Mi sembra che qualcosa di simile sarebbe già stato incorporato in .NET, è il caso e sto duplicando funzionalità?

Modifica: Le mie scuse per non aver dichiarato in anticipo che sto usando questo codice su Mono versione 2.4.2.

Answer 1

Se si sta utilizzando .NET 3.5, è facile:

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

Questo controlla se ci sono elementi in b che non sono in a - e poi inverte il risultato.

Nota che sarebbe stato un po 'più convenzionale per rendere il metodo generico piuttosto che la classe, e non c'è motivo di esigere List<T> invece di IEnumerable<T> - quindi questo sarebbe probabilmente preferibile:

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

Answer 2

Proprio per divertimento, @ JonSkeet di answer come un metodo di estensione:

/// <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

Si potrebbe anche usare un altro modo. Override è uguale e utilizzare questo

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

Incluso nel .NET 4: Enumerable.All

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