BinaryReader - Lire un seul «bit»?

Question

Cas :
Essayant à nouveau de capturer des paquets à travers ma Nic,
J'ai développé 2 extensions à utiliser pour capturer le nombre variable de bits

    public static string ReadBits ( this BinaryReader Key , int Value )
    {
        BitArray _BitArray = new BitArray ( Value );

        for ( int Loop = 0 ; Loop > Value ; Loop++ )
        {
/* Problem HERE ---> */   _BitArray [ Loop ] = Key . ReadBoolean ( );
        }

        return BitConverter . ToString ( _BitArray . ToByteArray ( ) );
    }

    public static byte [ ] ToByteArray ( this BitArray Key )
    {
        byte [ ] Value = new byte [ ( int ) Math . Ceiling ( ( double ) Key . Length / 8 ) ];
        Key . CopyTo ( Value , 0 );
        return Value;
    }

Problème :

_BitArray [ Loop ] = Key . ReadBoolean ( );  

Comme j'essaye de lire des bits simples, mais faisant référence à Documentation MSDN,
Il fait avancer la position du flux par 1 octet pas 1 bit !!!

Lit une valeur booléenne à partir du flux actuel et fait avancer la position actuelle du flux par un octet.

Question :
Puis-je vraiment capturer "seulement" 1 bits et faire avancer la position du flux par 1 bit?
Veuillez me suggérer des solutions ou des idées :)

Salutations,

Answer 1

Non, le positionnement du flux est basé sur byte marcher. Vous pouvez écrire votre propre implémentation de flux avec le positionnement des bits.

class BitReader
{
    int _bit;
    byte _currentByte;
    Stream _stream;
    public BitReader(Stream stream)
    { _stream = stream; }

    public bool? ReadBit(bool bigEndian = false)
    {
      if (_bit == 8 ) 
      {

        var r = _stream.ReadByte();
        if (r== -1) return null;
        _bit = 0; 
        _currentByte  = (byte)r;
      }
      bool value;
      if (!bigEndian)
         value = (_currentByte & (1 << _bit)) > 0;
      else
         value = (_currentByte & (1 << (7-_bit))) > 0;

      _bit++;
      return value;
    }
}

Answer 2

Non, il n'est pas possible d'avancer un Stream instance par un bit. La plus petite granularité le Stream Les supports de type sont un byte.

Tu pourrais écrire un emballage autour Stream qui fournit une granularité à un bit en manipulant et en mettant en cache le mouvement d'un octet.

class BitStream { 
  private Stream _stream;
  private byte _current;
  private int _index = 8;


  public byte ReadBit() {
    if (_index >= 8) {
      _current = _stream.ReadByte();
      _index = 0;
    }
    return (_current >> _index++) & 0x1;
  }
}

Remarque: Cela lira l'octet du côté droit en bits. Si vous vouliez lire depuis la gauche, vous auriez besoin de changer le return tapisser un peu

Answer 3

Lisez 1 octet et le cachet à un tableau de bool à 8 éléments en utilisant des masques bits