What is the difference between StreamWriter.Flush() and StreamWriter.Close()?

What is the difference in functionality between StreamWriter.Flush() and StreamWriter.Close()?

When my data wasn't being written correctly to a file, I added both Flush() and Close() to the end of my code. However, I realized that adding either Flush() or Close() allowed the data to be written correctly.

I wasn't able to pick up on exactly what each of these methods does when I read the MSDN docs; I only figured out that one or the other is necessary to ensure data is written correctly. Any further explanation would be much appreciated.

---

Where s is a string to be written, here's what my code looks like currently:

StreamWriter sw = File.CreateText("TextOutput.txt");
sw.Write(s);
sw.Flush();
sw.Close();

---

Based on feedback from the answers, I've rewritten my code in a using block, which implements IDisposable and will automatically take care of writing the stream to the file when the object is disposed:

using (StreamWriter sw = File.CreateText("TextOutput.txt"))
{
    sw.Write(s);
}

StreamWriter.Flush() can be called any time you need to clear the buffer, and the stream will remain open.

StreamWriter.Close() is for closing the stream, at which point the buffer is also flushed.

But you shouldn't really need to call either of these. Any time I see a .Close() in code I take that as a code smell, because it usually means an unexpected exception could cause the resource to be left open. What you should do, is create your StreamWriter variable in a using block, like this:

using (var writer = new StreamWriter("somefilepath.txt"))
{
   // write a bunch of stuff here
} // the streamwriter WILL be closed and flushed here, even if an exception is thrown.

StreamWriter.Flush() will flush anything in the Stream out to the file. This can be done in the middle of using the Stream and you can continue to write.

StreamWriter.Close() closes the Stream for writing. This includes Flushing the Stream one last time.

There's a better way to do things though. Since StreamWriter implements IDisposable, you can wrap the StreamWriter in a using block.

using(StreamWriter sw = new StreamWriter(stream))
{
     // Work with things here
}

After the using block, Dispose will be called...which will Flush and Close the Stream for you.

I had a case where I was writing a very long string to a StreamWriter with an underlying MemoryStream. The MemoryStream was being consumed by something else before the writer and the stream were disposed.

using (var memoryStream = new MemoryStream())
using (var streamWriter = new StreamWriter(memoryStream , Encoding.UTF8))
{
    streamWriter.Write(someRealyLongStringValue);
    DoSomethingWithTheStream(memoryStream );
}

With really long strings the end of the string was being truncated. This was resolved by calling flush before the stream was used. Alternatively I could have set AutoFlush to true.

From MSDN:

Flush: Clears all buffers for the current writer and causes any buffered data to be written to the underlying stream.

Close: Closes the current StreamWriter object and the underlying stream.