C# StreamWriter

StreamWriter writes text files. It is used in many C# programs for easy and efficient text output. It is best placed in a using-statement to ensure it is removed from memory when no longer needed. It provides several constructors and many methods.

This C# tutorial covers the StreamWriter type from System.IO. It places the StreamWriter in using statements.

Example

To start, we see how you can declare and initialize a StreamWriter instance in a using construct in the C# language. Please note how the System.IO namespace is included at the top of the file. The keyword using means different things in different places.

Program that uses StreamWriter [C#]

using System.IO;

class Program
{
    static void Main()
    {
	using (StreamWriter writer = new StreamWriter("important.txt"))
	{
	    writer.Write("Word ");
	    writer.WriteLine("word 2");
	    writer.WriteLine("Line");
	}
    }
}

Output
    (Text is in "important.txt" file.)

Word word 2
Line

Description. The new StreamWriter is initialized and points to a file called "important.txt". Three writes are done using StreamWriter. The Write method does not append a newline. The WriteLine methods append a newline "\r\n" at each call.

Output: The file "important.txt", which is in the same directory as the application, will contain two lines of text and two newlines. One newline is at the end of the file.

Append text example

To continue, we see that it is possible and easy to append text to a file with StreamWriter. The file is not erased, but just reopened and new text is added to the end. Additionally, we see how you can specify a full path.

Program that appends to file [C#]

using System.IO;

class Program
{
    static void Main()
    {
	// 1: Write single line to new file
	using (StreamWriter writer = new StreamWriter("C:\\log.txt", true))
	{
	    writer.WriteLine("Important data line 1");
	}
	// 2: Append line to the file
	using (StreamWriter writer = new StreamWriter("C:\\log.txt", true))
	{
	    writer.WriteLine("Line 2");
	}
    }
}

Output
    (File "log.txt" contains these lines.)

Important data line 1
Line 2

Description. First, a new StreamWriter is initialized and it opens "C:\\log.txt" for appending. The second parameter to the constructor is true, which specifies append. The first string is appended to it. If it is empty, the file begins with that string.

Second StreamWriter usage. The next using construct reopens the "C:\\log.txt" file and then appends another string to it. If for some reason the file was deleted, the line will be added just the same.

Loop example

Often when using StreamWriter, you will need to write out an array or List of string data. The best way to do this is to put the loop inside the StreamWriter statement. This avoids creating more than one file handle in Windows.

Program that loops with StreamWriter [C#]

using System.IO;

class Program
{
    static void Main()
    {
	// Use var type which is shorter
	using (var writer = new StreamWriter("loop.txt"))
	{
	    // Loop through ten numbers
	    for (int i = 0; i < 10; i++)
	    {
		// Write format string to file
		writer.Write("{0:0.0} ", i);
	    }
	}
    }
}

Output
    (These numbers are in the file "loop.txt".)

0.0 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0

Notes. The code uses the var keyword, which makes the syntax shorter but equivalent in functionality. The file "loop.txt" is opened only once for writing.

The for-loop goes through ten numbers and writes a format string to the file each time. The format string can be used with Write easily. You have to specify a substitution marker {0} in the first parameter.

Available encodings

StreamWriter accepts a parameter that specifies your required encoding. This is useful in some globalization contexts, but isn't covered here. Your encoding requirements will vary depending on your project. Many projects will not need specialized encodings.

More methods

There are more members of StreamWriter you can use. You can manually call Dispose and Close on your StreamWriter. You only should do this if you are not using the "using" keyword. This is a more error-prone style. It is not recommended normally.

Using

The using statements in the examples here actually open and prepare the files. At the end of the statements they close and dispose of the resources. Therefore, if your program does lots of writes, it will manage system resources correctly if you use using.

Early returns. And if your program returns in the middle of a using statement, the resources will still be disposed. This is because of the finally statement, which is how using is compiled. Finally statements always run.

Note: Finally statements are stubborn about that.

Summary

We saw several tips and examples of using StreamWriter in the C# language. This is an excellent class and useful for many C# developers. The using statement here provides a clear and elegant way of disposing of system resources. Please refer to this site also for reading files with StreamReader.