比较两个.NET Array对象

我想比较两个.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;
}

这里可以看到更精致的方法(通过谷歌).

比较两个.NET数组的最简单方法(使用较少的代码但可读)是什么？

比较两个.NET数组最有效的方法是什么？

CMS.. 48

你可以使用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

这个[page](http://www.dotnetperls.com/sequenceequal)有一些性能信息,声称`SequenceEqual`比使用循环的自定义实现慢大约10倍.我想知道为什么. (3认同)

默认情况下,`SequenceEqual`方法不可用,你必须使用`System.Linq`.很高兴知道如果你感到困惑(就像我一样). (2认同)

---

Jon Skeet.. 18

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

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

bool AreEqual(T[] a, T[] b, IEqualityComparer 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如果长度不相等,我认为它不能做到"早出".(它可能会检查实现IList的两个序列,直接检查Count.)你可以多概括一点,使用IList

bool AreEqual(IList a, IList b, IEqualityComparer 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;
}

直接阵列版本可能是最有效的 - 添加通用性和抽象通常会达到性能,但它是否重要将取决于您的应用程序.

1> CMS..：

---

你可以使用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

---

这个[page](http://www.dotnetperls.com/sequenceequal)有一些性能信息,声称`SequenceEqual`比使用循环的自定义实现慢大约10倍.我想知道为什么.

---

默认情况下,`SequenceEqual`方法不可用,你必须使用`System.Linq`.很高兴知道如果你感到困惑(就像我一样).

2> Jon Skeet..：

---

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

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

bool AreEqual(T[] a, T[] b, IEqualityComparer 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如果长度不相等,我认为它不能做到"早出".(它可能会检查实现IList的两个序列,直接检查Count.)你可以多概括一点,使用IList

bool AreEqual(IList a, IList b, IEqualityComparer 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;
}

直接阵列版本可能是最有效的 - 添加通用性和抽象通常会达到性能,但它是否重要将取决于您的应用程序.

---

不应该上面的代码片段有`if(!comparer.Equals(a [i],b [i])返回false`？我刚刚检测到我的宇宙中的异常:)

3> Nico..：

---

随着.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中也是新的).)

---

或者使用`StructuralComparisons.StructuralEqualityComparer.Compare(a,b)`