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

Diese Version von ByteArrayToHexViaByteManipulation könnte schneller sein.

Aus meinen Berichten:

• ByteArrayToHexViaByteManipulation3: 1,68 durchschnittliche Ticks (über 1000 Durchläufe), 17,5X
• ByteArrayToHexViaByteManipulation2: 1,73 durchschnittliche Ticks (über 1000 Durchläufe), 16,9X
• ByteArrayToHexViaByteManipulation: 2,90 durchschnittliche Ticks (über 1000 Durchläufe), 10,1X
• ByteArrayToHexViaLookupAndShift: 3,22 durchschnittliche Ticks (über 1000 Durchläufe), 9,1X

• ...

  static private readonly char[] hexAlphabet = new char[]
      {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
  static string ByteArrayToHexViaByteManipulation3(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] = hexAlphabet[b];
          b = ((byte)(bytes[i] & 0xF));
          c[i * 2 + 1] = hexAlphabet[b];
      }
      return new string(c);
  }

Und ich denke, das ist eine Optimierung:

    static private readonly char[] hexAlphabet = new char[]
        {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
    static string ByteArrayToHexViaByteManipulation4(byte[] bytes)
    {
        char[] c = new char[bytes.Length * 2];
        for (int i = 0, ptr = 0; i < bytes.Length; i++, ptr += 2)
        {
            byte b = bytes[i];
            c[ptr] = hexAlphabet[b >> 4];
            c[ptr + 1] = hexAlphabet[b & 0xF];
        }
        return new string(c);
    }

Answer 2

Ich habe den von Ihnen vorgeschlagenen Code nicht zum Laufen gebracht, Olipro. hex[i] + hex[i+1] offenbar eine int .

Ich hatte jedoch einigen Erfolg, indem ich einige Hinweise von Waleeds Code nahm und diesen zusammenhämmerte. Es ist hässlich wie die Hölle, aber es scheint zu funktionieren und führt bei 1/3 der Zeit im Vergleich zu den anderen nach meinen Tests (mit Patridges Testmechanismus). Abhängig von der Eingabegröße. Wenn man die ?:s umdreht, um 0-9 zuerst zu trennen, würde man wahrscheinlich ein etwas schnelleres Ergebnis erzielen, da es mehr Zahlen als Buchstaben gibt.

public static byte[] StringToByteArray2(string hex)
{
    byte[] bytes = new byte[hex.Length/2];
    int bl = bytes.Length;
    for (int i = 0; i < bl; ++i)
    {
        bytes[i] = (byte)((hex[2 * i] > 'F' ? hex[2 * i] - 0x57 : hex[2 * i] > '9' ? hex[2 * i] - 0x37 : hex[2 * i] - 0x30) << 4);
        bytes[i] |= (byte)(hex[2 * i + 1] > 'F' ? hex[2 * i + 1] - 0x57 : hex[2 * i + 1] > '9' ? hex[2 * i + 1] - 0x37 : hex[2 * i + 1] - 0x30);
    }
    return bytes;
}

Answer 3

Kürzester Weg und .net core unterstützt:

    public static string BytesToString(byte[] ba) =>
        ba.Aggregate(new StringBuilder(32), (sb, b) => sb.Append(b.ToString("X2"))).ToString();

Answer 4

Es gibt eine einfache Ein-Zeilen-Lösung, die noch nicht erwähnt wurde, die hexadezimale Zeichenketten in Byte-Arrays konvertiert (wir kümmern uns hier nicht um die negative Interpretation, da sie keine Rolle spielt):

BigInteger.Parse(str, System.Globalization.NumberStyles.HexNumber).ToByteArray().Reverse().ToArray();

Answer 5

Eine weitere schnelle Funktion...

private static readonly byte[] HexNibble = new byte[] {
    0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,
    0x8, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
    0x0, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF, 0x0,
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
    0x0, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF
};

public static byte[] HexStringToByteArray( string str )
{
    int byteCount = str.Length >> 1;
    byte[] result = new byte[byteCount + (str.Length & 1)];
    for( int i = 0; i < byteCount; i++ )
        result[i] = (byte) (HexNibble[str[i << 1] - 48] << 4 | HexNibble[str[(i << 1) + 1] - 48]);
    if( (str.Length & 1) != 0 )
        result[byteCount] = (byte) HexNibble[str[str.Length - 1] - 48];
    return result;
}