¿Tiene .NET una forma de verificar si la Lista a contiene todos los elementos en la Lista b?

Question

que tienen el siguiente método:

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

El propósito es determinar si una lista contiene todos los elementos de otra lista. Me parece que algo así debería estar integrado en .NET, ¿es así y estoy duplicando la funcionalidad?

Editar: Mis disculpas por no mencionar desde el principio que estoy usando este código en la versión Mono 2.4.2.

Answer 1

Si está utilizando .NET 3.5, es fácil:

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

Esto comprueba si hay elementos en b que no están en a - y luego invierte el resultado.

Nota que sería un poco más convencional para hacer que el método genérico en lugar de la clase, y no hay razón para exigir List<T> en lugar de IEnumerable<T> - por lo que probablemente sería preferido:

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

Answer 2

Justo para la diversión, @ JonSkeet de answer como un método de extensión:

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

también es posible usar otra forma. Anulación y es igual a utilizar este

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

Incluido en .NET 4: Enumerable.All

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