Dot Net Perls

Problem

Read in a file from the disk and manage the file resources properly. Utilize using StreamReader to read in the file. We want a simple and graceful way to use StreamReader and dispose of our resources. This will also help with other expensive objects like database connections and commands and graphics objects.

C# Solution

In many languages, you must open a file in one line, deal with the file in another few lines, and then make a call to close to the file. You can do this in C#, too. The code shown below is the unclear version, which we can replace with using.

// Read a line from a file the old way.
StreamReader sr = new StreamReader("file.txt");
string line = sr.ReadLine();
sr.Close();
// You ought to call Dispose on 'sr' here, too, but often that is omitted.

What's wrong with it?

It is cumbersome to type and read, and bugs could creep into the code. It works as intended: we just open a file, read a line out of it, and then close it. (Note that if the file is not there, it will throw an exception, which you should probably be on the lookout for.)

using keyword

The using statement in C# allows you to leave the file disposal and opening routines to the C# compiler's knowledge of scope. This statement will instruct .NET to do all the dirty cleanup work with your file. Let's look at the same example I showed above, but with this new syntax.

// This is ideal. .NET will deal with memory in its optimal way.
// Plus, it is fewer characters to type. My recommendation: Always
// use using unless you are in an unusual circumstance.
string line;
using (StreamReader sr = new StreamReader("file.txt"))
{
    line = sr.ReadLine();
}

Scope is important here

When objects go out of scope, some code is called to clean them up. The garbage collector is run and your program's memory is reclaimed. (A scope in your C# code is a block between brackets.) Object goes out of scope when the block it was declared in is finished. Scope allows the compiler to make many assumptions about your program.

Read all lines in a file

Here's another example of "using StreamReader". One very common requirement for programs is that you need to read in a file line-by-line. And you want to store all those lines in a generic List or ArrayList object in C#. Let's look at an example that reads in a file line-by-line and stores it in a List.

// Read in a file line-by-line, and store it all in a List.
// You can then use the List to look at the contents of the
// file without having to open the file again.
List<string> allLines = new List<string>();
using (StreamReader reader = new StreamReader("file.txt"))
{
    string line;
    while ((line = reader.ReadLine()) != null)
    {
        // "line" is a line in the file. Add it to our List.
        allLines.Add(line);
    }
}

• List is created
  In the above code, a new List generic object that stores strings is created.
• using is used
  The using keyword surrounds the StreamReader. This ensures correct disposal of resources.
• while loop runs
  This loop reads in lines until the end of the file. ReadLine returns null at the end of a file--no need to check for EOF.
• Lines are added
  Individual lines are added to the List, resulting in a List that stores all the lines in a file.
• More detailed examples
  This site now has a page about reading files into arrays using the StreamReader and ReadLine methods. It contains more detail than this example.

Conclusion

The using keyword has performance that is essentially equal to any manual ways of doing it. Overall, I feel that .NET file IO methods are very efficient and well-designed. Using can reduce the resources used by your program--both your own personal resources, and those of the environment and electrical outlet.

Ads by The Lounge