System.IO.FileStream file = null;
using (file)
{
    file = System.IO.File.OpenRead("some.bin");
}

R>System.IO.FileStream file = null;
R>using (file)
R>{
R>    file = System.IO.File.OpenRead("some.bin");
R>}
R>

FileStream file = null;
FileStream file1 = file;
try{
  file = System.IO.File.OpenRead("some.bin");
}
finaly{
  ((IDisposable)file1).Dispose();
}

warning CS0728: Possibly incorrect assignment to local 'file' which is the argument to a using or lock statement. The Dispose call or unlocking will happen on the original value of the local.

    class InboundMessageBuffer : IDisposable
    {
        public int Read(byte[] data, int offset, int count)
        {
            return _stream.Read(data, offset, count);
        }

        public void PushInboundMessage(byte[] bytes)
        {
            // Вот так элегантно освобождается старый буфер и создается новый 
            using (_stream)
                _stream = new MemoryStream(bytes);
        }

        public void Dispose()
        {
            using (_stream)
            { }
        }
        #region Implementation
        MemoryStream _stream;
        #endregion
    };

R>    class InboundMessageBuffer : IDisposable
R>    {
R>        public int Read(byte[] data, int offset, int count)
R>        {
R>            return _stream.Read(data, offset, count);
R>        }

R>        public void PushInboundMessage(byte[] bytes)
R>        {
R>            // Вот так элегантно освобождается старый буфер и создается новый 
R>            using (_stream)
R>                _stream = new MemoryStream(bytes);
R>        }

R>        public void Dispose()
R>        {
R>            using (_stream)
R>            { }
R>        }
R>        #region Implementation
R>        MemoryStream _stream;
R>        #endregion
R>    };
R>

stream.Dispose();

System.IO.FileStream file = null;
using (file)
{
    file = System.IO.File.OpenRead("some.bin");
}

R>    class InboundMessageBuffer : IDisposable
R>    {
R>        public int Read(byte[] data, int offset, int count)
R>        {
R>            return _stream.Read(data, offset, count);
R>        }

R>        public void PushInboundMessage(byte[] bytes)
R>        {
R>            // Вот так элегантно освобождается старый буфер и создается новый 
R>            using (_stream)
R>                _stream = new MemoryStream(bytes);
R>        }

R>        public void Dispose()
R>        {
R>            using (_stream)
R>            { }
R>        }
R>        #region Implementation
R>        MemoryStream _stream;
R>        #endregion
R>    };
R>

R>            // Вот так элегантно освобождается старый буфер и создается новый 
R>            using (_stream)
R>                _stream = new MemoryStream(bytes);

...

    class SomeFacade : IDisposable
    {
        public SomeFacade()
        {
            try
            {
                _disposable1 = CreateDisposable1();
                _disposable2 = CreateDisposable2();
                _disposable3 = CreateDisposable3();
            }
            catch
            {
                using (this)
                    throw;
            }
        }

        public void Dispose()
        {
            using (_disposable1)
            using (_disposable1)
            using (_disposable1)
            { }
        }

        private IDisposable _disposable1;
        private IDisposable _disposable2;
        private IDisposable _disposable3;
    }

        public void Dispose()
        {
            if (_disposable1 != null)
                _disposable1.Dispose();

            if (_disposable2 != null)
                _disposable2.Dispose();

            if (_disposable3 != null)
                _disposable3.Dispose();
        }

class Util{
  public static void CheckAndDispose(IDisposable obj){
    if (obj != null)
      obj.Dispose();
  }
}

...
  public Dispose(){
    Util.CheckAndDispose(_disposable1);
    Util.CheckAndDispose(_disposable2);
    Util.CheckAndDispose(_disposable3);
  }