0x00 起因
　　近需要处理一些基于比特流的数据，计算机处理数据一般都是以byte（8bit）为单位的，使用BinaryReader读取的数据也是如此，即使读取bool型也是一个byte。不过借助于C#基础类库中提供的一些方法，也实现了对基于比特的数据的读取。任务完成后觉得基于比特的数据挺有意思，自己试了下用7比特和6比特编码常用ASCII字符。后把一点新的写成博客，一方面做个记录，另一方面希望对有类似需求的园友有所帮助。
　　0x01 比特流数据的读取
　　假设我们有一个byte b = 35，而我们需要把其中的前4bit和后4bit分别读取为两个数字，那么应该怎么做呢。虽然没有在基础类库中找到现成的方法，但用二进制字符串中转一下，分两步也可以做到。
　　1、先把b表示为二进制字符串00100011
　　2、分别取其前后4bit转为数字，核心方法是：
　　Convert.ToInt32("0010");
　　这样实现了基于比特的数据读取了。
　　关于第一步中把byte转化为二进制字符串有很多种方法，
　　1、简单的Convert.ToString(b，2)。不够8位在高位用0补足。
　　2、也可以把byte分别与1，2，4，8 … 128做与运算，由低到高取出各位。
　　3、也可以把byte和32做与运算，然后把byte左移再次与128做与运算。
　　其中第一种方法会产生大量的字符串对象，在第2、3种方法没有找到太大区别，我选择的3，纯靠感觉。代码如下：
　　public static char[] ByteToBinString(byte b)
　　{
　　var result = new char[8];
　　for (int i = 0; i < 8; i++)
　　{
　　var temp = b & 128;
　　result[i] = temp == 0 ? '0' : '1';
　　b = (byte)(b << 1);
　　}
　　return result;
　　}
　　为了能将byte[]转化为二进制字符串，可以
　　Public string BitReader(byte[] data)
　　{
　　BinString = new StringBuilder(data.Length * 8);
　　for (int i = 0; i < data.Length;
　　{
　　BinString.Append(ByteToBinString(data[i]));
　　}
　　return BinString.ToString();
　　}
　　这样一来当拿到byte[]数据时，可以转换为二进制字符串保存起来，根据偏移的bit位置和bit长度从中读取二进制字符串，并保转换为bool，Int16，Int32等。基于这个思路，可以写一个BitReader类，其中用StringBuilder存储二进制字符串，并提供Read方法从二进制字符串中读取数据。为了能够更好的处理数据流，在此基础上添加一个Position记录当前偏移，当使用某些Read方法读取数据时，Position也会相应移动。例如使用ReadInt16读取数据，BitReader会从Position当前位置，读取16bit并转换为Int16返回，同时Position向后移动16bit。区分方式是当读取数据时需要指定起始的偏移位置时，Position不移动，直接从当前Position读取时Position移动，BitReader类部分代码如下：
1 public class BitReader
2 {
3     public readonly StringBuilder BinString;
4     public int Position { get; set; }
5
6     public BitReader(byte[] data)
7     {
8         BinString = new StringBuilder(data.Length * 8);
9         for (int i = 0; i < data.Length; i++)
10         {
11             BinString.Append(ByteToBinString(data[i]));
12         }
13         Position = 0;
14     }
15
16     public byte ReadByte(int offset)
17     {
18         var bin = BinString.ToString(offset， 8);
19         return Convert.ToByte(bin， 2);
20     }
21
22     public byte ReadByte()
23     {
24         var result = ReadByte(Position);
25         Position += 8;
26         return result;
27     }
28
29     public int ReadInt(int offset， int bitLength)
30     {
31         var bin = BinString.ToString(offset， bitLength);
32         return Convert.ToInt32(bin， 2);
33     }
34
35     public int ReadInt(int bitLength)
36     {
37         var result = ReadInt(Position， bitLength);
38         Position += bitLength;
39         return result;
40     }
41
42     public static char[] ByteToBinString(byte b)
43     {
44         var result = new char[8];
45         for (int i = 0; i < 8; i++)
46         {
47             var temp = b & 128;
48             result[i] = temp == 0 ? '0' : '1';
49             b = (byte)(b << 1);
50         }
51         return result;
52      }
53 }
　　使用BitReader按照4bit从byte[] buff= {35，12};中读取数据可以这样：
　　var reader = new BitReader(buff); //二进制字符串为0010001100001100
　　var num1 = reader.ReadInt(4);   //从当前Position读取4bit为int，Position移动4bit，结果为2，当前Position=4
　　var num2 = reader.ReadInt(5，6);  //从偏移为5bit的位置读取6bit为int，Position不移动，结果为48，当前Position=4
　　var b = reader.ReadBool();  //从当前Position读取1bit为bool，Position移动1bit，结果为False，当前Position=5
　　0x02 比特流数据的写入
　　把数据写入比特流是一个相反的过程，我们用BitWriter类实现，在其中存储StringBuilder保存二进制字符串，当写入数据时，需要传入数据并指定保存这个数据所需要的bit数。当写入完毕后可以将StringBuilder中保存的二进制字符串按照8bit转换为byte[]并返回。BitWriter的核心部分如下：
1 public class BitWriter
2 {
3     public readonly StringBuilder BinString;
4
5     public BitWriter()
6     {
7         BinString = new StringBuilder();
8     }
9
10     public BitWriter(int bitLength)
11     {
12         var add = 8 - bitLength % 8;
13         BinString = new StringBuilder(bitLength + add);
14     }
15
16     public void WriteByte(byte b， int bitLength=8)
17     {
18         var bin = Convert.ToString(b， 2);
19         AppendBinString(bin， bitLength);
20     }
21
22     public void WriteInt(int i， int bitLength)
23     {
24         var bin = Convert.ToString(i， 2);
25         AppendBinString(bin， bitLength);
26     }
27
28     public void WriteChar7(char c)
29     {
30         var b = Convert.ToByte(c);
31         var bin = Convert.ToString(b， 2);
32         AppendBinString(bin， 7);
33     }
34
35     public byte[] GetBytes()
36     {
37         Check8();
38         var len = BinString.Length / 8;
39         var result = new byte[len];
40
41         for (int i = 0; i < len; i++)
42         {
43             var bits = BinString.ToString(i * 8， 8);
44             result[i] = Convert.ToByte(bits， 2);
45         }
46
47         return result;
48     }
49
50     public string GetBinString()
51     {
52         Check8();
53         return BinString.ToString();
54     }
55
56
57     private void AppendBinString(string bin， int bitLength)
58     {
59         if (bin.Length > bitLength)
60             throw new Exception("len is too short");
61         var add = bitLength - bin.Length;
62         for (int i = 0; i < add; i++)
63         {
64             BinString.Append('0');
65         }
66         BinString.Append(bin);
67     }
68
69     private void Check8()
70     {
71         var add = 8 - BinString.Length % 8;
72         for (int i = 0; i < add; i++)
73         {
74             BinString.Append("0");
75         }
76     }
77 }
　　下面举个简单的例子：
　　var writer = new BitWriter();
　　writer.Write(12，5);  //把12用5bit写入，此时二进制字符串为：01100
　　writer.Write(8，16);  //把8用16bit写入，此时二进制字符串为：011000000000000001000
　　var result = writer.GetBytes(); //8bit对齐为011000000000000001000000
　　//返回结果为[96，0，64]