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

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

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

这是对托马拉克大受欢迎的答案（以及随后的编辑）第4版的回答。

我会证明这个编辑是错误的，并解释为什么可以恢复。在这一过程中，您可能会学到一些关于内部的东西，并看到另一个关于过早优化到底是什么以及它如何影响您的例子。

tl；dr：如果你很着急，只需使用Convert.ToByte和String.Substring（下面的“原始代码”），如果你不想重新实现Convert.ToBByte，这是最好的组合。如果你需要性能，请使用不使用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;
    }

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

但是，为什么要调用StringReader。读两遍？只需调用它的第二个重载，并要求它一次读取两个字符数组中的两个字符；并将呼叫量减少两次。

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

剩下的是一个字符串读取器，其唯一添加的“值”是一个并行索引（internal_pos），您可以声明自己（例如j）、一个冗余长度变量（internal_length）和一个输入字符串的冗余引用（internal_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使用的相同代码，以避免调用开销。

字符串.子字符串

最坏的情况：一次快速分配，一次快速复制。最佳情况：无分配，无复制。

手动方法

最坏情况：两个正常分配，一个正常复制，一个快速复制。最佳情况：一个正常分配，一个正常复制。

结论如果您想使用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.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

Yes!

支撑Partridge的长凳框架，很容易破解。使用的输入是以下SHA-1哈希，重复5000次以生成100000字节长的字符串。

209113288F93A9AB8E474EA78D899AFDBB874355

玩得高兴（但要适度优化。）

此版本的ByteArrayToHexViaByteManipulation可能更快。

从我的报告中：

ByteArrayToHexViaByteManipulation3:1.68次平均滴答声（超过1000次），17,5XByteArrayToHexViaByteManipulation2:1,73平均滴答（超过1000次），16,9XByteArrayToHexViaByteManipulation:2,90平均刻度（超过1000次），10,1XByteArrayToHexViaLookupAndShift:3.22平均刻度（超过1000次），9,1X...静态专用只读字符[]hexAlphabet=新字符[]{'0'，'1'，'2'，'3'，'4'，'5'，'6'，'7'，'8'，'9'，'A'，'B'，'C'，'D'，'E'，'F'}；静态字符串ByteArrayToHexViaByteManipulation3（byte[]字节）{char[]c=新字符[bytes.Length*2]；字节b；for（int i=0；i<bytes.Length；i++）{b=（（字节）（字节[i]>>4））；c[i*2]=十六进制字母[b]；b=（（字节）（字节[i]&0xF））；c[i*2+1]=十六进制字母[b]；}返回新字符串（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);
    }

这个问题也可以使用查找表来解决。这将需要编码器和解码器的少量静态存储器。然而，这种方法很快：

编码器表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 *

*这个解决方案

Note

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

有一个名为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();
}