Bagaimana Anda mengonversi array byte ke string heksadesimal, dan sebaliknya?

Bagaimana Anda bisa mengubah array byte ke string heksadesimal, dan sebaliknya?

Antara:

public static string ByteArrayToString(byte[] ba)
{
  StringBuilder hex = new StringBuilder(ba.Length * 2);
  foreach (byte b in ba)
    hex.AppendFormat("{0:x2}", b);
  return hex.ToString();
}

atau:

public static string ByteArrayToString(byte[] ba)
{
  return BitConverter.ToString(ba).Replace("-","");
}

Bahkan ada lebih banyak varian untuk melakukannya, misalnya di sini .

Konversi terbalik akan seperti ini:

public static byte[] StringToByteArray(String hex)
{
  int NumberChars = hex.Length;
  byte[] bytes = new byte[NumberChars / 2];
  for (int i = 0; i < NumberChars; i += 2)
    bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
  return bytes;
}

Menggunakan Substringadalah pilihan terbaik dalam kombinasi dengan Convert.ToByte. Lihat jawaban ini untuk informasi lebih lanjut. Jika Anda membutuhkan kinerja yang lebih baik, Anda harus menghindari Convert.ToBytesebelum Anda dapat jatuh SubString.

Analisis Kinerja

Catatan: pemimpin baru pada 2015-08-20.

Saya menjalankan masing-masing dari berbagai metode konversi melalui beberapa Stopwatchpengujian kinerja kasar , menjalankan dengan kalimat acak (n = 61, 1000 iterasi) dan menjalankan dengan teks Project Gutenburg (n = 1.238.957, 150 iterasi). Inilah hasilnya, kira-kira dari yang tercepat hingga yang terlambat Semua pengukuran dalam kutu ( 10.000 kutu = 1 ms ) dan semua catatan relatif dibandingkan dengan StringBuilderimplementasi [paling lambat] . Untuk kode yang digunakan, lihat di bawah ini atau repo framework tes di mana saya sekarang memelihara kode untuk menjalankan ini.

Penolakan

PERINGATAN: Jangan mengandalkan statistik ini untuk sesuatu yang konkret; mereka hanyalah contoh sampel data. Jika Anda benar-benar membutuhkan kinerja terbaik, silakan uji metode ini di lingkungan yang mewakili kebutuhan produksi Anda dengan perwakilan data tentang apa yang akan Anda gunakan.

Hasil

• Cari berdasarkan byte unsafe(via CodesInChaos) (ditambahkan untuk menguji repo oleh airbreather )
  • Teks: 4,727.85 (105.2X)
  • Kalimat: 0.28 (99.7X)
• Cari berdasarkan byte (via CodesInChaos)
  • Teks: 10.853,96 (45.8X lebih cepat)
  • Kalimat: 0.65 (42.7X lebih cepat)
• Byte Manipulation 2 (via CodesInChaos)
  • Teks: 12.967,69 (38,4X lebih cepat)
  • Kalimat: 0.73 (37.9X lebih cepat)
• Manipulasi Byte (via Waleed Eissa)
  • Teks: 16.856,64 (29,5X lebih cepat)
  • Kalimat: 0,70 (39,5X lebih cepat)
• Lookup / Shift (via Nathan Moinvaziri)
  • Teks: 23.201,23 (21,4X lebih cepat)
  • Kalimat: 1.24 (22.3X lebih cepat)
• Cari dengan gigitan (via Brian Lambert)
  • Teks: 23.879.41 (20.8X lebih cepat)
  • Kalimat: 1.15 (23.9X lebih cepat)
• BitConverter (via Tomalak)
  • Teks: 113.269,34 (4,4X lebih cepat)
  • Kalimat: 9.98 (2.8X lebih cepat)
• {SoapHexBinary}.ToString (via Mykroft)
  • Teks: 178.601,39 (2.8X lebih cepat)
  • Kalimat: 10.68 (2.6X lebih cepat)
• {byte}.ToString("X2")(menggunakan foreach) (berasal dari jawaban Will Dean)
  • Teks: 308.805,38 (2,4X lebih cepat)
  • Kalimat: 16.89 (2.4X lebih cepat)
• {byte}.ToString("X2")(menggunakan {IEnumerable}.Aggregate, membutuhkan System.Linq) (melalui Mark)
  • Teks: 352.828.20 (2.1X lebih cepat)
  • Kalimat: 16.87 (2.4X lebih cepat)
• Array.ConvertAll(menggunakan string.Join) (via Will Dean)
  • Teks: 675.451,57 (1.1X lebih cepat)
  • Kalimat: 17,95 (2,2X lebih cepat)
• Array.ConvertAll(menggunakan string.Concat, membutuhkan .NET 4.0) (via Will Dean)
  • Teks: 752.078,70 (1,0X lebih cepat)
  • Kalimat: 18.28 (2.2X lebih cepat)
• {StringBuilder}.AppendFormat(menggunakan foreach) (via Tomalak)
  • Teks: 672.115,77 (1,1X lebih cepat)
  • Kalimat: 36.82 (1.1X lebih cepat)
• {StringBuilder}.AppendFormat(menggunakan {IEnumerable}.Aggregate, membutuhkan System.Linq) (berasal dari jawaban Tomalak)
  • Teks: 718.380,63 (1,0X lebih cepat)
  • Kalimat: 39.71 (1.0X lebih cepat)

Tabel pencarian telah mengambil alih manipulasi byte atas. Pada dasarnya, ada beberapa bentuk precomputing apa yang diberikan nibble atau byte dalam hex. Kemudian, saat Anda merobek data, Anda cukup mencari bagian selanjutnya untuk melihat apa string hex itu. Nilai itu kemudian ditambahkan ke output string yang dihasilkan dalam beberapa cara. Untuk manipulasi byte yang lama, yang berpotensi lebih sulit untuk dibaca oleh beberapa pengembang, adalah pendekatan dengan performa terbaik.

Taruhan terbaik Anda masih akan menemukan beberapa data representatif dan mencobanya di lingkungan seperti produksi. Jika Anda memiliki batasan memori yang berbeda, Anda dapat memilih metode dengan alokasi yang lebih sedikit daripada yang lebih cepat tetapi mengonsumsi lebih banyak memori.

Kode Pengujian

Jangan ragu untuk bermain dengan kode pengujian yang saya gunakan. Versi disertakan di sini tetapi jangan ragu untuk mengkloning repo dan menambahkan metode Anda sendiri. Kirimkan permintaan tarik jika Anda menemukan sesuatu yang menarik atau ingin membantu meningkatkan kerangka pengujian yang digunakannya.

1. Tambahkan metode statis baru (Func<byte[], string> ) ke /Tests/ConvertByteArrayToHexString/Test.cs.
2. Tambahkan nama metode itu ke TestCandidates kembali di kelas yang sama.
3. Pastikan Anda menjalankan versi input yang Anda inginkan, kalimat atau teks, dengan mengaktifkan komentar di GenerateTestInput kelas yang sama.
4. Tekan F5dan tunggu hasilnya (dump HTML juga dihasilkan di folder / bin).

static string ByteArrayToHexStringViaStringJoinArrayConvertAll(byte[] bytes) {
    return string.Join(string.Empty, Array.ConvertAll(bytes, b => b.ToString("X2")));
}
static string ByteArrayToHexStringViaStringConcatArrayConvertAll(byte[] bytes) {
    return string.Concat(Array.ConvertAll(bytes, b => b.ToString("X2")));
}
static string ByteArrayToHexStringViaBitConverter(byte[] bytes) {
    string hex = BitConverter.ToString(bytes);
    return hex.Replace("-", "");
}
static string ByteArrayToHexStringViaStringBuilderAggregateByteToString(byte[] bytes) {
    return bytes.Aggregate(new StringBuilder(bytes.Length * 2), (sb, b) => sb.Append(b.ToString("X2"))).ToString();
}
static string ByteArrayToHexStringViaStringBuilderForEachByteToString(byte[] bytes) {
    StringBuilder hex = new StringBuilder(bytes.Length * 2);
    foreach (byte b in bytes)
        hex.Append(b.ToString("X2"));
    return hex.ToString();
}
static string ByteArrayToHexStringViaStringBuilderAggregateAppendFormat(byte[] bytes) {
    return bytes.Aggregate(new StringBuilder(bytes.Length * 2), (sb, b) => sb.AppendFormat("{0:X2}", b)).ToString();
}
static string ByteArrayToHexStringViaStringBuilderForEachAppendFormat(byte[] bytes) {
    StringBuilder hex = new StringBuilder(bytes.Length * 2);
    foreach (byte b in bytes)
        hex.AppendFormat("{0:X2}", b);
    return hex.ToString();
}
static string ByteArrayToHexViaByteManipulation(byte[] bytes) {
    char[] c = new char[bytes.Length * 2];
    byte b;
    for (int i = 0; i < bytes.Length; i++) {
        b = ((byte)(bytes[i] >> 4));
        c[i * 2] = (char)(b > 9 ? b + 0x37 : b + 0x30);
        b = ((byte)(bytes[i] & 0xF));
        c[i * 2 + 1] = (char)(b > 9 ? b + 0x37 : b + 0x30);
    }
    return new string(c);
}
static string ByteArrayToHexViaByteManipulation2(byte[] bytes) {
    char[] c = new char[bytes.Length * 2];
    int b;
    for (int i = 0; i < bytes.Length; i++) {
        b = bytes[i] >> 4;
        c[i * 2] = (char)(55 + b + (((b - 10) >> 31) & -7));
        b = bytes[i] & 0xF;
        c[i * 2 + 1] = (char)(55 + b + (((b - 10) >> 31) & -7));
    }
    return new string(c);
}
static string ByteArrayToHexViaSoapHexBinary(byte[] bytes) {
    SoapHexBinary soapHexBinary = new SoapHexBinary(bytes);
    return soapHexBinary.ToString();
}
static string ByteArrayToHexViaLookupAndShift(byte[] bytes) {
    StringBuilder result = new StringBuilder(bytes.Length * 2);
    string hexAlphabet = "0123456789ABCDEF";
    foreach (byte b in bytes) {
        result.Append(hexAlphabet[(int)(b >> 4)]);
        result.Append(hexAlphabet[(int)(b & 0xF)]);
    }
    return result.ToString();
}
static readonly uint* _lookup32UnsafeP = (uint*)GCHandle.Alloc(_Lookup32, GCHandleType.Pinned).AddrOfPinnedObject();
static string ByteArrayToHexViaLookup32UnsafeDirect(byte[] bytes) {
    var lookupP = _lookup32UnsafeP;
    var result = new string((char)0, bytes.Length * 2);
    fixed (byte* bytesP = bytes)
    fixed (char* resultP = result) {
        uint* resultP2 = (uint*)resultP;
        for (int i = 0; i < bytes.Length; i++) {
            resultP2[i] = lookupP[bytesP[i]];
        }
    }
    return result;
}
static uint[] _Lookup32 = Enumerable.Range(0, 255).Select(i => {
    string s = i.ToString("X2");
    return ((uint)s[0]) + ((uint)s[1] << 16);
}).ToArray();
static string ByteArrayToHexViaLookupPerByte(byte[] bytes) {
    var result = new char[bytes.Length * 2];
    for (int i = 0; i < bytes.Length; i++)
    {
        var val = _Lookup32[bytes[i]];
        result[2*i] = (char)val;
        result[2*i + 1] = (char) (val >> 16);
    }
    return new string(result);
}
static string ByteArrayToHexViaLookup(byte[] bytes) {
    string[] hexStringTable = new string[] {
        "00", "01", "02", "03", "04", "05", "06", "07", "08", "09", "0A", "0B", "0C", "0D", "0E", "0F",
        "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "1A", "1B", "1C", "1D", "1E", "1F",
        "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "2A", "2B", "2C", "2D", "2E", "2F",
        "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "3A", "3B", "3C", "3D", "3E", "3F",
        "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "4A", "4B", "4C", "4D", "4E", "4F",
        "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "5A", "5B", "5C", "5D", "5E", "5F",
        "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "6A", "6B", "6C", "6D", "6E", "6F",
        "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "7A", "7B", "7C", "7D", "7E", "7F",
        "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "8A", "8B", "8C", "8D", "8E", "8F",
        "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "9A", "9B", "9C", "9D", "9E", "9F",
        "A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "A9", "AA", "AB", "AC", "AD", "AE", "AF",
        "B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9", "BA", "BB", "BC", "BD", "BE", "BF",
        "C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9", "CA", "CB", "CC", "CD", "CE", "CF",
        "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7", "D8", "D9", "DA", "DB", "DC", "DD", "DE", "DF",
        "E0", "E1", "E2", "E3", "E4", "E5", "E6", "E7", "E8", "E9", "EA", "EB", "EC", "ED", "EE", "EF",
        "F0", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "FA", "FB", "FC", "FD", "FE", "FF",
    };
    StringBuilder result = new StringBuilder(bytes.Length * 2);
    foreach (byte b in bytes) {
        result.Append(hexStringTable[b]);
    }
    return result.ToString();
}

Pembaruan (2010-01-13)

Menambahkan jawaban Waleed untuk analisis. Cukup cepat.

Pembaruan (2011-10-05)

string.Concat Array.ConvertAllVarian ditambahkan untuk kelengkapan (memerlukan .NET 4.0). Setara denganstring.Join versi.

Pembaruan (2012-02-05)

Repo uji mencakup lebih banyak varian seperti StringBuilder.Append(b.ToString("X2")). Tidak ada yang mengecewakan hasilnya. foreachlebih cepat daripada {IEnumerable}.Aggregate, misalnya, tetapi BitConvertermasih menang.

Pembaruan (2012-04-03)

Menambahkan SoapHexBinaryjawaban Mykroft untuk analisis, yang mengambil alih tempat ketiga.

Pembaruan (2013-01-15)

Menambahkan jawaban manipulasi byte CodesInChaos, yang mengambil alih tempat pertama (dengan margin besar pada blok teks besar).

Pembaruan (2013-05-23)

Ditambahkan jawaban pencarian Nathan Moinvaziri dan varian dari blog Brian Lambert. Keduanya agak cepat, tetapi tidak memimpin pada mesin uji yang saya gunakan (AMD Phenom 9750).

Pembaruan (2014-07-31)

Menambahkan jawaban lookup berbasis byte baru @ CodesInChaos. Tampaknya memimpin pada tes kalimat dan tes teks lengkap.

Pembaruan (2015-08-20)

Menambahkan pengoptimalan dan varian airbreatherunsafe ke repo jawaban ini . Jika Anda ingin bermain di permainan yang tidak aman, Anda bisa mendapatkan beberapa keuntungan kinerja besar dibandingkan pemenang teratas sebelumnya baik dalam string pendek maupun teks besar.

Ada kelas yang disebut SoapHexBinary yang melakukan apa yang Anda inginkan.

using System.Runtime.Remoting.Metadata.W3cXsd2001;

public static byte[] GetStringToBytes(string value)
{
    SoapHexBinary shb = SoapHexBinary.Parse(value);
    return shb.Value;
}

public static string GetBytesToString(byte[] value)
{
    SoapHexBinary shb = new SoapHexBinary(value);
    return shb.ToString();
}

Saat menulis kode kripto, adalah hal biasa untuk menghindari pencarian cabang dan tabel yang bergantung pada data untuk memastikan runtime tidak bergantung pada data, karena pengaturan waktu yang bergantung pada data dapat menyebabkan serangan saluran samping.

Ini juga cukup cepat.

static string ByteToHexBitFiddle(byte[] bytes)
{
    char[] c = new char[bytes.Length * 2];
    int b;
    for (int i = 0; i < bytes.Length; i++) {
        b = bytes[i] >> 4;
        c[i * 2] = (char)(55 + b + (((b-10)>>31)&-7));
        b = bytes[i] & 0xF;
        c[i * 2 + 1] = (char)(55 + b + (((b-10)>>31)&-7));
    }
    return new string(c);
}

_{Ph'nglui mglw'nafh Cthulhu R'lyeh wgah'nagl fhtagn}

Buang semua harapan, kamu yang masuk ke sini

Penjelasan dari si aneh yang mengutak-atik:

1. bytes[i] >> 4 mengekstrak nibble byte yang tinggi
   bytes[i] & 0xF yang rendah
2. b - 10
   adalah < 0untuk nilai b < 10, yang akan menjadi angka desimal
   adalah >= 0untuk nilai b > 10, yang akan menjadi surat dariA ke F.
3. Menggunakan i >> 31pada integer 32 bit yang ditandatangani mengekstrak tanda, terima kasih untuk menandatangani ekstensi. Itu akan -1untuk i < 0dan 0untuk i >= 0.
4. Menggabungkan 2) dan 3), menunjukkan bahwa (b-10)>>31akan 0untuk huruf dan -1untuk angka.
5. Melihat case untuk surat-surat, penjumlahan terakhir menjadi 0, dan bberada dalam kisaran 10 hingga 15. Kami ingin memetakannya ke A(65) hingga F(70), yang berarti menambahkan 55 ( 'A'-10).
6. Melihat case untuk digit, kami ingin mengadaptasi puncak terakhir sehingga memetakan bdari rentang 0 hingga 9 ke kisaran 0(48) hingga 9(57). Ini berarti harus menjadi -7 ( '0' - 55).
   Sekarang kita bisa mengalikannya dengan 7. Tapi karena -1 diwakili oleh semua bit menjadi 1, kita bisa menggunakan & -7sejak (0 & -7) == 0dan (-1 & -7) == -7.

Beberapa pertimbangan lebih lanjut:

• Saya tidak menggunakan variabel loop kedua untuk mengindeks c , karena pengukuran menunjukkan bahwa menghitung itu ilebih murah.
• Menggunakan persis i < bytes.Lengthseperti batas atas dari loop memungkinkan JITter untuk menghilangkan batas cek bytes[i], jadi saya memilih varian itu.
• Membuat bint memungkinkan konversi yang tidak perlu dari dan ke byte.

Jika Anda menginginkan lebih banyak fleksibilitas daripada BitConverter, tetapi tidak ingin loop eksplisit gaya 1990-an yang kikuk, maka Anda dapat melakukannya:

String.Join(String.Empty, Array.ConvertAll(bytes, x => x.ToString("X2")));

Atau, jika Anda menggunakan .NET 4.0:

String.Concat(Array.ConvertAll(bytes, x => x.ToString("X2")));

(Yang terakhir dari komentar pada posting asli.)

Pendekatan lain berdasarkan tabel pencarian. Yang ini hanya menggunakan satu tabel pencarian untuk setiap byte, bukan tabel pencarian per gigitan.

private static readonly uint[] _lookup32 = CreateLookup32();

private static uint[] CreateLookup32()
{
    var result = new uint[256];
    for (int i = 0; i < 256; i++)
    {
        string s=i.ToString("X2");
        result[i] = ((uint)s[0]) + ((uint)s[1] << 16);
    }
    return result;
}

private static string ByteArrayToHexViaLookup32(byte[] bytes)
{
    var lookup32 = _lookup32;
    var result = new char[bytes.Length * 2];
    for (int i = 0; i < bytes.Length; i++)
    {
        var val = lookup32[bytes[i]];
        result[2*i] = (char)val;
        result[2*i + 1] = (char) (val >> 16);
    }
    return new string(result);
}

Saya juga diuji varian ini menggunakan ushort, struct{char X1, X2},struct{byte X1, X2} di tabel.

Bergantung pada target kompilasi (x86, X64) yang memiliki kinerja yang kurang lebih sama atau sedikit lebih lambat dari varian ini.

Dan untuk kinerja yang lebih tinggi, unsafesaudara kandungnya:

private static readonly uint[] _lookup32Unsafe = CreateLookup32Unsafe();
private static readonly uint* _lookup32UnsafeP = (uint*)GCHandle.Alloc(_lookup32Unsafe,GCHandleType.Pinned).AddrOfPinnedObject();

private static uint[] CreateLookup32Unsafe()
{
    var result = new uint[256];
    for (int i = 0; i < 256; i++)
    {
        string s=i.ToString("X2");
        if(BitConverter.IsLittleEndian)
            result[i] = ((uint)s[0]) + ((uint)s[1] << 16);
        else
            result[i] = ((uint)s[1]) + ((uint)s[0] << 16);
    }
    return result;
}

public static string ByteArrayToHexViaLookup32Unsafe(byte[] bytes)
{
    var lookupP = _lookup32UnsafeP;
    var result = new char[bytes.Length * 2];
    fixed(byte* bytesP = bytes)
    fixed (char* resultP = result)
    {
        uint* resultP2 = (uint*)resultP;
        for (int i = 0; i < bytes.Length; i++)
        {
            resultP2[i] = lookupP[bytesP[i]];
        }
    }
    return new string(result);
}

Atau jika Anda menganggap dapat langsung menulis ke string:

public static string ByteArrayToHexViaLookup32UnsafeDirect(byte[] bytes)
{
    var lookupP = _lookup32UnsafeP;
    var result = new string((char)0, bytes.Length * 2);
    fixed (byte* bytesP = bytes)
    fixed (char* resultP = result)
    {
        uint* resultP2 = (uint*)resultP;
        for (int i = 0; i < bytes.Length; i++)
        {
            resultP2[i] = lookupP[bytesP[i]];
        }
    }
    return result;
}

Anda dapat menggunakan metode BitConverter.ToString:

byte[] bytes = {0, 1, 2, 4, 8, 16, 32, 64, 128, 256}
Console.WriteLine( BitConverter.ToString(bytes));

Keluaran:

00-01-02-04-08-10-20-40-80-FF

Informasi lebih lanjut: Metode BitConverter.ToString (Byte [])

Saya baru saja mengalami masalah yang sama hari ini, dan saya menemukan kode ini:

private static string ByteArrayToHex(byte[] barray)
{
    char[] c = new char[barray.Length * 2];
    byte b;
    for (int i = 0; i < barray.Length; ++i)
    {
        b = ((byte)(barray[i] >> 4));
        c[i * 2] = (char)(b > 9 ? b + 0x37 : b + 0x30);
        b = ((byte)(barray[i] & 0xF));
        c[i * 2 + 1] = (char)(b > 9 ? b + 0x37 : b + 0x30);
    }
    return new string(c);
}

Sumber: Forum post byte [] Array ke Hex String (lihat posting oleh PZahra). Saya memodifikasi kode sedikit untuk menghapus awalan 0x.

Saya melakukan beberapa pengujian kinerja untuk kode dan hampir delapan kali lebih cepat daripada menggunakan BitConverter.ToString () (tercepat menurut posting patridge).

Ini adalah jawaban untuk revisi 4 dari jawaban Tomalak yang sangat populer (dan suntingan berikutnya).

Saya akan membuat kasus bahwa pengeditan ini salah, dan menjelaskan mengapa itu dapat dikembalikan. Sepanjang jalan, Anda mungkin belajar satu atau dua hal tentang beberapa internal, dan melihat contoh lain dari apa sebenarnya optimasi prematur dan bagaimana hal itu dapat menggigit Anda.

tl; dr: Cukup gunakan Convert.ToBytedan String.Substringjika Anda sedang terburu-buru ("Kode asli" di bawah), itu kombinasi terbaik jika Anda tidak ingin menerapkan kembali Convert.ToByte. Gunakan sesuatu yang lebih maju (lihat jawaban lain) yang tidak digunakan Convert.ToBytejika Anda membutuhkan kinerja. Jangan tidak menggunakan apa-apa lagi selain String.Substringdalam kombinasi denganConvert.ToByte , kecuali seseorang memiliki sesuatu yang menarik untuk mengatakan tentang ini di komentar dari jawaban ini.

peringatan: Jawaban ini mungkin menjadi usang jika suatu Convert.ToByte(char[], Int32)kelebihan diimplementasikan dalam rangka. Ini tidak mungkin terjadi segera.

Sebagai aturan umum, saya tidak suka mengatakan "jangan optimalkan secara prematur", karena tidak ada yang tahu kapan "prematur" itu. Satu-satunya hal yang harus Anda pertimbangkan ketika memutuskan apakah akan mengoptimalkan atau tidak adalah: "Apakah saya punya waktu dan sumber daya untuk menyelidiki pendekatan optimasi dengan benar?". Jika tidak, maka terlalu cepat, tunggu sampai proyek Anda lebih matang atau sampai Anda membutuhkan kinerja (jika ada kebutuhan nyata, maka Anda akan meluangkan waktu). Sementara itu, lakukan hal paling sederhana yang mungkin bisa berhasil.

Kode asli:

    public static byte[] HexadecimalStringToByteArray_Original(string input)
    {
        var outputLength = input.Length / 2;
        var output = new byte[outputLength];
        for (var i = 0; i < outputLength; i++)
            output[i] = Convert.ToByte(input.Substring(i * 2, 2), 16);
        return output;
    }

Revisi 4:

    public static byte[] HexadecimalStringToByteArray_Rev4(string input)
    {
        var outputLength = input.Length / 2;
        var output = new byte[outputLength];
        using (var sr = new StringReader(input))
        {
            for (var i = 0; i < outputLength; i++)
                output[i] = Convert.ToByte(new string(new char[2] { (char)sr.Read(), (char)sr.Read() }), 16);
        }
        return output;
    }

Revisi menghindari String.Substringdan menggunakan StringReadergantinya. Alasan yang diberikan adalah:

Sunting: Anda dapat meningkatkan kinerja untuk string panjang dengan menggunakan pengurai pass tunggal, seperti:

Nah, melihat kode referensiString.Substring , itu sudah jelas "single-pass"; dan mengapa tidak? Ini beroperasi pada level byte, bukan pada pasangan pengganti.

Namun memang mengalokasikan string baru, tetapi kemudian Anda harus mengalokasikan satu untuk lewat Convert.ToByte. Selanjutnya, solusi yang disediakan dalam revisi mengalokasikan objek lain pada setiap iterasi (array dua-char); Anda dapat dengan aman meletakkan alokasi itu di luar loop dan menggunakan kembali array untuk menghindarinya.

    public static byte[] HexadecimalStringToByteArray(string input)
    {
        var outputLength = input.Length / 2;
        var output = new byte[outputLength];
        var numeral = new char[2];
        using (var sr = new StringReader(input))
        {
            for (var i = 0; i < outputLength; i++)
            {
                numeral[0] = (char)sr.Read();
                numeral[1] = (char)sr.Read();
                output[i] = Convert.ToByte(new string(numeral), 16);
            }
        }
        return output;
    }

Setiap heksadesimal numeral mewakili oktet tunggal menggunakan dua digit (simbol).

Tapi, mengapa menelepon StringReader.Readdua kali? Panggil saja kelebihan kedua dan minta untuk membaca dua karakter dalam array dua karakter sekaligus; dan kurangi jumlah panggilan dua.

    public static byte[] HexadecimalStringToByteArray(string input)
    {
        var outputLength = input.Length / 2;
        var output = new byte[outputLength];
        var numeral = new char[2];
        using (var sr = new StringReader(input))
        {
            for (var i = 0; i < outputLength; i++)
            {
                var read = sr.Read(numeral, 0, 2);
                Debug.Assert(read == 2);
                output[i] = Convert.ToByte(new string(numeral), 16);
            }
        }
        return output;
    }

Yang tersisa dengan Anda adalah pembaca string yang hanya menambahkan "nilai" adalah indeks paralel (internal _pos) yang bisa Anda nyatakan sendiri (seperti jmisalnya), variabel panjang redundan (internal _length), dan referensi redundan untuk input string (internal _s). Dengan kata lain, itu tidak berguna.

Jika Anda bertanya-tanya bagaimana Read"membaca", lihat saja kode , yang dilakukannya hanyalah memanggil String.CopyTostring input. Sisanya hanya biaya pembukuan untuk mempertahankan nilai-nilai yang tidak kita butuhkan.

Jadi, lepaskan pembaca string, dan panggil CopyTodiri Anda sendiri; lebih sederhana, lebih jelas, dan lebih efisien.

    public static byte[] HexadecimalStringToByteArray(string input)
    {
        var outputLength = input.Length / 2;
        var output = new byte[outputLength];
        var numeral = new char[2];
        for (int i = 0, j = 0; i < outputLength; i++, j += 2)
        {
            input.CopyTo(j, numeral, 0, 2);
            output[i] = Convert.ToByte(new string(numeral), 16);
        }
        return output;
    }

Apakah Anda benar-benar membutuhkan jindeks yang bertambah dalam langkah dua paralel i? Tentu saja tidak, hanya kalikan idengan dua (yang harus dioptimalkan oleh kompiler untuk penambahan).

    public static byte[] HexadecimalStringToByteArray_BestEffort(string input)
    {
        var outputLength = input.Length / 2;
        var output = new byte[outputLength];
        var numeral = new char[2];
        for (int i = 0; i < outputLength; i++)
        {
            input.CopyTo(i * 2, numeral, 0, 2);
            output[i] = Convert.ToByte(new string(numeral), 16);
        }
        return output;
    }

Seperti apa solusinya sekarang? Persis seperti di awal, hanya alih-alih menggunakan String.Substringuntuk mengalokasikan string dan menyalin data ke dalamnya, Anda menggunakan array perantara tempat Anda menyalin angka heksadesimal, kemudian mengalokasikan string sendiri dan menyalin data lagi dari array dan ke dalam string (ketika Anda meneruskannya di konstruktor string). Salinan kedua mungkin dioptimalkan-keluar jika string sudah ada di kolam magang, tetapi kemudian String.Substringjuga akan dapat menghindarinya dalam kasus ini.

Bahkan, jika Anda melihat String.Substringlagi, Anda melihat bahwa ia menggunakan beberapa pengetahuan internal tingkat rendah tentang bagaimana string dibangun untuk mengalokasikan string lebih cepat dari yang biasanya Anda lakukan, dan itu menguraikan kode yang sama yang digunakan CopyTosecara langsung di sana untuk menghindari panggilan overhead.

String.Substring

• Kasus terburuk: Satu alokasi cepat, satu salinan cepat.
• Kasus terbaik: Tidak ada alokasi, tidak ada salinan.

Metode manual

• Kasus terburuk: Dua alokasi normal, satu salinan normal, satu salinan cepat.
• Kasing terbaik: Satu alokasi normal, satu salinan normal.

Kesimpulan? Jika Anda ingin menggunakanConvert.ToByte(String, Int32) (karena Anda tidak ingin menerapkan kembali fungsi itu sendiri), sepertinya tidak ada cara untuk mengalahkan String.Substring; yang Anda lakukan hanyalah berputar-putar, menciptakan kembali roda (hanya dengan bahan yang kurang optimal).

Perhatikan bahwa menggunakan Convert.ToBytedan String.Substringmerupakan pilihan yang sangat valid jika Anda tidak membutuhkan kinerja ekstrem. Ingat: hanya memilih alternatif jika Anda memiliki waktu dan sumber daya untuk menyelidiki cara kerjanya dengan benar.

Jika ada Convert.ToByte(char[], Int32), tentu saja akan berbeda (mungkin untuk melakukan apa yang saya jelaskan di atas dan sepenuhnya menghindari String).

Saya menduga bahwa orang yang melaporkan kinerja yang lebih baik dengan "menghindari String.Substring" juga menghindari Convert.ToByte(String, Int32), yang seharusnya Anda lakukan jika Anda memang membutuhkan kinerja. Lihatlah jawaban lain yang tak terhitung jumlahnya untuk menemukan semua pendekatan berbeda untuk melakukan itu.

Penafian: Saya belum mendekompilasi versi terbaru kerangka kerja untuk memverifikasi bahwa sumber referensi terbaru, saya anggap benar.

Sekarang, semuanya terdengar bagus dan logis, semoga bahkan jelas jika Anda sudah berhasil sejauh ini. Tetapi apakah itu benar?

Intel(R) Core(TM) i7-3720QM CPU @ 2.60GHz
    Cores: 8
    Current Clock Speed: 2600
    Max Clock Speed: 2600
--------------------
Parsing hexadecimal string into an array of bytes
--------------------
HexadecimalStringToByteArray_Original: 7,777.09 average ticks (over 10000 runs), 1.2X
HexadecimalStringToByteArray_BestEffort: 8,550.82 average ticks (over 10000 runs), 1.1X
HexadecimalStringToByteArray_Rev4: 9,218.03 average ticks (over 10000 runs), 1.0X

Iya!

Props to Partridge untuk kerangka kerja bangku, mudah diretas. Input yang digunakan adalah hash SHA-1 berikut yang diulangi 5000 kali untuk menghasilkan string sepanjang 100.000 byte.

209113288F93A9AB8E474EA78D899AFDBB874355

Selamat bersenang-senang! (Tapi optimalkan dengan moderasi.)

Lengkapi untuk menjawab dengan @CodesInChaos (metode terbalik)

public static byte[] HexToByteUsingByteManipulation(string s)
{
    byte[] bytes = new byte[s.Length / 2];
    for (int i = 0; i < bytes.Length; i++)
    {
        int hi = s[i*2] - 65;
        hi = hi + 10 + ((hi >> 31) & 7);

        int lo = s[i*2 + 1] - 65;
        lo = lo + 10 + ((lo >> 31) & 7) & 0x0f;

        bytes[i] = (byte) (lo | hi << 4);
    }
    return bytes;
}

Penjelasan:

& 0x0f adalah untuk mendukung juga huruf kecil

hi = hi + 10 + ((hi >> 31) & 7); sama dengan:

hi = ch-65 + 10 + (((ch-65) >> 31) & 7);

Untuk '0' .. '9' itu sama dengan hi = ch - 65 + 10 + 7;yang hi = ch - 48(ini karena 0xffffffff & 7).

Untuk 'A' .. 'F' itu hi = ch - 65 + 10;(ini karena 0x00000000 & 7).

Untuk 'a' .. 'f' kita harus berjumlah besar sehingga kita harus mengurangi 32 dari versi default dengan membuat beberapa bit 0dengan menggunakan & 0x0f.

65 adalah kode untuk 'A'

48 adalah kode untuk '0'

7 adalah jumlah huruf antara '9'dan 'A'dalam tabel ASCII ( ...456789:;<=>?@ABCD...).

Masalah ini juga bisa diselesaikan dengan menggunakan tabel pencarian. Ini akan membutuhkan sejumlah kecil memori statis untuk encoder dan decoder. Namun metode ini akan cepat:

• Tabel enkoder 512 byte atau 1024 byte (dua kali ukuran jika dibutuhkan huruf besar dan kecil)
• Tabel dekoder 256 byte atau 64 KiB (baik pencarian karakter tunggal atau pencarian karakter ganda)

Solusi saya menggunakan 1024 byte untuk tabel penyandian, dan 256 byte untuk decoding.

Decoding

private static readonly byte[] LookupTable = new byte[] {
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};

private static byte Lookup(char c)
{
  var b = LookupTable[c];
  if (b == 255)
    throw new IOException("Expected a hex character, got " + c);
  return b;
}

public static byte ToByte(char[] chars, int offset)
{
  return (byte)(Lookup(chars[offset]) << 4 | Lookup(chars[offset + 1]));
}

Pengkodean

private static readonly char[][] LookupTableUpper;
private static readonly char[][] LookupTableLower;

static Hex()
{
  LookupTableLower = new char[256][];
  LookupTableUpper = new char[256][];
  for (var i = 0; i < 256; i++)
  {
    LookupTableLower[i] = i.ToString("x2").ToCharArray();
    LookupTableUpper[i] = i.ToString("X2").ToCharArray();
  }
}

public static char[] ToCharLower(byte[] b, int bOffset)
{
  return LookupTableLower[b[bOffset]];
}

public static char[] ToCharUpper(byte[] b, int bOffset)
{
  return LookupTableUpper[b[bOffset]];
}

Perbandingan

StringBuilderToStringFromBytes:   106148
BitConverterToStringFromBytes:     15783
ArrayConvertAllToStringFromBytes:  54290
ByteManipulationToCharArray:        8444
TableBasedToCharArray:              5651 *

* solusi ini

Catatan

Selama mendekode IOException dan IndexOutOfRangeException dapat terjadi (jika karakter memiliki nilai terlalu tinggi> 256). Metode untuk de / encoding stream atau array harus diimplementasikan, ini hanya bukti konsep.

Ini adalah pos yang bagus. Saya suka solusi Waleed. Saya belum menjalankannya melalui tes patridge tetapi tampaknya cukup cepat. Saya juga membutuhkan proses sebaliknya, mengubah string hex menjadi array byte, jadi saya menulisnya sebagai pembalikan dari solusi Waleed. Tidak yakin apakah itu lebih cepat daripada solusi asli Tomalak. Sekali lagi, saya juga tidak menjalankan proses sebaliknya melalui tes patridge.

private byte[] HexStringToByteArray(string hexString)
{
    int hexStringLength = hexString.Length;
    byte[] b = new byte[hexStringLength / 2];
    for (int i = 0; i < hexStringLength; i += 2)
    {
        int topChar = (hexString[i] > 0x40 ? hexString[i] - 0x37 : hexString[i] - 0x30) << 4;
        int bottomChar = hexString[i + 1] > 0x40 ? hexString[i + 1] - 0x37 : hexString[i + 1] - 0x30;
        b[i / 2] = Convert.ToByte(topChar + bottomChar);
    }
    return b;
}

Mengapa membuatnya rumit? Ini sederhana di Visual Studio 2008:

C #:

string hex = BitConverter.ToString(YourByteArray).Replace("-", "");

VB:

Dim hex As String = BitConverter.ToString(YourByteArray).Replace("-", "")

Bukan untuk menumpuk banyak jawaban di sini, tapi saya menemukan yang cukup optimal (~ 4.5x lebih baik daripada diterima), implementasi langsung dari pengurai string hex. Pertama, output dari tes saya (batch pertama adalah implementasi saya):

Give me that string:
04c63f7842740c77e545bb0b2ade90b384f119f6ab57b680b7aa575a2f40939f

Time to parse 100,000 times: 50.4192 ms
Result as base64: BMY/eEJ0DHflRbsLKt6Qs4TxGfarV7aAt6pXWi9Ak58=
BitConverter'd: 04-C6-3F-78-42-74-0C-77-E5-45-BB-0B-2A-DE-90-B3-84-F1-19-F6-AB-5
7-B6-80-B7-AA-57-5A-2F-40-93-9F

Accepted answer: (StringToByteArray)
Time to parse 100000 times: 233.1264ms
Result as base64: BMY/eEJ0DHflRbsLKt6Qs4TxGfarV7aAt6pXWi9Ak58=
BitConverter'd: 04-C6-3F-78-42-74-0C-77-E5-45-BB-0B-2A-DE-90-B3-84-F1-19-F6-AB-5
7-B6-80-B7-AA-57-5A-2F-40-93-9F

With Mono's implementation:
Time to parse 100000 times: 777.2544ms
Result as base64: BMY/eEJ0DHflRbsLKt6Qs4TxGfarV7aAt6pXWi9Ak58=
BitConverter'd: 04-C6-3F-78-42-74-0C-77-E5-45-BB-0B-2A-DE-90-B3-84-F1-19-F6-AB-5
7-B6-80-B7-AA-57-5A-2F-40-93-9F

With SoapHexBinary:
Time to parse 100000 times: 845.1456ms
Result as base64: BMY/eEJ0DHflRbsLKt6Qs4TxGfarV7aAt6pXWi9Ak58=
BitConverter'd: 04-C6-3F-78-42-74-0C-77-E5-45-BB-0B-2A-DE-90-B3-84-F1-19-F6-AB-5
7-B6-80-B7-AA-57-5A-2F-40-93-9F

Baris base64 dan 'BitConverter'd' ada untuk menguji kebenarannya. Perhatikan bahwa keduanya sama.

Pelaksanaan:

public static byte[] ToByteArrayFromHex(string hexString)
{
  if (hexString.Length % 2 != 0) throw new ArgumentException("String must have an even length");
  var array = new byte[hexString.Length / 2];
  for (int i = 0; i < hexString.Length; i += 2)
  {
    array[i/2] = ByteFromTwoChars(hexString[i], hexString[i + 1]);
  }
  return array;
}

private static byte ByteFromTwoChars(char p, char p_2)
{
  byte ret;
  if (p <= '9' && p >= '0')
  {
    ret = (byte) ((p - '0') << 4);
  }
  else if (p <= 'f' && p >= 'a')
  {
    ret = (byte) ((p - 'a' + 10) << 4);
  }
  else if (p <= 'F' && p >= 'A')
  {
    ret = (byte) ((p - 'A' + 10) << 4);
  } else throw new ArgumentException("Char is not a hex digit: " + p,"p");

  if (p_2 <= '9' && p_2 >= '0')
  {
    ret |= (byte) ((p_2 - '0'));
  }
  else if (p_2 <= 'f' && p_2 >= 'a')
  {
    ret |= (byte) ((p_2 - 'a' + 10));
  }
  else if (p_2 <= 'F' && p_2 >= 'A')
  {
    ret |= (byte) ((p_2 - 'A' + 10));
  } else throw new ArgumentException("Char is not a hex digit: " + p_2, "p_2");

  return ret;
}

Saya mencoba beberapa hal unsafe dan memindahkan urutan karakter-ke-gigitan ifke metode lain, tapi ini adalah yang tercepat yang didapatnya.

(Saya mengakui bahwa ini menjawab setengah dari pertanyaan. Saya merasa bahwa konversi string-> byte [] kurang terwakili, sedangkan sudut string byte [] -> tampaknya tercakup dengan baik. Jadi, jawaban ini.)

Versi aman:

public static class HexHelper
{
    [System.Diagnostics.Contracts.Pure]
    public static string ToHex(this byte[] value)
    {
        if (value == null)
            throw new ArgumentNullException("value");

        const string hexAlphabet = @"0123456789ABCDEF";

        var chars = new char[checked(value.Length * 2)];
        unchecked
        {
            for (int i = 0; i < value.Length; i++)
            {
                chars[i * 2] = hexAlphabet[value[i] >> 4];
                chars[i * 2 + 1] = hexAlphabet[value[i] & 0xF];
            }
        }
        return new string(chars);
    }

    [System.Diagnostics.Contracts.Pure]
    public static byte[] FromHex(this string value)
    {
        if (value == null)
            throw new ArgumentNullException("value");
        if (value.Length % 2 != 0)
            throw new ArgumentException("Hexadecimal value length must be even.", "value");

        unchecked
        {
            byte[] result = new byte[value.Length / 2];
            for (int i = 0; i < result.Length; i++)
            {
                // 0(48) - 9(57) -> 0 - 9
                // A(65) - F(70) -> 10 - 15
                int b = value[i * 2]; // High 4 bits.
                int val = ((b - '0') + ((('9' - b) >> 31) & -7)) << 4;
                b = value[i * 2 + 1]; // Low 4 bits.
                val += (b - '0') + ((('9' - b) >> 31) & -7);
                result[i] = checked((byte)val);
            }
            return result;
        }
    }
}

Versi tidak aman Bagi mereka yang lebih suka kinerja dan tidak takut ketidakamanan. Tentang 35% lebih cepat ToHex dan 10% lebih cepat DariHex.

public static class HexUnsafeHelper
{
    [System.Diagnostics.Contracts.Pure]
    public static unsafe string ToHex(this byte[] value)
    {
        if (value == null)
            throw new ArgumentNullException("value");

        const string alphabet = @"0123456789ABCDEF";

        string result = new string(' ', checked(value.Length * 2));
        fixed (char* alphabetPtr = alphabet)
        fixed (char* resultPtr = result)
        {
            char* ptr = resultPtr;
            unchecked
            {
                for (int i = 0; i < value.Length; i++)
                {
                    *ptr++ = *(alphabetPtr + (value[i] >> 4));
                    *ptr++ = *(alphabetPtr + (value[i] & 0xF));
                }
            }
        }
        return result;
    }

    [System.Diagnostics.Contracts.Pure]
    public static unsafe byte[] FromHex(this string value)
    {
        if (value == null)
            throw new ArgumentNullException("value");
        if (value.Length % 2 != 0)
            throw new ArgumentException("Hexadecimal value length must be even.", "value");

        unchecked
        {
            byte[] result = new byte[value.Length / 2];
            fixed (char* valuePtr = value)
            {
                char* valPtr = valuePtr;
                for (int i = 0; i < result.Length; i++)
                {
                    // 0(48) - 9(57) -> 0 - 9
                    // A(65) - F(70) -> 10 - 15
                    int b = *valPtr++; // High 4 bits.
                    int val = ((b - '0') + ((('9' - b) >> 31) & -7)) << 4;
                    b = *valPtr++; // Low 4 bits.
                    val += (b - '0') + ((('9' - b) >> 31) & -7);
                    result[i] = checked((byte)val);
                }
            }
            return result;
        }
    }
}