The reading and writing of text files from managed applications is aided and abetted by the FileStream, StreamReader, and StreamWriter classes. Suppose you wanted to write a simple app that dumps text files to the console window—the functional equivalent of the old DOS TYPE command. Here’s how to go about it:

StreamReader reader = new StreamReader (filename);
for (string line = reader.ReadLine (); line != null;line = reader.ReadLine ())
    Console.WriteLine (line);
reader.Close ();

The first line creates a StreamReader object that wraps a FileStream created from filename. The for loop uses StreamReader.ReadLine to iterate through the lines in the file and Console.WriteLine to output them to the console window. The final statement closes the file by closing the StreamReader.

That’s the general approach, but in real life you have to anticipate the possibility that things might not go strictly according to plan. For example, what if the file name passed to StreamReader’s constructor is invalid? Or what if the framework throws an exception before the final statement is executed, causing the file to be left open? Figure 3-1 contains the source code for a managed version of the TYPE command (called LIST to distinguish it from the real TYPE command) that responds gracefully to errors using C# exception handling. The catch block traps exceptions thrown when StreamReader’s constructor encounters an invalid file name or when I/O errors occur as the file is being read. The finally block ensures that the file is closed even if an exception is thrown.

using System;
using System.IO;

class MyApp
{
    static void Main (string[] args)
    {
        // Make sure a file name was entered on the command line
        if (args.Length == 0) {
            Console.WriteLine ("Error: Missing file name");
            return;
        }

        // Open the file and display its contents
        StreamReader reader = null;

        try {
            reader = new StreamReader (args[0]);
            for (string line = reader.ReadLine (); line != null;
                line = reader.ReadLine ())
                Console.WriteLine (line);
        }
        catch (IOException e) {
            Console.WriteLine (e.Message);
        }
        finally {
            if (reader != null)
                reader.Close ();
        }
    }
}

Because the FCL is such a comprehensive class library, passing a file name to StreamReader’s constructor isn’t the only way to open a text file for reading. Here are some others:

// Use File.Open to create a FileStream, and then wrap a
// StreamReader around it
FileStream stream = File.Open (filename, FileMode.Open, FileAccess.Read);
StreamReader reader = new StreamReader (stream);

// Create a FileStream directly, and then wrap a
// StreamReader around it
FileStream stream = new FileStream (filename, FileMode.Open, FileAccess.Read);
StreamReader reader = new StreamReader (stream);

// Use File.OpenText to create a FileStream and a
// StreamReader in one step
StreamReader reader = File.OpenText (filename);

There are other ways, too, but you get the picture. None of these methods for wrapping a StreamReader around a file is intrinsically better than the others, but they do demonstrate the numerous ways in which ordinary, everyday tasks can be accomplished using the .NET Framework class library.

StreamReaders read from text files; StreamWriters write to them. Suppose you wanted to write catch handlers that log exceptions to a text file. Here’s a LogException method that takes a file name and an Exception object as input and uses StreamWriter to append the error message in the Exception object to the file:

void LogException (string filename, Exception ex)
{
    StreamWriter writer = null;
    try {
        writer = new StreamWriter (filename, true);
        writer.WriteLine (ex.Message);
    }
    finally {
        if (writer != null)
            writer.Close ();
    }
}

Passing true in the second parameter to StreamWriter’s constructor tells the StreamWriter to append data if the file exists and to create a new file if it doesn’t.

BinaryReader and BinaryWriter are to binary files as StreamReader and StreamWriter are to text files. Their key methods are Read and Write, which do exactly what you would expect them to. To demonstrate, the sample program in Figure 3-2 uses BinaryReader and BinaryWriter to encrypt and unencrypt files by XORing their contents with passwords entered on the command line. Encrypting a file is as simple as running Scramble.exe from the command line and including a file name and password, in that order, as in:

scramble readme.txt imbatman

To unencrypt the file, execute the same command again:

scramble readme.txt imbatman

XOR-encryption is hardly industrial-strength encryption, but it’s sufficient to hide file contents from casual intruders. And it’s simple enough to not distract from the main point of the application, which is to get a firsthand look at BinaryReader and BinaryWriter.

Scramble.cs contains two lines of code that merit further explanation:

ASCIIEncoding enc = new ASCIIEncoding ();
byte[] keybytes = enc.GetBytes (key);

These statements convert the second command-line parameter—a string representing the encryption key—into an array of bytes. Strings in the .NET Framework are instances of System.String. ASCIIEncoding.GetBytes is a convenient way to convert a System.String into a byte array. Scramble XORs the bytes in the file with the bytes in the converted string. Had the program used UnicodeEncoding.GetBytes instead, encryption would be less effective because calling UnicodeEncoding.GetBytes on strings containing characters from Western alphabets produces a buffer in which every other byte is a 0. XORing a byte with 0 does absolutely nothing, and XOR encryption is weak enough as is without worsening matters by using keys that contain lots of zeros. ASCIIEncoding is a member of the System.Text namespace, which explains the using System.Text directive at the top of the file.

using System;
using System.IO;
using System.Text;

class MyApp
{
    const int bufsize = 1024;

    static void Main (string[] args)
    {
        // Make sure a file name and encryption key were entered
        if (args.Length < 2) {
            Console.WriteLine ("Syntax: SCRAMBLE filename key");
            return;
        }

        string filename = args[0];
        string key = args[1];
        FileStream stream = null;

        try {
            // Open the file for reading and writing

            stream = File.Open (filename, FileMode.Open,
                FileAccess.ReadWrite);

            // Wrap a reader and writer around the FileStream
            BinaryReader reader = new BinaryReader (stream);
            BinaryWriter writer = new BinaryWriter (stream);

            // Convert the key into a byte array
            ASCIIEncoding enc = new ASCIIEncoding ();
            byte[] keybytes = enc.GetBytes (key);

            // Allocate an I/O buffer and a key buffer
            byte[] buffer = new byte[bufsize];
            byte[] keybuf = new byte[bufsize + keybytes.Length - 1];

            // Replicate the byte array in the key buffer to create
            // an encryption key whose size equals or exceeds the
            // size of the I/O buffer
            int count = (1024 + keybytes.Length - 1) / keybytes.Length;
            for (int i=0; i<count; i++)            
                Array.Copy (keybytes, 0, keybuf, i * keybytes.Length,
                    keybytes.Length);

            // Read the file in bufsize blocks, XOR-encrypt each block,
            // and write the encrypted block back to the file
            long lBytesRemaining = stream.Length;

            while (lBytesRemaining > 0) {
                long lPosition = stream.Position;
                int nBytesRequested = (int) System.Math.Min (bufsize,
                    lBytesRemaining);
                int nBytesRead = reader.Read (buffer, 0,
                    nBytesRequested);

                for (int i=0; i<nBytesRead; i++)
                    buffer[i] ^= keybuf[i];									

                stream.Seek (lPosition, SeekOrigin.Begin);
                writer.Write (buffer, 0, nBytesRead);
                lBytesRemaining -= nBytesRead;
            }
        }
        catch (Exception e) {
            Console.WriteLine (e.Message);

        }
        finally {
            if (stream != null)
                stream.Close ();
        }
    }
}