C# 比较C语言中的数组#

我试图比较两个数组。我尝试了这段代码，得到了以下错误

static bool ArraysEqual(Array a1, Array a2)
{
    if (a1 == a2)
        return true;

    if (a1 == null || a2 == null)
        return false;

    if (a1.Length != a2.Length)
        return false;

    IList list1 = a1, list2 = a2; //error CS0305: Using the generic type 'System.Collections.Generic.IList<T>' requires '1' type arguments
    for (int i = 0; i < a1.Length; i++)
    {
        if (!Object.Equals(list1[i], list2[i])) //error CS0021: Cannot apply indexing with [] to an expression of type 'IList'(x2)
            return false;
    }
    return true;
}

静态布尔数组相等（数组a1、数组a2）
{
如果（a1==a2）
返回true；
如果（a1==null | | a2==null）
返回false；
如果（a1.长度！=a2.长度）
返回false；
IList list1=a1，list2=a2；//错误CS0305:使用泛型类型“System.Collections.generic.IList”需要“1”类型参数
对于（int i=0；i

为什么我会犯这样的错误？我选择了一个低技术的解决方案，这样做效果很好，但我需要为每种类型复制/粘贴几次

static bool ArraysEqual(byte[] a1, byte[] a2)
{
    if (a1 == a2)
        return true;

    if (a1 == null || a2 == null)
        return false;

    if (a1.Length != a2.Length)
        return false;

    for (int i = 0; i < a1.Length; i++)
    {
        if (a1[i] != a2[i])
            return false;
    }
    return true;
}

静态布尔数组相等（字节[]a1，字节[]a2）
{
如果（a1==a2）
返回true；
如果（a1==null | | a2==null）
返回false；
如果（a1.长度！=a2.长度）
返回false；
对于（int i=0；i

“为什么会出现此错误？”-可能，文件顶部没有“

使用System.Collections；

”-只有“

使用System.Collections.Generic；

”-但是，泛型可能更安全-请参见以下内容：

static bool ArraysEqual<T>(T[] a1, T[] a2)
{
    if (ReferenceEquals(a1,a2))
        return true;

    if (a1 == null || a2 == null)
        return false;

    if (a1.Length != a2.Length)
        return false;

    EqualityComparer<T> comparer = EqualityComparer<T>.Default;
    for (int i = 0; i < a1.Length; i++)
    {
        if (!comparer.Equals(a1[i], a2[i])) return false;
    }
    return true;
}

static bool ArraysEqual（T[]a1，T[]a2）
{
if（参考值等于（a1，a2））
返回true；
如果（a1==null | | a2==null）
返回false；
如果（a1.长度！=a2.长度）
返回false；
EqualityComparer comparer=EqualityComparer.Default；
对于（int i=0；i

如果您有可用的LINQ，并且不太关心性能，那么最简单的方法是：

var arraysAreEqual = Enumerable.SequenceEqual(a1, a2);

---

事实上，可能值得使用Reflector或ILSpy检查

SequenceEqual

方法的实际功能，因为它可以很好地优化数组值的特殊情况

SequenceEqual可以更快。也就是说，在几乎所有情况下，两个数组的长度确实相同，并且不是相同的对象

---

它的功能仍然与OP的函数不同，因为它不会默默地比较空值。

推荐SequenceEqual是可以的，但认为（；；）循环的速度可能比平常快太天真了

下面是反映的代码：

public static bool SequenceEqual<TSource>(this IEnumerable<TSource> first, 
    IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
{
    if (comparer == null)
    {
        comparer = EqualityComparer<TSource>.Default;
    }
    if (first == null)
    {
        throw Error.ArgumentNull("first");
    }
    if (second == null)
    {
        throw Error.ArgumentNull("second");
    }
    using (IEnumerator<TSource> enumerator = first.GetEnumerator())     
    using (IEnumerator<TSource> enumerator2 = second.GetEnumerator())
    {
        while (enumerator.MoveNext())
        {
            if (!enumerator2.MoveNext() || !comparer.Equals(enumerator.Current, enumerator2.Current))
            {
                return false;
            }
        }
        if (enumerator2.MoveNext())
        {
            return false;
        }
    }
    return true;
}

你就会明白我说的表演是什么意思了

---

它可以用于性能不是很关键的情况，可能是在单元测试代码中，或者在很少调用方法的短列表中。

对于.NET 4.0及更高版本，您可以使用以下类型比较数组或元组中的元素：

---

我知道这是一个老话题，但我认为它仍然是相关的，我想分享一个数组比较方法的实现，我觉得它在性能和优雅之间取得了正确的平衡

static bool CollectionEquals<T>(ICollection<T> a, ICollection<T> b, IEqualityComparer<T> comparer = null)
{
    return ReferenceEquals(a, b) || a != null && b != null && a.Count == b.Count && a.SequenceEqual(b, comparer);
}

static bool CollectionEquals（ICollection a、ICollection b、IEqualityComparer comparer=null）
{
返回ReferenceEquals（a，b）| a！=null&&b！=null&&a.Count==b.Count&&a.SequenceEqual（b，比较器）；
}

这里的想法是先检查所有早期退出条件，然后再回到

SequenceEqual

。它还避免了额外的分支，而是依靠布尔短路来避免不必要的执行。我也觉得它看起来很干净，很容易理解

---

另外，通过对参数使用

ICollection

，它将不仅仅适用于数组。

感谢您今天第二次使用Marc:d这应该只适用于已排序的数组。如果它们没有排序，您至少需要O（nlgn）。@user177883 Eh？如果这两个数组的顺序不同，它们不应该被认为是不同的吗；在被问到的问题中，秩序被打破了important@DarthVader：这些将是相同的集合，但不是相同的数组。或者只是a1。SequenceEquals（a2）。是什么让你相信这会比公认的答案更糟糕？我想枚举版本不能依赖于比较长度，因此，在被比较的数组长度不同的情况下，接受的答案会更快。如果Enumerable.SequenceEqual被优化以检查可枚举数组是否为数组等，我不会感到惊讶。我尝试在ILSpy中检查该方法，但它只显示了一个空方法，其上有TargetedPatchingOptOut属性。如果您知道数组通常具有不同的长度，您可以在前面添加

a1.Length==a2.Length&

。在某些情况下，

Enumerable

通过尝试将序列强制转换为

ICollection

——例如读取

计数

——进行优化，但

SequenceEqual

的情况并非如此（请参阅）。因此，在调用

SequenceEqual

之前，您应该检查

Length

的不平等性。我稍微修改了您的代码。特定于using语句。我几乎让它使用

var

，但我现在只使用SequenceEqual。

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

static bool CollectionEquals<T>(ICollection<T> a, ICollection<T> b, IEqualityComparer<T> comparer = null)
{
    return ReferenceEquals(a, b) || a != null && b != null && a.Count == b.Count && a.SequenceEqual(b, comparer);
}