.NET - Replacing nested using statements with single using statement

Question

If you came across some C# code like this with nested using statements/resources:

using (var response = (HttpWebResponse)request.GetResponse())
{
    using (var responseStream = response.GetResponseStream())
    {
        using (var reader = new BinaryReader(responseStream))
        {
            // do something with reader
        }
    }
}

Is it safe to replace it with something like this?

using (var reader = new BinaryReader(((HttpWebResponse)request.GetResponse()).GetResponseStream()))
{
    // do something with reader
}

The example above is just an example of nested disposable resources, so forgive me if it's not exactly correct usage. I'm curious if when you dispose the outermost resource (the BinaryReader in this case), if it will recursively dispose its children for you, or if you need to explicitly dispose each "layer" with separate using statements? E.g. if you dispose the BinaryReader, is it supposed to dispose the response stream, which in turn disposes the response? Thinking about that last sentence makes me think you actually do need the separate using statements, because there's no way to guarantee that a wrapper object would dispose of the inner object. Is that right?

Ken Richards · Accepted Answer · 2010-10-19 23:23:34Z

13

You should just stack your using statements - it has the desired effect you are looking for:

using (var response = (HttpWebResponse)request.GetResponse())
using (var responseStream = response.GetResponseStream())
using (var reader = new BinaryReader(responseStream))
{
    // do something with reader
}

answered Oct 19, 2010 at 23:23

Ken Richards

3,0512 gold badges22 silver badges23 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Reed Copsey Over a year ago

This is, essentially, the same code with different formatting (just removing the braces).

slugster Over a year ago

How does this improve things, that is effectively what the OP had just minus the curly brackets which were optional for the first two using statements.

Ken Richards Over a year ago

Yes it's the same, but compared to what the author wanted to replace the original with, this is a lot easier to read and maintain

Reed Copsey · Accepted Answer · 2010-10-19 23:22:18Z

12

You need the separate using statements.

In your second example, only the BinaryReader will get disposed, not the objects used to construct it.

In order to see why, look at what the using statement actually does. It takes your second code, and does something equivalent to:

{
    var reader = new BinaryReader(((HttpWebResponse)request.GetResponse()).GetResponseStream());
    try
    {
      // do something with reader
    }
    finally
    {
        if (reader != null)
            ((IDisposable)reader).Dispose();
    }
}

As you can see, there would never be a Dispose() call on the Response or ResponseStream.

answered Oct 19, 2010 at 23:22

Reed Copsey

567k80 gold badges1.2k silver badges1.4k bronze badges

12 Comments

Matt H Over a year ago

You need them, but I don't think they need to be nested. I think they can just be stacked on top of each other.

Reed Copsey Over a year ago

@Matt: Yes, but they must all three exist.

Jim Mischel Over a year ago

BinaryReader.Close closes the underlying stream. And since Stream.Close ends up calling Stream.Dispose, there's no need to close the stream after closing the reader. See msdn.microsoft.com/en-us/library/… and msdn.microsoft.com/en-us/library/system.io.stream.close.aspx.

Jim Mischel Over a year ago

@Reed: But you don't need to dispose the HttpWebResponse if you close the stream. See msdn.microsoft.com/en-us/library/…. "You must call either the Stream.Close or the HttpWebResponse.Close method to close the response and release the connection for reuse. It is not necessary to call both Stream.Close and HttpWebResponse.Close, but doing so does not cause an error."

Reed Copsey Over a year ago

@Jim: Yes - I was taking this code as an example of the issue - in this case, it's not necessary to dispose of all of them - but as a general rule, it should be done. However, the same can be said of any properly written IDisposable - you never should have to dispose of them, as the finalizer should handle it, but it's still good practice.

|

Curt Nichols · Accepted Answer · 2010-10-19 23:24:45Z

3

FWIW, here's another way to spell your original example which may satisfy any dismay over nesting:

using (var response = (HttpWebResponse)request.GetResponse())
using (var responseStream = response.GetResponseStream())
using (var reader = new BinaryReader(responseStream))
{
    // do something with reader
}

Whether the reader disposes of the stream is really a function of the reader, not the 'using'. As I recall that is often what the behavior with readers is--they take ownership of the stream and dispose of it when the reader is itself closed. But the form I've provided above should be fine.

answered Oct 19, 2010 at 23:24

Curt Nichols

2,7671 gold badge17 silver badges24 bronze badges

Comments

Jim Mischel · Accepted Answer · 2010-10-19 23:29:46Z

2

According to the documentation, BinaryReader.Close will close the underlying stream. http://msdn.microsoft.com/en-us/library/system.io.binaryreader.close.aspx

Also, according to the documentation for HttpWebResponse, you either have to close the underlying stream or dispose the response. http://msdn.microsoft.com/en-us/library/system.net.httpwebresponse.aspx

So the second example you provided would work.

answered Oct 19, 2010 at 23:29

Jim Mischel

135k25 gold badges197 silver badges377 bronze badges

1 Comment

Andy White Over a year ago

Thanks for the answer... I suspected there were other possibilities. I guess when in doubt, it's best to just Close or Dispose everything, unless you know what each type does.

hcp · Accepted Answer · 2014-02-21 16:09:42Z

I posted this elsewhere, but separating your declarations by comma seems to treat each statement separated this way as a new declaration and disposes of them.

using (IType1 a = new Type1(), b = new Type1()){}

This however means your objects must be of the same type. You could call them like

using (IDisposable a = new Type1(), b = new Type2()){}

But then of course, you only have access to IDisposable methods, without casting the object, which is kinda dumb. So instead, I believe you can use

using (var a = new Type1(), b = new Type2()){}

This appears to give you the correctly typed object references allowing you access to the proper method of the allocated type, and disposes of both objects created. If anyone knows why I'm not right, please let me know because this appears to work for me? (I know this question is really old n stuff, but it's all I could find while searching for this answer myself)

Collectives™ on Stack Overflow

.NET - Replacing nested using statements with single using statement

5 Answers 5

3 Comments

12 Comments

Comments

1 Comment

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

3 Comments

12 Comments

Comments

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related