我想出了一个不同的代码，它可以容忍额外的字符（空格、破折号…）。它的灵感主要来自这里一些可以接受的快速答案。它允许解析以下“文件”

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
}

复制时请参考完整代码。包括单元测试。

有些人可能会说它对额外的字符太宽容了。因此，不要依赖此代码来执行验证（或更改）。

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

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

在我的机器上，它排在Byte Manipulation 2之后，排在第二位，是非常可读的代码。以下测试结果也值得关注：

ToHexStringCharArrayWithCharArrayLookup：41589.69平均刻度（超过1000次），1.5倍ToHexStringCharArrayWithStringLookup:50764.06平均滴答（超过1000次），1.2XToHexStringStringBuilderWithCharArrayLookup:62812.87平均滴答（超过1000次），1.0X

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

索引到字符串以执行查找与char数组在大型文件测试中非常重要。使用已知容量的StringBuilder与使用字符的惩罚创建字符串的已知大小的数组甚至更重要。

代码如下：

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的答案。

Intel Pentium III Xeon处理器核心：4<br/>当前时钟速度：1576<br/>最大时钟速度：3092<br/>将字节数组转换为十六进制字符串表示ByteArrayToHexViaByteManipulation2:39366.64平均滴答（超过1000次），22.4倍ByteArrayToHexViaOptimizedLookupAndShift：41588.64平均刻度（超过1000次），21.2倍ByteArrayToHexViaLookup：55509.56次平均点击（超过1000次），15.9倍ByteArrayToHexViaByteManipulation:65349.12平均刻度（超过1000次），13.5XByteArrayToHexViaLookupAndShift：86926.87平均刻度（超过1000运行），10.2XByteArrayToHexStringViaBitConverter:平均139353.73滴答声（超过1000次），6.3XByteArrayToHexViaSoapHexBinary：314598.77平均刻度（超过1000次），2.8XByteArrayToHexStringViaStringBuilderForEachByteToString:344264.63平均刻度（超过1000次），2.6XByteArrayToHexStringViaStringBuilderAggregateByteToString:382623.44平均滴答声（超过1000次），2.3XByteArrayToHexStringViaStringBuilderForEachAppend格式：818111.95平均滴答声（超过1000次），1.1倍ByteArrayToHexStringViaStringConcatArray ConvertAll:839424.84平均值滴答声（超过1000次），1.1XByteArrayToHexStringViaStringBuilderAggregateAppend格式：867303.98平均刻度（超过1000次），1.0XByteArrayToHexStringViaStringJoinArray ConvertAll:平均882710.28滴答声（超过1000次），1.0X

将byte[]转换为十六进制字符串-基准测试/性能分析

更新日期：2022-04-17

从.NET 5开始，您应该使用Convert.ToHexString（bytes[]）！

using System;
string result = Convert.ToHexString(bytesToConvert);

关于此排行榜和基准

Thymine的比较似乎过时且不完整，尤其是在.NET 5及其Convert.ToHexString之后，所以我决定~~从字节到十六进制字符串的兔子洞~~创建一个新的、更新的比较，其中包含这两个问题的答案中的更多方法。

我使用的是BencharkDotNet，而不是定制的基准测试脚本，这有望使结果更准确。请记住，微观基准测试永远不能代表实际情况，您应该进行测试。

我在AMD Ryzen 5800H的Linux上运行了这些基准测试，内核为5.15.32，内存为2x8 GB DDR4@2133 MHz。请注意，完成整个基准测试可能需要很多时间——在我的机器上大约需要40分钟。

大写输出与小写输出

所有提到的方法（除非另有说明）都只关注UPPERCASE输出。这意味着输出将看起来像B33F69，而不是B33F69。

Convert.ToHexString的输出始终为大写。不过，值得庆幸的是，与ToLower（）配合使用时，性能并没有显著下降，尽管这两种不安全的方法都会更快。

在某些方法中（尤其是具有位运算符魔力的方法），有效地将字符串小写可能是一个挑战，但在大多数情况下，将参数X2更改为X2或将映射中的字母从大写更改为小写就足够了。

排行榜

按平均值N=100排序。参考点是StringBuilderForEachByte方法。

结论

ConvertToHexString方法无疑是目前最快的方法，在我看来，如果您有选择的话，应该始终使用它-它既快速又干净。

using System;

string result = Convert.ToHexString(bytesToConvert);

如果没有，我决定在下面强调另外两种我认为值得使用的方法。我决定不强调不安全的方法，因为这样的代码可能不仅是不安全的，而且我合作过的大多数项目都不允许这样的代码。

值得一提

第一个是LookupPerByteSpan。从这个答案中可以看出，该代码与LookupPerBytebyCodesInChaos中的代码几乎相同。这是最快且不安全的基准方法。原始版本和本版本之间的区别在于，对更短的输入使用堆栈分配（最多512字节）。这使得该方法在这些输入上快10%左右，但在较大的输入上慢5%左右。由于我使用的大多数数据都比大数据短，所以我选择了这个。LookupSpanPerByteSpan也非常快，但与所有其他方法相比，其ReadOnlySpan<byte>映射的代码大小太大。

private static readonly uint[] Lookup32 = Enumerable.Range(0, 256).Select(i =>
{
    string s = i.ToString("X2");
    return s[0] + ((uint)s[1] << 16);
}).ToArray();

public string ToHexString(byte[] bytes)
{
    var result = bytes.Length * 2 <= 1024
        ? stackalloc char[bytes.Length * 2]
        : 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);
}

第二个是LookupAndShiftAlphabetSpanMultiply。首先，我想提一下，这是我的创作。然而，我相信这种方法不仅速度很快，而且很容易理解。速度来自于C#7.3中发生的变化，其中声明的ReadOnlyPan＜byte＞方法返回常量数组初始化-新字节｛1，2，3，…｝-被编译为程序的静态数据，因此省略了冗余内存。[来源]

private static ReadOnlySpan<byte> HexAlphabetSpan => new[]
{
    (byte)'0', (byte)'1', (byte)'2', (byte)'3',
    (byte)'4', (byte)'5', (byte)'6', (byte)'7',
    (byte)'8', (byte)'9', (byte)'A', (byte)'B',
    (byte)'C', (byte)'D', (byte)'E', (byte)'F'
};

public static string ToHexString(byte[] bytes)
{
    var res = bytes.Length * 2 <= 1024 ? stackalloc char[bytes.Length * 2] : new char[bytes.Length * 2];

    for (var i = 0; i < bytes.Length; ++i)
    {
        var j = i * 2;
        res[j] = (char)HexAlphabetSpan[bytes[i] >> 4];
        res[j + 1] = (char)HexAlphabetSpan[bytes[i] & 0xF];
    }

    return new string(res);
}

源代码

所有方法的源代码、基准和这个答案都可以在GitHub上的Gist中找到。

可以使用从.NET 5开始的Convert.ToHexString。还有一个用于反向操作的方法：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();
}

or:

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。

您可以使用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方法（Byte[]）

多样性的另一种变化：

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