我不确定你是否需要这样做的性能，但这里是最快的方法转换字节[]到十六进制字符串，我能想到:

static readonly char[] hexchar = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
public static string HexStr(byte[] data, int offset, int len, bool space = false)
{
    int i = 0, k = 2;
    if (space) k++;
    var c = new char[len * k];
    while (i < len)
    {
        byte d = data[offset + i];
        c[i * k] = hexchar[d / 0x10];
        c[i * k + 1] = hexchar[d % 0x10];
        if (space && i < len - 1) c[i * k + 2] = ' ';
        i++;
    }
    return new string(c, 0, c.Length);
}

你把LINQ和字符串方法结合起来:

string hex = string.Join("",
  bin.Select(
    bin => bin.ToString("X2")
      ).ToArray());

有一个内置的方法:

byte[] data = { 1, 2, 4, 8, 16, 32 };

string hex = BitConverter.ToString(data);

结果:01-02-04-08-10-20

如果你想要没有破折号，只需删除它们:

string hex = BitConverter.ToString(data).Replace("-", string.Empty);

结果:010204081020

如果你想要一个更紧凑的表示，你可以使用Base64:

string base64 = Convert.ToBase64String(data);

结果:AQIECBAg

十六进制,Linq-fu:

string.Concat(ba.Select(b => b.ToString("X2")).ToArray())

与时俱进

正如@RubenBartelink所指出的，没有将IEnumerable<string>转换为数组的代码:ba。Select(b => b. tostring ("X2"))在4.0之前不工作，相同的代码现在在4.0上工作。

这段代码…

byte[] ba = { 1, 2, 4, 8, 16, 32 };

string s = string.Concat(ba.Select(b => b.ToString("X2")));
string t = string.Concat(ba.Select(b => b.ToString("X2")).ToArray());

Console.WriteLine (s);
Console.WriteLine (t);

.．.在。net 4.0之前，输出是:

System.Linq.Enumerable+<CreateSelectIterator>c__Iterator10`2[System.Byte,System.String]
010204081020

在。net 4.0以后，字符串。Concat有一个接受IEnumerable的重载。因此，在4.0版本中，上述代码对于变量s和t将有相同的输出

010204081020
010204081020

4.0之前，ba。Select(b => b.ToString("X2"))将重载(对象arg0)， IEnumerable<string>进入适当重载的方式，即(params string[] values)，是我们需要将IEnumerable<string>转换为字符串数组。4.0之前，字符串。Concat有10个过载功能，在4.0现在是12个

我想我应该给出一个答案。从我的测试来看，这种方法是最快的

public static class Helper
{
    public static string[] HexTbl = Enumerable.Range(0, 256).Select(v => v.ToString("X2")).ToArray();
    public static string ToHex(this IEnumerable<byte> array)
    {
        StringBuilder s = new StringBuilder();
        foreach (var v in array)
            s.Append(HexTbl[v]);
        return s.ToString();
    }
    public static string ToHex(this byte[] array)
    {
        StringBuilder s = new StringBuilder(array.Length*2);
        foreach (var v in array)
            s.Append(HexTbl[v]);
        return s.ToString();
    }
}

我想我做了一个更快的字节数组到字符串转换器:

public static class HexTable
{
    private static readonly string[] table = BitConverter.ToString(Enumerable.Range(0, 256).Select(x => (byte)x).ToArray()).Split('-');

    public static string ToHexTable(byte[] value)
    {
        StringBuilder sb = new StringBuilder(2 * value.Length);

        for (int i = 0; i < value.Length; i++)
            sb.Append(table[value[i]]);

        return sb.ToString();
    }

并且测试设置:

static void Main(string[] args)
{
        const int TEST_COUNT = 10000;
        const int BUFFER_LENGTH = 100000;

        Random random = new Random();

        Stopwatch sw = new Stopwatch();
        Stopwatch sw2 = new Stopwatch();

        byte[] buffer = new byte[BUFFER_LENGTH];
        random.NextBytes(buffer);

        sw.Start();
        for (int j = 0; j < TEST_COUNT; j++)
            HexTable.ToHexTable(buffer);

        sw.Stop();

        sw2.Start();
        for (int j = 0; j < TEST_COUNT; j++)
            ToHexChar.ToHex(buffer);

        sw2.Stop();

        Console.WriteLine("Hex Table Elapsed Milliseconds: {0}", sw.ElapsedMilliseconds);
        Console.WriteLine("ToHex Elapsed Milliseconds: {0}", sw2.ElapsedMilliseconds);
    }

ToHexChar.ToHEx()方法是前面所示的ToHex()方法。

结果如下:

HexTable = 11808 ms ToHEx = 12168ms

它看起来可能没有太大的不同，但它仍然更快:)