Membandingkan dua byte array di .NET

Bagaimana saya bisa melakukan ini dengan cepat?

Tentu saya bisa melakukan ini:

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

Tapi saya sedang mencari fungsi BCL atau beberapa cara yang terbukti sangat optimal untuk melakukan ini.

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

berfungsi dengan baik, tetapi sepertinya itu tidak akan berfungsi untuk x64.

Perhatikan jawaban super cepat saya di sini .

Anda dapat menggunakan metode Enumerable.SequenceEqual .

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

Jika Anda tidak dapat menggunakan .NET 3.5 karena alasan tertentu, metode Anda OK.
Lingkungan compiler \ run-time akan mengoptimalkan loop Anda sehingga Anda tidak perlu khawatir tentang kinerja.

P / aktifkan kekuatan!

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

Ada solusi bawaan baru untuk ini di .NET 4 - IStructuralEquatable

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

Pengguna gil menyarankan kode tidak aman yang menghasilkan solusi ini:

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

yang melakukan perbandingan berbasis 64-bit untuk sebanyak mungkin array. Semacam ini diperhitungkan pada fakta bahwa array mulai selaras qword. Ini akan bekerja jika tidak selaras qword, hanya saja tidak secepat itu.

Ia melakukan sekitar tujuh timer lebih cepat dari forloop sederhana . Menggunakan perpustakaan J # dilakukan secara setara dengan forloop asli . Menggunakan .SequenceEqual berjalan sekitar tujuh kali lebih lambat; Saya pikir hanya karena menggunakan IEnumerator.MoveNext. Saya membayangkan solusi berbasis LINQ setidaknya yang lambat atau lebih buruk.

Span<T> menawarkan alternatif yang sangat kompetitif tanpa harus membuang bulu yang membingungkan dan / atau tidak portabel ke dalam basis kode aplikasi Anda sendiri:

// byte[] is implicitly convertible to ReadOnlySpan<byte>
static bool ByteArrayCompare(ReadOnlySpan<byte> a1, ReadOnlySpan<byte> a2)
{
    return a1.SequenceEqual(a2);
}

Implementasi (nyali dari) pada .NET Core 3.1.0 dapat ditemukan di sini .

Saya telah merevisi inti @ EliArbel untuk menambahkan metode ini sebagai SpansEqual, letakkan sebagian besar pemain yang kurang menarik di tolok ukur orang lain, jalankan dengan berbagai ukuran array, grafik output, dan tandai SpansEqualsebagai garis dasar sehingga melaporkan bagaimana metode yang berbeda dibandingkan dengan SpansEqual.

Angka-angka di bawah ini dari hasil, diedit dengan ringan untuk menghapus kolom "Kesalahan".

|        Method |  ByteCount |               Mean |            StdDev | Ratio |
|-------------- |----------- |-------------------:|------------------:|------:|
|    SpansEqual |         15 |           3.562 ns |         0.0035 ns |  1.00 |
|  LongPointers |         15 |           4.611 ns |         0.0028 ns |  1.29 |
|      Unrolled |         15 |          18.035 ns |         0.0195 ns |  5.06 |
| PInvokeMemcmp |         15 |          11.210 ns |         0.0353 ns |  3.15 |
|               |            |                    |                   |       |
|    SpansEqual |       1026 |          20.048 ns |         0.0286 ns |  1.00 |
|  LongPointers |       1026 |          63.347 ns |         0.1062 ns |  3.16 |
|      Unrolled |       1026 |          39.175 ns |         0.0304 ns |  1.95 |
| PInvokeMemcmp |       1026 |          40.830 ns |         0.0350 ns |  2.04 |
|               |            |                    |                   |       |
|    SpansEqual |    1048585 |      44,070.526 ns |        35.3348 ns |  1.00 |
|  LongPointers |    1048585 |      59,973.407 ns |        80.4145 ns |  1.36 |
|      Unrolled |    1048585 |      55,032.945 ns |        24.4745 ns |  1.25 |
| PInvokeMemcmp |    1048585 |      55,593.719 ns |        22.4301 ns |  1.26 |
|               |            |                    |                   |       |
|    SpansEqual | 2147483591 | 253,648,180.000 ns | 1,112,524.3074 ns |  1.00 |
|  LongPointers | 2147483591 | 249,412,064.286 ns | 1,079,409.5670 ns |  0.98 |
|      Unrolled | 2147483591 | 246,329,091.667 ns |   852,021.7992 ns |  0.97 |
| PInvokeMemcmp | 2147483591 | 247,795,940.000 ns | 3,390,676.3644 ns |  0.98 |

Saya terkejut melihat SpansEqualtidak keluar di atas untuk metode max-array-size, tetapi perbedaannya sangat kecil sehingga saya tidak berpikir itu akan menjadi masalah.

Info sistem saya:

BenchmarkDotNet=v0.12.0, OS=Windows 10.0.18362
Intel Core i7-6850K CPU 3.60GHz (Skylake), 1 CPU, 12 logical and 6 physical cores
.NET Core SDK=3.1.100
  [Host]     : .NET Core 3.1.0 (CoreCLR 4.700.19.56402, CoreFX 4.700.19.56404), X64 RyuJIT
  DefaultJob : .NET Core 3.1.0 (CoreCLR 4.700.19.56402, CoreFX 4.700.19.56404), X64 RyuJIT

Jika Anda tidak menentang untuk melakukannya, Anda dapat mengimpor rakitan J # "vjslib.dll" dan menggunakan metode Arrays.equals (byte [], byte []) ...

Jangan salahkan saya jika seseorang menertawakan Anda ...

EDIT: Untuk apa nilainya sedikit, saya menggunakan Reflector untuk membongkar kode untuk itu, dan di sini seperti apa itu:

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

.NET 3.5 dan yang lebih baru memiliki tipe publik baru, System.Data.Linq.Binaryyang merangkum byte[]. Ini mengimplementasikan IEquatable<Binary>bahwa (efeknya) membandingkan array dua byte. Perhatikan bahwa System.Data.Linq.Binaryoperator konversi implisit juga berasal dari byte[].

Dokumentasi MSDN: System.Data.Linq.Binary

Dekompilasi reflektor dari metode Equals:

private bool EqualsTo(Binary binary)
{
    if (this != binary)
    {
        if (binary == null)
        {
            return false;
        }
        if (this.bytes.Length != binary.bytes.Length)
        {
            return false;
        }
        if (this.hashCode != binary.hashCode)
        {
            return false;
        }
        int index = 0;
        int length = this.bytes.Length;
        while (index < length)
        {
            if (this.bytes[index] != binary.bytes[index])
            {
                return false;
            }
            index++;
        }
    }
    return true;
}

Sentuhan yang menarik adalah bahwa mereka hanya melanjutkan ke loop perbandingan byte-by-byte jika hash dari dua objek Biner adalah sama. Ini, bagaimanapun, datang pada biaya komputasi hash dalam konstruktor Binaryobjek (dengan melintasi array dengan forloop :-)).

Implementasi di atas berarti bahwa dalam kasus terburuk Anda mungkin harus melintasi array tiga kali: pertama untuk menghitung hash dari array1, kemudian untuk menghitung hash dari array2 dan akhirnya (karena ini adalah skenario terburuk, panjang dan hash sama) untuk membandingkan byte dalam array1 dengan byte dalam array 2.

Secara keseluruhan, meskipun System.Data.Linq.Binarydibangun ke dalam BCL, saya tidak berpikir itu adalah cara tercepat untuk membandingkan array dua byte: - |.

Saya memposting pertanyaan serupa tentang memeriksa apakah byte [] penuh dengan nol. (Kode SIMD dipukuli jadi saya menghapusnya dari jawaban ini.) Berikut adalah kode tercepat dari perbandingan saya:

static unsafe bool EqualBytesLongUnrolled (byte[] data1, byte[] data2)
{
    if (data1 == data2)
        return true;
    if (data1.Length != data2.Length)
        return false;

    fixed (byte* bytes1 = data1, bytes2 = data2) {
        int len = data1.Length;
        int rem = len % (sizeof(long) * 16);
        long* b1 = (long*)bytes1;
        long* b2 = (long*)bytes2;
        long* e1 = (long*)(bytes1 + len - rem);

        while (b1 < e1) {
            if (*(b1) != *(b2) || *(b1 + 1) != *(b2 + 1) || 
                *(b1 + 2) != *(b2 + 2) || *(b1 + 3) != *(b2 + 3) ||
                *(b1 + 4) != *(b2 + 4) || *(b1 + 5) != *(b2 + 5) || 
                *(b1 + 6) != *(b2 + 6) || *(b1 + 7) != *(b2 + 7) ||
                *(b1 + 8) != *(b2 + 8) || *(b1 + 9) != *(b2 + 9) || 
                *(b1 + 10) != *(b2 + 10) || *(b1 + 11) != *(b2 + 11) ||
                *(b1 + 12) != *(b2 + 12) || *(b1 + 13) != *(b2 + 13) || 
                *(b1 + 14) != *(b2 + 14) || *(b1 + 15) != *(b2 + 15))
                return false;
            b1 += 16;
            b2 += 16;
        }

        for (int i = 0; i < rem; i++)
            if (data1 [len - 1 - i] != data2 [len - 1 - i])
                return false;

        return true;
    }
}

Diukur pada dua array byte 256MB:

UnsafeCompare                           : 86,8784 ms
EqualBytesSimd                          : 71,5125 ms
EqualBytesSimdUnrolled                  : 73,1917 ms
EqualBytesLongUnrolled                  : 39,8623 ms

 using System.Linq; //SequenceEqual

 byte[] ByteArray1 = null;
 byte[] ByteArray2 = null;

 ByteArray1 = MyFunct1();
 ByteArray2 = MyFunct2();

 if (ByteArray1.SequenceEqual<byte>(ByteArray2) == true)
 {
    MessageBox.Show("Match");
 }
 else
 {
   MessageBox.Show("Don't match");
 }

Mari tambahkan satu lagi!

Baru-baru ini Microsoft merilis paket NuGet khusus, System.Runtime.CompilerServices.Unsafe . Ini istimewa karena ditulis dalam IL , dan menyediakan fungsionalitas tingkat rendah yang tidak tersedia secara langsung dalam C #.

Salah satu metodenya, Unsafe.As<T>(object)memungkinkan casting jenis referensi apa pun ke jenis referensi lain, melewatkan pemeriksaan keamanan apa pun. Ini biasanya ide yang sangat buruk, tetapi jika kedua jenis memiliki struktur yang sama, itu bisa berhasil. Jadi kita bisa menggunakan ini untuk melemparkan byte[]ke long[]:

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

    var longSize = (int)Math.Floor(a1.Length / 8.0);
    var long1 = Unsafe.As<long[]>(a1);
    var long2 = Unsafe.As<long[]>(a2);

    for (var i = 0; i < longSize; i++)
    {
        if (long1[i] != long2[i]) return false;
    }

    for (var i = longSize * 8; i < a1.Length; i++)
    {
        if (a1[i] != a2[i]) return false;
    }

    return true;
}

Perhatikan bahwa long1.Lengthmasih akan mengembalikan panjang array asli, karena itu disimpan dalam bidang dalam struktur memori array.

Metode ini tidak secepat metode lain yang ditunjukkan di sini, tetapi jauh lebih cepat daripada metode naif, tidak menggunakan kode yang tidak aman atau P / Invoke atau pinning, dan implementasinya cukup mudah (IMO). Berikut adalah beberapa hasil BenchmarkDotNet dari mesin saya:

BenchmarkDotNet=v0.10.3.0, OS=Microsoft Windows NT 6.2.9200.0
Processor=Intel(R) Core(TM) i7-4870HQ CPU 2.50GHz, ProcessorCount=8
Frequency=2435775 Hz, Resolution=410.5470 ns, Timer=TSC
  [Host]     : Clr 4.0.30319.42000, 64bit RyuJIT-v4.6.1637.0
  DefaultJob : Clr 4.0.30319.42000, 64bit RyuJIT-v4.6.1637.0

                 Method |          Mean |    StdDev |
----------------------- |-------------- |---------- |
          UnsafeLibrary |   125.8229 ns | 0.3588 ns |
          UnsafeCompare |    89.9036 ns | 0.8243 ns |
           JSharpEquals | 1,432.1717 ns | 1.3161 ns |
 EqualBytesLongUnrolled |    43.7863 ns | 0.8923 ns |
              NewMemCmp |    65.4108 ns | 0.2202 ns |
            ArraysEqual |   910.8372 ns | 2.6082 ns |
          PInvokeMemcmp |    52.7201 ns | 0.1105 ns |

Saya juga membuat intisari dengan semua tes .

Saya mengembangkan metode yang sedikit mengalahkan memcmp()(jawaban alas) dan ketukan sangat lambat EqualBytesLongUnrolled()(jawaban Arek Bulski) pada PC saya. Pada dasarnya, ini membuka gulungannya dengan 4 bukannya 8.

Pembaruan 30 Maret 2019 :

Dimulai dengan .NET core 3.0, kami memiliki dukungan SIMD!

Solusi ini tercepat dengan selisih yang cukup besar pada PC saya:

#if NETCOREAPP3_0
using System.Runtime.Intrinsics.X86;
#endif
…

public static unsafe bool Compare(byte[] arr0, byte[] arr1)
{
    if (arr0 == arr1)
    {
        return true;
    }
    if (arr0 == null || arr1 == null)
    {
        return false;
    }
    if (arr0.Length != arr1.Length)
    {
        return false;
    }
    if (arr0.Length == 0)
    {
        return true;
    }
    fixed (byte* b0 = arr0, b1 = arr1)
    {
#if NETCOREAPP3_0
        if (Avx2.IsSupported)
        {
            return Compare256(b0, b1, arr0.Length);
        }
        else if (Sse2.IsSupported)
        {
            return Compare128(b0, b1, arr0.Length);
        }
        else
#endif
        {
            return Compare64(b0, b1, arr0.Length);
        }
    }
}
#if NETCOREAPP3_0
public static unsafe bool Compare256(byte* b0, byte* b1, int length)
{
    byte* lastAddr = b0 + length;
    byte* lastAddrMinus128 = lastAddr - 128;
    const int mask = -1;
    while (b0 < lastAddrMinus128) // unroll the loop so that we are comparing 128 bytes at a time.
    {
        if (Avx2.MoveMask(Avx2.CompareEqual(Avx.LoadVector256(b0), Avx.LoadVector256(b1))) != mask)
        {
            return false;
        }
        if (Avx2.MoveMask(Avx2.CompareEqual(Avx.LoadVector256(b0 + 32), Avx.LoadVector256(b1 + 32))) != mask)
        {
            return false;
        }
        if (Avx2.MoveMask(Avx2.CompareEqual(Avx.LoadVector256(b0 + 64), Avx.LoadVector256(b1 + 64))) != mask)
        {
            return false;
        }
        if (Avx2.MoveMask(Avx2.CompareEqual(Avx.LoadVector256(b0 + 96), Avx.LoadVector256(b1 + 96))) != mask)
        {
            return false;
        }
        b0 += 128;
        b1 += 128;
    }
    while (b0 < lastAddr)
    {
        if (*b0 != *b1) return false;
        b0++;
        b1++;
    }
    return true;
}
public static unsafe bool Compare128(byte* b0, byte* b1, int length)
{
    byte* lastAddr = b0 + length;
    byte* lastAddrMinus64 = lastAddr - 64;
    const int mask = 0xFFFF;
    while (b0 < lastAddrMinus64) // unroll the loop so that we are comparing 64 bytes at a time.
    {
        if (Sse2.MoveMask(Sse2.CompareEqual(Sse2.LoadVector128(b0), Sse2.LoadVector128(b1))) != mask)
        {
            return false;
        }
        if (Sse2.MoveMask(Sse2.CompareEqual(Sse2.LoadVector128(b0 + 16), Sse2.LoadVector128(b1 + 16))) != mask)
        {
            return false;
        }
        if (Sse2.MoveMask(Sse2.CompareEqual(Sse2.LoadVector128(b0 + 32), Sse2.LoadVector128(b1 + 32))) != mask)
        {
            return false;
        }
        if (Sse2.MoveMask(Sse2.CompareEqual(Sse2.LoadVector128(b0 + 48), Sse2.LoadVector128(b1 + 48))) != mask)
        {
            return false;
        }
        b0 += 64;
        b1 += 64;
    }
    while (b0 < lastAddr)
    {
        if (*b0 != *b1) return false;
        b0++;
        b1++;
    }
    return true;
}
#endif
public static unsafe bool Compare64(byte* b0, byte* b1, int length)
{
    byte* lastAddr = b0 + length;
    byte* lastAddrMinus32 = lastAddr - 32;
    while (b0 < lastAddrMinus32) // unroll the loop so that we are comparing 32 bytes at a time.
    {
        if (*(ulong*)b0 != *(ulong*)b1) return false;
        if (*(ulong*)(b0 + 8) != *(ulong*)(b1 + 8)) return false;
        if (*(ulong*)(b0 + 16) != *(ulong*)(b1 + 16)) return false;
        if (*(ulong*)(b0 + 24) != *(ulong*)(b1 + 24)) return false;
        b0 += 32;
        b1 += 32;
    }
    while (b0 < lastAddr)
    {
        if (*b0 != *b1) return false;
        b0++;
        b1++;
    }
    return true;
}

Saya akan menggunakan kode yang tidak aman dan menjalankan forloop membandingkan pointer Int32.

Mungkin Anda juga harus mempertimbangkan memeriksa array menjadi non-null.

Jika Anda melihat bagaimana .NET melakukan string.Equals, Anda melihat bahwa itu menggunakan metode pribadi yang disebut EqualsHelper yang memiliki implementasi pointer "tidak aman". .NET Reflector adalah teman Anda untuk melihat bagaimana berbagai hal dilakukan secara internal.

Ini dapat digunakan sebagai template untuk perbandingan array byte yang saya lakukan implementasi di dalam posting blog perbandingan array byte cepat di C # . Saya juga melakukan beberapa tolok ukur yang belum sempurna untuk melihat kapan implementasi yang aman lebih cepat daripada yang tidak aman.

Yang mengatakan, kecuali Anda benar-benar membutuhkan kinerja pembunuh, saya akan pergi untuk perbandingan fr loop sederhana.

Tidak dapat menemukan solusi yang benar-benar saya sukai (kinerja yang wajar, tetapi tidak ada kode / pinvoke yang tidak aman) jadi saya datang dengan ini, tidak ada yang benar-benar asli, tetapi berfungsi:

    /// <summary>
    /// 
    /// </summary>
    /// <param name="array1"></param>
    /// <param name="array2"></param>
    /// <param name="bytesToCompare"> 0 means compare entire arrays</param>
    /// <returns></returns>
    public static bool ArraysEqual(byte[] array1, byte[] array2, int bytesToCompare = 0)
    {
        if (array1.Length != array2.Length) return false;

        var length = (bytesToCompare == 0) ? array1.Length : bytesToCompare;
        var tailIdx = length - length % sizeof(Int64);

        //check in 8 byte chunks
        for (var i = 0; i < tailIdx; i += sizeof(Int64))
        {
            if (BitConverter.ToInt64(array1, i) != BitConverter.ToInt64(array2, i)) return false;
        }

        //check the remainder of the array, always shorter than 8 bytes
        for (var i = tailIdx; i < length; i++)
        {
            if (array1[i] != array2[i]) return false;
        }

        return true;
    }

Kinerja dibandingkan dengan beberapa solusi lain di halaman ini:

Simple Loop: 19837 ticks, 1.00

* BitConverter: 4886 ticks, 4.06

Tidak Aman Membandingkan: 1636 ticks, 12.12

EqualBytesLongUnrolled: 637 ticks, 31.09

P / Invoke memcmp: 369 ticks, 53.67

Diuji dalam linqpad, 1000000 byte array identik (skenario kasus terburuk), masing-masing 500 iterasi.

Tampaknya EqualBytesLongUnrolled adalah yang terbaik dari yang disarankan di atas.

Metode yang dilewati (Enumerable.SequenceEqual, StructuralComparisons.StructuralEqualityComparer.Equals), tidak sabar untuk lambat. Pada array 265MB saya telah mengukur ini:

Host Process Environment Information:
BenchmarkDotNet.Core=v0.9.9.0
OS=Microsoft Windows NT 6.2.9200.0
Processor=Intel(R) Core(TM) i7-3770 CPU 3.40GHz, ProcessorCount=8
Frequency=3323582 ticks, Resolution=300.8802 ns, Timer=TSC
CLR=MS.NET 4.0.30319.42000, Arch=64-bit RELEASE [RyuJIT]
GC=Concurrent Workstation
JitModules=clrjit-v4.6.1590.0

Type=CompareMemoriesBenchmarks  Mode=Throughput  

                 Method |      Median |    StdDev | Scaled | Scaled-SD |
----------------------- |------------ |---------- |------- |---------- |
             NewMemCopy |  30.0443 ms | 1.1880 ms |   1.00 |      0.00 |
 EqualBytesLongUnrolled |  29.9917 ms | 0.7480 ms |   0.99 |      0.04 |
          msvcrt_memcmp |  30.0930 ms | 0.2964 ms |   1.00 |      0.03 |
          UnsafeCompare |  31.0520 ms | 0.7072 ms |   1.03 |      0.04 |
       ByteArrayCompare | 212.9980 ms | 2.0776 ms |   7.06 |      0.25 |

OS=Windows
Processor=?, ProcessorCount=8
Frequency=3323582 ticks, Resolution=300.8802 ns, Timer=TSC
CLR=CORE, Arch=64-bit ? [RyuJIT]
GC=Concurrent Workstation
dotnet cli version: 1.0.0-preview2-003131

Type=CompareMemoriesBenchmarks  Mode=Throughput  

                 Method |      Median |    StdDev | Scaled | Scaled-SD |
----------------------- |------------ |---------- |------- |---------- |
             NewMemCopy |  30.1789 ms | 0.0437 ms |   1.00 |      0.00 |
 EqualBytesLongUnrolled |  30.1985 ms | 0.1782 ms |   1.00 |      0.01 |
          msvcrt_memcmp |  30.1084 ms | 0.0660 ms |   1.00 |      0.00 |
          UnsafeCompare |  31.1845 ms | 0.4051 ms |   1.03 |      0.01 |
       ByteArrayCompare | 212.0213 ms | 0.1694 ms |   7.03 |      0.01 |

Saya belum melihat banyak solusi LINQ di sini.

Saya tidak yakin dengan implikasi kinerja, namun saya umumnya tetap berpegang pada linqaturan praktis dan kemudian mengoptimalkan nanti jika perlu.

public bool CompareTwoArrays(byte[] array1, byte[] array2)
 {
   return !array1.Where((t, i) => t != array2[i]).Any();
 }

Harap dicatat ini hanya berfungsi jika array ukurannya sama. ekstensi bisa terlihat seperti itu

public bool CompareTwoArrays(byte[] array1, byte[] array2)
 {
   if (array1.Length != array2.Length) return false;
   return !array1.Where((t, i) => t != array2[i]).Any();
 }

Saya melakukan beberapa pengukuran menggunakan program terlampir. Net 4.7 rilis build tanpa debugger terpasang. Saya pikir orang telah menggunakan metrik yang salah karena apa yang Anda tentang jika Anda peduli tentang kecepatan di sini adalah berapa lama waktu yang dibutuhkan untuk mengetahui apakah array dua byte sama. yaitu throughput dalam byte.

StructuralComparison :              4.6 MiB/s
for                  :            274.5 MiB/s
ToUInt32             :            263.6 MiB/s
ToUInt64             :            474.9 MiB/s
memcmp               :           8500.8 MiB/s

Seperti yang Anda lihat, tidak ada cara yang lebih baik daripada memcmpdan ini perintah besarnya lebih cepat. Simpul sederhana foradalah pilihan terbaik kedua. Dan itu masih mengejutkan saya mengapa Microsoft tidak bisa begitu saja memasukkan Buffer.Comparemetode.

[Program.cs]:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace memcmp
{
    class Program
    {
        static byte[] TestVector(int size)
        {
            var data = new byte[size];
            using (var rng = new System.Security.Cryptography.RNGCryptoServiceProvider())
            {
                rng.GetBytes(data);
            }
            return data;
        }

        static TimeSpan Measure(string testCase, TimeSpan offset, Action action, bool ignore = false)
        {
            var t = Stopwatch.StartNew();
            var n = 0L;
            while (t.Elapsed < TimeSpan.FromSeconds(10))
            {
                action();
                n++;
            }
            var elapsed = t.Elapsed - offset;
            if (!ignore)
            {
                Console.WriteLine($"{testCase,-16} : {n / elapsed.TotalSeconds,16:0.0} MiB/s");
            }
            return elapsed;
        }

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

        static void Main(string[] args)
        {
            // how quickly can we establish if two sequences of bytes are equal?

            // note that we are testing the speed of different comparsion methods

            var a = TestVector(1024 * 1024); // 1 MiB
            var b = (byte[])a.Clone();

            // was meant to offset the overhead of everything but copying but my attempt was a horrible mistake... should have reacted sooner due to the initially ridiculous throughput values...
            // Measure("offset", new TimeSpan(), () => { return; }, ignore: true);
            var offset = TimeZone.Zero

            Measure("StructuralComparison", offset, () =>
            {
                StructuralComparisons.StructuralEqualityComparer.Equals(a, b);
            });

            Measure("for", offset, () =>
            {
                for (int i = 0; i < a.Length; i++)
                {
                    if (a[i] != b[i]) break;
                }
            });

            Measure("ToUInt32", offset, () =>
            {
                for (int i = 0; i < a.Length; i += 4)
                {
                    if (BitConverter.ToUInt32(a, i) != BitConverter.ToUInt32(b, i)) break;
                }
            });

            Measure("ToUInt64", offset, () =>
            {
                for (int i = 0; i < a.Length; i += 8)
                {
                    if (BitConverter.ToUInt64(a, i) != BitConverter.ToUInt64(b, i)) break;
                }
            });

            Measure("memcmp", offset, () =>
            {
                memcmp(a, b, a.Length);
            });
        }
    }
}

Untuk membandingkan array byte pendek, berikut ini adalah hack yang menarik:

if(myByteArray1.Length != myByteArray2.Length) return false;
if(myByteArray1.Length == 8)
   return BitConverter.ToInt64(myByteArray1, 0) == BitConverter.ToInt64(myByteArray2, 0); 
else if(myByteArray.Length == 4)
   return BitConverter.ToInt32(myByteArray2, 0) == BitConverter.ToInt32(myByteArray2, 0); 

Maka saya mungkin akan jatuh ke solusi yang tercantum dalam pertanyaan.

Akan menarik untuk melakukan analisis kinerja kode ini.

Bagi Anda yang peduli pesanan (yaitu ingin Anda memcmpmengembalikan yang intseharusnya bukan apa-apa), .NET Core 3.0 (dan mungkin .NET Standard 2.1 alias .NET 5.0) akan mencakup Span.SequenceCompareTo(...)metode ekstensi (plus a Span.SequenceEqualTo) yang dapat digunakan untuk membandingkan dua ReadOnlySpan<T>instance ( where T: IComparable<T>).

Dalam proposal GitHub asli , diskusi termasuk perbandingan pendekatan dengan perhitungan tabel lompatan, membaca byte[]as long[], penggunaan SIMD, dan p / invoke ke implementasi CLR memcmp.

Ke depan, ini harus Anda pergi-metode untuk membandingkan array byte atau rentang byte (sebagai harus menggunakan Span<byte>bukan byte[]untuk Anda NET Standard 2.1 API), dan itu cukup cukup cepat bahwa Anda harus hati tidak lagi tentang cara mengoptimalkan itu (dan tidak, meskipun ada kesamaan dalam namanya, itu tidak berkinerja sangat buruk Enumerable.SequenceEqual).

#if NETCOREAPP3_0
// Using the platform-native Span<T>.SequenceEqual<T>(..)
public static int Compare(byte[] range1, int offset1, byte[] range2, int offset2, int count)
{
    var span1 = range1.AsSpan(offset1, count);
    var span2 = range2.AsSpan(offset2, count);

    return span1.SequenceCompareTo(span2);
    // or, if you don't care about ordering
    // return span1.SequenceEqual(span2);
}
#else
// The most basic implementation, in platform-agnostic, safe C#
public static bool Compare(byte[] range1, int offset1, byte[] range2, int offset2, int count)
{
    // Working backwards lets the compiler optimize away bound checking after the first loop
    for (int i = count - 1; i >= 0; --i)
    {
        if (range1[offset1 + i] != range2[offset2 + i])
        {
            return false;
        }
    }

    return true;
}
#endif

Saya berpikir tentang metode akselerasi blok-transfer yang dibangun ke banyak kartu grafis. Tetapi kemudian Anda harus menyalin semua data byte-bijaksana, jadi ini tidak banyak membantu Anda jika Anda tidak ingin menerapkan seluruh bagian dari logika Anda dalam kode yang tidak dikelola dan tergantung perangkat keras ...

Cara optimasi lain yang mirip dengan pendekatan yang ditunjukkan di atas adalah menyimpan sebanyak mungkin data Anda dalam [] daripada byte [] sejak awal, misalnya jika Anda membacanya secara berurutan dari file biner, atau jika Anda menggunakan file yang dipetakan memori, baca data selama [] atau nilai tunggal tunggal. Kemudian, loop perbandingan Anda hanya perlu 1/8 dari jumlah iterasi yang harus dilakukan untuk byte [] yang berisi jumlah data yang sama. Ini adalah masalah kapan dan seberapa sering Anda perlu membandingkan vs kapan dan seberapa sering Anda perlu mengakses data dengan cara byte-by-byte, misalnya untuk menggunakannya dalam panggilan API sebagai parameter dalam metode yang mengharapkan satu byte []. Pada akhirnya, Anda hanya dapat mengetahui apakah Anda benar-benar mengetahui kasus penggunaan ...

Ini hampir pasti jauh lebih lambat daripada versi lain yang diberikan di sini, tapi itu menyenangkan untuk ditulis.

static bool ByteArrayEquals(byte[] a1, byte[] a2) 
{
    return a1.Zip(a2, (l, r) => l == r).All(x => x);
}

Saya memilih solusi yang terinspirasi oleh metode EqualBytesLongUnrolled yang diposting oleh ArekBulski dengan optimasi tambahan. Dalam contoh saya, perbedaan array dalam array cenderung dekat dengan ujung array. Dalam pengujian, saya menemukan bahwa ketika ini adalah kasus untuk array besar, mampu membandingkan elemen array dalam urutan terbalik memberikan solusi ini keuntungan kinerja yang sangat besar dibandingkan solusi berbasis memcmp. Inilah solusinya:

public enum CompareDirection { Forward, Backward }

private static unsafe bool UnsafeEquals(byte[] a, byte[] b, CompareDirection direction = CompareDirection.Forward)
{
    // returns when a and b are same array or both null
    if (a == b) return true;

    // if either is null or different lengths, can't be equal
    if (a == null || b == null || a.Length != b.Length)
        return false;

    const int UNROLLED = 16;                // count of longs 'unrolled' in optimization
    int size = sizeof(long) * UNROLLED;     // 128 bytes (min size for 'unrolled' optimization)
    int len = a.Length;
    int n = len / size;         // count of full 128 byte segments
    int r = len % size;         // count of remaining 'unoptimized' bytes

    // pin the arrays and access them via pointers
    fixed (byte* pb_a = a, pb_b = b)
    {
        if (r > 0 && direction == CompareDirection.Backward)
        {
            byte* pa = pb_a + len - 1;
            byte* pb = pb_b + len - 1;
            byte* phead = pb_a + len - r;
            while(pa >= phead)
            {
                if (*pa != *pb) return false;
                pa--;
                pb--;
            }
        }

        if (n > 0)
        {
            int nOffset = n * size;
            if (direction == CompareDirection.Forward)
            {
                long* pa = (long*)pb_a;
                long* pb = (long*)pb_b;
                long* ptail = (long*)(pb_a + nOffset);
                while (pa < ptail)
                {
                    if (*(pa + 0) != *(pb + 0) || *(pa + 1) != *(pb + 1) ||
                        *(pa + 2) != *(pb + 2) || *(pa + 3) != *(pb + 3) ||
                        *(pa + 4) != *(pb + 4) || *(pa + 5) != *(pb + 5) ||
                        *(pa + 6) != *(pb + 6) || *(pa + 7) != *(pb + 7) ||
                        *(pa + 8) != *(pb + 8) || *(pa + 9) != *(pb + 9) ||
                        *(pa + 10) != *(pb + 10) || *(pa + 11) != *(pb + 11) ||
                        *(pa + 12) != *(pb + 12) || *(pa + 13) != *(pb + 13) ||
                        *(pa + 14) != *(pb + 14) || *(pa + 15) != *(pb + 15)
                    )
                    {
                        return false;
                    }
                    pa += UNROLLED;
                    pb += UNROLLED;
                }
            }
            else
            {
                long* pa = (long*)(pb_a + nOffset);
                long* pb = (long*)(pb_b + nOffset);
                long* phead = (long*)pb_a;
                while (phead < pa)
                {
                    if (*(pa - 1) != *(pb - 1) || *(pa - 2) != *(pb - 2) ||
                        *(pa - 3) != *(pb - 3) || *(pa - 4) != *(pb - 4) ||
                        *(pa - 5) != *(pb - 5) || *(pa - 6) != *(pb - 6) ||
                        *(pa - 7) != *(pb - 7) || *(pa - 8) != *(pb - 8) ||
                        *(pa - 9) != *(pb - 9) || *(pa - 10) != *(pb - 10) ||
                        *(pa - 11) != *(pb - 11) || *(pa - 12) != *(pb - 12) ||
                        *(pa - 13) != *(pb - 13) || *(pa - 14) != *(pb - 14) ||
                        *(pa - 15) != *(pb - 15) || *(pa - 16) != *(pb - 16)
                    )
                    {
                        return false;
                    }
                    pa -= UNROLLED;
                    pb -= UNROLLED;
                }
            }
        }

        if (r > 0 && direction == CompareDirection.Forward)
        {
            byte* pa = pb_a + len - r;
            byte* pb = pb_b + len - r;
            byte* ptail = pb_a + len;
            while(pa < ptail)
            {
                if (*pa != *pb) return false;
                pa++;
                pb++;
            }
        }
    }

    return true;
}

Maaf, jika Anda mencari cara yang dikelola, Anda sudah melakukannya dengan benar dan setahu saya tidak ada metode bawaan di BCL untuk melakukan ini.

Anda harus menambahkan beberapa cek nol awal dan kemudian menggunakannya kembali seolah-olah itu di BCL.

Gunakan SequenceEqualsuntuk perbandingan ini.

Jika Anda mencari pembanding kesetaraan array byte yang sangat cepat, saya sarankan Anda melihat artikel Lab STSdb ​​ini: pembanding kesetaraan array byte.Ini menampilkan beberapa implementasi tercepat untuk membandingkan kesetaraan array byte [], yang disajikan, diuji kinerja dan dirangkum.

Anda juga dapat fokus pada implementasi ini:

BigEndianByteArrayComparer - byte cepat [] array pembanding dari kiri ke kanan (BigEndian) BigEndianByteArrayEqualityComparer - - byte cepat [] pembanding kesetaraan dari kiri ke kanan (BigEndian) LittleEndianByteArrayComparer - byte cepat [sedikit] array bit dari array ke kananLebih cepat [] pembanding kesetaraan dari kanan ke kiri (LittleEndian)

Jawaban singkatnya adalah ini:

    public bool Compare(byte[] b1, byte[] b2)
    {
        return Encoding.ASCII.GetString(b1) == Encoding.ASCII.GetString(b2);
    }

Sedemikian rupa Anda dapat menggunakan .NET string yang dioptimalkan untuk membuat perbandingan byte byte tanpa perlu menulis kode yang tidak aman. Ini adalah bagaimana hal itu dilakukan di latar belakang :

private unsafe static bool EqualsHelper(String strA, String strB)
{
    Contract.Requires(strA != null);
    Contract.Requires(strB != null);
    Contract.Requires(strA.Length == strB.Length);

    int length = strA.Length;

    fixed (char* ap = &strA.m_firstChar) fixed (char* bp = &strB.m_firstChar)
    {
        char* a = ap;
        char* b = bp;

        // Unroll the loop

        #if AMD64
            // For the AMD64 bit platform we unroll by 12 and
            // check three qwords at a time. This is less code
            // than the 32 bit case and is shorter
            // pathlength.

            while (length >= 12)
            {
                if (*(long*)a     != *(long*)b)     return false;
                if (*(long*)(a+4) != *(long*)(b+4)) return false;
                if (*(long*)(a+8) != *(long*)(b+8)) return false;
                a += 12; b += 12; length -= 12;
            }
       #else
           while (length >= 10)
           {
               if (*(int*)a != *(int*)b) return false;
               if (*(int*)(a+2) != *(int*)(b+2)) return false;
               if (*(int*)(a+4) != *(int*)(b+4)) return false;
               if (*(int*)(a+6) != *(int*)(b+6)) return false;
               if (*(int*)(a+8) != *(int*)(b+8)) return false;
               a += 10; b += 10; length -= 10;
           }
       #endif

        // This depends on the fact that the String objects are
        // always zero terminated and that the terminating zero is not included
        // in the length. For odd string sizes, the last compare will include
        // the zero terminator.
        while (length > 0)
        {
            if (*(int*)a != *(int*)b) break;
            a += 2; b += 2; length -= 2;
        }

        return (length <= 0);
    }
}

Karena banyak dari solusi mewah di atas tidak bekerja dengan UWP dan karena saya suka Linq dan pendekatan fungsional saya menekan Anda versi saya untuk masalah ini. Untuk menghindari perbandingan ketika perbedaan pertama terjadi, saya memilih .FirstOrDefault ()

public static bool CompareByteArrays(byte[] ba0, byte[] ba1) =>
    !(ba0.Length != ba1.Length || Enumerable.Range(1,ba0.Length)
        .FirstOrDefault(n => ba0[n] != ba1[n]) > 0);