Any difference between File.ReadAllText() and using a StreamReader to read file contents?

At first I used a StreamReader to read text from a file:

StreamReader reader = new StreamReader(dialog.OpenFile());
txtEditor.Text = reader.ReadToEnd();

but found out about File.ReadAllText which seems to simplify my code to 1 line. Are there are any differences between the two? When should I use one over the other?

txtEditor.Text = File.ReadAllText(dialog.FileName);

There are no differences if you are using the ReadToEnd() method. The difference is if you are using the ReadLine() method for large files as you are not loading the whole file into memory but rather allows you to process it in chunks.

So use File.ReadAllText() instead of ReadToEnd() as it makes your code shorter and more readable. It also takes care of properly disposing resources as you might forget doing with a StreamReader (as you did in your snippet).

Looking at the code within mscorlib, File.ReadAllText actually calls StreamReader.ReadToEnd internally!

[SecurityCritical]
private static string InternalReadAllText(string path, Encoding encoding, bool checkHost)
{
	string result;
	using (StreamReader streamReader = new StreamReader(path, encoding, true, StreamReader.DefaultBufferSize, checkHost))
	{
		result = streamReader.ReadToEnd();
	}
	return result;
}

If you use ReadToEnd, they are the same. Otherwise, using the StreamReader allows you to read bytes at a time, do some computation with them, and then throw them away as needed. For example, if you had a file containing a list of 2,000 numbers, and you wanted to add them together, you could:

• Call File.ReadAllText to read everything into a string and then parse through that string to compute the sum.
• Or you could create a StreamReader and read a few bytes at a time, computing the sum as you go.

The major difference between these two approaches is the transient memory usage. After you have the sum, you can always throw all the intermediate data away. In the File.ReadAllText approach, at some point you had the entire file contents in memory, while with the StreamReader approach, you only had a few bytes worth of file contents in memory at any one time. This can be an issue depending on the size of your files and the kind of computation you're doing.

File.ReadAllText is convenient and quick. StreamReader is powerful but more work.

If you use File.ReadAllText to read an unmanaged logging file (control by fstream), call File.ReadAllText, there will have IO.Exception:

> The file is control by another process

You must to use StreamReader ReadToEnd to replace it.