如何将字节数组转换为十六进制字符串，反之亦然？

---

#1楼

在此不谈很多答案，但我发现十六进制字符串解析器的实现相当理想（比公认的要好约4.5倍），直接实现。 首先，我的测试输出（第一批是我的实现）：

Give me that string:
04c63f7842740c77e545bb0b2ade90b384f119f6ab57b680b7aa575a2f40939fTime 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-9FAccepted 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-9FWith 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-9FWith 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

base64和'BitConverter'd'行在那里测试正确性。 请注意，它们是相等的。

实现：

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

我尝试了一些东西与unsafe和移动（显然是多余）字符到四位if序列的另一种方法，但这是它得到了最快的。

（我承认这回答了一半的问题。我认为string-> byte []转换的代表性不足，而byte []-> string的角度似乎已被很好地涵盖了。因此，此答案。）

---

#2楼

并用于插入SQL字符串（如果您不使用命令参数）：

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

---

#3楼

编写加密代码时，通常要避免依赖数据的分支和表查找，以确保运行时不依赖数据，因为依赖数据的时序会导致边信道攻击。

它也非常快。

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}

---

放弃所有希望，进入这里的你们

奇怪的摆弄的解释：

1. bytes[i] >> 4提取一个字节的高半字节
   bytes[i] & 0xF提取字节的低半字节
2. b - 10
   对于b < 10 ， < 0 ，它将成为一个十进制数字
   对于值b > 10等于>= 0 ，这将成为从A到F的字母。
3. 由于符号扩展，对有符号的32位整数使用i >> 31提取符号。 这将是-1为i < 0和0为i >= 0 。
4. 组合2）和3），表明(b-10)>>31对于字母将为0 ，对于数字为-1 。
5. 查看字母的大小写，最后一个被加数变为0 ，并且b在10到15的范围内。我们想将其映射到A （65）到F （70），这意味着添加55（ 'A'-10 ） 。
6. 考虑数字的大小写，我们要调整最后一个被加数，以便将b从0到9的范围映射到0 （48）到9 （57）的范围。 这意味着它需要变为-7（ '0' - 55 ）。
   现在我们可以乘以7。但是由于-1表示所有位均为1，因此我们可以使用& -7因为(0 & -7) == 0和(-1 & -7) == -7 。

一些进一步的考虑：

• 我没有使用第二个循环变量来索引c ，因为测量表明从i计算更便宜。
• 精确地使用i < bytes.Length作为循环的上限允许JITter消除对bytes[i]边界检查，因此我选择了该变体。
• 将b为int允许从字节到字节的不必要转换。

---

#4楼

两个混搭将两个半字节操作折叠为一个。

可能是非常有效的版本：

public static string ByteArrayToString2(byte[] ba)
{char[] c = new char[ba.Length * 2];for( int i = 0; i < ba.Length * 2; ++i){byte b = (byte)((ba[i>>1] >> 4*((i&1)^1)) & 0xF);c[i] = (char)(55 + b + (((b-10)>>31)&-7));}return new string( c );
}

a废linq-with-bit-hacking版本：

public static string ByteArrayToString(byte[] ba)
{return string.Concat( ba.SelectMany( b => new int[] { b >> 4, b & 0xF }).Select( b => (char)(55 + b + (((b-10)>>31)&-7))) );
}

反过来：

public static byte[] HexStringToByteArray( string s )
{byte[] ab = new byte[s.Length>>1];for( int i = 0; i < s.Length; i++ ){int b = s[i];b = (b - '0') + ((('9' - b)>>31)&-7);ab[i>>1] |= (byte)(b << 4*((i&1)^1));}return ab;
}

---

#5楼

这是我的照片。 我创建了一对扩展类来扩展字符串和字节。 在大文件测试中，性能可与Byte Manipulation 2媲美。

下面的ToHexString代码是查找和移位算法的优化实现。 它几乎与Behrooz的相同，但是事实证明，使用foreach进行迭代，并且计数器比的显式索引for快。

它在我的机器上的字节操作2之后排在第二位，并且代码可读性强。 以下测试结果也很有趣：

ToHexStringCharArrayWithCharArrayLookup：41,589.69平均滴答声（超过1000次运行），1.5X ToHexStringCharArrayWithStringLookup：50,764.06平均滴答声（超过1000次运行），1.2X ToHexStringStringBuilderWithCharArrayLookup：62,812.87平均滴答声（超过1000次运行），1.0X

根据以上结果，可以得出结论：

1. 在大型文件测试中，索引到字符串以执行查找与char数组相比要付出很大的代价。
2. 使用已知容量的StringBuilder与已知大小的char数组来创建字符串的代价甚至更大。

这是代码：

using System;namespace ConversionExtensions
{public static class ByteArrayExtensions{private readonly static char[] digits = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };public static string ToHexString(this byte[] bytes){char[] hex = new char[bytes.Length * 2];int index = 0;foreach (byte b in bytes){hex[index++] = digits[b >> 4];hex[index++] = digits[b & 0x0F];}return new string(hex);}}
}using System;
using System.IO;namespace ConversionExtensions
{public static class StringExtensions{public static byte[] ToBytes(this string hexString){if (!string.IsNullOrEmpty(hexString) && hexString.Length % 2 != 0){throw new FormatException("Hexadecimal string must not be empty and must contain an even number of digits to be valid.");}hexString = hexString.ToUpperInvariant();byte[] data = new byte[hexString.Length / 2];for (int index = 0; index < hexString.Length; index += 2){int highDigitValue = hexString[index] <= '9' ? hexString[index] - '0' : hexString[index] - 'A' + 10;int lowDigitValue = hexString[index + 1] <= '9' ? hexString[index + 1] - '0' : hexString[index + 1] - 'A' + 10;if (highDigitValue < 0 || lowDigitValue < 0 || highDigitValue > 15 || lowDigitValue > 15){throw new FormatException("An invalid digit was encountered. Valid hexadecimal digits are 0-9 and A-F.");}else{byte value = (byte)((highDigitValue << 4) | (lowDigitValue & 0x0F));data[index / 2] = value;}}return data;}}
}

以下是将代码放入计算机上@patridge的测试项目中时得到的测试结果。 我还添加了一个从十六进制转换为字节数组的测试。 行使我的代码的测试运行是ByteArrayToHexViaOptimizedLookupAndShift和HexToByteArrayViaByteManipulation。 HexToByteArrayViaConvertToByte来自XXXX。 HexToByteArrayViaSoapHexBinary是@Mykroft的答案之一。

英特尔奔腾III至强处理器

  Cores: 4 <br/> Current Clock Speed: 1576 <br/> Max Clock Speed: 3092 <br/> 

---

将字节数组转换为十六进制字符串表示形式

---

ByteArrayToHexViaByteManipulation2：39,366.64个平均滴答声（超过1000次运行），22.4X

ByteArrayToHexViaOptimizedLookupAndShift：平均滴答声41588.64（运行1000多次），21.2X

ByteArrayToHexViaLookup：55,509.56平均滴答声（超过1000次运行），15.9X

ByteArrayToHexViaByteManipulation：65,349.12平均滴答声（超过1000次运行），13.5X

ByteArrayToHexViaLookupAndShift：平均滴答声86,926.87（运行1000多次），10.2倍

ByteArrayToHexStringViaBitConverter：139,353.73平均滴答声（运行1000多次），6.3X

ByteArrayToHexViaSoapHexBinary：314,598.77平均滴答声（运行1000多次），2.8X

ByteArrayToHexStringViaStringBuilderForEachByteToString：344,264.63平均滴答声（运行1000多次），2.6X

ByteArrayToHexStringViaStringBuilderAggregateByteToString：382,623.44平均滴答声（运行1000多次），2.3倍

ByteArrayToHexStringViaStringBuilderForEachAppendFormat：平均滴答声（超过1000次运行）为818,111.95，1.1X

ByteArrayToHexStringViaStringConcatArrayConvertAll：839,244.84平均滴答声（运行1000多次），1.1X

ByteArrayToHexStringViaStringBuilderAggregateAppendFormat：平均滴答声（超过1000次运行），1.0X

ByteArrayToHexStringViaStringJoinArrayConvertAll：882,710.28平均滴答声（运行1000多次），1.0X

---

---

#6楼

通过@CodesInChaos回答的补充（反向方法）

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

说明：

& 0x0f也支持小写字母

hi = hi + 10 + ((hi >> 31) & 7); 是相同的：

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

对于“ 0” ..“ 9”，它与hi = ch - 65 + 10 + 7; hi = ch - 48 （这是因为0xffffffff & 7 ）。

对于“ A” ..“ F”，它是hi = ch - 65 + 10; （这是因为0x00000000 & 7 ）。

对于'a'..'f'，我们必须使用大数字，因此必须通过使用& 0x0f将一些位设置为0 ，从而从默认版本中减去32。

65是'A'代码

48是代码'0'

7是ASCII表中'9'和'A'之间的字母数（ ...456789:;<=>?@ABCD... ）。

---

#7楼

此版本的ByteArrayToHexViaByteManipulation可能会更快。

从我的报告中：

• ByteArrayToHexViaByteManipulation3：1,68个平均滴答声（运行1000次以上），17.5X
• ByteArrayToHexViaByteManipulation2：1,73个平均滴答声（超过1000次运行），16,9X
• ByteArrayToHexViaByteManipulation：2,90平均滴答声（超过1000次运行），10,1X
• ByteArrayToHexViaLookupAndShift：3,22个平均滴答声（超过1000次运行），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); } 

我认为这是一种优化：

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

---

#8楼

尚未针对速度进行优化，但是比大多数答案（.NET 4.0）更多的LINQy：

<Extension()>
Public Function FromHexToByteArray(hex As String) As Byte()hex = If(hex, String.Empty)If hex.Length Mod 2 = 1 Then hex = "0" & hexReturn Enumerable.Range(0, hex.Length \ 2).Select(Function(i) Convert.ToByte(hex.Substring(i * 2, 2), 16)).ToArray
End Function<Extension()>
Public Function ToHexString(bytes As IEnumerable(Of Byte)) As StringReturn String.Concat(bytes.Select(Function(b) b.ToString("X2")))
End Function

---

#9楼

另一个快速功能...

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

---

#10楼

这是一个很棒的帖子。 我喜欢Waleed的解决方案。 我还没有通过patridge的测试来运行它，但是它似乎很快。 我还需要反向过程，将十六进制字符串转换为字节数组，因此我将其编写为与Waleed解决方案相反。 不知道它是否比Tomalak的原始解决方案更快。 同样，我也没有通过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;
}

---

#11楼

安全版本：

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

不安全版本适用于喜欢性能且不怕不安全的人。 ToHex快大约35％，FromHex快10％。

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

BTW为了进行基准测试，每次调用的转换函数错误时初始化字母，字母必须为const（对于字符串）或静态只读（对于char []）。 然后，基于字母的byte []到字符串的转换变得和字节操作版本一样快。

当然，测试必须在Release（带有优化）中进行编译，并且调试选项“抑制JIT优化”处于关闭状态（如果代码必须是可调试的，则与“ Enable Just My Code”相同）。

---

#12楼

我将参加这个有点挑剔的比赛，因为我有一个答案，该答案也使用了点缀对十六进制进行解码 。 请注意，使用字符数组可能更快，因为调用StringBuilder方法也将花费时间。

public static String ToHex (byte[] data)
{int dataLength = data.Length;// pre-create the stringbuilder using the length of the data * 2, precisely enoughStringBuilder 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 letterint 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 characterint code = '0' + ((b >> 4) & 0xF) + isLetter * ('A' - '9' - 1);// now append the result, after casting the code point to a charactersb.Append ((Char)code);// do the same with the lower (less significant) tupleisLetter = (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 arrayint 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 basedvalue = ((c & 0xF) + isLetter * (-1 + 10)) << 4;// check validity of all the other bitsvalidity |= 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) tuplec = hex [hexOffset + 1];isLetter = (c >> 6) & 1;value ^= (c & 0xF) + isLetter * (-1 + 10);result [i] = (byte)value;// check validity of all the other bitsvalidity |= 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;
}

从Java代码转换而成。

---

#13楼

另一种基于查找表的方法。 这个每个字节只使用一个查询表，而不是每个半字节使用一个查询表。

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

我还使用查找表中的ushort ， struct{char X1, X2} ， struct{byte X1, X2}测试了它的变体。

根据编译目标（x86，X64），它们的性能大致相同，或者比此变体稍慢。

---

为了获得更高的性能，它的unsafe同级产品：

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

或者，如果您认为直接写入字符串是可以接受的：

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

---

#14楼

有一个名为SoapHexBinary的类可以完全满足您的需求。

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

---

#15楼

这是对Tomalak最受欢迎的答案 （及其后续编辑）的修订版4的回答 。

我将以为这种编辑是错误的，并解释为什么可以将其还原。 在此过程中，您可能会学到一些关于内部原理的东西，然后再看一个示例，该示例实际上是什么过早的优化及其如何对您造成伤害。

tl; dr：如果需要的话，只需使用Convert.ToByte和String.Substring （下面的“原始代码”），如果您不想重新实现Convert.ToByte ，这是最好的组合。 如果需要性能，请使用不使用Convert.ToByte更高级的功能（请参阅其他答案）。 不要使用任何东西比其他String.Substring结合Convert.ToByte ，除非有人些有趣的说这个在这个答案的评论。

警告： 如果在框架中实现了Convert.ToByte(char[], Int32)重载，则此答案可能已过时。 这不太可能很快发生。

通常，我不太喜欢说“不要过早优化”，因为没人知道“过早”的时间。 在决定是否进行优化时，您必须考虑的唯一事情是：“我是否有时间和资源来正确研究优化方法？”。 如果不这样做，那么它的太早，等到项目比较成熟，或者直到你所需要的性能（如果有实际需要，那么你会做的时间）。 同时，请执行可能可行的最简单的操作。

原始代码：

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

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

该修订版避免使用String.Substring ，而是使用StringReader 。 给定的原因是：

编辑：您可以使用单遍解析器来提高长字符串的性能，如下所示：

好吧，看一下String.Substring的参考代码 ，它显然已经是“单次通过”了； 为什么不呢？ 它以字节级别运行，而不是在代理对上运行。

但是，它确实分配了一个新字符串，但是无论如何，您都需要分配一个字符串以传递给Convert.ToByte 。 此外，修订版中提供的解决方案在每次迭代中分配了另一个对象（两字符数组）。 您可以安全地将该分配放到循环之外，并重新使用该数组来避免这种情况。

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

每个十六进制numeral使用两个数字（符号）表示一个八位字节。

但是，为什么StringReader.Read调用StringReader.Read两次呢？ 只需调用它的第二个重载，并要求它一次读取2个字符的数组中的两个字符即可； 并将通话量减少两个。

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

剩下的是一个字符串读取器，其唯一添加的“值”是您可以声明自己的并行索引（内部_pos ，例如j ），冗余长度变量（内部_length ）和冗余引用到输入字符串（内部_s ）。 换句话说，它是没有用的。

如果您想了解Read是如何“读取”的，只需看一下代码 ，它所做的就是在输入字符串上调用String.CopyTo 。 剩下的只是簿记管理费用，以维持我们不需要的价值。

因此，已经删除了字符串阅读器，然后调用CopyTo自己； 更简单，更清晰，更高效。

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

您是否真的需要一个j索引，它以与i平行的两个步长递增？ 当然，不可以，只需将i乘以2（编译器应该可以将其优化为加法）。

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

现在的解决方案是什么样的？ 就像刚开始时一样，只是使用中间数组，而不是使用String.Substring分配字符串并将数据复制到其中，而是将十六进制数字复制到该中间数组，然后自己分配字符串并复制再次将数据从数组传入字符串（当您在字符串构造函数中传递数据时）。 如果该字符串已经在内部缓冲池中，则第二个副本可能已被优化，但是在这种情况下， String.Substring也可以避免使用它。

实际上，如果再次查看String.Substring ，您会发现它使用了一些底层的内部知识，即如何构造字符串以比通常更快的速度分配字符串，并且它内联了直接由CopyTo使用的代码在那里避免通话开销。

String.Substring

• 最坏的情况：一种快速分配，一种快速复制。
• 最佳情况：无分配，无副本。

手动方式

• 最坏的情况：两个普通分配，一个普通副本，一个快速副本。
• 最佳情况：一份普通分配，一份普通副本。

结论？ 如果您要使用Convert.ToByte(String, Int32) （因为您不想自己重新实现该功能），似乎没有办法击败String.Substring ； 您要做的只是绕圈运行，重新发明轮子（仅适用于次优材料）。

请注意，如果您不需要极端的性能，则使用Convert.ToByte和String.Substring是一个完全有效的选择。 切记：只有在您有时间和资源调查其工作方式的情况下，才选择其他方法。

如果有一个Convert.ToByte(char[], Int32) ，那么事情当然会有所不同（可以做我上面描述的事情，完全避免使用String ）。

我怀疑通过“避免使用String.Substring ”报告更好的性能的人也避免使用Convert.ToByte(String, Int32) ，如果仍然需要性能，则应该这样做。 查看无数其他答案，以发现实现此目的的所有不同方法。

免责声明：我尚未反编译该框架的最新版本，以确认参考源是最新的（我认为是最新的）。

现在，这一切听起来不错且合乎逻辑，如果您已经走到了这一步，希望甚至显而易见。 但这是真的吗？

Intel(R) Core(TM) i7-3720QM CPU @ 2.60GHzCores: 8Current Clock Speed: 2600Max 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

是!

为Benchridge的Partridge提供支持，很容易被黑客入侵。 所使用的输入是以下SHA-1哈希，重复进行了5000次，以生成100,000个字节长的字符串。

209113288F93A9AB8E474EA78D899AFDBB874355

玩得开心！ （但要适度优化。）

---

#16楼

我没有收到您建议使用的代码，Olipro。 hex[i] + hex[i+1]显然返回了一个int 。

但是，通过从Waleeds代码中获得一些提示并将其整合在一起，我确实取得了一些成功。 根据我的测试（使用色标测试机制），它看起来像地狱一样丑陋，但它似乎可以工作并且比其他时间的性能高出1/3。 取决于输入大小。 先切换？：s来分开0-9可能会产生更快的结果，因为数字多于字母。

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

---

#17楼

在速度方面，这似乎比这里的任何东西都要好：

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

---

#18楼

要么：

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

要么：

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

例如， 这里还有更多的变体。

反向转换将如下所示：

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

---

与Convert.ToByte结合使用Substring是最好的选择。 有关更多信息，请参见此答案 。 如果需要更好的性能，则在删除SubString之前必须避免Convert.ToByte 。

---

#19楼

扩展方法 （免责声明：完全未经测试的代码，BTW ...）：

public static class ByteExtensions
{public static string ToHexString(this byte[] ba){StringBuilder hex = new StringBuilder(ba.Length * 2);foreach (byte b in ba){hex.AppendFormat("{0:x2}", b);}return hex.ToString();}
}

等。使用Tomalak的三种解决方案之一 （最后一种是对字符串的扩展方法）。

---

#20楼

您可以使用BitConverter.ToString方法：

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

输出：

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

详细信息： BitConverter.ToString方法（字节[]）

---

#21楼

如果您想要比BitConverter更大的灵活性，但又不想那些笨拙的1990年代风格的显式循环，则可以执行以下操作：

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

或者，如果您使用的是.NET 4.0：

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

（后者来自对原始帖子的评论。）

---

#22楼

Waleed Eissa代码的反函数（十六进制字符串到字节数组）：

    public static byte[] HexToBytes(this string hexString)        {byte[] b = new byte[hexString.Length / 2];            char c;for (int i = 0; i < hexString.Length / 2; i++){c = hexString[i * 2];b[i] = (byte)((c < 0x40 ? c - 0x30 : (c < 0x47 ? c - 0x37 : c - 0x57)) << 4);c = hexString[i * 2 + 1];b[i] += (byte)(c < 0x40 ? c - 0x30 : (c < 0x47 ? c - 0x37 : c - 0x57));}return b;}

Waleed Eissa函数具有小写字母支持：

    public static string BytesToHex(this byte[] barray, bool toLowerCase = true){byte addByte = 0x37;if (toLowerCase) addByte = 0x57;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 + addByte : b + 0x30);b = ((byte)(barray[i] & 0xF));c[i * 2 + 1] = (char)(b > 9 ? b + addByte : b + 0x30);}return new string(c);}

---

#23楼

另一种方法是使用stackalloc降低GC内存压力：

static string ByteToHexBitFiddle(byte[] bytes)
{var c = stackalloc char[bytes.Length * 2 + 1];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));}c[bytes.Length * 2 ] = '\0';return new string(c);
}

---

#24楼

从微软的开发人员那里，一个很好的，简单的转换：

public static string ByteArrayToString(byte[] ba)
{// Concatenate the bytes into one long stringreturn ba.Aggregate(new StringBuilder(32),(sb, b) => sb.Append(b.ToString("X2"))).ToString();
}

尽管上面的内容干净紧凑，但是性能迷们会使用枚举器大喊大叫。 您可以使用Tomalak原始答案的改进版本获得最佳性能：

public static string ByteArrayToString(byte[] ba)
{   StringBuilder hex = new StringBuilder(ba.Length * 2);   for(int i=0; i < ba.Length; i++)       // <-- Use for loop is faster than foreach   hex.Append(ba[i].ToString("X2"));   // <-- ToString is faster than AppendFormat   return hex.ToString();
}

到目前为止，这是我在此处看到的所有例程中最快的。 不要只是相信我的话...对每个例程进行性能测试，并亲自检查其CIL代码。

---

#25楼

为什么要使其复杂？ 在Visual Studio 2008中，这很简单：

C＃：

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

VB：

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

---

#26楼

绩效分析

注意：截至2015年8月20日的新领导者。

我通过一些简单的Stopwatch性能测试运行了每种转换方法，使用随机语句运行（n = 61，1000次迭代），使用Project Gutenburg文本运行（n = 1,238,957，150次迭代）。 结果如下，大致从最快到最慢。 所有度量单位均为滴答声（ 10,000 ticks = 1 ms ），并将所有相关注释与[最慢] StringBuilder实现进行比较。 有关使用的代码，请参见下文或测试框架库 ，我现在在其中维护用于运行该代码的代码。

免责声明

警告：不要依赖这些统计信息来获取任何具体信息； 它们只是样本数据的样本运行。 如果您确实需要一流的性能，请在代表您的生产需求的环境中测试这些方法，并使用代表您将要使用的数据。

结果

• 查找由字节unsafe （经由CodesInChaos） （由加入到测试回购airbreather ）
  • 文字：4,727.85（105.2X）
  • 句子：0.28（99.7X）
• 按字节查找（通过CodesInChaos）
  • 文字：10,853.96（快了45.8倍）
  • 句子：0.65（快42.7倍）
• 字节操作2（通过CodesInChaos）
  • 文字：12,967.69（快了38.4倍）
  • 句子：0.73（快37.9倍）
• 字节操作（通过Waleed Eissa）
  • 文字：16,856.64（快了29.5倍）
  • 句子：0.70（快39.5倍）
• 查找/转移（通过Nathan Moinvaziri）
  • 文字：23,201.23（快了21.4倍）
  • 句子：1.24（快22.3倍）
• 通过半字节查找（通过Brian Lambert）
  • 文字：23,879.41（快了20.8倍）
  • 句子：1.15（快23.9倍）
• BitConverter （通过Tomalak）
  • 文字：113,269.34（快了4.4倍）
  • 句子：9.98（速度提高了2.8倍）
• {SoapHexBinary}.ToString （通过Mykroft）
  • 文字：178,601.39（速度提高了2.8倍）
  • 句子：10.68（速度提高了2.6倍）
• {byte}.ToString("X2") （使用foreach ）（源自Will Dean的回答）
  • 文字：308,805.38（速度提高了2.4倍）
  • 句子：16.89（速度提高了2.4倍）
• {byte}.ToString("X2") （使用{IEnumerable}.Aggregate ，需要System.Linq）（通过Mark）
  • 文字：352828.20（速度提高了2.1倍）
  • 句子：16.87（速度提高了2.4倍）
• Array.ConvertAll （使用string.Join ）（通过Will Dean）
  • 文字：675,451.57（快了1.1倍）
  • 句子：17.95（速度提高了2.2倍）
• Array.ConvertAll （使用string.Concat ，需要.NET 4.0）（通过Will Dean）
  • 文字：752,078.70（速度提高了1.0倍）
  • 句子：18.28（速度提高了2.2倍）
• {StringBuilder}.AppendFormat （使用foreach ）（通过Tomalak）
  • 文字：672,115.77（快了1.1倍）
  • 句子：36.82（速度提高了1.1倍）
• {StringBuilder}.AppendFormat （使用{IEnumerable}.Aggregate ，需要System.Linq）（来自Tomalak的答案）
  • 文字：718,380.63（速度提高了1.0倍）
  • 句子：39.71（速度提高了1.0倍）

查找表已领先于字节操作。 基本上，有某种形式的预计算什么给定的半字节或字节。 然后，当您翻阅数据时，您只需查找下一部分即可看到它是十六进制字符串。 然后将该值以某种方式添加到结果字符串输出中。 长期以来，性能最佳的方法是字节操作，某些开发人员可能更难以阅读。

您最好的选择仍然是找到一些具有代表性的数据，然后在类似于生产的环境中进行尝试。 如果您有不同的内存限制，则您可能更喜欢分配较少的方法，而不是分配更快但消耗更多内存的方法。

测试代码

随意使用我使用的测试代码。 这里包含一个版本，但可以随时克隆存储库并添加自己的方法。 如果您发现任何有趣的东西或想要帮助改进它使用的测试框架，请提交请求请求。

1. 将新的静态方法（ Func<byte[], string> ）添加到/Tests/ConvertByteArrayToHexString/Test.cs。
2. 将该方法的名称添加到同一类的TestCandidates返回值中。
3. 通过在同一类的GenerateTestInput中切换注释，确保正在运行所需的输入版本，句子或文本。
4. 按F5键并等待输出（/ bin文件夹中还将生成HTML转储）。

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

更新（2010-01-13）

在分析中添加了Waleed的答案。 蛮快。

更新（2011-10-05）

添加了string.Concat Array.ConvertAll变体，以实现完整性（需要.NET 4.0）。 与string.Join版本同等。

更新（2012-02-05）

测试库包含更多变体，例如StringBuilder.Append(b.ToString("X2")) 。 没有人会破坏结果。 foreach比{IEnumerable}.Aggregate ，例如，但BitConverter仍然获胜。

更新（2012-04-03）

在分析中添加了Mykroft的SoapHexBinary答案，该答案排在第三位。

更新（2013-01-15）

添加了CodesInChaos的字节操作答案，该答案占据了第一位（在大块文本上占据了很大的空间）。

更新（2013-05-23）

添加了内森·莫因瓦济里（Nathan Moinvaziri）的查找答案以及布莱恩·兰伯特（Brian Lambert）博客的变体。 两者都相当快，但是在我使用的测试机器（AMD Phenom 9750）上却没有领先。

更新（2014-07-31）

添加了@CodesInChaos的新的基于字节的查找答案。 它似乎在句子测试和全文测试上都处于领先地位。

更新（2015-08-20）

向此答案的repo添加了airbreather的优化和unsafe变体。 如果您想玩这种不安全的游戏，无论是短字符串还是大文本，您都可以比以前的任何顶级赢家都获得巨大的性能提升。

---

#27楼

使用查找表也可以解决此问题。 对于编码器和解码器，这将需要少量的静态存储器。 但是，此方法将很快：

• 编码器表512字节或1024字节（如果需要大小写，则为两倍）
• 解码器表256字节或64 KiB（单字符查找或双字符查找）

我的解决方案将1024字节用于编码表，将256字节用于解码。

解码

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

编码方式

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

比较方式

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

*此解决方案

注意

在解码期间，可能会发生IOException和IndexOutOfRangeException（如果字符的值太高，大于256）。 应该实现对流或数组进行解码/编码的方法，这只是概念上的证明。

---

#28楼

为了性能，我会选择drphrozens解决方案。 解码器的一个微小优化可能是使用一个表作为char来摆脱“ << 4”。

显然，这两种方法调用的成本很高。 如果对输入或输出数据进行某种类型的检查（可能是CRC，校验和或其他）， if (b == 255)...可以跳过if (b == 255)... ，因此该方法也将完全调用。

使用offset++和offset而不是offset和offset + 1可能会提供一些理论上的好处，但是我怀疑编译器会比我更好地处理此问题。

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

这只是我的脑袋，尚未经过测试或基准测试。

---

#29楼

我今天遇到了同样的问题，遇到了以下代码：

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

来源：论坛帖子byte []数组到十六进制字符串 （请参阅PZahra的帖子）。 我对代码做了一些修改以删除0x前缀。

我对代码进行了性能测试，它几乎比使用BitConverter.ToString（）快八倍（根据patridge的帖子，最快）。

---

#30楼

多样性的另一种变化：

public static byte[] FromHexString(string src)
{if (String.IsNullOrEmpty(src))return null;int index = src.Length;int sz = index / 2;if (sz <= 0)return null;byte[] rc = new byte[sz];while (--sz >= 0){char lo = src[--index];char hi = src[--index];rc[sz] = (byte)(((hi >= '0' && hi <= '9') ? hi - '0' :(hi >= 'a' && hi <= 'f') ? hi - 'a' + 10 :(hi >= 'A' && hi <= 'F') ? hi - 'A' + 10 :0)<< 4 | ((lo >= '0' && lo <= '9') ? lo - '0' :(lo >= 'a' && lo <= 'f') ? lo - 'a' + 10 :(lo >= 'A' && lo <= 'F') ? lo - 'A' + 10 :0));}return rc;
}

如何将字节数组转换为十六进制字符串，反之亦然？相关推荐

1. 如何在Java中将字节数组转换为十六进制字符串？

   我有一个用十六进制数字填充并打印的字节数组,简单的方法是毫无意义的,因为有许多不可打印的元素. 我需要的是以下形式的确切十六进制代码: 3a5f771c #1楼 最简单的解决方案,没有外部库,没有数字 ...

2. android byte转16进制字符串,如何将字节数组转换为十六进制字符串，反之亦然？...

   我通过一些粗略的Stopwatch性能测试运行了各种转换方法,一个带有随机句子的运行(n = 61,1000次迭代)和一个带有Project Gutenburg文本的运行(n = 1,238,957, ...

3. java 打印16进制数组_如何在Java中将字节数组转换为十六进制字符串？

   从这里的讨论,特别是这个答案,这是我目前使用的功能:private final static char[] hexArray = "0123456789ABCDEF".toChar ...

4. Java中字节数组和十六进制字符串之间的转换

   1. 概述 在本教程中,我们将看看将字节数组转换为十六进制字符串,反之亦然的不同方法. 我们还将了解转换机制并编写我们的实现来实现这一点. 2. 字节和十六进制之间的转换 首先,我们来看看字节和十六进 ...

5. byte数组转16进制 java_如何在Java中将字节数组转换为十六进制格...

   我知道您可以使用printf并使用StringBuilder.append(String.format("%x",byte))将值转换为HEX值并在控制台上显示它们.但我希望能够实 ...

6. 二进制字节数组与十六进制字符串间的转换

   在加密算法中,经常会遇到将加密后得到的二进制字节数组转16进制字符串后返回:在解密算法中,则需要将字符串转二进制然后解密:下面将列举常用的几种转换方法,在文末会给出几种常用加解密算法示例. 1.二进制 ...

7. Java byte数组与十六进制字符串互转

   Java byte数组与十六进制字符串互转 博客分类: Java Javajava 十六进制java hex Java 加密解密基础 Java byte数组与十六进制字符串互转 Java BASE64 ...

8. java二进制 字节数组 字符 十六进制 BCD编码转换

   // 整数到字节数组转换 public static byte[] int2bytes(int n) { byte[] ab = new byte[4]; ab[0] = (byte) (0xff & ...

9. java 十六进制数组转字符串_Java通用将字节数组转换为字符串(非十六进制,十进制)...

   将字节数组转换为具有选择基数的字符串的最佳方法是什么? S.O上有大量示例.在其他地方转换为十六进制字符串.我主要感兴趣的是将其转换为十六进制或十进制字符串以外的内容:也是更通用的方式 这是我目前正在 ...

最新文章

1. c++ 常见问题之string
2. MySQL5.6解压版详细安装教程(附安装配置、MySQL数据库设置root管理员密码，MySQL字符集设置问题及解决办法)
3. PaaS case study
4. 浅析django的abstract,proxy, managed
5. 【已解决】IDEA:Cannot start compiler:the SDK is not specified for module...
6. 从输入URL到页面显示的过程
7. 《视觉SLAM十四讲——从理论到实践》学习笔记
8. 【学习 OpenCV】—— 图像减色（color reduced）
9. 好听又好看！歌曲视频制作，手把手教你制作音乐视频
10. 苹果输入法怎么换行_朋友圈长文字不折叠输入法，复制粘贴避免只显示一行
11. 已下载好的OpenCV4.5.5 CMake .cache文件夹
12. html css 实现文字竖排模拟古籍排版
13. matlab 触发脉冲建模,简单五步实现 MATLAB/Simulink 锂电池建模
14. python文件加密
15. Julia：报错 no method matching increment_deriv!(::Float64, ::Float64)
16. JAVA 关于hasNext的白话理解
17. ArcGIS教程：ArcGIS中的图表是什么
18. 分分钟搞定LabVIEW读取与写入Word【三易电子工作室】
19. 树莓派自启动python程序，远程树莓派桌面，重装树莓派系统，串口驱动，永不休眠，树莓派旋转屏幕方向，树莓派定时重启，修改矫正树莓派时间，raspbian Linux 系统命令常用
20. CSR8670蓝牙芯片驱动I2C接口的1602LCD显示屏

热门文章

1. Grunt安装与入门
2. 一生要做的九十九件事
3. Web项目之Flask框架
4. 6-19 day17 内置函数 16:52-17:43
5. mysql privileges
6. 【Java】synchronized与lock的区别
7. 【转】CentOS 使用yum命令安装出现错误提示”could not retrieve mirrorlist http://mirrorlist.centos.org ***”...
8. 02~ 一步一步教你使用 SVN之SVN 的介绍
9. 【驱动】linux设备驱动·字符设备驱动开发
10. 简明Python3教程 15.异常