两个mashup，将两个半字节操作合并为一个。

可能非常有效的版本：

public static string ByteArrayToString2(byte[] ba)
{
    char[] c = new char[ba.Length * 2];
    for( int i = 0; i < ba.Length * 2; ++i)
    {
        byte b = (byte)((ba[i>>1] >> 4*((i&1)^1)) & 0xF);
        c[i] = (char)(55 + b + (((b-10)>>31)&-7));
    }
    return new string( c );
}

Decadent linq与比特黑客版本：

public static string ByteArrayToString(byte[] ba)
{
    return string.Concat( ba.SelectMany( b => new int[] { b >> 4, b & 0xF }).Select( b => (char)(55 + b + (((b-10)>>31)&-7))) );
}

并反转：

public static byte[] HexStringToByteArray( string s )
{
    byte[] ab = new byte[s.Length>>1];
    for( int i = 0; i < s.Length; i++ )
    {
        int b = s[i];
        b = (b - '0') + ((('9' - b)>>31)&-7);
        ab[i>>1] |= (byte)(b << 4*((i&1)^1));
    }
    return ab;
}

这是我的尝试。我创建了一对扩展类来扩展字符串和字节。在大文件测试中，性能与Byte Manipulation 2相当。

下面的ToHexString代码是查找和移位算法的优化实现。它与Behrooz的方法几乎相同，但使用foreach进行迭代，计数器比显式索引更快。

在我的机器上，它排在Byte Manipulation 2之后，排在第二位，是非常可读的代码。以下测试结果也值得关注：

ToHexStringCharArrayWithCharArrayLookup：41589.69平均刻度（超过1000次），1.5倍ToHexStringCharArrayWithStringLookup:50764.06平均滴答（超过1000次），1.2XToHexStringStringBuilderWithCharArrayLookup:62812.87平均滴答（超过1000次），1.0X

根据上述结果，可以得出以下结论：

索引到字符串以执行查找与char数组在大型文件测试中非常重要。使用已知容量的StringBuilder与使用字符的惩罚创建字符串的已知大小的数组甚至更重要。

代码如下：

using System;

namespace ConversionExtensions
{
    public static class ByteArrayExtensions
    {
        private readonly static char[] digits = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };

        public static string ToHexString(this byte[] bytes)
        {
            char[] hex = new char[bytes.Length * 2];
            int index = 0;

            foreach (byte b in bytes)
            {
                hex[index++] = digits[b >> 4];
                hex[index++] = digits[b & 0x0F];
            }

            return new string(hex);
        }
    }
}


using System;
using System.IO;

namespace ConversionExtensions
{
    public static class StringExtensions
    {
        public static byte[] ToBytes(this string hexString)
        {
            if (!string.IsNullOrEmpty(hexString) && hexString.Length % 2 != 0)
            {
                throw new FormatException("Hexadecimal string must not be empty and must contain an even number of digits to be valid.");
            }

            hexString = hexString.ToUpperInvariant();
            byte[] data = new byte[hexString.Length / 2];

            for (int index = 0; index < hexString.Length; index += 2)
            {
                int highDigitValue = hexString[index] <= '9' ? hexString[index] - '0' : hexString[index] - 'A' + 10;
                int lowDigitValue = hexString[index + 1] <= '9' ? hexString[index + 1] - '0' : hexString[index + 1] - 'A' + 10;

                if (highDigitValue < 0 || lowDigitValue < 0 || highDigitValue > 15 || lowDigitValue > 15)
                {
                    throw new FormatException("An invalid digit was encountered. Valid hexadecimal digits are 0-9 and A-F.");
                }
                else
                {
                    byte value = (byte)((highDigitValue << 4) | (lowDigitValue & 0x0F));
                    data[index / 2] = value;
                }
            }

            return data;
        }
    }
}

下面是当我将代码放在我机器上的@patridge测试项目中时得到的测试结果。我还添加了一个从十六进制转换为字节数组的测试。使用我的代码的测试运行是ByteArrayToHexViaOptimizedLookupAndShift和HexToByteArrayViaByteManipulation。HexToByteArrayViaConvertToByte取自XXXX。HexToByteArrayViaSoapHexBinary是@Mykroft的答案。

Intel Pentium III Xeon处理器核心：4<br/>当前时钟速度：1576<br/>最大时钟速度：3092<br/>将字节数组转换为十六进制字符串表示ByteArrayToHexViaByteManipulation2:39366.64平均滴答（超过1000次），22.4倍ByteArrayToHexViaOptimizedLookupAndShift：41588.64平均刻度（超过1000次），21.2倍ByteArrayToHexViaLookup：55509.56次平均点击（超过1000次），15.9倍ByteArrayToHexViaByteManipulation:65349.12平均刻度（超过1000次），13.5XByteArrayToHexViaLookupAndShift：86926.87平均刻度（超过1000运行），10.2XByteArrayToHexStringViaBitConverter:平均139353.73滴答声（超过1000次），6.3XByteArrayToHexViaSoapHexBinary：314598.77平均刻度（超过1000次），2.8XByteArrayToHexStringViaStringBuilderForEachByteToString:344264.63平均刻度（超过1000次），2.6XByteArrayToHexStringViaStringBuilderAggregateByteToString:382623.44平均滴答声（超过1000次），2.3XByteArrayToHexStringViaStringBuilderForEachAppend格式：818111.95平均滴答声（超过1000次），1.1倍ByteArrayToHexStringViaStringConcatArray ConvertAll:839424.84平均值滴答声（超过1000次），1.1XByteArrayToHexStringViaStringBuilderAggregateAppend格式：867303.98平均刻度（超过1000次），1.0XByteArrayToHexStringViaStringJoinArray ConvertAll:平均882710.28滴答声（超过1000次），1.0X

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

static string ByteArrayToHexViaLookupPerByte2(byte[] bytes)
{                
        var result3 = new uint[bytes.Length];
        for (int i = 0; i < bytes.Length; i++)
                result3[i] = _Lookup32[bytes[i]];
        var handle = GCHandle.Alloc(result3, GCHandleType.Pinned);
        try
        {
                var result = Marshal.PtrToStringUni(handle.AddrOfPinnedObject(), bytes.Length * 2);
                return result;
        }
        finally
        {
                handle.Free();
        }
}

在我的测试中，这个函数总是不安全实现之后的第二个条目。

不幸的是，测试台不太可靠。。。如果你多次运行它，列表会被打乱，以至于谁知道在不安全之后哪个才是最快的！它没有考虑预热、jit编译时间和GC性能影响。我很想重写它以获得更多信息，但我真的没有时间。

扩展BigInteger方法（Gregory Morse在上面提到过）。我不能评论效率，它使用System.Linq.Reverse（），但它很小而且内置。

        // To hex
        byte[] bytes = System.Text.Encoding.UTF8.GetBytes("Test String!£");
        string hexString = new System.Numerics.BigInteger(bytes.Reverse().ToArray()).ToString("x2");

        // From hex
        byte[] fromHexBytes = System.Numerics.BigInteger.Parse(hexString, System.Globalization.NumberStyles.HexNumber).ToByteArray().Reverse().ToArray();

        // Unit test
        CollectionAssert.AreEqual(bytes, fromHexBytes);

有一个简单的一行解决方案尚未提及，它将十六进制字符串转换为字节数组（我们不在乎这里的否定解释，因为这无关紧要）：

BigInteger.Parse(str, System.Globalization.NumberStyles.HexNumber).ToByteArray().Reverse().ToArray();