int[] a = { 2, 1, 3, 4, 5, 2 };

        int[] b = { 2, 1, 3, 4, 5, 2 };

        bool ans = true;

        if(a.Length != b.Length)
        {
            ans = false;
        }
        else
        {
            for (int i = 0; i < a.Length; i++)
            {
                if( a[i] != b[i])
                {
                    ans = false;
                }
            }
        }

        string str = "";

        if(ans == true)
        {
            str = "Two Arrays are Equal";
        }

        if (ans == false)
        {
            str = "Two Arrays are not Equal";
        }

       //--------------Or You can write One line of Code-------------

        var ArrayEquals = a.SequenceEqual(b);   // returns true

我在视觉工作室做了这个，效果非常好;用简短的此代码逐个索引地比较数组。

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

输出将是;匹配的数字是7 不匹配的数字是3

我想确定两个集合是否有相同的内容，以任何顺序。这意味着，对于集合A中的每个元素，在两个集合中都有相同数量的具有该值的元素。我想要解释重复(所以{1,2,2,3}和{1,2,3,3}不应该被认为是“相同的”)。

这是我想出的(注意，IsNullOrEmpty是另一个静态扩展方法，如果枚举对象为空或有0个元素，则返回true):

    public static bool HasSameContentsAs<T>(this IEnumerable<T> source, IEnumerable<T> target) 
        where T : IComparable
    {
        //If our source is null or empty, then it's just a matter of whether or not the target is too
        if (source.IsNullOrEmpty())
            return target.IsNullOrEmpty();

        //Otherwise, if the target is null/emtpy, they can't be equal
        if (target.IsNullOrEmpty())
            return false;

        //Neither is null or empty, so we'll compare contents.  To account for multiples of 
        //a given value (ex. 1,2,2,3 and 1,1,2,3 are not equal) we'll group the first set
        foreach (var group in source.GroupBy(s => s))
        {
            //If there are a different number of elements in the target set, they don't match
            if (target.Count(t => t.Equals(group.Key)) != group.Count())
                return false;
        }

        //If we got this far, they have the same contents
        return true;
    }

SequenceEqual只在满足两个条件时才返回true。

它们包含相同的元素。 元素的顺序是一样的。

如果您只想检查它们是否包含相同的元素，而不管它们的顺序如何，那么您的问题属于

values2是否包含values1中包含的所有值?

可以使用LINQ扩展方法Enumerable。Except，然后检查结果是否有任何值。这里有一个例子

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
}

通过这个你也可以自动得到不同的项目。一石二鸟。

请记住，如果像这样执行代码

var result = values2.Except(values1);

你会得到不同的结果。

在我的例子中，我有一个数组的本地副本，想要检查是否有任何东西已经从原始数组中删除，所以我使用这个方法。

这个LINQ解决方案是有效的，不知道它在性能上如何与SequenceEquals相比。但是它处理不同的数组长度，. all将在不遍历整个数组的情况下，在第一个不相等的项上退出。

private static bool arraysEqual<T>(IList<T> arr1, IList<T> arr2)
        =>
            ReferenceEquals(arr1, arr2) || (
                arr1 != null && arr2 != null &&
                arr1.Count == arr2.Count &&
                arr1.Select((a, i) => arr2[i].Equals(a)).All(i => i)
            );

检查这个线程的答案，它将其中一个数组转换为HashSet，并使用SetEquals与另一个数组进行比较。 但是请注意，这并不检查顺序或副本。