比较 C# 中的数组

Posted 2023-04-13

【中文标题】比较 C# 中的数组

【英文标题】：Comparing arrays in C#

【发布时间】：2010-10-17 08:00:47

【问题描述】：

我正在尝试将两个数组相互比较。我尝试了这段代码并得到了以下错误。

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;

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

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;

【参考方案1】：

假设你有可用的 LINQ 并且不太关心性能，最简单的事情如下：

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

事实上，可能值得用 Reflector 或 ILSpy 检查SequenceEqual 方法的实际作用，因为无论如何它都可以针对数组值的特殊情况进行优化！

【讨论】：

或者只是 a1.SequenceEquals(a2)。是什么让您相信这会比公认的答案更糟糕？

我认为可枚举版本不能依赖于比较长度，因此在被比较的数组长度不同的情况下，接受的答案会更快。

如果 Enumerable.SequenceEqual 经过优化以检查可枚举项是否为数组等，我不会感到惊讶。我尝试检查 ILSpy 中的方法，但它只显示了一个带有 TargetedPatchingOptOut 属性的空方法。

如果你知道数组经常会有不同的长度，你可以在前面加上a1.Length == a2.Length &&。

在某些情况下Enumerable 会通过尝试将序列转换为ICollection<T> 进行优化——例如读取Count——但SequenceEqual 并非如此（参见@987654321 @)。所以你应该在调用SequenceEqual之前检查Length的不等式。

【参考方案2】：

“为什么会出现这个错误？” - 可能，文件顶部没有“using System.Collections;” - 只有“using 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;

【讨论】：

今天第二次感谢 Marc :D

这应该只适用于排序数组。如果它们未排序，则至少需要 O(nlgn)。

@user177883 嗯？如果两个数组的顺序不同，难道不应该认为是不同的吗？

@RandomInsano 确实；在as问的问题中，顺序很重要

@DarthVader：这些将是相同的 sets，但不相同的 arrays。

【参考方案3】：

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

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

【参考方案4】：

推荐 SequenceEqual 是可以的，但认为它可能比平常更快的 for(;;) 循环太天真了。

这是反映的代码：

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;

如您所见，它使用 2 个枚举器并触发大量方法调用，这严重减慢了一切速度。而且它根本不检查长度，所以在糟糕的情况下它可能会慢得离谱。

比较移动两个迭代器和漂亮

if (a1[i] != a2[i])

你就会明白我所说的性能是什么意思。

它可以用在性能真的不是那么重要的情况下，可能是在单元测试代码中，或者在很少被调用的方法中的一些短列表的情况下。

【讨论】：

我稍微修改了你的代码。具体使用语句。我几乎让它使用var，但不管它

【参考方案5】：

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

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

【参考方案6】：

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

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

这里的想法是首先检查所有提前退出条件，然后返回SequenceEqual。它还避免了额外的分支，而是依靠布尔短路来避免不必要的执行。我也觉得它看起来很干净，很容易理解。

此外，通过将ICollection 用作参数，它不仅适用于数组。

【讨论】：

我现在只使用 SequenceEqual。