Wie konvertiert man ein Byte-Array in eine hexadezimale Zeichenfolge und umgekehrt?

Question

Wie kann man ein Byte-Array in eine hexadezimale Zeichenkette umwandeln und umgekehrt?

Answer 1

Tests: Hex-String in Byte-Array

Mir ist aufgefallen, dass die meisten Tests mit Funktionen durchgeführt wurden, die Bytes-Array in Hex-String konvertieren. Daher werde ich mich in diesem Beitrag auf die andere Seite konzentrieren: Funktionen, die Hex-String in Byte-Array konvertieren. Wenn Sie nur an den Ergebnissen interessiert sind, können Sie nach unten springen zu Zusammenfassung Abschnitt. Die Testcode-Datei befindet sich am Ende des Beitrags.

Etiketten

Ich möchte die Funktion aus der akzeptierten Antwort (von Tomalak) StringToByteArrayV1 nennen, oder sie mit V1 abkürzen. Der Rest der Funktionen wird auf die gleiche Weise benannt werden: V2, V3, V4, ..., usw.

Index der teilnehmenden Funktionen

• StringToByteArrayV1 von Tomalak (die akzeptierte Antwort)
• StringToByteArrayV2 von Mykroft (unter Verwendung von SoapHexBinary)
• StringToByteArrayV3 von drphrozen (Nachschlagetabelle)
• StringToByteArrayV4 von CoperNick (Byte-Manipulation)
• StringToByteArrayV5_1 von Chris F (Byte-Manipulation)
• StringToByteArrayV5_2 von Chris F ( V5_1 + auf der Grundlage des Kommentars von Amir Rezaei verbessert)
• StringToByteArrayV5_3 von Chris F ( V5_2 + ehanced it based on Ben Voigt's comment) (Sie konnten die endgültige Form des Codes in diesem Post veröffentlichten Testcode sehen)
• StringToByteArrayV6 von Ben Mosher (Byte-Manipulation)
• StringToByteArrayV7 von Maratius (Byte-Manipulation - die sichere Version)
• StringToByteArrayV8 von Maratius (Byte-Manipulation - die unsichere Version)
• StringToByteArrayV9 von Geograph
• StringToByteArrayV10 von AlejandroAlis
• StringToByteArrayV11 von Fredrik Hu
• StringToByteArrayV12 von Maarten Bodewes
• StringToByteArrayV13 von ClausAndersen
• StringToByteArrayV14 von Stas Makutin
• StringToByteArrayV15 von JJJ
• StringToByteArrayV16 von JamieSee
• StringToByteArrayV17 von spacepille
• StringToByteArrayV18 von Gregory Morse
• StringToByteArrayV19 von Rick
• StringToByteArrayV20 von SandRock
• StringToByteArrayV21 von Paul

Korrektheitstest

Ich habe die Korrektheit getestet, indem ich alle 256 möglichen Werte von 1 Byte übergeben und dann die Ausgabe überprüft habe, um zu sehen, ob sie korrekt ist. Ergebnis:

• V18 hat ein Problem mit Strings, die mit "00" beginnen (siehe Roger Stewarts Kommentar dazu). Ansonsten besteht es alle Tests.
• wenn die Buchstaben des hexadezimalen Alphabets in Großbuchstaben geschrieben sind: alle Funktionen wurden erfolgreich ausgeführt
• Wenn die Buchstaben des hexadezimalen Alphabets Kleinbuchstaben sind, schlagen die folgenden Funktionen fehl: V5_1, V5_2, v7, V8, V15, V19

Hinweis: V5_3 behebt dieses Problem (von V5_1 und V5_2)

Leistungstest

Ich habe Leistungstests mit der Klasse Stopwatch durchgeführt.

• Leistung für lange Saiten

  input length: 10,000,000 bytes runs: 100 average elapsed time per run: V1 = 136.4ms V2 = 104.5ms V3 = 22.0ms V4 = 9.9ms V5_1 = 10.2ms V5_2 = 9.0ms V5_3 = 9.3ms V6 = 18.3ms V7 = 9.8ms V8 = 8.8ms V9 = 10.2ms V10 = 19.0ms V11 = 12.2ms V12 = 27.4ms V13 = 21.8ms V14 = 12.0ms V15 = 14.9ms V16 = 15.3ms V17 = 9.5ms V18 got excluded from this test, because it was very slow when using very long string V19 = 222.8ms V20 = 66.0ms V21 = 15.4ms

  V1 average ticks per run: 1363529.4 V2 is more fast than V1 by: 1.3 times (ticks ratio) V3 is more fast than V1 by: 6.2 times (ticks ratio) V4 is more fast than V1 by: 13.8 times (ticks ratio) V5_1 is more fast than V1 by: 13.3 times (ticks ratio) V5_2 is more fast than V1 by: 15.2 times (ticks ratio) V5_3 is more fast than V1 by: 14.8 times (ticks ratio) V6 is more fast than V1 by: 7.4 times (ticks ratio) V7 is more fast than V1 by: 13.9 times (ticks ratio) V8 is more fast than V1 by: 15.4 times (ticks ratio) V9 is more fast than V1 by: 13.4 times (ticks ratio) V10 is more fast than V1 by: 7.2 times (ticks ratio) V11 is more fast than V1 by: 11.1 times (ticks ratio) V12 is more fast than V1 by: 5.0 times (ticks ratio) V13 is more fast than V1 by: 6.3 times (ticks ratio) V14 is more fast than V1 by: 11.4 times (ticks ratio) V15 is more fast than V1 by: 9.2 times (ticks ratio) V16 is more fast than V1 by: 8.9 times (ticks ratio) V17 is more fast than V1 by: 14.4 times (ticks ratio) V19 is more SLOW than V1 by: 1.6 times (ticks ratio) V20 is more fast than V1 by: 2.1 times (ticks ratio) V21 is more fast than V1 by: 8.9 times (ticks ratio)

• Leistung der V18 bei langen Saiten

  V18 took long time at the previous test, so let's decrease length for it:
  input length: 1,000,000 bytes runs: 100 average elapsed time per run: V1 = 14.1ms , V18 = 146.7ms V1 average ticks per run: 140630.3 V18 is more SLOW than V1 by: 10.4 times (ticks ratio)

• Leistung für kurze Saiten

  input length: 100 byte runs: 1,000,000 V1 average ticks per run: 14.6 V2 is more fast than V1 by: 1.4 times (ticks ratio) V3 is more fast than V1 by: 5.9 times (ticks ratio) V4 is more fast than V1 by: 15.7 times (ticks ratio) V5_1 is more fast than V1 by: 15.1 times (ticks ratio) V5_2 is more fast than V1 by: 18.4 times (ticks ratio) V5_3 is more fast than V1 by: 16.3 times (ticks ratio) V6 is more fast than V1 by: 5.3 times (ticks ratio) V7 is more fast than V1 by: 15.7 times (ticks ratio) V8 is more fast than V1 by: 18.0 times (ticks ratio) V9 is more fast than V1 by: 15.5 times (ticks ratio) V10 is more fast than V1 by: 7.8 times (ticks ratio) V11 is more fast than V1 by: 12.4 times (ticks ratio) V12 is more fast than V1 by: 5.3 times (ticks ratio) V13 is more fast than V1 by: 5.2 times (ticks ratio) V14 is more fast than V1 by: 13.4 times (ticks ratio) V15 is more fast than V1 by: 9.9 times (ticks ratio) V16 is more fast than V1 by: 9.2 times (ticks ratio) V17 is more fast than V1 by: 16.2 times (ticks ratio) V18 is more fast than V1 by: 1.1 times (ticks ratio) V19 is more SLOW than V1 by: 1.6 times (ticks ratio) V20 is more fast than V1 by: 1.9 times (ticks ratio) V21 is more fast than V1 by: 11.4 times (ticks ratio)

Prüfung Code

Es ist eine gute Idee, den Abschnitt Disclaimer hier unten in diesem Beitrag zu lesen, bevor Sie den folgenden Code verwenden https://github.com/Ghosticollis/performance-tests/blob/main/MTestPerformance.cs

Zusammenfassung

Ich empfehle, eine der folgenden Funktionen zu verwenden, da sie eine gute Leistung bieten und sowohl Groß- als auch Kleinschreibung unterstützen:

• StringToByteArrayV4 von CoperNick
• StringToByteArrayV9 von Geograph
• StringToByteArrayV17 von spacepille
• StringToByteArrayV5_3 grundsätzlich von Chris F (es basiert auf V5_1, aber ich habe es auf der Grundlage von Amir Rezaeis und Ben Voigts Kommentaren verbessert).

Hier ist die endgültige Form von V5_3:

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

Haftungsausschluss

WARNUNG: Ich habe keine richtigen Kenntnisse im Testen. Der Hauptzweck dieser primitiven Tests ist es, einen schnellen Überblick darüber zu geben, was von allen veröffentlichten Funktionen gut sein könnte. Wenn Sie genaue Ergebnisse benötigen, verwenden Sie bitte geeignete Testwerkzeuge.

Abschließend möchte ich sagen, dass ich neu auf Stackoverflow bin und es mir leid tut, wenn mein Beitrag mangelhaft ist. Kommentare, um diesen Beitrag zu verbessern, wären sehr willkommen.

Answer 2

Und zum Einfügen in einen SQL-String (wenn Sie keine Befehlsparameter verwenden):

public static String ByteArrayToSQLHexString(byte[] Source)
{
    return = "0x" + BitConverter.ToString(Source).Replace("-", "");
}

Answer 3

In Bezug auf die Geschwindigkeit scheint dies besser zu sein als alles andere hier:

  public static string ToHexString(byte[] data) {
    byte b;
    int i, j, k;
    int l = data.Length;
    char[] r = new char[l * 2];
    for (i = 0, j = 0; i < l; ++i) {
      b = data[i];
      k = b >> 4;
      r[j++] = (char)(k > 9 ? k + 0x37 : k + 0x30);
      k = b & 15;
      r[j++] = (char)(k > 9 ? k + 0x37 : k + 0x30);
    }
    return new string(r);
  }

Answer 4

Ich nehme an diesem Wettbewerb teil, da ich eine Antwort habe, die ebenfalls Bit-Fiddling verwendet, um dekodieren Hexadezimale. Beachten Sie, dass die Verwendung von Zeichenarrays sogar schneller sein kann als der Aufruf von StringBuilder Methoden werden ebenfalls Zeit brauchen.

public static String ToHex (byte[] data)
{
    int dataLength = data.Length;
    // pre-create the stringbuilder using the length of the data * 2, precisely enough
    StringBuilder sb = new StringBuilder (dataLength * 2);
    for (int i = 0; i < dataLength; i++) {
        int b = data [i];

        // check using calculation over bits to see if first tuple is a letter
        // isLetter is zero if it is a digit, 1 if it is a letter
        int isLetter = (b >> 7) & ((b >> 6) | (b >> 5)) & 1;

        // calculate the code using a multiplication to make up the difference between
        // a digit character and an alphanumerical character
        int code = '0' + ((b >> 4) & 0xF) + isLetter * ('A' - '9' - 1);
        // now append the result, after casting the code point to a character
        sb.Append ((Char)code);

        // do the same with the lower (less significant) tuple
        isLetter = (b >> 3) & ((b >> 2) | (b >> 1)) & 1;
        code = '0' + (b & 0xF) + isLetter * ('A' - '9' - 1);
        sb.Append ((Char)code);
    }
    return sb.ToString ();
}

public static byte[] FromHex (String hex)
{

    // pre-create the array
    int resultLength = hex.Length / 2;
    byte[] result = new byte[resultLength];
    // set validity = 0 (0 = valid, anything else is not valid)
    int validity = 0;
    int c, isLetter, value, validDigitStruct, validDigit, validLetterStruct, validLetter;
    for (int i = 0, hexOffset = 0; i < resultLength; i++, hexOffset += 2) {
        c = hex [hexOffset];

        // check using calculation over bits to see if first char is a letter
        // isLetter is zero if it is a digit, 1 if it is a letter (upper & lowercase)
        isLetter = (c >> 6) & 1;

        // calculate the tuple value using a multiplication to make up the difference between
        // a digit character and an alphanumerical character
        // minus 1 for the fact that the letters are not zero based
        value = ((c & 0xF) + isLetter * (-1 + 10)) << 4;

        // check validity of all the other bits
        validity |= c >> 7; // changed to >>, maybe not OK, use UInt?

        validDigitStruct = (c & 0x30) ^ 0x30;
        validDigit = ((c & 0x8) >> 3) * (c & 0x6);
        validity |= (isLetter ^ 1) * (validDigitStruct | validDigit);

        validLetterStruct = c & 0x18;
        validLetter = (((c - 1) & 0x4) >> 2) * ((c - 1) & 0x2);
        validity |= isLetter * (validLetterStruct | validLetter);

        // do the same with the lower (less significant) tuple
        c = hex [hexOffset + 1];
        isLetter = (c >> 6) & 1;
        value ^= (c & 0xF) + isLetter * (-1 + 10);
        result [i] = (byte)value;

        // check validity of all the other bits
        validity |= c >> 7; // changed to >>, maybe not OK, use UInt?

        validDigitStruct = (c & 0x30) ^ 0x30;
        validDigit = ((c & 0x8) >> 3) * (c & 0x6);
        validity |= (isLetter ^ 1) * (validDigitStruct | validDigit);

        validLetterStruct = c & 0x18;
        validLetter = (((c - 1) & 0x4) >> 2) * ((c - 1) & 0x2);
        validity |= isLetter * (validLetterStruct | validLetter);
    }

    if (validity != 0) {
        throw new ArgumentException ("Hexadecimal encoding incorrect for input " + hex);
    }

    return result;
}

Konvertiert aus Java-Code.

Answer 5

Was die Leistung angeht, würde ich mich an drphrozens Lösung halten. Eine kleine Optimierung für den Decoder könnte darin bestehen, eine Tabelle für jedes Zeichen zu verwenden, um das "<< 4" loszuwerden.

Es ist klar, dass die beiden Methodenaufrufe kostspielig sind. Wenn eine Art von Prüfung entweder der Eingabe- oder der Ausgabedaten vorgenommen wird (z.B. CRC, Prüfsumme oder was auch immer), muss die if (b == 255)... und damit auch die Methodenaufrufe insgesamt übersprungen werden können.

Verwendung von offset++ y offset anstelle von offset y offset + 1 könnte einen theoretischen Vorteil bringen, aber ich vermute, dass der Compiler dies besser handhabt als ich.

private static readonly byte[] LookupTableLow = 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
};

private static readonly byte[] LookupTableHigh = 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, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0, 0xFF, 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 LookupLow(char c)
{
  var b = LookupTableLow[c];
  if (b == 255)
    throw new IOException("Expected a hex character, got " + c);
  return b;
}

private static byte LookupHigh(char c)
{
  var b = LookupTableHigh[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)(LookupHigh(chars[offset++]) | LookupLow(chars[offset]));
}

Dies ist nur eine spontane Idee und wurde nicht getestet oder verglichen.