Is there a better deterministic disposal pattern than nested “using”s in C#?

using (FileStream fs = new FileStream("c:file.txt", FileMode.Open))
{
    using (BufferedStream bs = new BufferedStream(fs))
    {
        using (StreamReader sr = new StreamReader(bs))
        {
            // use sr, and have everything cleaned up when done.
        }
    }
}

{
    FileStream fs("c:file.txt", FileMode.Open);
    BufferedStream bs(fs);
    StreamReader sr(bs);
    // use sr, and have everything cleaned up when done.
}

using (FileStream fs = new FileStream("c:file.txt", FileMode.Open))
using (BufferedStream bs = new BufferedStream(fs))
using (StreamReader sr = new StreamReader(bs))
{
    // all three get disposed when you're done
}

using (StreamWriter w1 = File.CreateText("W1"))
  using (StreamWriter w2 = File.CreateText("W2"))
  {
      // code here
  }

using (FileStream fs = new FileStream("c:file.txt", FileMode.Open))
using (BufferedStream bs = new BufferedStream(fs))
using (StreamReader sr = new StreamReader(bs))
{
}

public void Dispose()
{
    Exception ex = null;

    try
    {
        sr.Dispose();
    }
    catch (Exception e)
    {
        ex = e;
    }

    try
    {
        bs.Dispose();
    }
    catch (Exception e)
    {
        if (ex != null)
        {
            ex.InnerException = e;
        }
        else
        {
            ex = e;
        }
    }

    try
    {
        fs.Dispose();
    }
    catch (Exception e)
    {
        if (ex != null)
        {
            if (ex.InnerException != null)
            {
                ex.InnerException.InnerException = e;
            }
            else
            {
                ex.InnerException = e;
            }
        }
        else
        {
            ex = e;
        }
    }

    if (ex != null)
    {
        throw ex;
    }
}

using (FileStream fs = new FileStream("c:file.txt", FileMode.Open))
using (BufferedStream bs = new BufferedStream(fs))
using (StreamReader sr = new StreamReader(bs))
{
        // use sr, and have everything cleaned up when done.
}

FileStream fs = new FileStream("c:file.txt", FileMode.Open);
BufferedStream bs = new BufferedStream(fs);
StreamReader sr = new StreamReader(bs);
try
{
        // use sr, and have everything cleaned up when done.
}finally{
   sr.Close(); // should be enough since you hand control to the reader
}

using (StreamWrapper wrapper = new StreamWrapper("c:file.txt", FileMode.Open))
{
    // do stuff using wrapper.Reader
}

private class StreamWrapper : IDisposable
{
    private readonly FileStream fs;
    private readonly BufferedStream bs;
    private readonly StreamReader sr;

    public StreamWrapper(string fileName, FileMode mode)
    {
        fs = new FileStream(fileName, mode);
        bs = new BufferedStream(fs);
        sr = new StreamReader(bs);
    }

    public StreamReader Reader
    {
        get { return sr; }
    }

    public void Dispose()
    {
        sr.Dispose();
        bs.Dispose();
        fs.Dispose();
    }
}

using (Stream Reader sr = new StreamReader( new BufferedStream( new FileStream("c:file.txt", FileMode.Open))))
{
    // all three get disposed when you're done
}

const string fname = @"c:1.xml";

StreamReader sr=new StreamReader(new BufferedStream(new FileStream(fname,FileMode.Open,FileAccess.Read,FileShare.Delete)));
textBox1.Text = sr.ReadToEnd();

try
   {
      obj declaration
      ...
   }
   finally
   {
      obj.Dispose();
   }