Jak przekonwertować tablicę bajtów na ciąg szesnastkowy i odwrotnie?

Jak przekonwertować tablicę bajtów na ciąg szesnastkowy i odwrotnie?

Zarówno:

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

lub:

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

Istnieje jeszcze więcej wariantów robienia tego, na przykład tutaj .

Odwrotna konwersja wyglądałaby następująco:

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

Używanie Substringjest najlepszą opcją w połączeniu z Convert.ToByte. Zobacz tę odpowiedź, aby uzyskać więcej informacji. Jeśli potrzebujesz lepszej wydajności, musisz tego uniknąć, Convert.ToBytezanim spadniesz SubString.

Analiza wydajności

Uwaga: nowy lider od 20.08.2015.

Przeanalizowałem każdą z różnych metod konwersji przez pewne prymitywne Stopwatchtesty wydajności, przebieg z losowym zdaniem (n = 61, 1000 iteracji) i przebieg z tekstem Projektu Gutenburga (n = 1 238 957, 150 iteracji). Oto wyniki, z grubsza od najszybszego do najwolniejszego. Wszystkie pomiary są w tikach ( 10 000 tików = 1 ms ), a wszystkie uwagi względne są porównywane z [najwolniejszą] StringBuilderimplementacją. Informacje na temat użytego kodu znajdują się poniżej lub w repozytorium środowiska testowego, w którym teraz utrzymuję kod do uruchomienia tego.

Zrzeczenie się

OSTRZEŻENIE: Nie polegaj na tych statystykach na niczym konkretnym; są po prostu próbką danych przykładowych. Jeśli naprawdę potrzebujesz najwyższej wydajności, przetestuj te metody w środowisku reprezentatywnym dla twoich potrzeb produkcyjnych, z danymi reprezentującymi to, czego będziesz używać.

Wyniki

• Wyszukiwanie według bajtu unsafe(przez CodesInChaos) (dodane do testowego repozytorium przez airbreather )
  • Tekst: 4 727,85 (105,2X)
  • Zdanie: 0,28 (99,7X)
• Wyszukiwanie według bajtu (przez CodesInChaos)
  • Tekst: 10 853,96 (45,8X szybciej)
  • Zdanie: 0,65 (42,7X szybciej)
• Byte Manipulation 2 (via CodesInChaos)
  • Tekst: 12967,69 (38,4X szybciej)
  • Zdanie: 0,73 (37,9X szybciej)
• Manipulacja bajtami (przez Waleed Eissa)
  • Tekst: 166,66.64 (29,5X szybciej)
  • Zdanie: 0,70 (39,5 x szybciej)
• Lookup / Shift (via Nathan Moinvaziri)
  • Tekst: 23.201,23 (21,4X szybciej)
  • Zdanie: 1,24 (22,3X szybciej)
• Wyszukiwanie przez nibble (via Brian Lambert)
  • Tekst: 23.879.41 (20.8X szybciej)
  • Zdanie: 1,15 (23,9 x szybciej)
• BitConverter (przez Tomalak)
  • Tekst: 113 269,34 (4,4 x szybciej)
  • Zdanie: 9,98 (2,8 x szybciej)
• {SoapHexBinary}.ToString (przez Mykroft)
  • Tekst: 178 601,39 (2,8 x szybciej)
  • Zdanie: 10,68 (2,6 razy szybszy)
• {byte}.ToString("X2")(using foreach) (pochodzi z odpowiedzi Willa Deana)
  • Tekst: 308,805,38 (2,4 razy szybszy)
  • Zdanie: 16,89 (2,4 x szybciej)
• {byte}.ToString("X2")(używanie {IEnumerable}.Aggregate, wymaga System.Linq) (przez Mark)
  • Tekst: 352 828,20 (2,1 razy szybszy)
  • Zdanie: 16,87 (2,4 x szybciej)
• Array.ConvertAll(za pomocą string.Join) (przez Will Dean)
  • Tekst: 675,451,57 (1,1 raza szybszy)
  • Zdanie: 17,95 (2,2 x szybciej)
• Array.ConvertAll(używanie string.Concat, wymaga .NET 4.0) (przez Will Dean)
  • Tekst: 752 028,70 (1,0X szybciej)
  • Zdanie: 18,28 (2,2 x szybciej)
• {StringBuilder}.AppendFormat(za pomocą foreach) (przez Tomalak)
  • Tekst: 672,115,77 (1,1 x szybciej)
  • Zdanie: 36,82 (1,1 x szybciej)
• {StringBuilder}.AppendFormat(używanie {IEnumerable}.Aggregate, wymaga System.Linq) (pochodzi z odpowiedzi Tomalaka)
  • Tekst: 718,380,63 (1,0X szybciej)
  • Zdanie: 39,71 (1,0X szybciej)

Tabele odnośników przejęły kontrolę nad przetwarzaniem bajtów. Zasadniczo istnieje pewna forma wstępnego obliczania tego, co dany skubek lub bajt będzie w formacie szesnastkowym. Następnie, przeglądając dane, po prostu przeglądasz kolejną część, aby zobaczyć, jaki to byłby szesnastkowy ciąg znaków. Ta wartość jest następnie dodawana do wynikowego ciągu w pewien sposób. Przez długi czas manipulowanie bajtami, potencjalnie trudniejsze do odczytania przez niektórych programistów, było najskuteczniejszym podejściem.

Najlepszym rozwiązaniem będzie znalezienie reprezentatywnych danych i wypróbowanie ich w środowisku produkcyjnym. Jeśli masz inne ograniczenia pamięci, możesz preferować metodę z mniejszą alokacją niż taką, która byłaby szybsza, ale zużywałaby więcej pamięci.

Kod testowy

Zachęcamy do zabawy przy użyciu kodu testowego, którego użyłem. Dołączona jest tutaj wersja, ale możesz sklonować repozytorium i dodać własne metody. Prześlij żądanie ściągnięcia, jeśli znajdziesz coś interesującego lub chcesz ulepszyć używaną platformę testową.

1. Dodaj nową metodę statyczną ( Func<byte[], string>) do /Tests/ConvertByteArrayToHexString/Test.cs.
2. Dodaj nazwę tej metody do TestCandidateswartości zwracanej w tej samej klasie.
3. Upewnij się, że korzystasz z żądanej wersji wejściowej, zdania lub tekstu, przełączając komentarze GenerateTestInputw tej samej klasie.
4. Naciśnij F5i poczekaj na wynik (zrzut HTML jest również generowany w folderze / 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();
}

Aktualizacja (13.01.2010)

Dodano odpowiedź Waleeda do analizy. Dosyć szybko.

Aktualizacja (2011-10-05)

Dodano string.Concat Array.ConvertAllwariant kompletności (wymaga .NET 4.0). Na równi z string.Joinwersją.

Aktualizacja (2012-02-05)

Repozytorium testów zawiera więcej wariantów, takich jak StringBuilder.Append(b.ToString("X2")). Żadne nie zakłóciło żadnych wyników. foreachjest szybszy niż {IEnumerable}.Aggregate, na przykład, ale BitConverterwciąż wygrywa.

Aktualizacja (2012-04-03)

Dodano SoapHexBinaryodpowiedź Mykroft do analizy, która zajęła trzecie miejsce.

Aktualizacja (15.01.2013)

Dodano odpowiedź manipulacji bajtami CodesInChaos, która zajęła pierwsze miejsce (z dużym marginesem na dużych blokach tekstu).

Aktualizacja (23.05.2013)

Dodano odpowiedź Nathana Moinvaziriego i wariant z bloga Briana Lamberta. Oba są dość szybkie, ale nie przejmują prowadzenia na testowej maszynie, z której korzystałem (AMD Phenom 9750).

Aktualizacja (2014-07-31)

Dodano nową odpowiedź bajtową @ CodesInChaos. Wydaje się, że przejął inicjatywę zarówno w testach zdań, jak i testach pełnotekstowych.

Aktualizacja (2015-08-20)

Dodano optymalizacje i wariant airbreatherunsafe do repozytorium tej odpowiedzi . Jeśli chcesz zagrać w niebezpieczną grę, możesz uzyskać ogromny wzrost wydajności w stosunku do któregokolwiek z poprzednich najlepszych zwycięzców zarówno w przypadku krótkich ciągów, jak i dużych tekstów.

Istnieje klasa SoapHexBinary, która robi dokładnie to, co chcesz.

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

Podczas pisania kodu kryptograficznego często zdarza się, aby unikać gałęzi zależnych od danych i przeszukiwania tabel, aby upewnić się, że środowisko wykonawcze nie zależy od danych, ponieważ czas zależny od danych może prowadzić do ataków bocznych.

Jest również dość szybki.

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}

Porzucić wszelką nadzieję wy, którzy wchodzą tutaj

Wyjaśnienie tego dziwnego bicia:

1. bytes[i] >> 4wyodrębnia wysoką część bajtu
   bytes[i] & 0xFwyodrębnia niską wartość części bajtu
2. b - 10
   jest < 0dla wartości b < 10, które staną się cyfrą dziesiętną
   jest >= 0dla wartości b > 10, które staną się literą od Ado F.
3. Użycie i >> 3132-bitowej liczby całkowitej ze znakiem powoduje wyodrębnienie znaku dzięki rozszerzeniu znaku. Będzie -1za i < 0i 0za i >= 0.
4. Łączenie 2) i 3) pokazuje, że (b-10)>>31będą to 0litery i -1cyfry.
5. Patrząc na sprawy do listów, ostatni do składnika staje 0, a bmieści się w zakresie od 10 do 15. Chcemy mapować go do A(65) do F(70), co oznacza dodanie 55 ( 'A'-10).
6. Patrząc na przypadek cyfr, chcemy dostosować ostatnie podsumowanie, aby mapowało się ono bw zakresie od 0 do 9 do zakresu 0(48) do 9(57). Oznacza to, że musi być -7 ( '0' - 55).
   Teraz możemy po prostu pomnożyć przez 7. Ale ponieważ -1 jest reprezentowane przez wszystkie bity równe 1, możemy zamiast tego używać & -7od (0 & -7) == 0i (-1 & -7) == -7.

Kilka dalszych uwag:

• Nie użyłem drugiej zmiennej pętli do indeksowania c, ponieważ pomiar pokazuje, że obliczenie jej na podstawie ijest tańsze.
• Użycie dokładnie i < bytes.Lengthjako górnej granicy pętli pozwala JITterowi na wyeliminowanie sprawdzania granic bytes[i], więc wybrałem ten wariant.
• Utworzenie bint pozwala na niepotrzebne konwersje zi do bajtu.

Jeśli chcesz większej elastyczności BitConverter, ale nie chcesz tych niezgrabnych wyraźnych pętli w stylu lat 90., możesz:

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

Lub, jeśli używasz .NET 4.0:

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

(To ostatnie z komentarza do oryginalnego postu.)

Inne podejście oparte na tabeli odnośników. Ten używa tylko jednej tabeli odnośników dla każdego bajtu, zamiast tabeli odnośników na skubanie.

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

I również badane warianty to za pomocą ushort, struct{char X1, X2}, struct{byte X1, X2}w tabeli przeglądowej.

W zależności od celu kompilacji (x86, X64) te albo miały mniej więcej tę samą wydajność lub były nieco wolniejsze niż ten wariant.

A dla jeszcze wyższej wydajności jego unsaferodzeństwo:

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

Lub jeśli uważasz, że dopuszczalne jest zapisanie bezpośrednio w ciągu:

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

Możesz użyć metody BitConverter.ToString:

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

Wynik:

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

Więcej informacji: BitConverter.ToString Method (Byte [])

Właśnie dzisiaj spotkałem ten sam problem i natknąłem się na ten kod:

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

Źródło: Post post byte [] Array to Hex String (patrz post PZahra). Zmodyfikowałem trochę kod, aby usunąć prefiks 0x.

Przeprowadziłem testy wydajności kodu i było ono prawie osiem razy szybsze niż użycie BitConverter.ToString () (najszybszy zgodnie z postem Patridge'a).

Jest to odpowiedź na zmiany 4 z bardzo popularnej odpowiedź Tomalak za (i kolejnych edycji).

Wyjaśnię, że ta edycja jest błędna, i wyjaśnię, dlaczego można ją cofnąć. Po drodze możesz dowiedzieć się czegoś o niektórych elementach wewnętrznych i zobaczyć jeszcze jeden przykład tego, czym tak naprawdę jest przedwczesna optymalizacja i jak może cię ugryźć.

tl; dr: Po prostu użyj Convert.ToBytei String.Substringjeśli się spieszysz („Kod oryginalny” poniżej), jest to najlepsza kombinacja, jeśli nie chcesz ponownie wdrożyć Convert.ToByte. Użyj czegoś bardziej zaawansowanego (zobacz inne odpowiedzi), z którego nie skorzystasz, Convert.ToBytejeśli potrzebujesz wydajności. Czy nie używać niczego innego niż String.Substringw połączeniu z Convert.ToByte, chyba że ktoś ma coś ciekawego do powiedzenia na ten temat w komentarzach tej odpowiedzi.

ostrzeżenie: Ta odpowiedź może stać się nieaktualna, jeśli w ramach Convert.ToByte(char[], Int32)zostanie zaimplementowane przeciążenie. Jest mało prawdopodobne, aby stało się to wkrótce.

Zasadniczo nie lubię mówić „nie optymalizuj przedwcześnie”, ponieważ nikt nie wie, kiedy jest „przedwczesny”. Jedyną rzeczą, którą należy wziąć pod uwagę przy podejmowaniu decyzji o optymalizacji, jest: „Czy mam czas i zasoby, aby właściwie zbadać podejścia optymalizacyjne?”. Jeśli tego nie zrobisz, to jest za wcześnie, poczekaj, aż twój projekt stanie się bardziej dojrzały lub do momentu, gdy będziesz potrzebować wydajności (jeśli jest taka potrzeba, to poświęcisz czas). W międzyczasie zrób najprostszą rzecz, która może działać.

Oryginalny kod:

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

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

Wersja unika String.Substringi używa StringReaderzamiast niej. Podany powód to:

Edycja: możesz poprawić wydajność długich ciągów znaków, używając parsera jednoprzebiegowego, na przykład:

Patrząc na kod referencyjnyString.Substring , jest już wyraźnie „jednoprzebiegowy”; a dlaczego nie? Działa na poziomie bajtów, a nie na parach zastępczych.

Przydziela jednak nowy ciąg, ale i tak musisz go przydzielić Convert.ToByte. Ponadto rozwiązanie przedstawione w wersji przydziela kolejny obiekt na każdej iteracji (tablica dwuznakowa); możesz bezpiecznie umieścić ten przydział poza pętlą i ponownie użyć tablicy, aby tego uniknąć.

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

Każdy szesnastkowy numeralreprezentuje pojedynczy oktet przy użyciu dwóch cyfr (symboli).

Ale dlaczego dzwonisz StringReader.Readdwa razy? Po prostu wywołaj drugie przeciążenie i poproś, aby odczytał dwa znaki jednocześnie w tablicy dwóch znaków; i zmniejsz liczbę połączeń o dwa.

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

Pozostaje Ci czytnik łańcuchów, którego jedyną „wartością” jest indeks równoległy (wewnętrzny _pos), który mógłbyś zadeklarować ( jna przykład), redundantna zmienna długości (wewnętrzna _length) i redundantne odniesienie do danych wejściowych ciąg (wewnętrzny _s). Innymi słowy, jest bezużyteczny.

Jeśli zastanawiasz się, jak Read„czyta”, wystarczy spojrzeć na kod , wystarczy wywołać String.CopyTociąg wejściowy. Reszta to po prostu księgowość, aby zachować wartości, których nie potrzebujemy.

Więc usuń już czytnik ciągów i zadzwoń do CopyTosiebie; jest prostszy, jaśniejszy i bardziej wydajny.

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

Czy naprawdę potrzebujesz jindeksu, który zwiększa się w krokach po dwa równolegle i? Oczywiście nie, wystarczy pomnożyć iprzez dwa (które kompilator powinien być w stanie zoptymalizować do dodatku).

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

Jak teraz wygląda rozwiązanie? Dokładnie tak, jak było na początku, tylko zamiast String.Substringprzydzielić do przydzielenia ciągu i skopiowania do niego danych, używasz tablicy pośredniej, do której skopiujesz liczby szesnastkowe, a następnie przydzielisz ciąg i skopiujesz dane ponownie z tablicę i ciąg (po przekazaniu go w konstruktorze ciągu). Druga kopia może zostać zoptymalizowana, jeśli ciąg znajduje się już w puli wewnętrznej, ale String.Substringw takich przypadkach będzie można go również uniknąć.

W rzeczywistości, jeśli spojrzysz String.Substringponownie, zobaczysz, że wykorzystuje on pewną wewnętrzną wiedzę niskiego poziomu o tym, jak skonstruowane są łańcuchy, aby przydzielić ciąg szybciej niż można to normalnie zrobić, i wstawia ten sam kod używany CopyTobezpośrednio tam, aby uniknąć koszt połączenia.

String.Substring

• Najgorszy przypadek: jeden szybki przydział, jeden szybki egzemplarz.
• Najlepszy przypadek: bez przydziału, bez kopii.

Metoda ręczna

• Najgorszy przypadek: dwa normalne przydziały, jeden zwykły egzemplarz, jeden szybki egzemplarz.
• Najlepszy przypadek: jeden normalny przydział, jedna normalna kopia.

Wniosek? Jeśli chcesz skorzystaćConvert.ToByte(String, Int32) (ponieważ nie chcesz samodzielnie wdrożyć tej funkcji), nie ma sposobu na pokonanie String.Substring; wszystko, co robisz, to bieganie w kółko, ponowne wymyślanie koła (tylko z materiałami nieoptymalnymi).

Pamiętaj, że użycie Convert.ToBytei String.Substringjest doskonałym wyborem, jeśli nie potrzebujesz ekstremalnej wydajności. Pamiętaj: wybierz alternatywę tylko wtedy, gdy masz czas i zasoby, aby sprawdzić, jak działa ona poprawnie.

Gdyby tak było Convert.ToByte(char[], Int32), rzeczy byłyby oczywiście inne (byłoby możliwe zrobienie tego, co opisałem powyżej i całkowite uniknięcie String).

Podejrzewam, że ludzie, którzy zgłaszają lepszą wydajność poprzez „unikanie String.Substring”, również unikają Convert.ToByte(String, Int32), co naprawdę powinieneś zrobić, jeśli i tak potrzebujesz wydajności. Spójrz na niezliczone inne odpowiedzi, aby odkryć różne podejścia do tego celu.

Oświadczenie: Nie zdekompilowałem najnowszej wersji frameworka, aby sprawdzić, czy źródło referencyjne jest aktualne, zakładam, że tak jest.

Teraz wszystko brzmi dobrze i logicznie, miejmy nadzieję nawet oczywiste, jeśli udało ci się dotrzeć tak daleko. Ale czy to prawda?

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

Tak!

Podpory dla kuropatwy na ławce, łatwo jest zhakować. Zastosowano dane wejściowe: następujący skrót SHA-1 powtórzony 5000 razy, aby utworzyć łańcuch o długości 100 000 bajtów.

209113288F93A9AB8E474EA78D899AFDBB874355

Baw się dobrze! (Ale optymalizuj z umiarem).

Uzupełnienie odpowiedzi przez @CodesInChaos (metoda odwrócona)

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

Wyjaśnienie:

& 0x0f ma również obsługiwać małe litery

hi = hi + 10 + ((hi >> 31) & 7); jest taki sam jak:

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

Dla „0” .. „9” jest to to samo, hi = ch - 65 + 10 + 7;co jest hi = ch - 48(wynika to z 0xffffffff & 7).

W przypadku „A” .. „F” jest hi = ch - 65 + 10;(z powodu 0x00000000 & 7).

W przypadku „a” .. „f” mamy duże liczby, więc musimy odjąć 32 od wersji domyślnej, tworząc pewne bity 0za pomocą & 0x0f.

65 to kod 'A'

48 to kod '0'

7 to liczba liter między '9'iw 'A'tabeli ASCII ( ...456789:;<=>?@ABCD...).

Ten problem można również rozwiązać za pomocą tabeli przeglądowej. Wymagałoby to niewielkiej ilości pamięci statycznej zarówno dla kodera, jak i dekodera. Ta metoda będzie jednak szybka:

• Tabela enkoderów 512 bajtów lub 1024 bajtów (dwukrotność rozmiaru, jeśli potrzebne są zarówno duże, jak i małe litery)
• Tabela dekodera 256 bajtów lub 64 KiB (wyszukiwanie pojedynczych znaków lub wyszukiwanie podwójnych znaków)

Moje rozwiązanie używa 1024 bajtów na tablicę kodowania i 256 bajtów na dekodowanie.

Rozszyfrowanie

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

Kodowanie

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

Porównanie

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

* to rozwiązanie

Uwaga

Podczas dekodowania może wystąpić wyjątek IOException i IndexOutOfRangeException (jeśli znak ma zbyt wysoką wartość> 256). Należy wdrożyć metody de / kodowania strumieni lub tablic, to tylko dowód koncepcji.

To jest świetny post. Podoba mi się rozwiązanie Waleeda. Nie przeprowadziłem testu Patridge'a, ale wydaje się, że jest dość szybki. Potrzebowałem również procesu odwrotnego, przekształcając ciąg szesnastkowy w tablicę bajtów, więc napisałem go jako odwrócenie rozwiązania Waleeda. Nie jestem pewien, czy jest to szybsze niż oryginalne rozwiązanie Tomalaka. Ponownie nie przeprowadziłem również procesu odwrotnego poprzez test Patridge'a.

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

Po co to komplikować? Jest to proste w Visual Studio 2008:

DO#:

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

VB:

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

Nie stosuję tutaj wielu odpowiedzi, ale znalazłem dość optymalną (~ 4,5x lepszą niż zaakceptowana), prostą implementację parsera ciągu szesnastkowego. Po pierwsze, wynik moich testów (pierwsza partia to moja implementacja):

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

Linie base64 i „BitConverter'd” służą do testowania poprawności. Zauważ, że są równe.

Implementacja:

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

Próbowałem trochę rzeczy unsafei przesunąłem (wyraźnie redundantną) ifsekwencję znaków do skubania na inną metodę, ale była to najszybsza metoda.

(Przyznaję, że to odpowiada na połowę pytania. Czułem, że konwersja string-> bajt [] była niewystarczająco reprezentowana, podczas gdy kąt bajt [] -> wydaje się być dobrze uwzględniony. Zatem ta odpowiedź.)

Bezpieczne wersje:

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

Niebezpieczne wersje Dla tych, którzy wolą wydajność i nie boją się niepewności. O 35% szybszy ToHex i 10% szybszy FromHex.

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