从.NET 5 RC2开始，您可以使用：

Convert.ToHexString（byte[]inArray），返回字符串和Convert.FromHexString（字符串s），返回字节[]。

可以使用跨度参数的重载。

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

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
}

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

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

可以使用从.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。

另一个快速功能。。。

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

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

Dotnet 5更新

要从byte[]（字节数组）转换为十六进制字符串，请使用：

System.Convert.ToHexString

var myBytes = new byte[100];
var myString = System.Convert.ToHexString(myBytes);

要将十六进制字符串转换为字节[]，请使用：

System.Convert.FromHexString

var myString  = "E10B116E8530A340BCC7B3EAC208487B";
var myBytes = System.Convert.FromHexString(myString);