这里没人提到你为什么会有"系统"字节[]"字符串，而不是值，所以我将。

当一个对象隐式转换为String类型时，程序将默认使用该对象的公共String ToString()方法，该方法从System继承而来。对象:

public virtual string ToString()
{
    return this.GetType().ToString();
}

如果你发现你经常进行这种转换，你可以简单地创建一个包装器类，并像这样重写这个方法:

public override string ToString()
{
    // do the processing here
    // return the nicely formatted string
}

现在每次打印这个包装器对象时，你将得到你自己的值，而不是this. gettype (). tostring()的值。

.Net5.0更新

感谢@antoninkriz的基准比较，我们可以看到Convert。到目前为止，ToHexString是明显的赢家

使用Convert.ToHexString以外的任何方法都是愚蠢的。在我看来，它在可读性、性能和安全性方面明显更胜一筹

剩下的是2012年4月10日之前的数据:

我想我应该尝试比较这里列出的每个方法的速度。我基于这个编写了速度测试代码。

结果是BitConverter+String。替换似乎比大多数其他简单的方法更快。但是可以通过像Nathan Moinvaziri的ByteArrayToHexString或Kurt的ToHex这样的算法来提高速度。

我还发现了一个有趣的字符串。连接和串。对于长字符串，Join比StringBuilder实现慢得多，但对于较短的数组也类似。可能是由于在较长的字符串上扩展StringBuilder，所以设置初始大小应该消除这种差异。

Took each bit of code from an answer here: BitConvertRep = Answer by Guffa, BitConverter and String.Replace (I'd recommend for most cases, [edit:] where you can't use Convert.ToHexString) StringBuilder = Answer by Quintin Robinson, foreach char StringBuilder.Append LinqConcat = Answer by Michael Buen, string.Concat of Linq built array LinqJoin = Answer by mloskot, string.Join of Linq built array LinqAgg = Answer by Matthew Whited, IEnumerable.Aggregate with StringBuilder ToHex = Answer by Kurt, sets chars in an array, using byte values to get hex ByteArrayToHexString = Answer by Nathan Moinvaziri, approx same speed as the ToHex above, and is probably easier to read (I'd recommend for speed, [edit:] where you can't use Convert.ToHexString) ToHexFromTable = Linked in answer by Nathan Moinvaziri, for me this is near the same speed as the above 2 but requires an array of 256 strings to always exist

With: LONG_STRING_LENGTH = 1000 * 1024; BitConvertRep calculation Time Elapsed 27,202 ms (fastest built in/simple) StringBuilder calculation Time Elapsed 75,723 ms (StringBuilder no reallocate) LinqConcat calculation Time Elapsed 182,094 ms LinqJoin calculation Time Elapsed 181,142 ms LinqAgg calculation Time Elapsed 93,087 ms (StringBuilder with reallocating) ToHex calculation Time Elapsed 19,167 ms (fastest) With: LONG_STRING_LENGTH = 100 * 1024;, Similar results BitConvertReplace calculation Time Elapsed 3431 ms StringBuilder calculation Time Elapsed 8289 ms LinqConcat calculation Time Elapsed 21512 ms LinqJoin calculation Time Elapsed 19433 ms LinqAgg calculation Time Elapsed 9230 ms ToHex calculation Time Elapsed 1976 ms With: int MANY_STRING_COUNT = 1000; int MANY_STRING_LENGTH = 1024; (Same byte count as first test but in different arrays) BitConvertReplace calculation Time Elapsed 25,680 ms StringBuilder calculation Time Elapsed 78,411 ms LinqConcat calculation Time Elapsed 101,233 ms LinqJoin calculation Time Elapsed 99,311 ms LinqAgg calculation Time Elapsed 84,660 ms ToHex calculation Time Elapsed 18,221 ms With: int MANY_STRING_COUNT = 2000; int MANY_STRING_LENGTH = 20; BitConvertReplace calculation Time Elapsed 1347 ms StringBuilder calculation Time Elapsed 3234 ms LinqConcat calculation Time Elapsed 5013 ms LinqJoin calculation Time Elapsed 4826 ms LinqAgg calculation Time Elapsed 3589 ms ToHex calculation Time Elapsed 772 ms

我使用的测试代码:

void Main()
{
    int LONG_STRING_LENGTH = 100 * 1024;
    int MANY_STRING_COUNT = 1024;
    int MANY_STRING_LENGTH = 100;

    var source = GetRandomBytes(LONG_STRING_LENGTH);

    List<byte[]> manyString = new List<byte[]>(MANY_STRING_COUNT);
    for (int i = 0; i < MANY_STRING_COUNT; ++i)
    {
        manyString.Add(GetRandomBytes(MANY_STRING_LENGTH));
    }

    var algorithms = new Dictionary<string,Func<byte[], string>>();
    algorithms["BitConvertReplace"] = BitConv;
    algorithms["StringBuilder"] = StringBuilderTest;
    algorithms["LinqConcat"] = LinqConcat;
    algorithms["LinqJoin"] = LinqJoin;
    algorithms["LinqAgg"] = LinqAgg;
    algorithms["ToHex"] = ToHex;
    algorithms["ByteArrayToHexString"] = ByteArrayToHexString;

    Console.WriteLine(" === Long string test");
    foreach (var pair in algorithms) {
        TimeAction(pair.Key + " calculation", 500, () =>
        {
            pair.Value(source);
        });
    }

    Console.WriteLine(" === Many string test");
    foreach (var pair in algorithms) {
        TimeAction(pair.Key + " calculation", 500, () =>
        {
            foreach (var str in manyString)
            {
                pair.Value(str);
            }
        });
    }
}

// Define other methods and classes here
static void TimeAction(string description, int iterations, Action func) {
    var watch = new Stopwatch();
    watch.Start();
    for (int i = 0; i < iterations; i++) {
        func();
    }
    watch.Stop();
    Console.Write(description);
    Console.WriteLine(" Time Elapsed {0} ms", watch.ElapsedMilliseconds);
}

//static byte[] GetRandomBytes(int count) {
//  var bytes = new byte[count];
//  (new Random()).NextBytes(bytes);
//  return bytes;
//}
static Random rand = new Random();
static byte[] GetRandomBytes(int count) {
    var bytes = new byte[count];
    rand.NextBytes(bytes);
    return bytes;
}


static string BitConv(byte[] data)
{
    return BitConverter.ToString(data).Replace("-", string.Empty);
}
static string StringBuilderTest(byte[] data)
{
    StringBuilder sb = new StringBuilder(data.Length*2);
    foreach (byte b in data)
        sb.Append(b.ToString("X2"));

    return sb.ToString();
}
static string LinqConcat(byte[] data)
{
    return string.Concat(data.Select(b => b.ToString("X2")).ToArray());
}
static string LinqJoin(byte[] data)
{
    return string.Join("",
        data.Select(
            bin => bin.ToString("X2")
            ).ToArray());
}
static string LinqAgg(byte[] data)
{
    return data.Aggregate(new StringBuilder(),
                               (sb,v)=>sb.Append(v.ToString("X2"))
                              ).ToString();
}
static string ToHex(byte[] bytes)
{
    char[] c = new char[bytes.Length * 2];

    byte b;

    for(int bx = 0, cx = 0; bx < bytes.Length; ++bx, ++cx)
    {
        b = ((byte)(bytes[bx] >> 4));
        c[cx] = (char)(b > 9 ? b - 10 + 'A' : b + '0');

        b = ((byte)(bytes[bx] & 0x0F));
        c[++cx] = (char)(b > 9 ? b - 10 + 'A' : b + '0');
    }

    return new string(c);
}
public static string ByteArrayToHexString(byte[] Bytes)
{
    StringBuilder Result = new StringBuilder(Bytes.Length*2);
    string HexAlphabet = "0123456789ABCDEF";

    foreach (byte B in Bytes)
        {
        Result.Append(HexAlphabet[(int)(B >> 4)]);
        Result.Append(HexAlphabet[(int)(B & 0xF)]);
        }

    return Result.ToString();
}

还有一个类似过程的答案，我还没有比较我们的结果。

我不经常把字节转换成十六进制所以我不知道有没有更好的方法，但这里有一种方法。

StringBuilder sb = new StringBuilder();
foreach (byte b in myByteArray)
    sb.Append(b.ToString("X2"));

string hexString = sb.ToString();

你必须知道以字节表示的字符串的编码，但是你可以说System.Text.UTF8Encoding.GetString(字节)或System.Text.ASCIIEncoding.GetString(字节)。(我是根据记忆做的，所以API可能不完全正确，但它非常接近。)

第二个问题的答案，请看这个问题。

private static string GuidToRaw(Guid guid)
{
    byte[] bytes = guid.ToByteArray();

    int сharCount = bytes.Length * 2;
    char[] chars = new char[сharCount];

    int index = 0;
    for (int i = 0; i < сharCount; i += 2)
    {
        byte b = bytes[index++];
        chars[i] = GetHexValue((int)(b / 16));
        chars[i + 1] = GetHexValue((int)(b % 16));
    }
    return new string(chars, 0, chars.Length);
}

private static char GetHexValue(int i)
{
    return (char)(i < 10 ? i + 48 : i + 55);
}

正如其他人所说，这取决于字节数组中值的编码方式。尽管如此，您还是需要非常小心地处理这类事情，否则您可能会尝试转换未被所选编码处理的字节。

Jon Skeet有一篇关于。net中的编码和unicode的好文章。推荐阅读。