如何将字节数组转换为十六进制字符串，反之亦然？
alextansc
问问题
1034143 次
50 回答
1563
您可以Convert.ToHexString从 .NET 5 开始使用。
还有一种反向操作的方法：Convert.FromHexString.
对于旧版本的 .NET，您可以使用：
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;
}
结合使用Substring是最好的选择Convert.ToByte。有关更多信息，请参阅此答案。如果你需要更好的性能，你必须避免Convert.ToByte在你可以丢弃之前SubString。
于 2008-11-22T10:19:28.480 回答
527
性能分析
注：新领导人截至 2015-08-20。
我通过一些粗略的性能测试运行了各种转换方法Stopwatch，运行随机句子（n = 61，1000 次迭代）和运行 Project Gutenburg 文本（n = 1,238,957，150 次迭代）。以下是结果，大致从最快到最慢。所有测量都以滴答声（10,000 滴答声 = 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 倍）
- 通过 nibble 查找（通过 Brian Lambert）
- 文本：23,879.41（快 20.8 倍）
- 句子：1.15（快 23.9 倍）
BitConverter（通过托马拉克）- 文本：113,269.34（快 4.4 倍）
- 句子：9.98（快 2.8 倍）
{SoapHexBinary}.ToString（通过迈克罗夫特）- 文本：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）- 文本：352,828.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 倍）
查找表已经领先于字节操作。基本上，有某种形式的预计算任何给定的半字节或字节将以十六进制表示。然后，当您翻阅数据时，您只需查找下一部分以查看它将是什么十六进制字符串。然后以某种方式将该值添加到结果字符串输出中。长期以来，一些开发人员可能难以阅读的字节操作是性能最佳的方法。
您最好的选择仍然是找到一些有代表性的数据并在类似生产的环境中进行尝试。如果您有不同的内存限制，您可能更喜欢分配较少的方法，而不是更快但消耗更多内存的方法。
测试代码
随意使用我使用的测试代码。此处包含一个版本，但您可以随意克隆repo并添加您自己的方法。如果您发现任何有趣的东西或想帮助改进它使用的测试框架，请提交拉取请求。
- 将新的静态方法 (
Func<byte[], string>) 添加到 /Tests/ConvertByteArrayToHexString/Test.cs。 - 将该方法的名称添加到
TestCandidates同一类的返回值中。 GenerateTestInput通过切换同一类中的注释，确保您正在运行所需的输入版本、句子或文本。- 点击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}.AggregateBitConverter
更新 (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中添加了空气呼吸器的优化和unsafe变体。如果您想在不安全的游戏中玩，您可以在短字符串和大文本方面获得比之前任何顶级赢家的巨大性能提升。
于 2009-03-08T21:56:41.770 回答
255
有一个名为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();
}
于 2010-03-31T20:42:47.303 回答
152
在编写加密代码时，通常会避免依赖数据的分支和表查找，以确保运行时不依赖于数据，因为依赖于数据的时序会导致边信道攻击。
它也非常快。
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'nlui mglw'nafh 克苏鲁 R'lyeh wgah'nagl fhtagn
放弃所有希望，你们进入这里
对奇怪的摆弄的解释：
bytes[i] >> 4提取一个字节的高半字节
bytes[i] & 0xF提取一个字节的低半字节b - 10
用于< 0值b < 10，将变为十进制数字
用于>= 0值b > 10，将变为从Ato的字母F。i >> 31由于符号扩展，使用带符号的 32 位整数提取符号。这将是-1fori < 0和0fori >= 0。- 结合 2) 和 3)，表明
(b-10)>>31将0用于字母和-1数字。 - 查看字母的大小写，最后一个和变为
0，并且b在 10 到 15 的范围内。我们希望将其映射到A(65) 到F(70)，这意味着添加 55 ('A'-10)。 - 看看数字的情况，我们想要调整最后一个加数，使其
b从 0 到 9 映射到0(48) 到9(57) 的范围。这意味着它需要变为 -7 ('0' - 55)。
现在我们可以乘以 7。但由于 -1 表示所有位为 1，我们可以改为使用& -7since(0 & -7) == 0和(-1 & -7) == -7。
一些进一步的考虑：
- 我没有使用第二个循环变量来索引
c，因为测量表明计算它i更便宜。 - 完全使用
i < bytes.Length循环的上限允许 JITter 消除对 的边界检查bytes[i]，因此我选择了该变体。 - 制作
b一个 int 允许不必要的从和到字节的转换。
于 2013-01-15T08:04:48.533 回答
111
如果您想要比 更多的灵活性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")));
（后者来自对原始帖子的评论。）
于 2008-11-22T14:29:19.300 回答
79
另一种基于查找表的方法。这个对每个字节只使用一个查找表，而不是每个半字节的查找表。
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);
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);
}
或者，如果您认为可以直接写入字符串：
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;
}
于 2014-06-21T16:44:25.230 回答
68
您可以使用 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
于 2008-11-22T14:23:26.957 回答
57
我今天刚遇到同样的问题，我遇到了这段代码：
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[] Array to Hex String（参见 PZahra 的帖子）。我稍微修改了代码以删除 0x 前缀。
我对代码进行了一些性能测试，它几乎比使用 BitConverter.ToString() 快八倍（根据 patridge 的帖子最快）。
于 2009-03-11T00:51:09.213 回答
24
从 .NET 5 RC2 开始，您可以使用：
Convert.ToHexString(byte[] inArray)它返回一个string和Convert.FromHexString(string s)它返回一个byte[].
可以使用带跨度参数的重载。
于 2020-10-22T21:25:39.980 回答
22
这是对Tomalak 非常受欢迎的答案（以及随后的编辑）的修订版 4的答案。
我会证明这个编辑是错误的，并解释为什么它可以被还原。在此过程中，您可能会学到一两件关于一些内部结构的知识，并看到另一个例子，说明什么是过早优化以及它如何影响您。
tl;dr：如果您很着急，只需使用Convert.ToByteand String.Substring（下面的“原始代码”），如果您不想重新实现，这是最好的组合Convert.ToByte。Convert.ToByte如果您需要性能，请使用不使用的更高级的东西（请参阅其他答案） 。除了与 结合使用之外，不要使用其他任何东西，除非有人在这个答案的评论中有有趣的事情要说。String.SubstringConvert.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使用 aStringReader代替。给出的原因是：
编辑：您可以通过使用单遍解析器来提高长字符串的性能，如下所示：
好吧，看看 的参考代码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两次电话？只需调用它的第二个重载并要求它一次读取双字符数组中的两个字符；并减少两个呼叫量。
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吗？当然不是，只需乘以i2（编译器应该能够优化到加法）。
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.ToByteand是一个完全有效的选择。String.Substring请记住：只有在您有时间和资源来调查它如何正常工作时才选择替代方案。
如果有Convert.ToByte(char[], Int32)，事情当然会有所不同（可以做我上面描述的事情并完全避免String）。
我怀疑那些通过“避免String.Substring”来报告更好性能的人也会避免Convert.ToByte(String, Int32)，如果你仍然需要性能，你应该这样做。查看无数其他答案，以发现所有不同的方法来做到这一点。
免责声明：我没有反编译最新版本的框架来验证参考源是否是最新的，我假设它是最新的。
现在，这一切听起来都很好，也很合乎逻辑，如果你能做到这一点，希望甚至是显而易见的。但这是真的吗？
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
是的！
用于工作台框架的 Partridge 的道具，很容易破解。使用的输入是重复 5000 次以生成 100,000 字节长的字符串的以下 SHA-1 哈希。
209113288F93A9AB8E474EA78D899AFDBB874355
玩得开心！（但要适度优化。）
于 2014-10-10T16:39:28.987 回答
19
这个问题也可以使用查找表来解决。这将需要用于编码器和解码器的少量静态存储器。但是，此方法将很快：
- 编码器表 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）。应该实现对流或数组进行解码/编码的方法，这只是一个概念证明。
于 2011-06-08T06:01:42.040 回答
19
由@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;which is相同hi = ch - 48（这是因为0xffffffff & 7）。
对于 'A'..'F' 它是hi = ch - 65 + 10;（这是因为0x00000000 & 7）。
对于'a'..'f'，我们必须使用大数字，因此我们必须0通过使用& 0x0f..
65是代码'A'
48 是代码'0'
7 是ASCII 表 ( )之间'9'和之间的字母数。'A'...456789:;<=>?@ABCD...
于 2013-07-29T12:23:25.170 回答
14
点网 5 更新
要将byte[](byte array) 转换为 hexadecimal string，请使用：
System.Convert.ToHexString
var myBytes = new byte[100];
var myString = System.Convert.ToHexString(myBytes);
要将十六进制转换string为byte[]，请使用：
System.Convert.FromHexString
var myString = "E10B116E8530A340BCC7B3EAC208487B";
var myBytes = System.Convert.FromHexString(myString);
于 2021-07-30T19:56:52.283 回答
12
为什么要复杂？这在 Visual Studio 2008 中很简单：
C＃：
string hex = BitConverter.ToString(YourByteArray).Replace("-", "");
VB：
Dim hex As String = BitConverter.ToString(YourByteArray).Replace("-", "")
于 2010-10-20T00:55:42.277 回答
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;
}
于 2010-01-12T16:51:38.193 回答
8
不要在这里堆砌许多答案，但我发现了一个相当优化的（比接受的要好约 4.5 倍），直接实现十六进制字符串解析器。首先，我的测试输出（第一批是我的实现）：
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
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 角度似乎得到了很好的覆盖。因此，这个答案。）
于 2012-05-22T16:50:58.560 回答
7
来自 Microsoft 的开发人员，一个不错的简单转换：
public static string ByteArrayToString(byte[] ba)
{
// Concatenate the bytes into one long string
return 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 代码。
于 2010-09-29T18:41:29.303 回答
7
安全版本：
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;
}
}
}
不安全的版本适合那些喜欢性能并且不怕不安全的人。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 - 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;
}
}
}
顺便说一句 ，对于每次调用转换函数错误时初始化字母表的基准测试，字母表必须是 const（对于字符串）或静态只读（对于 char[]）。然后 byte[] 到字符串的基于字母的转换变得与字节操作版本一样快。
当然，测试必须在 Release 中编译（带优化），并且关闭调试选项“Suppress JIT optimization”（如果代码必须是可调试的，则与“Enable Just My Code”相同）。
于 2013-12-20T03:45:25.273 回答
6
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);
}
于 2015-12-17T11:15:19.587 回答
5
扩展方法（免责声明：完全未经测试的代码，顺便说一句......）：
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 的三个解决方案中的任何一个（最后一个是字符串上的扩展方法）。
于 2008-11-22T13:27:49.347 回答
5
老派人士的最快方法……想念你的指点
static public byte[] HexStrToByteArray(string str)
{
byte[] res = new byte[(str.Length % 2 != 0 ? 0 : str.Length / 2)]; //check and allocate memory
for (int i = 0, j = 0; j < res.Length; i += 2, j++) //convert loop
res[j] = (byte)((str[i] % 32 + 9) % 25 * 16 + (str[i + 1] % 32 + 9) % 25);
return res;
}
于 2020-10-23T10:58:33.440 回答
5
.NET 5 添加了Convert.ToHexString方法。
对于使用旧版本 .NET 的用户
internal static class ByteArrayExtensions
{
public static string ToHexString(this byte[] bytes, Casing casing = Casing.Upper)
{
Span<char> result = stackalloc char[0];
if (bytes.Length > 16)
{
var array = new char[bytes.Length * 2];
result = array.AsSpan();
}
else
{
result = stackalloc char[bytes.Length * 2];
}
int pos = 0;
foreach (byte b in bytes)
{
ToCharsBuffer(b, result, pos, casing);
pos += 2;
}
return result.ToString();
}
private static void ToCharsBuffer(byte value, Span<char> buffer, int startingIndex = 0, Casing casing = Casing.Upper)
{
uint difference = (((uint)value & 0xF0U) << 4) + ((uint)value & 0x0FU) - 0x8989U;
uint packedResult = ((((uint)(-(int)difference) & 0x7070U) >> 4) + difference + 0xB9B9U) | (uint)casing;
buffer[startingIndex + 1] = (char)(packedResult & 0xFF);
buffer[startingIndex] = (char)(packedResult >> 8);
}
}
public enum Casing : uint
{
// Output [ '0' .. '9' ] and [ 'A' .. 'F' ].
Upper = 0,
// Output [ '0' .. '9' ] and [ 'a' .. 'f' ].
Lower = 0x2020U,
}
改编自 .NET 存储库 https://github.com/dotnet/runtime/blob/v5.0.3/src/libraries/System.Private.CoreLib/src/System/Convert.cs https://github.com/dotnet /runtime/blob/v5.0.3/src/libraries/Common/src/System/HexConverter.cs
于 2021-03-02T09:58:08.157 回答
3
并用于插入 SQL 字符串（如果您不使用命令参数）：
public static String ByteArrayToSQLHexString(byte[] Source)
{
return = "0x" + BitConverter.ToString(Source).Replace("-", "");
}
于 2009-09-14T21:13:35.893 回答
3
我没有得到你建议的代码，Olipro。hex[i] + hex[i+1]显然返回了一个int.
我确实做到了，但是通过从 Waleeds 代码中获取一些提示并将其组合在一起，我取得了一些成功。它丑得要命，但根据我的测试（使用 patridges 测试机制），与其他人相比，它似乎工作和执行的时间只有 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;
}
于 2010-05-22T22:20:18.190 回答
3
就速度而言，这似乎比这里的任何东西都要好：
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);
}
于 2010-06-01T08:19:33.490 回答
3
对于性能，我会选择 drphrozens 解决方案。解码器的一个微小优化可能是为任一字符使用一个表来摆脱“<< 4”。
显然，这两种方法调用代价高昂。如果对输入或输出数据（可能是 CRC、校验和或其他）进行某种检查，则if (b == 255)...可以跳过该方法，从而完全调用该方法。
使用offset++andoffset而不是offsetandoffset + 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]));
}
这只是我的想法，尚未经过测试或基准测试。
于 2011-06-08T07:09:15.000 回答
3
这个版本的 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);
}
于 2013-08-23T07:07:38.153 回答
3
我将参加这个位摆弄比赛，因为我有一个答案也使用位摆弄来解码十六进制。请注意，使用字符数组可能会更快，因为调用StringBuilder方法也需要时间。
public static String ToHex (byte[] data)
{
int dataLength = data.Length;
// pre-create the stringbuilder using the length of the data * 2, precisely enough
StringBuilder 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 letter
int 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 character
int code = '0' + ((b >> 4) & 0xF) + isLetter * ('A' - '9' - 1);
// now append the result, after casting the code point to a character
sb.Append ((Char)code);
// do the same with the lower (less significant) tuple
isLetter = (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 array
int 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 based
value = ((c & 0xF) + isLetter * (-1 + 10)) << 4;
// check validity of all the other bits
validity |= 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) tuple
c = hex [hexOffset + 1];
isLetter = (c >> 6) & 1;
value ^= (c & 0xF) + isLetter * (-1 + 10);
result [i] = (byte)value;
// check validity of all the other bits
validity |= 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 代码转换而来。
于 2014-01-20T23:38:28.110 回答
2
多样性的另一种变化：
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;
}
于 2011-06-16T20:33:53.093 回答
2
两个混搭，将两个半字节操作合二为一。
可能非常有效的版本：
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 );
}
颓废的 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;
}
于 2013-05-15T13:09:00.830 回答
2
这是我的镜头。我创建了一对扩展类来扩展字符串和字节。在大文件测试上，性能与 Byte Manipulation 2 相当。
下面的 ToHexString 代码是查找和移位算法的优化实现。它与 Behrooz 的几乎相同，但结果证明使用 aforeach进行迭代并且计数器比显式索引更快for。
它在我的机器上排在 Byte Manipulation 2 之后的第二位，并且是非常易读的代码。以下测试结果也很有趣：
ToHexStringCharArrayWithCharArrayLookup：41,589.69 平均滴答（超过 1000 次运行），1.5X ToHexStringCharArrayWithStringLookup：50,764.06 平均滴答（超过 1000 次运行），1.2X ToHexStringStringBuilderWithCharArrayLookup：62,812.87 平均滴答（超过 1000 次运行），1.0X
基于上述结果，似乎可以得出以下结论：
- 在大文件测试中，索引到字符串以执行查找与 char 数组的惩罚是显着的。
- 使用已知容量的 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：平均 41,588.64 个刻度（超过 1000 次运行），21.2X
ByteArrayToHexViaLookup：55,509.56 个平均刻度（超过 1000 次运行），15.9X
ByteArrayToHexViaByteManipulation：65,349.12 平均滴答数（超过 1000 次运行），13.5X
ByteArrayToHexViaLookupAndShift：平均 86,926.87 个刻度（超过 1000 次运行），10.2X
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.3X
ByteArrayToHexStringViaStringBuilderForEachAppendFormat：818,111.95 平均滴答数（超过 1000 次运行），1.1X
ByteArrayToHexStringViaStringConcatArrayConvertAll：839,244.84 平均滴答数（超过 1000 次运行），1.1X
ByteArrayToHexStringViaStringBuilderAggregateAppendFormat：867,303.98 个平均刻度（超过 1000 次运行），1.0X
ByteArrayToHexStringViaStringJoinArrayConvertAll：882,710.28 个平均刻度（超过 1000 次运行），1.0X
于 2013-06-03T23:24:36.470 回答
2
没有针对速度进行优化，但比大多数答案（.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" & hex
Return 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 String
Return String.Concat(bytes.Select(Function(b) b.ToString("X2")))
End Function
于 2013-08-30T23:53:04.533 回答
2
另一个快速功能...
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;
}
于 2013-09-22T00:35:57.800 回答
2
另一种方法是通过使用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);
}
于 2016-05-20T16:23:25.693 回答
2
支持的最短路径和 .net 核心：
public static string BytesToString(byte[] ba) =>
ba.Aggregate(new StringBuilder(32), (sb, b) => sb.Append(b.ToString("X2"))).ToString();
于 2019-11-21T13:04:16.493 回答
2
有一个尚未提到的简单单行解决方案将十六进制字符串转换为字节数组（我们不关心这里的否定解释，因为它无关紧要）：
BigInteger.Parse(str, System.Globalization.NumberStyles.HexNumber).ToByteArray().Reverse().ToArray();
于 2020-03-10T21:23:22.687 回答
2
测试：十六进制字符串到字节数组
我注意到大多数测试都是在将字节数组转换为十六进制字符串的函数上执行的。因此，在这篇文章中，我将关注另一面：将十六进制字符串转换为字节数组的函数。如果你只对结果感兴趣，你可以跳到总结部分。测试代码文件在文章末尾提供。
标签
我想从接受的答案（由 Tomalak）StringToByteArrayV1 中命名该函数，或者将它的快捷方式命名为 V1。其余函数将以相同的方式命名：V2、V3、V4、...等。
参与职能索引
- Tomalak 的 StringToByteArrayV1（已接受的答案）
- Mykroft 的 StringToByteArrayV2（使用 SoapHexBinary）
- Drphrozen的 StringToByteArrayV3（查找表）
- CoperNick 的 StringToByteArrayV4（字节操作）
- Chris F 的 StringToByteArrayV5_1（字节操作）
- Chris F 的 StringToByteArrayV5_2（V5_1 + 根据 Amir Rezaei 的评论对其进行了增强）
- Chris F 的 StringToByteArrayV5_3（V5_2 + 根据 Ben Voigt 的评论对其进行了增强）（您可以在这篇发布的测试代码中看到它的最终形状）
- Ben Mosher 的 StringToByteArrayV6（字节操作）
- Maratius的 StringToByteArrayV7（字节操作 - 安全版本）
- Maratius 的 StringToByteArrayV8（字节操作 - 不安全的版本）
- 地理的 StringToByteArrayV9
- AlejandroAlis 的 StringToByteArrayV10
- Fredrik Hu 的 StringToByteArrayV11
- Maarten Bodewes 的 StringToByteArrayV12
- 克劳斯安德森的 StringToByteArrayV13
- Stas Makutin 的 StringToByteArrayV14
- JJJ 的 StringToByteArrayV15
- JamieSee 的 StringToByteArrayV16
- Spacepille 的 StringToByteArrayV17
- Gregory Morse 的 StringToByteArrayV18
- Rick 的 StringToByteArrayV19
- SandRock 的 StringToByteArrayV20
- Paul 的 StringToByteArrayV21
正确性测试
我通过传递 1 个字节的所有 256 个可能值来测试正确性，然后检查输出是否正确。结果：
- V18 存在以“00”开头的字符串的问题（请参阅 Roger Stewart 对此的评论）。除此之外，它通过了所有测试。
- 如果十六进制字符串字母为大写：所有函数成功通过
- 如果十六进制字符串字母为小写，则以下函数失败：V5_1、V5_2、v7、V8、V15、V19
注意：V5_3 解决了这个问题（V5_1 和 V5_2）
性能测试
我已经使用 Stopwatch 类进行了性能测试。
- 长字符串的性能
input length: 10,000,000 bytes
runs: 100
average elapsed time per run:
V1 = 136.4ms
V2 = 104.5ms
V3 = 22.0ms
V4 = 9.9ms
V5_1 = 10.2ms
V5_2 = 9.0ms
V5_3 = 9.3ms
V6 = 18.3ms
V7 = 9.8ms
V8 = 8.8ms
V9 = 10.2ms
V10 = 19.0ms
V11 = 12.2ms
V12 = 27.4ms
V13 = 21.8ms
V14 = 12.0ms
V15 = 14.9ms
V16 = 15.3ms
V17 = 9.5ms
V18 got excluded from this test, because it was very slow when using very long string
V19 = 222.8ms
V20 = 66.0ms
V21 = 15.4ms
V1 average ticks per run: 1363529.4
V2 is more fast than V1 by: 1.3 times (ticks ratio)
V3 is more fast than V1 by: 6.2 times (ticks ratio)
V4 is more fast than V1 by: 13.8 times (ticks ratio)
V5_1 is more fast than V1 by: 13.3 times (ticks ratio)
V5_2 is more fast than V1 by: 15.2 times (ticks ratio)
V5_3 is more fast than V1 by: 14.8 times (ticks ratio)
V6 is more fast than V1 by: 7.4 times (ticks ratio)
V7 is more fast than V1 by: 13.9 times (ticks ratio)
V8 is more fast than V1 by: 15.4 times (ticks ratio)
V9 is more fast than V1 by: 13.4 times (ticks ratio)
V10 is more fast than V1 by: 7.2 times (ticks ratio)
V11 is more fast than V1 by: 11.1 times (ticks ratio)
V12 is more fast than V1 by: 5.0 times (ticks ratio)
V13 is more fast than V1 by: 6.3 times (ticks ratio)
V14 is more fast than V1 by: 11.4 times (ticks ratio)
V15 is more fast than V1 by: 9.2 times (ticks ratio)
V16 is more fast than V1 by: 8.9 times (ticks ratio)
V17 is more fast than V1 by: 14.4 times (ticks ratio)
V19 is more SLOW than V1 by: 1.6 times (ticks ratio)
V20 is more fast than V1 by: 2.1 times (ticks ratio)
V21 is more fast than V1 by: 8.9 times (ticks ratio)
- 长弦V18的性能
V18 took long time at the previous test,
so let's decrease length for it:
input length: 1,000,000 bytes
runs: 100
average elapsed time per run: V1 = 14.1ms , V18 = 146.7ms
V1 average ticks per run: 140630.3
V18 is more SLOW than V1 by: 10.4 times (ticks ratio)
- 短字符串的性能
input length: 100 byte
runs: 1,000,000
V1 average ticks per run: 14.6
V2 is more fast than V1 by: 1.4 times (ticks ratio)
V3 is more fast than V1 by: 5.9 times (ticks ratio)
V4 is more fast than V1 by: 15.7 times (ticks ratio)
V5_1 is more fast than V1 by: 15.1 times (ticks ratio)
V5_2 is more fast than V1 by: 18.4 times (ticks ratio)
V5_3 is more fast than V1 by: 16.3 times (ticks ratio)
V6 is more fast than V1 by: 5.3 times (ticks ratio)
V7 is more fast than V1 by: 15.7 times (ticks ratio)
V8 is more fast than V1 by: 18.0 times (ticks ratio)
V9 is more fast than V1 by: 15.5 times (ticks ratio)
V10 is more fast than V1 by: 7.8 times (ticks ratio)
V11 is more fast than V1 by: 12.4 times (ticks ratio)
V12 is more fast than V1 by: 5.3 times (ticks ratio)
V13 is more fast than V1 by: 5.2 times (ticks ratio)
V14 is more fast than V1 by: 13.4 times (ticks ratio)
V15 is more fast than V1 by: 9.9 times (ticks ratio)
V16 is more fast than V1 by: 9.2 times (ticks ratio)
V17 is more fast than V1 by: 16.2 times (ticks ratio)
V18 is more fast than V1 by: 1.1 times (ticks ratio)
V19 is more SLOW than V1 by: 1.6 times (ticks ratio)
V20 is more fast than V1 by: 1.9 times (ticks ratio)
V21 is more fast than V1 by: 11.4 times (ticks ratio)
测试代码
在使用以下代码 https://github.com/Ghosticcollis/performance-tests/blob/main/MTestPerformance.cs之前，最好先阅读本文中的免责声明部分
概括
我推荐使用以下函数之一，因为它具有良好的性能，并且支持大小写：
- CoperNick 的 StringToByteArrayV4
- 地理的 StringToByteArrayV9
- Spacepille 的 StringToByteArrayV17
- StringToByteArrayV5_3 基本上由 Chris F编写（它基于 V5_1，但我根据 Amir Rezaei 和 Ben Voigt 的评论对其进行了增强）。
这是 V5_3 的最终形状：
static byte[] HexStringToByteArrayV5_3(string hexString) {
int hexStringLength = hexString.Length;
byte[] b = new byte[hexStringLength / 2];
for (int i = 0; i < hexStringLength; i += 2) {
int topChar = hexString[i];
topChar = (topChar > 0x40 ? (topChar & ~0x20) - 0x37 : topChar - 0x30) << 4;
int bottomChar = hexString[i + 1];
bottomChar = bottomChar > 0x40 ? (bottomChar & ~0x20) - 0x37 : bottomChar - 0x30;
b[i / 2] = (byte)(topChar + bottomChar);
}
return b;
}
免责声明
警告：我没有适当的测试知识。这些原始测试的主要目的是快速概述所有已发布功能的优点。如果您需要准确的结果，请使用适当的测试工具。
最后，我想说我是新来的 stackoverflow，如果缺少我的帖子，我很抱歉。评论以增强这篇文章将不胜感激。
于 2021-06-21T10:17:37.313 回答
1
如果性能很重要，这里有一个优化的解决方案：
static readonly char[] _hexDigits = "0123456789abcdef".ToCharArray();
public static string ToHexString(this byte[] bytes)
{
char[] digits = new char[bytes.Length * 2];
for (int i = 0; i < bytes.Length; i++)
{
int d1, d2;
d1 = Math.DivRem(bytes[i], 16, out d2);
digits[2 * i] = _hexDigits[d1];
digits[2 * i + 1] = _hexDigits[d2];
}
return new string(digits);
}
它大约快 2.5 倍BitConverter.ToString，大约快 7 倍BitConverter.ToString+ 删除“-”字符。
于 2011-04-10T00:56:25.790 回答
1
这适用于从字符串到字节数组......
public static byte[] StrToByteArray(string str)
{
Dictionary<string, byte> hexindex = new Dictionary<string, byte>();
for (byte i = 0; i < 255; i++)
hexindex.Add(i.ToString("X2"), i);
List<byte> hexres = new List<byte>();
for (int i = 0; i < str.Length; i += 2)
hexres.Add(hexindex[str.Substring(i, 2)]);
return hexres.ToArray();
}
于 2012-05-25T17:38:38.010 回答
1
我猜它的速度值得多出 16 个字节。
static char[] hexes = new char[]{'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
public static string ToHexadecimal (this byte[] Bytes)
{
char[] Result = new char[Bytes.Length << 1];
int Offset = 0;
for (int i = 0; i != Bytes.Length; i++) {
Result[Offset++] = hexes[Bytes[i] >> 4];
Result[Offset++] = hexes[Bytes[i] & 0x0F];
}
return new string(Result);
}
于 2012-12-16T20:40:59.690 回答
1
还有XmlWriter.WriteBinHex（参见 MSDN页面）。如果您需要将十六进制字符串放入 XML 流中，这将非常有用。
这是一个独立的方法来看看它是如何工作的：
public static string ToBinHex(byte[] bytes)
{
XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
xmlWriterSettings.ConformanceLevel = ConformanceLevel.Fragment;
xmlWriterSettings.CheckCharacters = false;
xmlWriterSettings.Encoding = ASCIIEncoding.ASCII;
MemoryStream memoryStream = new MemoryStream();
using (XmlWriter xmlWriter = XmlWriter.Create(memoryStream, xmlWriterSettings))
{
xmlWriter.WriteBinHex(bytes, 0, bytes.Length);
}
return Encoding.ASCII.GetString(memoryStream.ToArray());
}
于 2013-10-24T09:53:28.783 回答
1
下面通过允许本地小写选项以及处理 null 或空输入并使其成为扩展方法来扩展此处的出色答案。
/// <summary>
/// Converts the byte array to a hex string very fast. Excellent job
/// with code lightly adapted from 'community wiki' here: https://stackoverflow.com/a/14333437/264031
/// (the function was originally named: ByteToHexBitFiddle). Now allows a native lowerCase option
/// to be input and allows null or empty inputs (null returns null, empty returns empty).
/// </summary>
public static string ToHexString(this byte[] bytes, bool lowerCase = false)
{
if (bytes == null)
return null;
else if (bytes.Length == 0)
return "";
char[] c = new char[bytes.Length * 2];
int b;
int xAddToAlpha = lowerCase ? 87 : 55;
int xAddToDigit = lowerCase ? -39 : -7;
for (int i = 0; i < bytes.Length; i++) {
b = bytes[i] >> 4;
c[i * 2] = (char)(xAddToAlpha + b + (((b - 10) >> 31) & xAddToDigit));
b = bytes[i] & 0xF;
c[i * 2 + 1] = (char)(xAddToAlpha + b + (((b - 10) >> 31) & xAddToDigit));
}
string val = new string(c);
return val;
}
public static string ToHexString(this IEnumerable<byte> bytes, bool lowerCase = false)
{
if (bytes == null)
return null;
byte[] arr = bytes.ToArray();
return arr.ToHexString(lowerCase);
}
于 2015-10-20T22:51:39.553 回答
1
static string ByteArrayToHexViaLookupPerByte2(byte[] bytes)
{
var result3 = new uint[bytes.Length];
for (int i = 0; i < bytes.Length; i++)
result3[i] = _Lookup32[bytes[i]];
var handle = GCHandle.Alloc(result3, GCHandleType.Pinned);
try
{
var result = Marshal.PtrToStringUni(handle.AddrOfPinnedObject(), bytes.Length * 2);
return result;
}
finally
{
handle.Free();
}
}
在我的测试中，这个函数始终是 unsafe 实现之后的第二个条目。
不幸的是，测试台不是那么可靠......如果你多次运行它，列表就会被洗牌太多，谁知道在不安全之后这真的是最快的！它没有考虑预热、jit 编译时间和 GC 性能命中。我想重写它以获得更多信息，但我真的没有时间。
于 2017-05-02T11:12:09.570 回答
1
我想出了一个不同的代码，它可以容忍额外的字符（空格，破折号......）。它的灵感主要来自这里一些可以接受的快速答案。它允许解析以下“文件”
00-aa-84-fb
12 32 FF CD
12 00
12_32_FF_CD
1200d5e68a
/// <summary>Reads a hex string into bytes</summary>
public static IEnumerable<byte> HexadecimalStringToBytes(string hex) {
if (hex == null)
throw new ArgumentNullException(nameof(hex));
char c, c1 = default(char);
bool hasc1 = false;
unchecked {
for (int i = 0; i < hex.Length; i++) {
c = hex[i];
bool isValid = 'A' <= c && c <= 'f' || 'a' <= c && c <= 'f' || '0' <= c && c <= '9';
if (!hasc1) {
if (isValid) {
hasc1 = true;
}
} else {
hasc1 = false;
if (isValid) {
yield return (byte)((GetHexVal(c1) << 4) + GetHexVal(c));
}
}
c1 = c;
}
}
}
/// <summary>Reads a hex string into a byte array</summary>
public static byte[] HexadecimalStringToByteArray(string hex)
{
if (hex == null)
throw new ArgumentNullException(nameof(hex));
var bytes = new List<byte>(hex.Length / 2);
foreach (var item in HexadecimalStringToBytes(hex)) {
bytes.Add(item);
}
return bytes.ToArray();
}
private static byte GetHexVal(char val)
{
return (byte)(val - (val < 0x3A ? 0x30 : val < 0x5B ? 0x37 : 0x57));
// ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^
// digits 0-9 upper char A-Z a-z
}
复制时请参考完整代码。包括单元测试。
有人可能会说它对额外的字符太宽容了。所以不要依赖此代码来执行验证（或更改它）。
于 2019-05-30T12:55:50.510 回答
1
// a safe version of the lookup solution:
public static string ByteArrayToHexViaLookup32Safe(byte[] bytes, bool withZeroX)
{
if (bytes.Length == 0)
{
return withZeroX ? "0x" : "";
}
int length = bytes.Length * 2 + (withZeroX ? 2 : 0);
StateSmall stateToPass = new StateSmall(bytes, withZeroX);
return string.Create(length, stateToPass, (chars, state) =>
{
int offset0x = 0;
if (state.WithZeroX)
{
chars[0] = '0';
chars[1] = 'x';
offset0x += 2;
}
Span<uint> charsAsInts = MemoryMarshal.Cast<char, uint>(chars.Slice(offset0x));
int targetLength = state.Bytes.Length;
for (int i = 0; i < targetLength; i += 1)
{
uint val = Lookup32[state.Bytes[i]];
charsAsInts[i] = val;
}
});
}
private struct StateSmall
{
public StateSmall(byte[] bytes, bool withZeroX)
{
Bytes = bytes;
WithZeroX = withZeroX;
}
public byte[] Bytes;
public bool WithZeroX;
}
于 2019-11-01T23:30:35.193 回答
1
将一些答案合并到一个类中，以方便我以后复制和粘贴：
/// <summary>
/// Extension methods to quickly convert byte array to string and back.
/// </summary>
public static class HexConverter
{
/// <summary>
/// Map values to hex digits
/// </summary>
private static readonly char[] HexDigits =
{
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
};
/// <summary>
/// Map 56 characters between ['0', 'F'] to their hex equivalents, and set invalid characters
/// such that they will overflow byte to fail conversion.
/// </summary>
private static readonly ushort[] HexValues =
{
0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100,
0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100,
0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x000A, 0x000B,
0x000C, 0x000D, 0x000E, 0x000F
};
/// <summary>
/// Empty byte array
/// </summary>
private static readonly byte[] Empty = new byte[0];
/// <summary>
/// Convert a byte array to a hexadecimal string.
/// </summary>
/// <param name="bytes">
/// The input byte array.
/// </param>
/// <returns>
/// A string of hexadecimal digits.
/// </returns>
public static string ToHexString(this byte[] bytes)
{
var c = new char[bytes.Length * 2];
for (int i = 0, j = 0; i < bytes.Length; i++)
{
c[j++] = HexDigits[bytes[i] >> 4];
c[j++] = HexDigits[bytes[i] & 0x0F];
}
return new string(c);
}
/// <summary>
/// Parse a string of hexadecimal digits into a byte array.
/// </summary>
/// <param name="hexadecimalString">
/// The hexadecimal string.
/// </param>
/// <returns>
/// The parsed <see cref="byte[]"/> array.
/// </returns>
/// <exception cref="ArgumentException">
/// The input string either contained invalid characters, or was of an odd length.
/// </exception>
public static byte[] ToByteArray(string hexadecimalString)
{
if (!TryParse(hexadecimalString, out var value))
{
throw new ArgumentException("Invalid hexadecimal string", nameof(hexadecimalString));
}
return value;
}
/// <summary>
/// Parse a hexadecimal string to bytes
/// </summary>
/// <param name="hexadecimalString">
/// The hexadecimal string, which must be an even number of characters.
/// </param>
/// <param name="value">
/// The parsed value if successful.
/// </param>
/// <returns>
/// True if successful.
/// </returns>
public static bool TryParse(string hexadecimalString, out byte[] value)
{
if (hexadecimalString.Length == 0)
{
value = Empty;
return true;
}
if (hexadecimalString.Length % 2 != 0)
{
value = Empty;
return false;
}
try
{
value = new byte[hexadecimalString.Length / 2];
for (int i = 0, j = 0; j < hexadecimalString.Length; i++)
{
value[i] = (byte)((HexValues[hexadecimalString[j++] - '0'] << 4)
| HexValues[hexadecimalString[j++] - '0']);
}
return true;
}
catch (OverflowException)
{
value = Empty;
return false;
}
}
}
于 2020-09-12T20:33:33.540 回答
0
如果您想获得 wcoenen 报告的“4 倍速度提升”，那么如果它不明显：替换hex.Substring(i, 2)为hex[i]+hex[i+1]
你也可以更进一步，i+=2通过i++在两个地方使用来摆脱它。
于 2010-01-02T22:28:07.087 回答
0
具有扩展支持的基本解决方案
public static class Utils
{
public static byte[] ToBin(this 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;
}
public static string ToHex(this byte[] ba)
{
return BitConverter.ToString(ba).Replace("-", "");
}
}
并像下面这样使用这个类
byte[] arr1 = new byte[] { 1, 2, 3 };
string hex1 = arr1.ToHex();
byte[] arr2 = hex1.ToBin();
于 2018-05-14T12:53:59.247 回答
-2
在 Java 8 中，我们可以使用Byte.toUnsignedInt
public static String convertBytesToHex(byte[] bytes) {
StringBuilder result = new StringBuilder();
for (byte byt : bytes) {
int decimal = Byte.toUnsignedInt(byt);
String hex = Integer.toHexString(decimal);
result.append(hex);
}
return result.toString();
}
于 2020-04-29T01:10:40.093 回答
-3
我怀疑它的速度会让大多数其他测试都大吃一惊……
Public Function BufToHex(ByVal buf() As Byte) As String
Dim sB As New System.Text.StringBuilder
For i As Integer = 0 To buf.Length - 1
sB.Append(buf(i).ToString("x2"))
Next i
Return sB.ToString
End Function
于 2011-10-27T03:01:08.480 回答