Create a new version of paste:

using System;
using System.IO;
using System.Text;

namespace AlexClarai
{
  class Program
  {
    static void Main(string[] args)
    {
      using (var binaryStream = new BinaryStream())
      {
        binaryStream.Write(true, true, true);
        binaryStream.Write(false, false, false);
        binaryStream.Write(true, true, true);
        binaryStream.Write(false, false, false);
        binaryStream.Write(true, false, true);
        binaryStream.Write(true, true, false);
        binaryStream.Write(true, true, true);
        binaryStream.Write(false, false, false);
        binaryStream.Write(true, true, true);
        binaryStream.Write(false, false, false);
        binaryStream.Write(true, false, true);
        binaryStream.Write(true, true, false);
        binaryStream.Write(true, true);
        binaryStream.Flush();
        Console.WriteLine(binaryStream.ToBitString(true));
        using (var fileStream = new FileStream("C:/bits.bit", FileMode.Create))
        {
          binaryStream.WriteTo(fileStream);
        }
      }
      Console.ReadLine();
    }
  }

  /// <summary>
  /// Stream umožňující zápis jednotlivých bitů.
  /// </summary>
  public class BinaryStream : MemoryStream
  {
    // Pole celých bajtů, které se při naplněné zapíše 
    // a ukazatel na aktuální pozici v něm.
    private byte[] byteBuffer = new byte[32];
    private int byteIndex = 0;

    // Pole bitů (poslední, neúplný bajt), které se při 
    // naplnění zapíše do pole bajtů a ukazatel na 
    // aktuální pozici v něm.
    private byte bitBuffer = 0x00;
    private int bitIndex = 0;

    /// <summary>
    /// Meotda pro zápis jednoho či více samostatných bitů.
    /// </summary>
    /// <param name="bits">Pole bitů pro zápis.</param>
    public void Write(params bool[] bits)
    {
      foreach (var bit in bits)
      {
        // Posuneme bit buffer
        bitBuffer <<= 1;
        if (bit) bitBuffer |= 1;
        else bitBuffer |= 0;
        // Naplněno, zapíšeme bit buffer
        if (bitIndex++ == 7)
        {
          bitIndex = 0;
          // Posuneme byte buffer
          byteBuffer[byteIndex] = bitBuffer;
          // Naplněno, zapíšeme byte buffer
          if (byteIndex++ == byteBuffer.Length - 1)
          {
            byteIndex = 0;
            base.Write(byteBuffer, 0, byteBuffer.Length);
          }
        }
      }
    }
    /// <summary>
    /// Metoda, která zapíše do streamu obsah bufferu bajtů
    /// do aktuální pozice a odsadí do bajtu a zapíše buffer
    /// bitů.
    /// </summary>
    public override void Flush()
    {
      // Zapsat aktuální bajty
      base.Write(byteBuffer, 0, byteIndex);
      // Odsadit a zapsat bity
      base.Write(new byte[] { (byte)(bitBuffer << (8 - bitIndex)) }, 0, 1);
    }

  }

  public static class ExtensionMethods
  {
    /// <summary>
    /// Metoda vypisující v textové podobě binární podobu jednoho
    /// bajtu.
    /// </summary>
    /// <param name="buffer">Bajt k převedení na string.</param>
    /// <returns>Textová reprezentace bajtu.</returns>
    public static string ToBitString(this byte buffer)
    {
      var builder = new StringBuilder();
      for (var i = 128; i > 0; i /= 2)
      {
        builder.Append((buffer & i) == 0 ? '0' : '1');
      }
      return builder.ToString();
    }
    /// <summary>
    /// Metoda vypisující celé pole bajtů v jejich textové podobě,
    /// volitelně oddělené mezerou.
    /// </summary>
    /// <param name="buffer">Pole bajtů k převedení na string.</param>
    /// <param name="delimit">Pravidvostní hodnota určující, zda rozdělit bajty mezerou.</param>
    /// <returns>Textová reprezentace pole bajtů.</returns>
    public static string ToBitString(this byte[] buffer, bool delimit = false)
    {
      var builder = new StringBuilder();
      foreach (var individualBuffer in buffer)
      {
        builder.Append(individualBuffer.ToBitString());
        if (delimit) builder.Append(' ');
      }
      return builder.ToString();
    }
    /// <summary>
    /// Metoda vypisující binární obsah streamu v textové podobě,
    /// volitelně oddělený mezerami po jednom bajtu.
    /// </summary>
    /// <param name="stream">Stream k převedení na string.</param>
    /// <param name="delimit">Pravidvostní hodnota určující, zda rozdělit bajty mezerou.</param>
    /// <returns>Textová reprezentace streamu.</returns>
    /// <remarks>
    /// Určeno k ladění, nepoužívat na dlouhé streamy - čte celý stream najednou!
    /// </remarks>
    public static string ToBitString(this Stream stream, bool delimit = false)
    {
      if (!stream.CanSeek) throw new InvalidOperationException("Stream neumožňuje posouvání, nelze začít číst od počátku streamu.");
      stream.Seek(0, SeekOrigin.Begin);
      var buffer = new byte[stream.Length];
      stream.Read(buffer, 0, buffer.Length);
      stream.Seek(0, SeekOrigin.End);
      return buffer.ToBitString(delimit);
    }
  }
}