如何从 Stream 写入/读取位？ （C＃）

Question

How can I write bits to a stream (System.IO.Stream) or read in C#? thanks.

Answer 1

You could create an extension method on Stream that enumerates the bits, like this:

public static class StreamExtensions
{
    public static IEnumerable<bool> ReadBits(this Stream input)
    {
        if (input == null) throw new ArgumentNullException("input");
        if (!input.CanRead) throw new ArgumentException("Cannot read from input", "input");
        return ReadBitsCore(input);
    }

    private static IEnumerable<bool> ReadBitsCore(Stream input)
    {
        int readByte;
        while((readByte = input.ReadByte()) >= 0)
        {
            for(int i = 7; i >= 0; i--)
                yield return ((readByte >> i) & 1) == 1;
        }
    }
}

Using this extension method is easy:

foreach(bool bit in stream.ReadBits())
{
    // do something with the bit
}

Answer 2

This is not possible with the default stream class. The C# (BCL) Stream class operates on the granularity of bytes at it's lowest level. What you can do is write a wrapper class which reads bytes and partititions them out to bits.

For example:

class BitStream : IDisposable {
  private Stream m__stream;
  private byte? m_current;
  private int m_index;
  public byte ReadNextBit() { 
    if ( !m_current.HasValue ) {
      m_current = ReadNextByte();
      m_index = 0;
    }
    var value = (m_byte.Value >> m_index) & 0x1;
    m_index++;
    if (m_index == 8) {
      m_current = null;
    }
    return value;
  }
  private byte ReadNextByte() {
    ...
  }
  // Dispose implementation omitted
}

Note: This will read the bits in right to left fashion which may or may not be what you're intending.

Answer 3

If you need to retrieve separate sections of your byte stream a few bits at a time, you need to remember the position of the bit to read next between calls. The accepted answer here does not do that, so each call to the enumerator will start on the next byte of input each time. The following extension method for Stream takes care of caching the current byte and the bit position within it between calls.

// Binary MSB-first bit enumeration.
public static class StreamExtensions
{
    static int buffer;
    static int bitPos = -1;

    public static IEnumerable<bool> ReadBits(this Stream input)
    {
        do
        {
            while (bitPos >= 0)
            {
                yield return (buffer & (1 << bitPos--)) > 0;
            }
            // Exhausted all bits, so read the next byte from the stream.
            buffer = input.ReadByte();
            bitPos = 7;  
        } while (buffer > -1);
    }
}

Answer 4

For your purpose, I wrote an easy-to-use, fast and open-source (MIT license) library for this, called "BitStream", which is available at github ( https://github.com/martinweihrauch/BitStream ).

In this example, you can see how 5 unsigned integers, which can be represented with 6 bits (all below the value 63) are written with 6 bits each to a stream and then read back. Please note that the library takes and returns long or ulong values for the ease of it, so just convert your eg int, uint, etc to long/ulong first.

using SharpBitStream;

uint[] testDataUnsigned = { 5, 62, 17, 50, 33 };
var ms = new MemoryStream();
var bs = new BitStream(ms);
Console.WriteLine("Test1: \r\nFirst testing writing and reading small numbers of a max of 6 bits.");

Console.WriteLine("There are 5 unsigned ints , which shall be written into 6 bits each as they are all small than 64: 5, 62, 17, 50, 33");
foreach(var bits in testDataUnsigned)
{
    bs.WriteUnsigned(6, (ulong)bits);
}

Console.WriteLine("The original data are of the size: " + testDataUnsigned.Length + " bytes. The size of the stream is now: " + ms.Length + " bytes\r\nand the bytes in it are: ");

ms.Position = 0;

Console.WriteLine("The resulting bytes in the stream look like this: ");
for (int i = 0; i < ms.Length; i++)
{
    uint bits = (uint)ms.ReadByte();
    Console.WriteLine("Byte #" + Convert.ToString(i).PadLeft(4, '0') + ": " + Convert.ToString(bits, 2).PadLeft(8, '0'));
}

Console.WriteLine("\r\nNow reading the bits back:");
ms.Position = 0;
bs.SetPosition(0, 0);

foreach (var bits in testDataUnsigned)
{
    ulong number = (uint)bs.ReadUnsigned(6);
    Console.WriteLine("Number read: " + number);
}