Comment convertir un hex à un tableau d'octets?

Quelque chose comme ceci:

using System;
public static class Parser
{    
static void Main()
{
string hex = "0xBAC893CAB8B7FE03C927417A2A3F6A6"
+ "0BD30FF35E250011CB25507EBFCD5223B";
byte[] parsed = ParseHex(hex);
//Just for confirmation...
Console.WriteLine(BitConverter.ToString(parsed));
}
public static byte[] ParseHex(string hex)
{
int offset = hex.StartsWith("0x") ? 2 : 0;
if ((hex.Length % 2) != 0)
{
throw new ArgumentException("Invalid length: " + hex.Length);
}
byte[] ret = new byte[(hex.Length-offset)/2];
for (int i=0; i < ret.Length; i++)
{
ret[i] = (byte) ((ParseNybble(hex[offset]) << 4) 
| ParseNybble(hex[offset+1]));
offset += 2;
}
return ret;
}        
static int ParseNybble(char c)
{
if (c >= '0' && c <= '9')
{
return c-'0';
}
if (c >= 'A' && c <= 'F')
{
return c-'A'+10;
}
if (c >= 'a' && c <= 'f')
{
return c-'a'+10;
}
throw new ArgumentException("Invalid hex digit: " + c);
}
}

(EDIT: Maintenant légèrement plus efficace - pas de sous-chaînes...)

Il est possible que ParseNybble pourrait être plus efficace. Par exemple, un switch/case peut être plus efficace:

    static int ParseNybble(char c)
{
switch (c)
{
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
return c-'0';
case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
return c-'A'+10;
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
return c-'a'+10;
}
throw new ArgumentException("Invalid hex digit: " + c);
}

ou peut-être une recherche de tableau:

    //Omitted for brevity... I'm sure you get the gist
private static readonly int[] NybbleLookup = BuildLookup();
private int ParseNybble(char c)
{
if (c > 'f')
{
throw new ArgumentException("Invalid hex digit: " + c);
}
int ret = NybbleLookup[c];
if (ret == -1)
{
throw new ArgumentException("Invalid hex digit: " + c);
}
return ret;
}

Je n'ai pas comparé l'un de ces, et j'ai aucune idée de ce qui serait le plus rapide. La solution actuelle est probablement le plus simple.

OriginalL'auteur Jon Skeet

Simple:

string hexnum = "0000000F"; //Represents 15
int value = int.Parse(hexnum, System.Globalization.NumberStyles.HexNumber);

Tout ce que vous avez à vous rappeler de le faire est pour un int à diviser le nombre hexadécimal en groupes de 8 chiffres hex (hexadécimal de 4 bits chacun, et CLR type int est 32 bits, d'où 8 chiffres par int). Il y a aussi un octet.Parse() qui fonctionne de la même, mais passe à deux chiffres hexadécimaux à la fois.

OriginalL'auteur Kevin Anderson

Vous aurez besoin de modifier un peu (par exemple, sauter par-dessus les deux premiers caractères), mais il n'gérer les espaces dans la chaîne:

    ///<summary>
///Decodes a hex string, ignoring all non-hex characters, and stores
///the decodes series of bytes into the shared buffer. This returns
///the number of bytes that were decoded.
///<para>Hex characters are [0-9, a-f, A-F].</para>
///</summary>
///<param name="hexString">String to parse into bytes.</param>
///<param name="buffer">Buffer into which to store the decoded binary data.</param>
///<returns>The number of bytes decoded.</returns>
private static int DecodeHexIntoBuffer(string hexString, byte[] buffer)
{
int count = 0;
bool haveFirst = false;
bool haveSecond = false;
char first = '0';
char second = '0';
for (int i = 0; i < hexString.Length; i++)
{
if (!haveFirst)
{
first = hexString[i];
haveFirst = char.IsLetterOrDigit(first);
//we have to continue to the next iteration
//or we will miss characters
continue;
}
if (!haveSecond)
{
second = hexString[i];
haveSecond = char.IsLetterOrDigit(second);
}
if (haveFirst && haveSecond)
{
string hex = "" + first + second;
byte nextByte;
if (byte.TryParse(hex, NumberStyles.HexNumber, null, out nextByte))
{
//store the decoded byte into the next slot of the buffer
buffer[count++] = nextByte;
}
//reset the flags
haveFirst = haveSecond = false;
}
}
return count;
}

OriginalL'auteur Erich Mirabal

En fait, il y a un moyen plus facile de convertir deux caractères à un octet:

    ///<summary>
///This will convert a hex-encoded string to byte data
///</summary>
///<param name="hexData">The hex-encoded string to convert</param>
///<returns>The bytes that make up the hex string</returns>
public static byte[] FromHex(string hexData)
{
List<byte> data = new List<byte>();
string byteSet = string.Empty;
int stringLen = hexData.Length;
int length = 0;
for (int i = 0; i < stringLen; i = i + 2)
{
length = (stringLen - i) > 1 ? 2 : 1;
byteSet = hexData.Substring(i, length);
//try and parse the data
data.Add(Convert.ToByte(byteSet, 16 /*base*/));
} //next set
return data.ToArray();
}

OriginalL'auteur user991629