就速度而言，这似乎比这里的任何东西都要好：

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

如果您希望比BitConverter更灵活，但不希望使用那些笨重的90年代风格的显式循环，那么您可以这样做：

String.Join(String.Empty, Array.ConvertAll(bytes, x => x.ToString("X2")));

或者，如果您使用的是.NET 4.0：

String.Concat(Array.ConvertAll(bytes, x => x.ToString("X2")));

（后者来自对原帖子的评论。）

对老年人来说最快的方法。。。想念你的指针

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

我今天遇到了同样的问题，我遇到了以下代码：

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[]数组到十六进制字符串（见PZahra的帖子）。我稍微修改了一下代码，删除了0x前缀。

我对代码进行了一些性能测试，它几乎比使用BitConverter.ToString（）快八倍（根据patridge的帖子，速度最快）。

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

此版本的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);
    }