closing and disposing

[keithv]

I came across the following code snippet in a project
I inherited. Having 2 close() and 2 dispose() calls for
essentially one stream seems to me to be way too much
overkill.

What is the proper idiom for this?

MemoryStream memStream = new MemoryStream();
BinaryWriter writer = new BinaryWriter(memStream);
// ...use writer
writer.Close();
byte[] data = memStream.ToArray();
memStream.Close();
((IDisposable)writer).Dispose();
((IDisposable)memStream).Dispose();
return data;
Thanks,
Keith

[CBretana]

In fact all you need to do is close the file, and any one of the four calls
will do that.

The best way to do this, however is to use C#'s using construction...
using (MemoryStream memStream = new MemoryStream())
{
BinaryWriter writer = new BinaryWriter(memStream);
// ...use writer
byte[] data = memStream.ToArray();
return data;
}

The way you had it, if any of the code in
// ...use writer
threw an exception, the file would not get closed... if you use the "using"
construction, it puts all the enclosed into a try/finally block for you, and
then calls Dispose() in the finally block, regardless of whether or not any
exceptions were thrown.

"keithv" wrote:

I came across the following code snippet in a project
I inherited. Having 2 close() and 2 dispose() calls for
essentially one stream seems to me to be way too much
overkill.

What is the proper idiom for this?

MemoryStream memStream = new MemoryStream();
BinaryWriter writer = new BinaryWriter(memStream);
// ...use writer
writer.Close();
byte[] data = memStream.ToArray();
memStream.Close();
((IDisposable)writer).Dispose();
((IDisposable)memStream).Dispose();
return data;
Thanks,
Keith

[keithv]

CBretana wrote:

In fact all you need to do is close the file, and any one of the four calls will do that.

The best way to do this, however is to use C#'s using construction...
using (MemoryStream memStream = new MemoryStream())
{
BinaryWriter writer = new BinaryWriter(memStream);
// ...use writer
byte[] data = memStream.ToArray();
return data;
}

So you saying you don't need to explicitly close or dispose the
BinaryWriter class? I guess then that BinaryWriter doesn't do
any buffering?

Keith

[CBretana]

The only reason to call Close or dispose is to "clean up" external resources
which might not get properly disposed of when the Garbage Collector
"Collects" the instance of the object. The only EXTERNAL resource the Stream
writer or the Stream deals with is the file... ANy buffers used internally
are part of the CLR instance, and will be released when the instance is
"collected" by the GC..

"keithv" wrote:

CBretana wrote:

In fact all you need to do is close the file, and any one of the four

calls

will do that.

The best way to do this, however is to use C#'s using construction...
using (MemoryStream memStream = new MemoryStream())
{
BinaryWriter writer = new BinaryWriter(memStream);
// ...use writer
byte[] data = memStream.ToArray();
return data;
}

So you saying you don't need to explicitly close or dispose the
BinaryWriter class? I guess then that BinaryWriter doesn't do
any buffering?

Keith

[Wayne]

Actually he is saying you do need to close or dispose, but by doing:

using (MemoryStream memStream = new MemoryStream())
{
} <-- dispose is called for you at this point. So you yourself don't need to
call dispose/close

--
Thanks
Wayne Sepega
Jacksonville, Fl
"When a man sits with a pretty girl for an hour, it seems like a minute. But
let him sit on a hot stove for a minute and it's longer than any hour.
That's relativity." - Albert Einstein

"keithv" <kv*****@gmail.com> wrote in message
news:11**********************@o13g2000cwo.googlegr oups.com...

CBretana wrote:

In fact all you need to do is close the file, and any one of the four

calls

will do that.

The best way to do this, however is to use C#'s using construction...
using (MemoryStream memStream = new MemoryStream())
{
BinaryWriter writer = new BinaryWriter(memStream);
// ...use writer
byte[] data = memStream.ToArray();
return data;
}

So you saying you don't need to explicitly close or dispose the
BinaryWriter class? I guess then that BinaryWriter doesn't do
any buffering?

Keith

[keithv]

Wayne wrote:

Actually he is saying you do need to close or dispose, but by doing:

using (MemoryStream memStream = new MemoryStream())
{
} <-- dispose is called for you at this point.
So you yourself don't need to call dispose/close

Actually, my question was about explicitly closing/disposing a
BinaryWriter class that wraps the MemoryStream which you edited out.

Here's the unelided code snippet:

uing (MemoryStream memStream = new MemoryStream())
BinaryWriter writer = new BinaryWriter(memStream);
// ...use writer
byte[] data = memStream.ToArray();
return data;
}

So, again two questions:
1) do I need to explicitly close the BinaryWriter here?
Or, more generally, if you chain a bunch of Stream clases
does closing any one of them close them all? (If so, do
all the dispose() get called regardless of who gets the
first dispose call?)

2) for stream classes, are close and dispose equivalent such
that which gets called is stylistic question not a semantic
one?

Thanks
Keith