1 原理分析

先来看一下 Huffman 编码和解码的基本原理：

1.1 编码

1. 统计频率

   • 遍历待编码的字符串 / 字节数组，统计每个字符 / 字节出现的频率

2. 构建 Huffman 树

   • 将每个字符和其频率作为节点
   • 使用优先队列 (最小堆) 来构建 Huffman 树。
   • 每次取出频率最小的两个节点，合并成一个新节点，直到只剩下一个节点

3. 生成编码

   • 从根节点开始，遍历树，左子节点为 0，右子节点为 1，直到叶节点
   • 记录每个字符的编码

4. 替换

   • 使用生成的编码替换原字符串中的字符

1.2 解码

1. 构建 Huffman 树

   • 使用编码时生成的树结构

2. 遍历编码

   • 从根节点开始，根据编码的 0 和 1 走左子节点或右子节点
   • 到达叶节点时，将对应字符 / 字节添加到结果中，并返回根节点继续遍历

3. 重复直到遍历完整个编码

2 具体实现

先列举我们需要的几个类：

• BitStream：用于处理位流的类
• HuffmanNode：表示 Huffman 树的节点
• PriorityQueue：优先队列

其中，PriorityQueue 在 .NET 6 及以上版本中已经有了，我们可以直接使用。另外两个类需要我们自己实现。

2.1 BitStream

BitStream 的主要功能是处理位流的读写，通过维护一个 underlying Stream，记录当前缓存的字节、当前位的位置和移位实现。

Huffman 需要的是 MSB (Most Significant Bit) 顺序的位流，我们这里把二者 (MSB、LSB) 都实现了。

BitStream.cs

2.2 HuffmanNode

HuffmanNode 包含以下属性：父节点、左右节点、该节点的值 (字符 / 字节)、该节点的频率、对应的编码 (可选)。

对于编码的表示，思来想去还是 bool[] 最合适。

同时注意到，构造节点有两种情况：

• 通过频率和字符 / 字节构造叶节点
• 通过左右子节点构造非叶节点

因此需要两个构造函数。而且显然，构造时即可确定该节点是否为叶节点，后续无需变动。

HuffmanNode.cs

2.3 PriorityQueue

在高版本 .NET 中，可以直接使用 System.Collections.Generic.PriorityQueue<TElement, TPriority>。

在低版本 .NET 中，我们可以自行用最小堆实现一个简易的优先队列。

此处实现遵循 .NET Framework 4.8 的语法。

PriorityQueue.cs

构造函数中需要传入一个比较器 IComparer<T>，用于比较节点的优先级：

HuffmanNodeComparer.cs

使用独立的比较器而不是让 HuffmanNode 实现 IComparable<HuffmanNode> ，是为了保证 HuffmanNode 在不同版本间的一致性。

2.4 HuffmanCompression

接下来是 Huffman 编码和解码的核心类 HuffmanCompression。

2.4.1 编码

1. 统计频率

   csharp

   int[] freqs = new int[256];
   foreach (byte b in data)
   {
       freqs[b]++;
   }

   freqs 数组的索引是字节值，值是该字节出现的频率。

2. 构建 Huffman 树

   使用内置的 PriorityQueue 来构建 Huffman 树：

   csharp

   private HuffmanNode BuildTree(int[] freqs)
   {
       PriorityQueue<HuffmanNode, int> queue = new();
       for (int i = 0; i < freqs.Length; i++)
       {
           if (freqs[i] > 0)
           {
               queue.Enqueue(new(freqs[i], (byte)i), freqs[i]);
           }
       }
       while (queue.Count > 1)
       {
           HuffmanNode left = queue.Dequeue();
           HuffmanNode right = queue.Dequeue();
           HuffmanNode parent = new(left, right);
           queue.Enqueue(parent, parent.Frequency);
       }
       return queue.Count > 0 ? queue.Dequeue() : null;
   }

   for 循环中构造所有叶节点，并将它们加入优先队列。然后通过不断取出频率最小的两个节点，合并成一个新节点，直到只剩下一个节点。频率的加和与叶节点的判断均在 HuffmanNode 的构造函数中完成。

   使用自定义的 PriorityQueue 大同小异：

   csharp

   private HuffmanNode BuildTree(int[] freqs)
   {
       PriorityQueue<HuffmanNode> queue = new PriorityQueue<HuffmanNode>(new HuffmanNodeComparer());
       for (int i = 0; i < freqs.Length; i++)
       {
           if (freqs[i] > 0)
           {
               queue.Enqueue(new HuffmanNode(freqs[i], (byte)i));
           }
       }
       while (queue.Count > 1)
       {
           HuffmanNode left = queue.Dequeue();
           HuffmanNode right = queue.Dequeue();
           HuffmanNode parent = new HuffmanNode(left, right);
           queue.Enqueue(parent);
       }
       return queue.Count > 0 ? queue.Dequeue() : null;
   }

3. 生成编码

   用一个字典存储字节值和对应的编码。

   如果当前节点是叶节点，则从该节点开始向上遍历，记录路径上的 0 和 1，直到到达根节点。将路径反转即为该字节的编码。

   csharp

   private void GenerateCodes(HuffmanNode node, Dictionary<byte, bool[]> codeTable)
   {
       if (node == null)
       {
           return;
       }
   
       HuffmanNode current;
       if (node.IsLeaf)
       {
           List<bool> code = [];
           current = node;
           while (!current.IsRoot)
           {
               code.Add(current.Bit);
               current = current.Parent;
           }
           code.Reverse();
           codeTable[node.Value] = [.. code];
       }
       else
       {
           if (node.LeftChild != null)
           {
               GenerateCodes(node.LeftChild, codeTable);
           }
           if (node.RightChild != null)
           {
               GenerateCodes(node.RightChild, codeTable);
           }
       }
   }

4. 写入树

   为了在解码时能够重建 Huffman 树，我们需要将树结构序列化到输出流中。可以使用前序遍历的方式来写入树。

   csharp

   private void WriteTree(HuffmanNode node)
   {
       if (node.IsLeaf)
       {
           input.WriteBit(0);
           input.WriteBits(node.Value);
       }
       else
       {
           input.WriteBit(1);
           WriteTree(node.LeftChild);
           WriteTree(node.RightChild);
       }
   }

5. 替换

   这一步就简单了，遍历原数据，将每个字节替换为对应的编码。

   csharp

   foreach (byte b in data)
   {
       if (codeTable.TryGetValue(b, out bool[] code))
       {
           input.WriteBits(code);
       }
       else
       {
           throw new InvalidDataException($"No code found for byte {b}.");
       }
   }

2.4.2 解码

有一个很巧的思路：字节的取值是 0~255，因此我们可以直接拿一个二维数组 ushort[512, 2]：

第一位表示字节值 (<256) 或父节点的索引 (>=256)，第二位表示左右子节点。

1. 读取树

   csharp

   private const ushort MAX = 512;
   private ushort index = 256;
   private readonly ushort[,] children = new ushort[MAX, 2];
   
   private ushort RebuildTree()
   {
       switch (input.ReadBit())
       {
           case 0:
               return (ushort)input.ReadBits(8);
           case 1:
               ushort parent = index++;
               if (parent >= MAX)
               {
                   throw new InvalidDataException("Exceeded huffman tree.");
               }
               children[parent, 0] = RebuildTree();
               children[parent, 1] = RebuildTree();
               return parent;
           default:
               throw new InvalidDataException("Invalid bit.");
       }
   }

2. 解码

   这种表示的好处在于判断是否为叶节点非常简单：如果索引小于 256，则是叶节点，且该值即为字节值；如果索引大于等于 256，则是非叶节点，且可以通过 children 数组获取左右子节点。

   csharp

   public MemoryStream Decompress()
   {
       if (mode != CompressionMode.Decompress)
       {
           throw new InvalidOperationException("Not in decompression mode.");
       }
   
       ushort root = RebuildTree();
       while (output.Length != decompressedLength)
       {
           ushort node = root;
           while (node >= 256)                 // Keep reading bits until we reach a leaf node
           {
               int bit = input.ReadBit();
               if (bit != -1)
               {
                   node = children[node, bit]; // Traverse the tree based on the bit read
               }
           }
           output.WriteByte((byte)node);
       }
       return output;
   }

3 完整代码

见 https://github.com/detached64/Huffman。

1 字节数组转十六进制字符串

1.1 手动实现

public static string ByteArrayToHexString(byte[] bytes)
{
    StringBuilder sb = new StringBuilder();
    foreach (byte b in bytes)
    {
        sb.Append(b.ToString("x2"));
    }
    return sb.ToString();
}

1.2 手动实现优化

public static string ByteArrayToHexString(byte[] bytes)
{
    char[] c = new char[bytes.Length * 2];
    byte b;
    for (int i = 0; i < bytes.Length; i++)
    {
        b = ((byte)(bytes[i] >> 4));
        c[i * 2] = (char)(b > 9 ? b + 0x37 : b + 0x30);
        b = ((byte)(bytes[i] & 0xF));
        c[i * 2 + 1] = (char)(b > 9 ? b + 0x37 : b + 0x30);
    }
    return new string(c);
}

1.3 使用 BitConverter

public static string ByteArrayToHexString(byte[] bytes)
{
    return BitConverter.ToString(bytes).Replace("-", "");
}

1.4 使用 Convert.ToHexString (限.NET 5+)

string hex = Convert.ToHexString(bytes);

1.5 使用 SoapHexBinary (限.NET Framework)

string hex = new SoapHexBinary(bytes).ToString();

1.6 性能测试与比较

我们使用 BenchmarkDotNet 在.NET 9.0 和.NET Framework 4.8 上对上述方法进行性能测试。

1.6.1 .NET 9.0

测试代码：

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System.Text;

namespace BenchMarkerNet9
{
    public class Program
    {
        private static void Main(string[] args)
        {
            var summary = BenchmarkRunner.Run<Benchmarker>();
        }
    };

    [MemoryDiagnoser]
    public class Benchmarker
    {
        public byte[] bytes = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10 };

        [Benchmark]
        public string ByteArrayToHexString1()
        {
            StringBuilder sb = new StringBuilder();
            foreach (byte b in bytes)
            {
                sb.Append(b.ToString("x2"));
            }
            return sb.ToString();
        }

        [Benchmark]
        public string ByteArrayToHexString2()
        {
            char[] c = new char[bytes.Length * 2];
            byte b;
            for (int i = 0; i < bytes.Length; i++)
            {
                b = ((byte)(bytes[i] >> 4));
                c[i * 2] = (char)(b > 9 ? b + 0x37 : b + 0x30);
                b = ((byte)(bytes[i] & 0xF));
                c[i * 2 + 1] = (char)(b > 9 ? b + 0x37 : b + 0x30);
            }
            return new string(c);
        }

        [Benchmark]
        public string ByteArrayToHexString3()
        {
            return BitConverter.ToString(bytes).Replace("-", string.Empty);
        }

        [Benchmark]
        public string ByteArrayToHexString4()
        {
            return Convert.ToHexString(bytes);
        }
    }
}

测试结果如下：

| Method                | Mean      | Error    | StdDev   | Gen0   | Allocated |
|---------------------- |----------:|---------:|---------:|-------:|----------:|
| ByteArrayToHexString1 | 156.29 ns | 2.677 ns | 4.006 ns | 0.0429 |     808 B |
| ByteArrayToHexString2 |  22.63 ns | 0.475 ns | 0.650 ns | 0.0093 |     176 B |
| ByteArrayToHexString3 | 156.63 ns | 0.864 ns | 0.808 ns | 0.0110 |     208 B |
| ByteArrayToHexString4 |  11.45 ns | 0.262 ns | 0.408 ns | 0.0047 |      88 B |

• Mean : Arithmetic mean of all measurements 平均值
• Error : Half of 99.9% confidence interval 误差
• StdDev : Standard deviation of all measurements 方差
• Gen0 : GC Generation 0 collects per 1000 operations 第 0 代 GC 次数
• Allocated : Allocated memory per single operation (managed only, inclusive, 1KB = 1024B) 分配的内存
• 1 ns : 1 Nanosecond (0.000000001 sec) 纳秒

可见，Convert.ToHexString 是最快的，手动实现优化次之，BitConverter 和手动实现性能很差。

1.6.2 .NET Framework 4.8

测试代码：

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System;
using System.Runtime.Remoting.Metadata.W3cXsd2001;
using System.Text;

namespace BenchMarker480
{
    public class Program
    {
        private static void Main(string[] args)
        {
            var summary = BenchmarkRunner.Run<Benchmarker>();
        }
    };

    [MemoryDiagnoser]
    public class Benchmarker
    {
        public byte[] bytes = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10 };

        [Benchmark]
        public string ByteArrayToHexString1()
        {
            StringBuilder sb = new StringBuilder();
            foreach (byte b in bytes)
            {
                sb.Append(b.ToString("x2"));
            }
            return sb.ToString();
        }

        [Benchmark]
        public string ByteArrayToHexString2()
        {
            char[] c = new char[bytes.Length * 2];
            byte b;
            for (int i = 0; i < bytes.Length; i++)
            {
                b = ((byte)(bytes[i] >> 4));
                c[i * 2] = (char)(b > 9 ? b + 0x37 : b + 0x30);
                b = ((byte)(bytes[i] & 0xF));
                c[i * 2 + 1] = (char)(b > 9 ? b + 0x37 : b + 0x30);
            }
            return new string(c);
        }

        [Benchmark]
        public string ByteArrayToHexString3()
        {
            return BitConverter.ToString(bytes).Replace("-", string.Empty);
        }

        [Benchmark]
        public string ByteArrayToHexString4()
        {
            return new SoapHexBinary(bytes).ToString();
        }
    }
}

测试结果如下：

| Method                | Mean      | Error     | StdDev    | Median    | Gen0   | Allocated |
|---------------------- |----------:|----------:|----------:|----------:|-------:|----------:|
| ByteArrayToHexString1 | 539.00 ns | 22.907 ns | 67.543 ns | 513.00 ns | 0.1035 |     545 B |
| ByteArrayToHexString2 |  37.79 ns |  0.656 ns |  0.613 ns |  37.91 ns | 0.0297 |     156 B |
| ByteArrayToHexString3 | 194.82 ns |  2.988 ns |  3.557 ns | 194.53 ns | 0.0565 |     296 B |
| ByteArrayToHexString4 | 339.67 ns |  5.352 ns |  4.745 ns | 340.74 ns | 0.1135 |     597 B |

可见，手动实现优化是最快的，BitConverter 次之，SoapHexBinary 和手动实现性能很差。

1.7 结论

• Convert.ToHexString 是最快的，假设你的项目是.NET 5+，推荐使用。
• 如果你的项目是.NET 5 以下，推荐使用手动实现优化。
• 纵向对比会发现，.NET 9 的 StringBuilder 和 BitConverter 性能比.NET framework 4.8 有较大提升。

1.8 注意

• byte 数组有一个扩展方法 ToString()，但是它返回的是 "System.Byte[]"。这是因为 System.Byte 继承自 System.Object，而 System.Object 有一个 ToString() 方法，且 System.Byte 没有重写这个方法。同样，Console.WriteLine(bytes) 也会返回 System.Byte[]。
• 不可以使用 Encoding.xxx.GetString(bytes)，因为这个方法会将字节数组按照指定的编码转换成字符串，而不是转换为十六进制字符串。
• 将 byte 数组写入 json 或其他文本文件时，建议使用 Convert.ToBase64String(bytes)，不建议使用 hex string。

2 十六进制字符串转字节数组

2.1 手动实现

public static byte[] HexStringToByteArray(string hex)
{
    byte[] bytes = new byte[hex.Length / 2];
    for (int i = 0; i < hex.Length; i += 2)
    {
        bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
    }
    return bytes;
}

2.2 基于 Linq 的实现

public static byte[] HexStringToByteArray(string hex)
{
    return Enumerable.Range(0, hex.Length)
                     .Where(x => x % 2 == 0)
                     .Select(x => Convert.ToByte(hex.Substring(x, 2), 16))
                     .ToArray();
}

2.3 使用 Convert.FromHexString (限.NET 5+)

public static byte[] HexStringToByteArray(string hex)
{
    return Convert.FromHexString(hex);
}

2.4 使用 SoapHexBinary (限.NET Framework)

public static byte[] HexStringToByteArray(string hex)
{
    return new SoapHexBinary(hex).Value;
}

2.5 性能测试与比较

环境同上。

2.5.1 .NET 9.0

测试代码：

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

namespace BenchMarkerNet9
{
    public class Program
    {
        private static void Main(string[] args)
        {
            var summary = BenchmarkRunner.Run<Benchmarker>();
        }
    };

    [MemoryDiagnoser]
    public class Benchmarker
    {
        public string hex = "0102030405060708090A0B0C0D0E0F10";

        [Benchmark]
        public byte[] HexToBytes1()
        {
            byte[] bytes = new byte[hex.Length / 2];
            for (int i = 0; i < hex.Length; i += 2)
            {
                bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
            }
            return bytes;
        }

        [Benchmark]
        public byte[] HexToBytes2()
        {
            return Enumerable.Range(0, hex.Length)
                .Where(x => x % 2 == 0)
                .Select(x => Convert.ToByte(hex.Substring(x, 2), 16))
                .ToArray();
        }

        [Benchmark]
        public byte[] HexToBytes3()
        {
            return Convert.FromHexString(hex);
        }
    }
}

测试结果如下：

| Method      | Mean       | Error     | StdDev     | Gen0   | Allocated |
|------------ |-----------:|----------:|-----------:|-------:|----------:|
| HexToBytes1 | 172.904 ns | 8.5000 ns | 25.0625 ns | 0.0293 |     552 B |
| HexToBytes2 | 200.896 ns | 3.9337 ns |  5.7660 ns | 0.0410 |     776 B |
| HexToBytes3 |   7.851 ns | 0.1848 ns |  0.2270 ns | 0.0021 |      40 B |

可见，Convert.FromHexString 是最快的，手动实现和基于Linq的实现性能很差。

2.5.2 .NET Framework 4.8

测试代码：

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System;
using System.Linq;
using System.Runtime.Remoting.Metadata.W3cXsd2001;

namespace BenchMarker480
{
    public class Program
    {
        private static void Main(string[] args)
        {
            var summary = BenchmarkRunner.Run<Benchmarker>();
        }
    };

    [MemoryDiagnoser]
    public class Benchmarker
    {
        public string hex = "0102030405060708090A0B0C0D0E0F10";

        [Benchmark]
        public byte[] HexToBytes1()
        {
            byte[] bytes = new byte[hex.Length / 2];
            for (int i = 0; i < hex.Length; i += 2)
            {
                bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
            }
            return bytes;
        }

        [Benchmark]
        public byte[] HexToBytes2()
        {
            return Enumerable.Range(0, hex.Length)
                .Where(x => x % 2 == 0)
                .Select(x => Convert.ToByte(hex.Substring(x, 2), 16))
                .ToArray();
        }

        [Benchmark]
        public byte[] HexToBytes3()
        {
            return SoapHexBinary.Parse(hex).Value;
        }
    }
}

测试结果如下：

| Method      | Mean       | Error    | StdDev   | Gen0   | Allocated |
|------------ |-----------:|---------:|---------:|-------:|----------:|
| HexToBytes1 |   414.5 ns | 13.73 ns | 40.48 ns | 0.0663 |     349 B |
| HexToBytes2 |   586.6 ns |  3.08 ns |  2.57 ns | 0.0992 |     525 B |
| HexToBytes3 | 1,285.0 ns | 18.47 ns | 17.27 ns | 0.3071 |    1610 B |

可见，手动实现是最快的，基于Linq的实现次之，SoapHexBinary 性能很差。

2.6 结论

• Convert.FromHexString 是最快的，假设你的项目是.NET 5+，推荐使用。
• 如果你的项目是.NET 5 以下，推荐使用手动实现。
• 纵向对比会发现，.NET 9 的手动实现性能和 Linq 性能比.NET framework 4.8 有较大提升。

3 参考

• stackoverflow-how-do-you-convert-byte-array-to-hexadecimal-string-and-vice-versa