Vergleichen Sie zwei .NET-Array-Objekte

Question

Ich versuche, zwei .NET-Arrays zu vergleichen. Hier ist eine offensichtliche Implementierung für den Vergleich von Byte-Arrays:

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

Eine raffiniertere Herangehensweise kann hier (über Google) gefunden werden.

1. Was ist der einfachste Weg (mit weniger Code, aber lesbar), um zwei .NET-Arrays zu vergleichen?
2. Was ist der effizienteste Weg, um zwei .NET-Arrays zu vergleichen?

Answer 1

Sie könnten SequenceEqual verwenden:

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

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

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

Answer 2

Ich finde Kathys Ansatz gut. Ich würde persönlich den Vergleichenden ausdrücklich angeben lassen:

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

SequenceEqual wie von CMS erwähnt ist gut, aber aufgrund seiner Verallgemeinerung über IEnumerable glaube ich nicht, dass er das "early out" machen kann, wenn die Längen nicht übereinstimmen. (Es ist möglich, dass er beide Sequenzen überprüft, die IList implementieren, um direkt die Count zu prüfen.) Sie könnten noch etwas mehr verallgemeinern, um IList zu verwenden

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

Die direkte Array-Version wird wahrscheinlich am effizientesten sein - die Hinzufügung von Allgemeinheit und Abstraktion beeinträchtigt in der Regel die Leistung, obwohl es darauf ankommt, ob es für Ihre Anwendung signifikant ist.

Answer 3

Mit dem Aufkommen von .NET 4 können Sie die von .NET-Arrays bereitgestellte Methode Equals() verwenden, die vom Interface IStructuralEquatable explizit implementiert wird. Dann könnte der Code so aussehen (ich habe das Beispiel von CMS neu geschrieben):

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

(IStructuralEquatable ist auch in Tupeln implementiert (ebenfalls neu in .NET 4)).

Answer 4

Vielleicht so etwas?

static bool AreEqual(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;
}

Ich bin mir allerdings nicht sicher, wie sich dies auf die Leistung auswirkt.

BEARBEITEN

Überarbeitete Version unter Berücksichtigung der Vorschläge von Jon:

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