如何将字节数组拆分为指定比特长度的二进制块？

需求概述 #

需要完成以下操作：

• 读取二进制文件foo.bin内容到byte数组：

  byte[] data = File.ReadAllBytes("foo.bin");
  

• 将该byte数组拆分为每个块长度为x比特的二进制块，可使用自定义结构体BinaryChunk，期望实现方法：

  BinaryChunk[] binaryChunks = SplitDataIntoBinaryChunksOfSize(data, x);
  

自定义结构体定义：

struct BinaryChunk { 
    public bool[] data;
    public int size;
}

示例说明（简写方法名为SplitData） #

// 输入数据（示例用byte值模拟比特流）
byte[] foo = new byte[]{0b11100110, 0b00010110};
SplitData(foo, 3) // 输出块：111, 001, 100, 001, 011, 000
// 原数据比特流：1 1 1 0 0 1 1 0;0 0 0 1 0 1 1 0
// 拆分后：1 1 1;0 0 1;1 0 0;0 0 1;0 1 1;0 0 0

SplitData(foo, 12) // 输出块：111001100001, 011000000000
// 原数据比特流：1 1 1 0 0 1 1 0;0 0 0 1 0 1 1 0
// 拆分后：1 1 1 0 0 1 1 0 0 0 0 1;0 1 1 0 0 0 0 0 0 0 0 0

基于BitArray的优化实现 #

利用.NET自带的BitArray可以直接按索引访问每一位的特性，能实现时间复杂度O(n)、空间复杂度O(n)的高效方案，代码如下：

using System.Collections;

struct BinaryChunk { 
    public bool[] data;
    public int size;
}

BinaryChunk[] SplitDataIntoBinaryChunksOfSize(byte[] data, int chunkBitSize)
{
    if (chunkBitSize <= 0)
        throw new ArgumentException("Chunk bit size must be positive");
    
    BitArray bitArray = new BitArray(data);
    int totalBits = bitArray.Length;
    // 向上取整计算总块数，避免遗漏最后一块不足比特的情况
    int chunkCount = (totalBits + chunkBitSize - 1) / chunkBitSize;
    BinaryChunk[] chunks = new BinaryChunk[chunkCount];
    
    for (int i = 0; i < chunkCount; i++)
    {
        int startBit = i * chunkBitSize;
        int currentChunkBitCount = Math.Min(chunkBitSize, totalBits - startBit);
        bool[] chunkData = new bool[currentChunkBitCount];
        
        // 从BitArray中逐位复制对应比特到块数组
        for (int j = 0; j < currentChunkBitCount; j++)
        {
            // BitArray索引与比特位的对应：byte的最高位对应索引0，最低位对应索引7，与示例逻辑匹配
            chunkData[j] = bitArray[startBit + j];
        }
        
        chunks[i] = new BinaryChunk { data = chunkData, size = currentChunkBitCount };
    }
    
    return chunks;
}

代码说明 #

• BitArray自动将byte数组转换为可按位访问的集合，无需手动处理比特移位、字节拼接等细节
• 通过(totalBits + chunkBitSize - 1) / chunkBitSize向上取整计算总块数，确保所有比特都被拆分
• 遍历过程仅做一次逐位复制，时间复杂度为O(totalBits)（即O(n)，n为原byte数组长度），性能远优于临时实现的O(n²)

临时实现的问题 #

你提供的临时实现通过自定义BinaryStream类处理比特拆分，但存在以下不足：

• 时间复杂度高：MoveBytes方法每次创建新数组并拷贝数据，数据量大时性能损耗明显
• 代码冗余：需要手动处理比特移位、字节拼接等底层操作，容易出现逻辑漏洞

而基于BitArray的实现更简洁、高效，且符合.NET框架的设计规范。

内容的提问来源于stack exchange，提问作者Mickey