Question

我正在尝试比较两个.NET数组。这是一个比较字节数组的明显实现：

bool AreEqual(byte[] a, byte[] b){
    if(a.Length != b.Length)
        return false;
    for(int i = 0; i < a.Length; i++)
        if(a[i] != b[i])
            return false;

    return true;
}

可以看到更精确的方法here（通过Google）。

最简单的方法是什么（少用代码但可读）比较两个 .NET数组？
什么是最有效的方式比较两个.NET数组？

Answer 1

您可以使用SequenceEqual：

string[] a = { "1", "2", "3" };
string[] b = { "1", "2", "3" };

bool areEqual = a.SequenceEqual(b); // true


string[] c = { "1", "2", "5" };
areEqual = a.SequenceEqual(c);      // false

Answer 2

凯西的做法对我来说似乎很好。我个人允许明确指定比较器：

bool AreEqual<T>(T[] a, T[] b)
{
    return AreEqual(a, b, EqualityComparer<T>.Default);
}

bool AreEqual<T>(T[] a, T[] b, IEqualityComparer<T> comparer)
{
    // Handle identity comparison, including comparing nulls
    if (a == b)
    {
        return true;
    }

    if (a == null || b == null)
    {
        return false;
    }

    if(a.Length != b.Length)
    {
        return false;
    }

    for(int i = 0; i < a.Length; i++)
    {
        if(!comparer.Equals(a[i], b[i]))
        {
            return false;
        }
    }
    return true;
}

CMS提到的

SequenceEqual是好的，但由于它在IEnumerable<T>上的通用性，如果长度不相等，我认为它不能做到“早出”。（它可能会检查实现IList的两个序列，直接检查Count。）您可以进一步概括，使用IList<T>

bool AreEqual<T>(IList<T> a, IList<T> b, IEqualityComparer<T> comparer)
{
    if(a.Count != b.Count)
    {
        return false;
    }
    for(int i = 0; i < a.Count; i++)
    {
        if(!comparer.Equals(a[i], b[i]))
        {
            return false;
        }
    }
    return true;
}

直接阵列版本可能是最有效的 - 添加通用性和抽象通常会影响性能，但是重要是否取决于您的应用。

Answer 3

随着.NET 4的出现，您可以使用.NET数组显式实现的接口IStructuralEquatable提供的方法Equals（）。然后代码看起来像这样（我重写了CMS的例子）：

string[] a = { "1", "2", "3" };
string[] b = { "1", "2", "3" };
bool result = ((IStructuralEquatable)a).Equals(b, StructuralComparisons.StructuralEqualityComparer);
// result evaluates to true.

（IStructuralEquatable也在元组中实现（在.NET 4中也是新的）。）

Answer 4

也许是这样的？

static bool AreEqual<T>(T[] a, T[] b) 
{
    bool areEqual = false ;
    T[] result = a.Intersect(b.AsEnumerable()).ToArray();
    areEqual = (result.Length == a.Length) && (result.Length == b.Length);
    return areEqual;
}

我不确定这个表现会受到什么影响。

修改

考虑到Jon建议的修订版：

    static bool AreEqual<T>(T[] a, T[] b) 
    {
        return a.SequenceEqual(b);
    }

比较两个.NET Array对象

4 个答案: