Comparaison de deux tableaux d'octets en .NET

Question

Comment puis-je faire ça rapidement ?

Bien sûr que je peux le faire :

static bool ByteArrayCompare(byte[] a1, byte[] a2)
{
    if (a1.Length != a2.Length)
        return false;

    for (int i=0; i<a1.Length; i++)
        if (a1[i]!=a2[i])
            return false;

    return true;
}

Mais je suis à la recherche soit d'un BCL ou un autre moyen éprouvé et hautement optimisé de le faire.

java.util.Arrays.equals((sbyte[])(Array)a1, (sbyte[])(Array)a2);

fonctionne bien, mais il ne semble pas que cela puisse fonctionner pour x64.

Notez ma réponse ultra-rapide aquí .

Answer 1

Vous pouvez utiliser Enumerable.SequenceEqual método.

using System;
using System.Linq;
...
var a1 = new int[] { 1, 2, 3};
var a2 = new int[] { 1, 2, 3};
var a3 = new int[] { 1, 2, 4};
var x = a1.SequenceEqual(a2); // true
var y = a1.SequenceEqual(a3); // false

Si vous ne pouvez pas utiliser .NET 3.5 pour une raison quelconque, votre méthode est correcte.
Compilateur \run -L'environnement temps réel optimisera votre boucle afin que vous n'ayez pas à vous soucier des performances.

Answer 2

P/Invocation pouvoirs activés !

[DllImport("msvcrt.dll", CallingConvention=CallingConvention.Cdecl)]
static extern int memcmp(byte[] b1, byte[] b2, long count);

static bool ByteArrayCompare(byte[] b1, byte[] b2)
{
    // Validate buffers are the same length.
    // This also ensures that the count does not exceed the length of either buffer.  
    return b1.Length == b2.Length && memcmp(b1, b2, b1.Length) == 0;
}

Answer 3

Il y a une nouvelle solution intégrée pour cela dans .NET 4 - IStructuralEquatable

static bool ByteArrayCompare(byte[] a1, byte[] a2) 
{
    return StructuralComparisons.StructuralEqualityComparer.Equals(a1, a2);
}

Answer 4

Utilisateur gil a suggéré un code dangereux qui a donné naissance à cette solution :

// Copyright (c) 2008-2013 Hafthor Stefansson
// Distributed under the MIT/X11 software license
// Ref: http://www.opensource.org/licenses/mit-license.php.
static unsafe bool UnsafeCompare(byte[] a1, byte[] a2) {
  if(a1==a2) return true;
  if(a1==null || a2==null || a1.Length!=a2.Length)
    return false;
  fixed (byte* p1=a1, p2=a2) {
    byte* x1=p1, x2=p2;
    int l = a1.Length;
    for (int i=0; i < l/8; i++, x1+=8, x2+=8)
      if (*((long*)x1) != *((long*)x2)) return false;
    if ((l & 4)!=0) { if (*((int*)x1)!=*((int*)x2)) return false; x1+=4; x2+=4; }
    if ((l & 2)!=0) { if (*((short*)x1)!=*((short*)x2)) return false; x1+=2; x2+=2; }
    if ((l & 1)!=0) if (*((byte*)x1) != *((byte*)x2)) return false;
    return true;
  }
}

qui effectue une comparaison basée sur 64 bits pour la plus grande partie possible du tableau. Cela compte en quelque sorte sur le fait que les tableaux sont alignés sur qword. Cela fonctionnera s'ils ne sont pas alignés sur qword, mais pas aussi rapidement que s'ils l'étaient.

Il exécute environ sept minuteries plus rapidement que le simple for boucle. L'utilisation de la bibliothèque J# a donné des résultats équivalents à ceux de l'original. for boucle. L'utilisation de .SequenceEqual est environ sept fois plus lente ; je pense que c'est simplement parce qu'elle utilise IEnumerator.MoveNext. J'imagine que les solutions basées sur LINQ sont au moins aussi lentes, voire pires.

Answer 5

Si vous n'y êtes pas opposé, vous pouvez importer l'assemblage J# "vjslib.dll" et utiliser sa fonction Méthode Arrays.equals(byte[], byte[]) ...

Ne me blâmez pas si quelqu'un se moque de vous...

---

EDIT : Pour le peu que ça vaut, j'ai utilisé Reflector pour désassembler le code de cet article, et voici à quoi ça ressemble :

public static bool equals(sbyte[] a1, sbyte[] a2)
{
  if (a1 == a2)
  {
    return true;
  }
  if ((a1 != null) && (a2 != null))
  {
    if (a1.Length != a2.Length)
    {
      return false;
    }
    for (int i = 0; i < a1.Length; i++)
    {
      if (a1[i] != a2[i])
      {
        return false;
      }
    }
    return true;
  }
  return false;
}