Understanding Streams and their lifetime (Flush, D

Question

Note: I've read the following two questions already:

Can you explain the concept of streams?

C# using streams

I'm coding in C#

1. In almost all code samples that use streams, .Dispose(), .Flush(), .Close() are almost always called.
   • In the concept of a stream, what does accomplish?
   • If I don't dispose a stream that I stored in a variable, is my application leaking somewhere?
   • Why do I need to call any of these functions? I've seen code samples that don't do this and still get the job done (without an apparent breakage)

I'm currently building a class in my application that contains a primary method (lets call it GetStream()) that returns a stream via myWebRequest.GetResponse().GetResponseStream()

The primary method GetStream() returns a Stream object that can be used for any operation that requires a stream (StreamReader, Bitmap() etc.).

Is there a way to have the stream Disposed of automatically after its last use (garbage collected?) without forcing anyone that calls .GetStream() to manually dispose of it?

As you can probably tell, my questions are vague and general. My understanding of streams is not solid, so any links to helpful articles that offer a more in-depth look at streams than a SO question can offer would be appreciated.

Answer 1

Disposing a stream closes it (and probably doesn't do much else.) Closing a stream flushes it, and releases any resources related to the stream, like a file handle. Flushing a stream takes any buffered data which hasn't been written yet, and writes it out right away; some streams use buffering internally to avoid making a ton of small updates to relatively expensive resources like a disk file or a network pipe.

You need to call either Close or Dispose on most streams, or your code is incorrect, because the underlying resource won't be freed for someone else to use until the garbage collector comes (who knows how long that'll take.) Dispose is preferred as a matter of course; it's expected that you'll dispose all disposable things in C#. You probably don't have to call Flush explicitly in most scenarios.

In C#, it's idiomatic to call Dispose by way of a using block, which is syntactic sugar for a try-finally block that disposes in the finally, e.g.:

using (FileStream stream = new FileStream(path))
{
    // ...
}

is functionally identical to

FileStream stream;

try
{
    stream = new FileStream(path);
    // ...
}
finally
{
    if (stream != null)
        stream.Dispose();
}