多样性的另一种变化：

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

另一种方法是使用stackaloc来降低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);
}

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

扩展方法（免责声明：完全未经测试的代码，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的三种解决方案之一（最后一种是字符串上的扩展方法）。

如果性能很重要，这里有一个优化的解决方案：

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

它比BitConverter.ToString快2.5倍，比BitConverter.ToString+删除“-”字符快7倍。

将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中找到。