比较两个 .NET Array 对象

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）。

1. 什么是最简单的方法（使用少 代码但可读）比较两个 .NET 数组？
2. 什么是最有效的方法 比较两个 .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

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

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