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

            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.

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