¿Cómo comparar dos listas <String> entre sí?

Question

Digamos que hay

List<string> a1 = new List<string>(); 

List<string> a2 = new List<string>(); 

¿Hay manera de hacerlo de esta manera?

if (a1 == a2) 
{ 

} 

Answer 1

Si desea comprobar que los elementos dentro de la lista son iguales y en el mismo orden, puede utilizar SequenceEqual:

if (a1.SequenceEqual(a2)) 

ver su funcionamiento en línea: ideone

Answer 2

Usted podría también use Except (produce la diferencia establecida de dos secuencias) para verificar si hay una diferencia o no:

IEnumerable<string> difference = a1.Except(a2); 
if(!difference.Any()){} 

Answer 3

Puede comprobar en todos los caminos a continuación una lista

List<string> FilteredList = new List<string>(); 
//Comparing the two lists and gettings common elements. 
FilteredList = a1.Intersect(a2, StringComparer.OrdinalIgnoreCase); 

Answer 4

descubrí que SequenceEqual no es la forma más eficiente para comparar dos listas de cadenas (inicialmente de http://www.dotnetperls.com/sequenceequal).

quería probar esto mismo lo que he creado dos métodos:

/// <summary> 
    /// Compares two string lists using LINQ's SequenceEqual. 
    /// </summary> 
    public bool CompareLists1(List<string> list1, List<string> list2) 
    { 
     return list1.SequenceEqual(list2); 
    } 

    /// <summary> 
    /// Compares two string lists using a loop. 
    /// </summary> 
    public bool CompareLists2(List<string> list1, List<string> list2) 
    { 
     if (list1.Count != list2.Count) 
      return false; 

     for (int i = 0; i < list1.Count; i++) 
     { 
      if (list1[i] != list2[i]) 
       return false; 
     } 

     return true; 
    } 

El segundo método es un poco de código que me encontré y me preguntaba si podría ser rediseñado para ser "fácil de leer". (Y también se preguntó si LINQ optimización sería más rápido.)

Como resultado, con dos listas que contienen 32k cuerdas, más de 100 ejecuciones:

• Método 1 tuvo un promedio de 6761.8 garrapatas
• Método 2 tomó un promedio de 3268.4 ticks

Normalmente prefiero LINQ para la brevedad, el rendimiento y la legibilidad del código; pero en este caso creo que se prefiere un método basado en bucle.

Editar:

I vuelve a compilar usando código optimizado, y corrió la prueba para 1000 iteraciones. Los resultados todavía favorecen el bucle (más aún):

• Método 1 tuvo un promedio de 4227.2 garrapatas
• Método 2 tuvo un promedio de 1831.9 garrapatas

probada usando Visual Studio 2010, C# .NET 4 Client Profile en un Core i7-920

Answer 5

private static bool CompareDictionaries(IDictionary<string, IEnumerable<string>> dict1, IDictionary<string, IEnumerable<string>> dict2) 
    { 
     if (dict1.Count != dict2.Count) 
     { 
      return false; 
     } 

     var keyDiff = dict1.Keys.Except(dict2.Keys); 
     if (keyDiff.Any()) 
     { 
      return false; 
     } 

     return (from key in dict1.Keys 
       let value1 = dict1[key] 
       let value2 = dict2[key] 
       select value1.Except(value2)).All(diffInValues => !diffInValues.Any()); 
    }