La façon la plus facile de comparer des tableaux en C#

utiliser Sequencequal dans 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

aussi pour les tableaux (et tuples) vous pouvez utiliser de nouvelles interfaces de .NET 4.0: IStructuralComparable et IStructuralEquatable . En les utilisant, vous pouvez non seulement vérifier l'égalité des tableaux, mais aussi de les comparer.

static class StructuralExtensions
{
    public static bool StructuralEquals<T>(this T a, T b)
        where T : IStructuralEquatable
    {
        return a.Equals(b, StructuralComparisons.StructuralEqualityComparer);
    }

    public static int StructuralCompare<T>(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
}

Pour .NET 4.0 et plus vous pouvez comparer les éléments de matrice ou de tuples par l'aide de StructuralComparisons type:

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 ne retournera true que si deux conditions sont remplies.

1. Ils contiennent les mêmes éléments.
2. Les éléments sont dans le même ordre.

Si vous voulez seulement vérifier s'ils contiennent les mêmes éléments, indépendamment de leur ordre et votre problème est du type

Ne values2 contenir toutes les valeurs contenues dans values1?

vous pouvez utiliser la méthode D'extension LINQ Enumerable.Except et ensuite vérifier si le résultat a une valeur. Voici un exemple

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
}

et aussi en utilisant ceci vous obtenez les différents articles aussi bien automatiquement. Deux oiseaux avec une pierre.

Gardez à l'esprit, si vous exécutez votre code comme ceci

var result = values2.Except(values1);

, vous obtiendrez des résultats différents.

Dans mon cas, j'ai une copie locale d'un tableau et souhaitez pour vérifier si quelque chose a été retiré du tableau original donc j'utilise cette méthode.

pour les tests unitaires, vous pouvez utiliser CollectionAssert.AreEqual au lieu de Assert.AreEqual .

c'est probablement la voie la plus facile.

comparaison élémentaire ? qu'en est-il de

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

remplacer la condition (a= = b) par tout ce que vous souhaitez comparer dans a et B.

(ce qui combine deux exemples de de développement MSDN Linq échantillons )

j'ai fait ceci dans visual studios et cela a fonctionné parfaitement; comparer des tableaux index par index avec court ce code.

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

de la sortie; Les nombres correspondants sont 7 Les numéros qui ne correspondent pas sont 3

pour certaines applications peut être mieux:

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

si vous souhaitez gérer avec élégance les entrées null et ignorer l'ordre des éléments, essayez la solution suivante:

static class Extensions
{
    public static bool ItemsEqual<TSource>(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();
    }
}

le code d'essai ressemble à:

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.
    }
}

voici une implémentation étrange.

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