Working with Files and Directories

The System.IO namespace contains the basic file I/O functions that enable you to read and write files, list directories, get file information, and manipulate files and directories. Most applications interact with a file in one way or another, and the System.IO namespace helps you do so.

In this section, you learn how to

• List directories and files

• Read and write simple text files

Inside the System.IO Namespace

The System.IO namespace contains static (or shared) classes and instance classes that enable you to interact with files, paths, directories, and streams. Streams can be from any type of resource, such as a file on the file system, a network stream, or even a URL from the Internet. You determine which classes in the System.IO namespace to use based on the type of stream you're accessing. If you look up the System.IO namespace in the SDK help file, you'll see something similar to Figure 9.12, which is a long list of the classes and namespaces that make up the System.IO namespace.

Figure 9.13 is a compact representation of the hierarchy of the System.IO namespace. You can see the static (shared) classes and the instance classes in the figure.

As you can see in Figure 9.13, the System.IO namespace hierarchy contains many objects that interact with files and the file system. We'll discuss the File, Path, and Directory classes, and the StreamReader and StreamWriter classes. These are common classes for basic file I/O.

Understanding the File Class

The File class provides static methods that give you access to files. The instance class FileInfo gives you functionality similar to the static File class. But because the File class is static, it performs security checks each time you access a file object. If you're going to access the same file objects more than once, you should use the FileInfo class to avoid the overhead of performing security checks on the same objects each time. Table 9.3 lists the methods of the File class and their descriptions.

Using the methods of the File class is straightforward. The following snippets use some of the methods to get you familiar with the syntax:

Imports System.IO

Public Class Class1

 Sub FileClassStuff()

  ' using Exists, Move, SetCreationTime,
  ' SetLastAccessTime, SetLastWriteTime

  If File.Exists("C:Junk.txt") Then
   File.Move("C:Junk.txt", "D:Junk.txt")
   File.SetCreationTime("D:Junk.txt", Date.Now)
   File.SetLastAccessTime("D:Junk.txt", Date.Now)
   File.SetLastWriteTime("D:Junk.txt", Date.Now)
  End If

  ' using Exists and Delete methods

  If File.Exists("C:Junk.txt") Then
   File.Delete("C:Junk.txt")
  End If

 End Sub
End Class

using System;
using System.IO;

namespace IO_FileClass_CS
{
 public class Class1
 {
  static void Main()
  {

  // using Exists, Move, SetCreationTime,
  // SetLastAccessTime, SetLastWriteTime

  if (File.Exists(@"C:Junk.txt"))
  {
   File.Move(@"C:Junk.txt", @"D:Junk.txt");
   File.SetCreationTime(@"D:Junk.txt", Date.Now);
   File.SetLastAccessTime(@"D:Junk.txt", Date.Now);
   File.SetLastWriteTime(@"D:Junk.txt", Date.Now);
  }

  // using Exists and Delete methods

  if (File.Exists(@"C:Junk.txt"))
  {
   File.Delete(@"C:Junk.txt");
  }
  }
 }
}

Understanding the Path Class

The Path class has methods that enable you to retrieve or modify paths on the operating system. When working with the Path class, the methods are smart enough to realize the rules of the operating system that your code is running on. For example, if an OS only allows 256-character pathnames with a 3-character extension, the Path class returns ArgumentException to let you know that you're doing something wrong. The same code might work perfectly on a system such as Windows XP, which has greater flexibility when working with file paths. Table 9.4 lists the more common available methods to you in the Path class.

As is the File class, working with the Path class is very straightforward. All methods can be called directly without creating an instance of the Path class.

Understanding the Directory Class

The Directory class exposes methods that enable you to create, delete, move, rename, and enumerate directories and subdirectories. The Directory class is also a static class. The DirectoryInfo class is the instance class that enables you to create directory instances. Using the DirectoryInfo class avoids the overhead of security checks for each directory reference. Table 9.5 lists the common methods of the Directory class.

You'll notice that some of these methods are similar to the methods of the Environment class (for example, GetLogicalDrives, which returns a string array of drives). Methods such as SetLastWriteTime and GetLastWriteTime are also similar to the methods of the File class. Because files and directories are similar object types, they share methods that perform similar operations.

In the next section, you create a sample application that uses some of the methods of the Directory class.

Creating an I/O Sample Application

To use some of the classes in the System.IO namespace, you're going to write a Windows Forms application that lists directories and files, writes a list of items from a list box to a text file, and then reads the text file back into a list box. To achieve this, you

• Use the Directory class of the System.IO namespace

• Use the StreamWriter class of the System.IO namespace to write to a file

• Use the StreamReader class of the System.IO namespace to read from a file

• Use arrays

• Use the ListBox control

Follow these steps to set up the new application. But before you start, look at Figure 9.14 to see what the end result of your form should look like.

Text = "Using the System.IO Namespace"

StartupPosition = CenterScreen

Name = ListFolders

Text = "List Folders"

Name = ListFiles

Text = "List Files"

Name = WriteToFile

Text = "Write To ListBox File"

Name = ReadFromFile

Text = "Read ListBox From File"

Anchor = Top, Bottom, Left, Right

Your completed form should look like Figure 9.14.

Writing the IO Application Code

Now that you have the project set up, you can start writing the code to retrieve directory information. Double-click the List Folders button and add the code in Listing 9.4 to the code-behind for the ListFolders_Click event. This code uses the Directory.GetDirectories methods to return an array of directories.

Listing 9.4. ListFolders_Click Event Code

Private Sub ListFolders_Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles ListFolders.Click ' Create a string variable array named ' dirs to hold the directory entries for the ' special folder Program Files Dim dirs As String() = _ Directory.GetDirectories _ (Environment.GetFolderPath _ (Environment.SpecialFolder.ProgramFiles)) ' Create a string variable for the For Each loop Dim dir As String ' Loop thru the array of folders and add them to the ' ListBox1 using the Items.Add method For Each dir In dirs With ListBox1.Items .Add(dir) End With Next End Sub private void listFolders_Click(object sender, System.EventArgs e) { /* Create a string variable array named dirs to hold the directory entries for the special folder Program Files */ string[] dirs = Directory.GetDirectories (Environment.GetFolderPath (Environment.SpecialFolder.ProgramFiles)); /* Loop thru the array of folders and add them to the ListBox1 using the Items.Add method */ foreach (string dir in dirs) { listBox1.Items.Add(dir); } }

If you press the F5 key to run the application and click the Get List Folders button, you should see a listing of the subdirectories of your Program Files folder. My output looks like Figure 9.15.

In Listing 9.4, you build on techniques you used in the Environment application you created earlier today. You use the GetFolderpath method of the Environment class to return the location of the Program Files folder. The Directory.GetDirectories method returns a string array of folders in the Program Files directory. You then loop through and add them to the list box using the Items.Add method. Using the GetFolderPath method of the Environment class ensures that you won't get an error if the user has a path for Program Files other than C:Program Files.

To get folders and files, you use the GetFileSystemEntries method of the Directory class. Double-click the List Files button and add the code in Listing 9.5 to the ListFiles_Click event.

Listing 9.5. Using the GetFileSystemEntries Method

Private Sub ListFiles_Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles ListFiles.Click ' Clear the ListBox ListBox1.Items.Clear() ' Create a string variable array named ' files to hold the directory and file entries for the ' special folder My Documents Dim files As String() = _ Directory.GetFileSystemEntries _ (Environment.GetFolderPath _ (Environment.SpecialFolder.Personal)) ' Create a string variable for the For Each loop Dim file As String ' Loop thru the array of files and folders and add ' them to the ListBox1 using the Items.Add method For Each file In files With ListBox1.Items .Add(file) End With Next End Sub private void listFiles_Click(object sender, System.EventArgs e) { // Clear the listBox listBox1.Items.Clear(); /* Create a string variable array named files to hold the directory and file entries for the special folder My Documents */ string[] files = Directory.GetFileSystemEntries (Environment.GetFolderPath (Environment.SpecialFolder.Personal)); /* Loop thru the array of files and folders and add them to the ListBox1 using the Items.Add method */ foreach (string file in files) { listBox1.Items.Add(file); } }

Now you can run the application by pressing F5 and observe the output. In Listing 9.5, you use the GetFileSystemEntries method to return an array of files and directories in the My Documents directory. The Environment.SpecialFolder.Personal enumeration returns the correct location of the My Documents folder to list the files and folders. You could also replace the GetFileSystemEntries method with the GetFiles method to return only the files in the My Documents folder.

Using the StreamWriter and StreamReader Classes

Up to now, you've used the classes of the System.IO namespace to access file system objects. But to read and write data, you must use the methods of the StreamReader and StreamWriter classes.

In Figure 9.13, you saw a representation of the System.IO namespaces and its members. There are classes that handle network streams, crypto streams, binary streams, text streams, and buffered streams. To accomplish basic reading and writing of files, you use the methods of the StreamReader and StreamWriter classes to complete the I/O project you started earlier. But before we write that code, examine Tables 9.6 and 9.7 to get an idea of what methods are available in the StreamReader and StreamWriter classes.

The StreamReader class gives you all the read methods to accomplish reads on a stream after you've opened it. Read, Peek, ReadToEnd, ReadLine, and ReadBlock all read data from a stream. The StreamWriter methods perform the task of writing data to a stream.

Write and WriteLine are the methods to write data, with the only difference being that the WriteLine method adds a line terminator to the end of the line of data you're writing.

To implement the code to loop through the items in the ListBox control on your form, double-click the Write To File button, and add the code in Listing 9.6 to the WriteToFile_Click event.

Listing 9.6. Using the StreamWriter Class

Private Sub WriteToFile_Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles WriteToFile.Click ' Create a new text file using the StreamWriter class Dim sw As New StreamWriter("C:List.txt") ' Create a temp counting variable Dim intX As Short ' Loop thru the ListBox, grabbing the items and ' writing them to the stream using the WriteLine method Dim s As String For Each s In ListBox1.Items sw.WriteLine(s) Next ' Close the StreamWriter sw.Close() End Sub private void WriteToFile_Click(object sender, System.EventArgs e) { // Create a new text file using the StreamWriter class StreamWriter sw = new StreamWriter(@"C:List.txt"); /* Loop thru the ListBox, grabbing the items and writing them to the stream using the WriteLine method */ foreach (string s in listBox1.Items) { sw.WriteLine(s); } // Close the StreamWriter sw.Close(); }

After you run the application, you can check the List.txt file in the C drive. It lists the files that are also listed in the ListBox in a nice text format. Using the WriteLine method of the StreamWriter class adds the line terminator after each item it writes out in the List.txt file. Figure 9.16 shows the List.txt file from my machine.

The last step in the code for the I/O application is writing the code-behind for the Read From File button. Listing 9.7 has the code that uses the StreamReader class to create a new stream object based on the List.txt file you just created in Listing 9.6. Add the code in Listing 9.7 to the code-behind for the ReadFromFile_Click event to see this in action.

Listing 9.7. Using the StreamReader Class

Private Sub ReadFromFile_Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles ReadFromFile.Click ' Clear the ListBox ListBox1.Items.Clear() ' Create a new StreamReader and pass the file ' created in the WriteToFile_Click event Dim sr As New StreamReader("C:List.txt") ' Use the Peek method to move to the next character ' and the ReadLine method to get the next line While sr.Peek <> -1 With ListBox1.Items .Add(sr.ReadLine) End With End While ' Close the StreamReader sr.Close() End Sub private void ReadFromFile_Click(object sender, System.EventArgs e) { // Clear the listBox listBox1.Items.Clear(); /* Create a new StreamReader and pass the file created in the WriteToFile_Click event */ StreamReader sr = new StreamReader(@"C:List.txt"); /* Use the Peek method to move to the next character and the ReadLine method to get the next line */ do { listBox1.Items.Add(sr.ReadLine()); } while (sr.Peek() != -1); // Close the StreamReader sr.Close(); }

Now run the application to read the data from the file. The first line of code in Listing 9.7 clears the ListBox, and then the new StreamReader is created based on the file previously created. Using a loop, you're peeking into the file, one line at a time, using the Peek method. The ReadLine method reads the next line, and adds the string it reads into the ListBox. Because Peek doesn't consume the bytes of data that it reads, you can keep peeking into a stream while consuming its data with any of the read methods of the stream class. You finally call the Close method of the StreamReader to release the resource. You should always be diligent about using Close on resources that have a Close method. Not using Close could keep the stream handle open or waste unnecessary resources.