Comment convertir un tableau d'octets en une chaîne hexadécimale et vice versa?

Comment pouvez-vous convertir un tableau d'octets en une chaîne hexadécimale et vice versa?

Soit:

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

ou:

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

Il y a encore plus de variantes de le faire, par exemple ici .

La conversion inverse se passerait comme ceci:

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

L'utilisation Substringest la meilleure option en combinaison avec Convert.ToByte. Voir cette réponse pour plus d'informations. Si vous avez besoin de meilleures performances, vous devez éviter Convert.ToByteavant de pouvoir abandonner SubString.

Analyse de performance

Remarque: nouveau leader au 20/08/2015.

J'ai exécuté chacune des différentes méthodes de conversion à travers des Stopwatchtests de performances bruts , une analyse avec une phrase aléatoire (n = 61, 1000 itérations) et une analyse avec un texte Project Gutenburg (n = 1238957, 150 itérations). Voici les résultats, du plus rapide au plus lent. Toutes les mesures sont en ticks ( 10 000 ticks = 1 ms ) et toutes les notes relatives sont comparées à l' StringBuilderimplémentation [la plus lente] . Pour le code utilisé, voir ci-dessous ou le référentiel du framework de test où je maintiens maintenant le code pour l'exécuter.

Avertissement

AVERTISSEMENT: ne vous fiez pas à ces statistiques pour quoi que ce soit de concret; ce sont simplement des échantillons de données. Si vous avez vraiment besoin de performances de premier ordre, veuillez tester ces méthodes dans un environnement représentatif de vos besoins de production avec des données représentatives de ce que vous utiliserez.

Résultats

• Recherche par octet unsafe(via CodesInChaos) (ajouté au test repo par airbreather )
  • Texte: 4727,85 (105,2X)
  • Phrase: 0,28 (99,7X)
• Recherche par octet (via CodesInChaos)
  • Texte: 10 853,96 (45,8 fois plus rapide)
  • Phrase: 0,65 (42,7 fois plus rapide)
• Manipulation d'octets 2 (via CodesInChaos)
  • Texte: 12967,69 (38,4 fois plus rapide)
  • Phrase: 0,73 (37,9 fois plus rapide)
• Manipulation d'octets (via Waleed Eissa)
  • Texte: 16 856,64 (29,5 fois plus rapide)
  • Phrase: 0,70 (39,5 fois plus rapide)
• Recherche / changement (via Nathan Moinvaziri)
  • Texte: 23201,23 (21,4 fois plus rapide)
  • Phrase: 1,24 (22,3 fois plus rapide)
• Recherche par grignotage (via Brian Lambert)
  • Texte: 23 879,41 (20,8 fois plus rapide)
  • Phrase: 1,15 (23,9 fois plus rapide)
• BitConverter (via Tomalak)
  • Texte: 113,269.34 (4.4X plus rapide)
  • Phrase: 9,98 (2,8 fois plus rapide)
• {SoapHexBinary}.ToString (via Mykroft)
  • Texte: 178 601,39 (2,8 fois plus rapide)
  • Phrase: 10,68 (2,6 fois plus rapide)
• {byte}.ToString("X2")(en utilisant foreach) (dérivé de la réponse de Will Dean)
  • Texte: 308 805,38 (2,4 fois plus rapide)
  • Phrase: 16,89 (2,4 fois plus rapide)
• {byte}.ToString("X2")(utilisation {IEnumerable}.Aggregate, nécessite System.Linq) (via Mark)
  • Texte: 352828,20 (2,1 fois plus rapide)
  • Phrase: 16,87 (2,4 fois plus rapide)
• Array.ConvertAll(en utilisant string.Join) (via Will Dean)
  • Texte: 675 451,57 (1,1 fois plus rapide)
  • Phrase: 17,95 (2,2 fois plus rapide)
• Array.ConvertAll(en utilisant string.Concat, nécessite .NET 4.0) (via Will Dean)
  • Texte: 752 078,70 (1,0 fois plus rapide)
  • Phrase: 18,28 (2,2 fois plus rapide)
• {StringBuilder}.AppendFormat(en utilisant foreach) (via Tomalak)
  • Texte: 672 115,77 (1,1 fois plus rapide)
  • Phrase: 36.82 (1.1X plus rapide)
• {StringBuilder}.AppendFormat(en utilisant {IEnumerable}.Aggregate, nécessite System.Linq) (dérivé de la réponse de Tomalak)
  • Texte: 718 380,63 (1,0 fois plus rapide)
  • Phrase: 39,71 (1,0 fois plus rapide)

Les tables de recherche ont pris le pas sur la manipulation des octets. Fondamentalement, il existe une certaine forme de précalcul du grignotage ou de l'octet donné en hexadécimal. Ensuite, lorsque vous extrayez les données, vous recherchez simplement la partie suivante pour voir quelle chaîne hexadécimale il s'agirait. Cette valeur est ensuite ajoutée à la sortie de chaîne résultante d'une certaine manière. Pendant longtemps, la manipulation d'octets, potentiellement plus difficile à lire par certains développeurs, a été l'approche la plus performante.

Votre meilleur pari sera toujours de trouver des données représentatives et de les essayer dans un environnement de production. Si vous avez des contraintes de mémoire différentes, vous pouvez préférer une méthode avec moins d'allocations à une qui serait plus rapide mais consommerait plus de mémoire.

Code de test

N'hésitez pas à jouer avec le code de test que j'ai utilisé. Une version est incluse ici, mais n'hésitez pas à cloner le dépôt et à ajouter vos propres méthodes. Veuillez soumettre une demande d'extraction si vous trouvez quelque chose d'intéressant ou souhaitez aider à améliorer le cadre de test qu'il utilise.

1. Ajoutez la nouvelle méthode statique ( Func<byte[], string>) à /Tests/ConvertByteArrayToHexString/Test.cs.
2. Ajoutez le nom de cette méthode à la TestCandidatesvaleur de retour dans cette même classe.
3. Assurez-vous que vous exécutez la version d'entrée souhaitée, phrase ou texte, en basculant les commentaires GenerateTestInputdans cette même classe.
4. Appuyez F5et attendez la sortie (un vidage HTML est également généré dans le dossier / 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();
}

Mise à jour (2010-01-13)

Ajout de la réponse de Waleed à l'analyse. Tres rapide.

Mise à jour (2011-10-05)

Ajout d'une string.Concat Array.ConvertAllvariante pour être complet (nécessite .NET 4.0). Au même niveau que la string.Joinversion.

Mise à jour (2012-02-05)

Le repo de test comprend plus de variantes telles que StringBuilder.Append(b.ToString("X2")). Aucun n'a bouleversé les résultats. foreachest plus rapide que {IEnumerable}.Aggregate, par exemple, mais BitConvertergagne toujours.

Mise à jour (2012-04-03)

Ajout de la SoapHexBinaryréponse de Mykroft à l'analyse, qui a pris la troisième place.

Mise à jour (2013-01-15)

Ajout de la réponse de manipulation d'octets de CodesInChaos, qui a pris la première place (par une grande marge sur de gros blocs de texte).

Mise à jour (2013-05-23)

Ajout de la réponse de recherche de Nathan Moinvaziri et de la variante du blog de Brian Lambert. Tous deux assez rapides, mais ne prenant pas les devants sur la machine de test que j'ai utilisée (AMD Phenom 9750).

Mise à jour (2014-07-31)

Ajout de la nouvelle réponse de recherche basée sur octets de @ CodesInChaos. Il semble avoir pris la tête des tests de phrases et des tests de texte intégral.

Mise à jour (2015-08-20)

Ajout des optimisations et de la unsafevariante de l' aérographe au dépôt de cette réponse . Si vous voulez jouer dans le jeu dangereux, vous pouvez obtenir d'énormes gains de performance par rapport à l'un des meilleurs gagnants précédents sur les chaînes courtes et les gros textes.

Il existe une classe appelée SoapHexBinary qui fait exactement ce que vous voulez.

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

Lors de l'écriture de code cryptographique, il est courant d'éviter les branches dépendantes des données et les recherches de table pour garantir que l'exécution ne dépend pas des données, car le timing dépendant des données peut conduire à des attaques par canal latéral.

C'est aussi assez rapide.

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}

Abandonnez tout espoir, vous qui entrez ici

Une explication du bricolage bizarre:

1. bytes[i] >> 4extrait le quartet haut d'un octet
   bytes[i] & 0xFextrait le quartet bas d'un octet
2. b - 10
   est < 0pour les valeurs b < 10, qui deviendra un chiffre décimal
   est >= 0pour les valeurs b > 10, qui deviendra une lettre de Aà F.
3. L'utilisation i >> 31sur un entier signé de 32 bits extrait le signe, grâce à l'extension de signe. Ce sera -1pour i < 0et 0pour i >= 0.
4. La combinaison de 2) et 3) montre que ce (b-10)>>31sera 0pour les lettres et -1pour les chiffres.
5. En examinant la casse des lettres, la dernière sommation devient 0et se bsitue dans la plage de 10 à 15. Nous voulons la mapper sur A(65) à F(70), ce qui implique d'ajouter 55 ( 'A'-10).
6. En examinant le cas des chiffres, nous voulons adapter le dernier sommet afin qu'il mappe bde la plage 0 à 9 à la plage 0(48) à 9(57). Cela signifie qu'il doit devenir -7 ( '0' - 55).
   Maintenant, nous pourrions simplement multiplier par 7. Mais puisque -1 est représenté par tous les bits étant 1, nous pouvons utiliser à la place & -7depuis (0 & -7) == 0et (-1 & -7) == -7.

Quelques considérations supplémentaires:

• Je n'ai pas utilisé de deuxième variable de boucle pour l'indexation c, car la mesure montre que son calcul iest moins cher.
• Utiliser exactement i < bytes.Lengthla limite supérieure de la boucle permet au JITter d'éliminer les vérifications de limites bytes[i], j'ai donc choisi cette variante.
• Faire bun int permet des conversions inutiles de et vers octet.

Si vous voulez plus de flexibilité que BitConverter, mais ne voulez pas ces boucles explicites de style maladroit des années 1990, alors vous pouvez faire:

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

Ou, si vous utilisez .NET 4.0:

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

(Ce dernier à partir d'un commentaire sur le message d'origine.)

Une autre approche basée sur une table de recherche. Celui-ci utilise une seule table de recherche pour chaque octet, au lieu d'une table de recherche par quartet.

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

J'ai aussi testé des variantes de ce en utilisant ushort, struct{char X1, X2},struct{byte X1, X2} dans la table de consultation.

Selon la cible de compilation (x86, X64), ceux-ci avaient à peu près les mêmes performances ou étaient légèrement plus lents que cette variante.

Et pour des performances encore plus élevées, son unsafefrère:

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

Ou si vous jugez acceptable d'écrire directement dans la chaîne:

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

Vous pouvez utiliser la méthode BitConverter.ToString:

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

Production:

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

Pour plus d'informations: Méthode BitConverter.ToString (octet [])

Je viens de rencontrer le même problème aujourd'hui, et je suis tombé sur ce code:

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

Source: Forum post byte [] Array to Hex String (voir l'article de PZahra). J'ai un peu modifié le code pour supprimer le préfixe 0x.

J'ai fait des tests de performances sur le code et c'était presque huit fois plus rapide que d'utiliser BitConverter.ToString () (le plus rapide selon le post de patridge).

Il s'agit d'une réponse à la révision 4 de la réponse très populaire de Tomalak (et des modifications ultérieures).

Je ferai valoir que cette modification est erronée et expliquerai pourquoi elle pourrait être annulée. En cours de route, vous pourriez apprendre une ou deux choses sur certains éléments internes et voir encore un autre exemple de ce qu'est vraiment l'optimisation prématurée et comment elle peut vous mordre.

tl; dr: utilisez simplement Convert.ToByteet String.Substringsi vous êtes pressé ("Code original" ci-dessous), c'est la meilleure combinaison si vous ne voulez pas réimplémenter Convert.ToByte. Utilisez quelque chose de plus avancé (voir les autres réponses) qui ne sert pas Convert.ToBytesi vous avez besoin de performances. Ne pas utiliser autre chose que , String.Substringen combinaison avec Convert.ToByte, à moins que quelqu'un a quelque chose d' intéressant à dire à ce sujet dans les commentaires de cette réponse.

avertissement: cette réponse peut devenir obsolète si une Convert.ToByte(char[], Int32)surcharge est implémentée dans le framework. Il est peu probable que cela se produise bientôt.

En règle générale, je n'aime pas beaucoup dire "ne pas optimiser prématurément", car personne ne sait quand "prématuré" est. La seule chose que vous devez considérer lorsque vous décidez d'optimiser ou non est: "Ai-je le temps et les ressources nécessaires pour étudier correctement les approches d'optimisation?". Si vous ne le faites pas, alors il est trop tôt, attendez que votre projet est plus mature ou jusqu'à ce que vous avez besoin de la performance (s'il y a un réel besoin, alors vous rendre le temps). En attendant, faites la chose la plus simple qui pourrait fonctionner à la place.

Code d'origine:

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

Révision 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;
    }

La révision évite String.Substringet utilise un à la StringReaderplace. La raison donnée est:

Edit: vous pouvez améliorer les performances des chaînes longues en utilisant un analyseur en un seul passage, comme ceci:

Eh bien, en regardant le code de référence pourString.Substring , il est déjà clairement "en un seul passage"; et pourquoi ne le serait-il pas? Il fonctionne au niveau de l'octet, pas sur des paires de substitution.

Cependant, il alloue une nouvelle chaîne, mais vous devez Convert.ToBytequand même en allouer une à laquelle passer . De plus, la solution fournie dans la révision alloue encore un autre objet à chaque itération (le tableau à deux caractères); vous pouvez mettre cette allocation en toute sécurité en dehors de la boucle et réutiliser le tableau pour éviter cela.

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

Chaque hexadécimal numeralreprésente un seul octet utilisant deux chiffres (symboles).

Mais alors, pourquoi appeler StringReader.Readdeux fois? Appelez simplement sa deuxième surcharge et demandez-lui de lire deux caractères à la fois dans le tableau à deux caractères; et réduisez de deux le nombre d'appels.

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

Il vous reste un lecteur de chaîne dont la seule "valeur" ajoutée est un index parallèle (interne _pos) que vous auriez pu déclarer vous-même (comme jpar exemple), une variable de longueur redondante (interne _length) et une référence redondante à l'entrée chaîne (interne _s). En d'autres termes, c'est inutile.

Si vous vous demandez comment Read"lit", regardez simplement le code , il ne fait qu'appeler String.CopyTosur la chaîne d'entrée. Le reste est juste des frais généraux de tenue de livres pour maintenir des valeurs dont nous n'avons pas besoin.

Donc, retirez déjà le lecteur de chaîne et appelez- CopyTovous; c'est plus simple, plus clair et plus efficace.

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

Avez-vous vraiment besoin d'un jindex qui s'incrémente par incréments de deux parallèlement à i? Bien sûr que non, il suffit de multiplier ipar deux (que le compilateur devrait être en mesure d'optimiser pour un ajout).

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

À quoi ressemble la solution maintenant? Exactement comme au début, mais au lieu d'utiliser String.Substringpour allouer la chaîne et y copier les données, vous utilisez un tableau intermédiaire dans lequel vous copiez les chiffres hexadécimaux, puis allouez la chaîne vous-même et recopiez les données à partir de le tableau et dans la chaîne (lorsque vous le passez dans le constructeur de chaîne). La deuxième copie peut être optimisée si la chaîne est déjà dans le pool interne, mais String.Substringpourra également l'éviter dans ces cas.

En fait, si vous regardez à String.Substringnouveau, vous voyez qu'il utilise des connaissances internes de bas niveau sur la façon dont les chaînes sont construites pour allouer la chaîne plus rapidement que vous ne le feriez normalement, et il insère le même code utilisé CopyTodirectement par là pour éviter les frais généraux d'appel.

String.Substring

• Pire: une allocation rapide, une copie rapide.
• Meilleur cas: pas d'allocation, pas de copie.

Méthode manuelle

• Pire: deux allocations normales, une copie normale, une copie rapide.
• Meilleur cas: une allocation normale, une copie normale.

Conclusion? Si vous voulez utiliserConvert.ToByte(String, Int32) (parce que vous ne voulez pas réimplémenter cette fonctionnalité vous-même), il ne semble pas y avoir de moyen de battre String.Substring; tout ce que vous faites, c'est tourner en rond, réinventer la roue (uniquement avec des matériaux sous-optimaux).

Notez que l'utilisation de Convert.ToByteet String.Substringest un choix parfaitement valide si vous n'avez pas besoin de performances extrêmes. N'oubliez pas: n'optez pour une alternative que si vous avez le temps et les ressources pour enquêter sur son bon fonctionnement.

S'il y en avait un Convert.ToByte(char[], Int32), les choses seraient bien sûr différentes (il serait possible de faire ce que je viens de décrire et d'éviter complètement String).

Je soupçonne que les personnes qui signalent de meilleures performances en «évitant String.Substring» évitent également Convert.ToByte(String, Int32), ce que vous devriez vraiment faire si vous avez besoin de la performance de toute façon. Regardez les innombrables autres réponses pour découvrir toutes les différentes approches pour le faire.

Avertissement: je n'ai pas décompilé la dernière version du framework pour vérifier que la source de référence est à jour, je suppose que oui.

Maintenant, tout cela semble bien et logique, j'espère même évident si vous avez réussi à aller aussi loin. Mais est-ce vrai?

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

Oui!

Props à Partridge pour le cadre de banc, il est facile de pirater. L'entrée utilisée est le hachage SHA-1 suivant répété 5000 fois pour créer une chaîne longue de 100 000 octets.

209113288F93A9AB8E474EA78D899AFDBB874355

S'amuser! (Mais optimisez avec modération.)

Complément pour répondre par @CodesInChaos (méthode inversée)

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

Explication:

& 0x0f est de prendre en charge également les lettres minuscules

hi = hi + 10 + ((hi >> 31) & 7); est le même que:

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

Pour '0' .. '9' c'est la même chose que hi = ch - 65 + 10 + 7; c'est hi = ch - 48(c'est à cause de 0xffffffff & 7).

Pour 'A' .. 'F' c'est hi = ch - 65 + 10;(c'est à cause de 0x00000000 & 7).

Pour 'a' .. 'f' nous devons faire de grands nombres, nous devons donc soustraire 32 de la version par défaut en faisant quelques bits 0 en utilisant & 0x0f.

65 est le code pour 'A'

48 est le code pour '0'

7 est le nombre de lettres entre '9'et 'A'dans la table ASCII ( ...456789:;<=>?@ABCD...).

Ce problème peut également être résolu à l'aide d'une table de correspondance. Cela nécessiterait une petite quantité de mémoire statique pour l'encodeur et le décodeur. Cette méthode sera cependant rapide:

• Table du codeur 512 octets ou 1024 octets (deux fois la taille si les majuscules et les minuscules sont nécessaires)
• Table du décodeur 256 octets ou 64 Ko (soit une recherche à un seul caractère soit une recherche à deux caractères)

Ma solution utilise 1024 octets pour la table de codage et 256 octets pour le décodage.

Décodage

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

Codage

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

Comparaison

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

* cette solution

Remarque

Pendant le décodage, IOException et IndexOutOfRangeException peuvent se produire (si un caractère a une valeur trop élevée> 256). Des méthodes de dé / codage des flux ou des tableaux doivent être implémentées, ce n'est qu'une preuve de concept.

Ceci est un excellent article. J'aime la solution de Waleed. Je ne l'ai pas passé à travers le test de patridge, mais il semble être assez rapide. J'avais également besoin du processus inverse, convertissant une chaîne hexadécimale en un tableau d'octets, donc je l'ai écrit comme une inversion de la solution de Waleed. Je ne sais pas si c'est plus rapide que la solution originale de Tomalak. Encore une fois, je n'ai pas non plus exécuté le processus inverse via le test de 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;
}

Pourquoi le rendre complexe? C'est simple dans Visual Studio 2008:

C #:

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

VB:

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

Ne pas empiler les nombreuses réponses ici, mais j'ai trouvé une implémentation assez optimale (~ 4,5x meilleure qu'acceptée), simple de l'analyseur de chaîne hexadécimal. Tout d'abord, sortie de mes tests (le premier lot est mon implémentation):

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

Les lignes base64 et «BitConverter'd» sont là pour tester l'exactitude. Notez qu'ils sont égaux.

La mise en oeuvre:

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

J'ai essayé quelques trucs avec unsafeet déplacé la ifséquence caractère à grignoter (clairement redondante) vers une autre méthode, mais c'était la plus rapide.

(Je concède que cela répond à la moitié de la question. J'ai senti que la conversion chaîne -> octet [] était sous-représentée, tandis que l'angle octet [] -> chaîne semble être bien couvert. Ainsi, cette réponse.)

Versions sûres:

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

Versions dangereuses Pour ceux qui préfèrent les performances et n'ont pas peur de l'insécurité. ToHex environ 35% plus rapide et FromHex 10% plus rapide.

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