Wie konvertieren von hex ein byte-array?

Etwas wie dieses:

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: Jetzt etwas mehr effiziente - keine Teilstrings benötigt...)

Ist es möglich, dass ParseNybble könnte effizienter sein. Zum Beispiel, ein switch/case kann werden effizienter:

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

oder möglicherweise ein lookup-array:

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

Habe ich noch nicht getestet dieser, und ich habe keine Ahnung, das wäre das Schnellste. Die aktuelle Lösung ist wohl die einfachste wenn.

Einfach:

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

Alles, was Sie haben, zu erinnern, zu tun, ist für einen int teilen die hex-Zahl in Gruppen von 8 hex-Ziffern (hex sind 4 bits jedes, und CLR-Typ int ist 32 bit, also 8 Ziffern pro int). Es gibt auch ein byte.Parse (), die gleich funktioniert, sondern übergeben Sie in zwei hex-Ziffern in einer Zeit.

Müssen Sie ein wenig mehr (zum Beispiel, überspringen Sie die ersten zwei Zeichen), aber es nicht umgehen Leerzeichen in der Zeichenfolge:

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

Tatsächlich, es ist ein einfacher Weg, um zu konvertieren zwei Zeichen in einer Zeit, um ein byte:

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