La forma más fácil de comparar matrices en C #

En Java, Arrays.equals () permite comparar fácilmente el contenido de dos matrices básicas (las sobrecargas están disponibles para todos los tipos básicos).

¿Hay tal cosa en C #? ¿Hay alguna forma “mágica” de comparar el contenido de dos matrices en C #?

Puede usar SequenceEqual . Esto funciona para cualquier IEnumerable , no solo para matrices.

Use SequenceEqual en LINQ .

 int[] arr1 = new int[] { 1,2,3}; int[] arr2 = new int[] { 3,2,1 }; Console.WriteLine(arr1.SequenceEqual(arr2)); // false Console.WriteLine(arr1.Reverse().SequenceEqual(arr2)); // true 

También para matrices (y tuplas) puede usar nuevas interfaces de .NET 4.0: IStructuralComparable e IStructuralEquatable . Utilizándolos no solo puedes verificar la igualdad de matrices sino también compararlas.

 static class StructuralExtensions { public static bool StructuralEquals(this T a, T b) where T : IStructuralEquatable { return a.Equals(b, StructuralComparisons.StructuralEqualityComparer); } public static int StructuralCompare(this T a, T b) where T : IStructuralComparable { return a.CompareTo(b, StructuralComparisons.StructuralComparer); } } { var a = new[] { 1, 2, 3 }; var b = new[] { 1, 2, 3 }; Console.WriteLine(a.Equals(b)); // False Console.WriteLine(a.StructuralEquals(b)); // True } { var a = new[] { 1, 3, 3 }; var b = new[] { 1, 2, 3 }; Console.WriteLine(a.StructuralCompare(b)); // 1 } 

Para .NET 4.0 y superior, puede comparar elementos en matriz o tuplas mediante el uso de StructuralComparisons tipo:

 object[] a1 = { "string", 123, true }; object[] a2 = { "string", 123, true }; Console.WriteLine (a1 == a2); // False (because arrays is reference types) Console.WriteLine (a1.Equals (a2)); // False (because arrays is reference types) IStructuralEquatable se1 = a1; //Next returns True Console.WriteLine (se1.Equals (a2, StructuralComparisons.StructuralEqualityComparer)); 

SequenceEqual solo volverá verdadero si se cumplen dos condiciones.

  1. Contienen los mismos elementos.
  2. Los elementos están en el mismo orden.

Si solo desea verificar si contienen los mismos elementos independientemente de su orden y su problema es del tipo

¿Values2 contiene todos los valores contenidos en values1?

puede usar el método de extensión LINQ Enumerable.Except y luego verificar si el resultado tiene algún valor. Aquí hay un ejemplo

 int[] values1 = { 1, 2, 3, 4 }; int[] values2 = { 1, 2, 5 }; var result = values1.Except(values2); if(result.Count()==0) { //They are the same } else { //They are different } 

Y también al usar esto obtienes los diferentes artículos también automáticamente. Dos pájaros con una piedra.

Tenga en cuenta que si ejecuta su código de esta manera

 var result = values2.Except(values1); 

obtendrás resultados diferentes

En mi caso, tengo una copia local de una matriz y quiero verificar si se ha eliminado algo de la matriz original, así que utilizo este método.

Para las pruebas unitarias, puede usar CollectionAssert.AreEqual lugar de Assert.AreEqual .

Probablemente sea la forma más fácil.

elemento comparar? qué pasa

 public void Linq78a() { int[] numbers1 = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 }; int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 }; bool bb = numbers.Zip(numbers1, (a, b) => (a == b)).Any(p => !p); if (!bb) Console.WriteLine("Lists are equal (bb)"); else Console.WriteLine("Lists are not equal (bb)"); } 

Reemplace la condición (a == b) por cualquier cosa que quiera comparar en ay b.

(Esto combina dos ejemplos de MSDN developer Linq samples )

Hice esto en estudios visuales y funcionó perfectamente; comparando matrices índice por índice con short este código.

 private void compareButton_Click(object sender, EventArgs e) { int[] answer = { 1, 3, 4, 6, 8, 9, 5, 4, 0, 6 }; int[] exam = { 1, 2, 3, 6, 8, 9, 5, 4, 0, 7 }; int correctAnswers = 0; int wrongAnswers = 0; for (int index = 0; index < answer.Length; index++) { if (answer[index] == exam[index]) { correctAnswers += 1; } else { wrongAnswers += 1; } } outputLabel.Text = ("The matching numbers are " + correctAnswers + "\n" + "The non matching numbers are " + wrongAnswers); } 

la salida será; Los números coincidentes son 7 Los números que no coinciden son 3

Para algunas aplicaciones puede ser mejor:

 string.Join("", arr1) == string.Join("", arr2) 

Aquí hay una implementación extraña.

  static bool ArraysEqual(T[] a, T[] b) { int k = 0; return a.All(x => x.Equals(b[k++])); } 

Si desea manejar entradas null elegancia e ignorar el orden de los elementos, pruebe la siguiente solución:

 static class Extensions { public static bool ItemsEqual(this TSource[] array1, TSource[] array2) { if (array1 == null && array2 == null) return true; if (array1 == null || array2 == null) return false; return array1.Count() == array2.Count() && !array1.Except(array2).Any(); } } 

El código de prueba se ve así:

 class Program { static void Main(string[] args) { int[] a1 = new int[] { 1, 2, 3 }; int[] a2 = new int[] { 3, 2, 1 }; int[] a3 = new int[] { 1, 3 }; int[] a4 = null; int[] a5 = null; int[] a6 = new int[0]; Console.WriteLine(a1.ItemsEqual(a2)); // Output: True. Console.WriteLine(a2.ItemsEqual(a3)); // Output: False. Console.WriteLine(a4.ItemsEqual(a5)); // Output: True. No Exception. Console.WriteLine(a4.ItemsEqual(a3)); // Output: False. No Exception. Console.WriteLine(a5.ItemsEqual(a6)); // Output: False. No Exception. } }