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
    };

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>

• Компилятор поступает так, как я предполагаю
  
• В компиляторе есть некий специальный кейс на данный случай

            sealed class Disposable : IDisposable
            {
                public void Dispose()
                {
                    throw new NotImplementedException();
                }
            }
            ...
            try
            {
                using (var disposable = new Disposable())
                {
                    throw new OutOfMemoryException();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }

Результат: System.NotImplementedException: The method or operation is not implemented.

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

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.

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();
}

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();

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);
  }

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

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

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

...
    public static class DisposableExtension
    {
        public static void MyDispose(this IDisposable d)
        {
            if (d != null)
                d.Dispose();
        }
    }
...
        public void Dispose()
        {
            _disposable1.MyDispose();
            _disposable1.MyDispose();
            _disposable1.MyDispose();
        }
...

...

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

...
    public static class DisposableExtension
    {
        public static void MyDispose(this IDisposable d)
        {
            if (d != null)
                d.Dispose();
        }
    }
...
        public void Dispose()
        {
            _disposable1.MyDispose();
            _disposable1.MyDispose();
            _disposable1.MyDispose();
        }
...

L>Только то, что вы за замысловатыми конструкциями прячете простой по сути код. Зачем делать сложно, когда можно сделать просто?

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

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

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

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

using (disposable1) { }

Util.CheckAndDispose(_disposable1);

  public Dispose(){
    using(_disposable1)
    using(_disposable2)
    using(_disposable3)
    { } 
  }

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

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

R>        MemoryStream _stream;
R>    };
R>

public void PushInboundMessage(byte[] bytes)
{
    Stream stream;
    stream = this._stream;
Label_0007:
    try
    {
        this._stream = new MemoryStream(bytes);
        goto Label_001F;
    }
    finally
    {
    Label_0015:
        if (stream == null)
        {
            goto Label_001E;
        }
        stream.Dispose();
    Label_001E:;
    }
Label_001F:
    return;
}

    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                using (var writer = new MyStreamWriter("D:\\file.txt"))
                {
                }

            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
        }
    }

    public class MyStreamWriter : IDisposable
    {
        private System.IO.Stream _stream;

        public MyStreamWriter(string filePath)
        {
            Console.WriteLine("ctor");
            _stream = new System.IO.FileStream(filePath, System.IO.FileMode.Create);
            throw new Exception("oops!");
        }

        ~MyStreamWriter()
        {
            Console.WriteLine("finalizer");
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            Console.WriteLine("dispose");
            _stream = _stream.DisposeIfNotNull();
        }

    }

    public static class Ext
    {
        public static T DisposeIfNotNull<T>(this T obj)
            where T : IDisposable
        {
            if (!object.ReferenceEquals(obj, null))
            {
                obj.Dispose();
            }

            return (T)(object)null;
        }
    }

PO>public void PushInboundMessage(byte[] bytes)
PO>{
PO>    Stream stream;
PO>    stream = this._stream;
PO>Label_0007:
PO>    try
PO>    {
PO>        this._stream = new MemoryStream(bytes);
PO>        goto Label_001F;
PO>    }
PO>    finally
PO>    {
PO>    Label_0015:
PO>        if (stream == null)
PO>        {
PO>            goto Label_001E;
PO>        }
PO>        stream.Dispose();
PO>    Label_001E:;
PO>    }
PO>Label_001F:
PO>    return;
PO>}
PO>

using System;

class SomeDisposable : IDisposable
{
    public string Name;

    public SomeDisposable(string name) { Name = name; }

    public void Dispose() { Console.WriteLine(Name + " is disposed"); }
}

class Program
{
    static void Main(string[] args)
    {
        SomeDisposable someDisposable = new SomeDisposable("First");
        using(someDisposable)
            someDisposable = new SomeDisposable("Second");
    }
}

First is disposed

public void Dispose()
{
    try
    {
        disposable1.Dispose();
        disposable2.Dispose();
        disposable3.Dispose();
    }
    catch(Exception innerException)
    {
       throw new FatalError_DoNotCatchThis(innerException);
    }
}