Multiple variables within same using block

Question

I'm currently using two objects as follows:

using (var ms = new MemoryStream())
using (var bw = new BinaryWriter(ms))
{
    // work with ms and bw, both referenced here
}

It works "fine" and is in fact an answer here too. However, when I run VS2012's code analysis tool, I get a warning like:

CA2202  Do not dispose objects multiple times   
Object 'ms' can be disposed more than once in method '<my method name>'. 
To avoid generating a System.ObjectDisposedException you should not 
call Dispose more than one time on an object.

This leads me to believe there might an alternative way to handle this situation, but I don't know what it is.

Does anyone know what is the 'proper' way to use two objects within a single using block in a warning-free manner?

I would personally ignore this rule; it seems very misguided. As per the documentation for Dispose (http://msdn.microsoft.com/en-us/library/system.idisposable.dispose.aspx), "The object *must not* throw an exception if its Dispose method is called multiple times." I suppose there could be some poorly-implemented objects that do throw, but on the whole it's better to Dispose everything that's IDisposable, and not worry if something gets disposed twice (which should be a no-op). — Bradley Grainger, Feb 09 '13 at 21:06
@HansPassant: Thx but I wouldn't necessarily call it a duplicate since that one targets VB.net's syntax (although, after-the-fact, you can see the similarities rooted from the common IL) — DeepSpace101, Feb 09 '13 at 23:41

score 2 · Accepted Answer · answered Feb 09 '13 at 20:23

The BinaryWriter class is written such that it will dispose the underlying stream that you pass to it when you dispose the BinaryWriter unless you use the optional constructor parameter to tell it not to. Since the binary writer is disposing the underlying memory stream and you are also disposing of it in the using block it is being disposed of twice.

Now, this isn't really an issue for most classes, as they should be (and memory stream is) written to work just fine if disposed twice, as long as you don't use it after it's dispose (you're not) so you can safely ignore the warning. If you want the warning to go away you can just take the memory stream out of the using since it's already being disposed.

bas · Answer 2 · 2013-02-09T20:01:07.177

1

If you don't need the object reference to MemoryStream this would work fine

using (var bw = new BinaryWriter(new MemoryStream()))
{
    var memStream = bw.BaseStream as MemoryStream;
}

Otherwise go for the multiple using. Especially in cases where you are using .NET framework objects, since they are implemented with correct dispose pattern.

A double using statement can cause trouble when the object that could have a second dispose call does not implement the dispose pattern correctly.

PS: do you get the same warning this way:

using (var memStream = new MemoryStream())
{
    using (var bw = new BinaryWriter(memStream))
    {
        // work with ms and bw
    }
}

edited Feb 09 '13 at 20:01

answered Feb 09 '13 at 19:47

bas

13,550
20
69
146

I like that idea but the MemoryStream is referenced in the code block in the middle (`ms.ToAray()`) – DeepSpace101 Feb 09 '13 at 19:58
you can still access your MemoryStream via `bw.BaseStream`. But tbh I would go for the nested `using` – bas Feb 09 '13 at 19:59

score 1 · Answer 3 · answered Feb 09 '13 at 20:21

You assumption that this is a single using block is incorrect. The code in your example is syntactic sugar for a nested using block like this:

using (var ms = new MemoryStream())
{
   using (var bw = new BinaryWriter(ms)) 
   {
    // work with ms and bw, both referenced here
   }
}

There is no single way to right this down correctly and avoid the warning. In cases where the inner resource wraps the outer resource and they both go out of scope together, you need to consult the documentation: if the contract states that the inner resource's dispose methods invoked the dispose of the wrapped object, you simply do not need to put the outer resource in a using block.

That being said, there will probably be no mention of such details in most docs. You can check the behavior by yourself (by inheriting and observing side effects) but than you must be careful since in the first place it was not documented, this behavior may change in future releases.

So if you are very worried about it, you can leave the double using block (just in case), suppress the warning and put the whole block in a try{} catch (ObjectDisposedException e) {} to safe gourd yourself completely.

Sounds paranoid? depends on what library you are working with :-)

The documentation of binary write *does* actually specify that it disposes of the wrapped resource until you use the constructor overload that indicated not to. — Servy, Feb 09 '13 at 20:25

score -4 · Answer 4 · answered Feb 09 '13 at 20:06

-4

I think you shouldn't use "using( ... ){}" for:

using (var ms = new MemoryStream())

because the OS managment memory and "dispose" it!

answered Feb 09 '13 at 20:06

Peyman Panjehbashi

85
1
7

it's a good practice to dispose memory streams. – bas Feb 09 '13 at 20:08
This answer is very misleading. Dispose method can be automatically called by the finalizer but (a) This has nothing to do with the OS, it part of the Garbage collection mechanism and (b) You should dispose of unmanaged resources deterministically – Vitaliy Feb 09 '13 at 20:34

Multiple variables within same using block

4 Answers4