What’s in This Chapter

• Directory and File classes
• DriveInfo, DirectoryInfo, and FileInfo classes
• FileSystemWatcher and Path classes
• Managing the recycle bin

Wrox.com Downloads for This Chapter

Please note that all the code examples for this chapter are available as a part of this chapter’s code download on the book’s website at www.wrox.com/go/csharp5programmersref on the Download Code tab.

The preceding chapter described stream classes that you can use to read and write files. (It also described the File class, which isn’t a stream class but is just too useful to ignore when you use streams.) Those classes are handy but even those like StreamWriter that work at the highest levels still represent only the contents of files. They don’t give you any tools for working with the filesystem. Some of their methods can create a file, but they cannot rename or delete a file, or create or delete a directory.

This chapter describes classes that represent the filesystem. They allow you to create, rename, and delete files and directories. The final section in this chapter explains another important file-managing topic: how to use the recycle bin (wastebasket).

Filesystem Permissions

A program cannot perform a task unless the user has the appropriate permissions. Although this is true of every application, it’s a particular issue for those that work with files. Users need the appropriate permissions to read, write, create, and delete files and directories.

A common mistake is for developers to build and test an application from an account that has a lot of privileges. The program runs fine from the developer’s account, but normal users can’t use it because they don’t have the necessary privileges.

To ensure that users can use a program, you should always test it from an account that has typical user privileges.

.NET Framework Classes

The System.IO namespace provides several classes for working with the filesystem. The DirectoryInfo and FileInfo classes let you work with specific filesystem objects. For example, a FileInfo object represents a particular file and provides methods to create, rename, delete, and get information about that file.

The Directory and File classes provide static methods that you can use to manipulate the filesystem without creating instances of helper objects. For example, the Directory class’s Delete method lets you delete a directory without creating a DirectoryInfo object associated with the directory.

The following sections describe these and the other classes that the .NET Framework provides to help you work with the filesystem.

Directory

The Directory class provides static methods for working with directories. These methods let you create, rename, move, and delete directories. They also let you enumerate the files and subdirectories within a directory, and get and set directory information such as the directory’s creation and last access times.

The following table describes the Directory class’s static methods.

File

The preceding chapter mentioned the File class and specifically its Exists method. This class provides many other static methods for working with files. These methods let you create, rename, move, and delete files. They also make working with file streams a bit easier.

The following table describes the File class’s most useful static methods.

DriveInfo

A DriveInfo object represents one of the computer’s drives. The following table describes the properties provided by this class. Note that some of these properties are available only when the drive is ready, as indicated in the following table’s Must Be Ready column. If you try to access them when the drive is not ready, C# throws an exception.

The DriveInfo class also has a public static GetDrives method that returns an array of DriveInfo objects describing the system’s drives.

DirectoryInfo

A DirectoryInfo object represents a directory. You can use its properties and methods to create and delete directories and to move through a directory hierarchy. The following table describes the most useful public properties and methods provided by the DirectoryInfo class.

FileInfo

A FileInfo object represents a file. You can use its properties and methods to create and delete files. The following table describes the most useful public properties and methods provided by the FileInfo class.

FileSystemWatcher

The FileSystemWatcher class keeps an eye on part of the file system and raises events to let your program know if something changes. For example, a FileSystemWatcher can monitor a directory and raise an event when a new file appears so your program can process the file.

The FileSystemWatcher class’s constructor takes parameters that tell it which directory to watch and that give it a filter for selecting files to watch. For example, the filter *.txt makes it watch for changes to text files. The default filter is *.*, which catches changes to all files that have extensions.

The following table describes the FileSystemWatcher class’s most useful properties.

The FileSystemWatcher class provides only two useful methods. The first method, Dispose, releases resources used by the component. As usual, be sure to call Dispose when you are done with the object (or use a using statement).

The second method, WaitForChanged, waits for a change synchronously (with an optional timeout). When a change occurs, the method returns a WaitForChangedResult object, giving information about the change that occurred.

When the FileSystemWatcher detects a change asynchronously, it raises an event to let the program know what has happened. The following table describes the class’s events.

Path

The Path class provides static properties and methods that you can use to manipulate paths. Its methods return the path’s filename, extension, directory name, and so forth.

Other methods provide values that relate to system-generated paths. For example, they can give you the system’s temporary directory path or the name of a temporary file.

The following table describes the Path class’s most useful public properties.

The following table describes the Path class’s most useful methods.

Using the Recycle Bin

Unfortunately, C# doesn’t include methods for working with the recycle bin. However, you can use a combination of three different techniques: using the FileIO.FileSystem class, using API functions, and using Shell32.Shell.

The ManageRecycleBin example program, which is available for download on this book’s website, demonstrates the techniques described in the following sections. Enter a file or directory name and click the corresponding Delete button to move that item into the recycle bin. Click Refresh to refresh the list of files in the recycle bin. Click Empty to permanently remove all the files from the recycle bin. Finally, right-click a file in the recycle bin to see a context menu giving commands you can apply to that file, as shown in Figure 19-1.

You may want to download the ManageRecycleBin example program so that you can refer to it as you read the following sections.

Using the FileIO.FileSystem Class

The Microsoft.VisualBasic.FileIO namespace includes a FileSystem class that provides DeleteDirectory and DeleteFile methods. Those methods can take an optional parameter that indicates whether you want to move the directory or file into the recycle bin, or whether you want to delete the directory or file permanently. (They can also take a parameter that lets you decide whether the methods should display progress dialogs.)

Some C# developers prefer not to use classes defined in the Microsoft.VisualBasic namespace, feeling they are somehow not C#ish enough. Personally, I think that’s just plain silly. If the Microsoft.VisualBasic namespace includes tools that you can use to make your life easier, you’re only hurting yourself by ignoring them. This class is in the .NET Framework, so it’s not like you’re sneaking around using some sort of substandard back alley code.

The following code shows the event handlers the ManageRecycleBin program executes when you click one of its Delete buttons.

// Delete a file.
private void deleteFileButton_Click(object sender, EventArgs e)
{
    FileSystem.DeleteFile(fileTextBox.Text,
        UIOption.OnlyErrorDialogs, RecycleOption.SendToRecycleBin);
    fileTextBox.Clear();
    ListFiles();
}

// Delete a directory.
private void deleteDirectoryButton_Click(object sender, EventArgs e)
{
    FileSystem.DeleteDirectory(directoryTextBox.Text,
        UIOption.OnlyErrorDialogs, RecycleOption.SendToRecycleBin);
    directoryTextBox.Clear();
    ListFiles();
}

The first event handler deletes a file. It calls the FileSystem class’s DeleteFile method, passing it the name of the file to delete, a UIOption flag indicating the method should display only error messages (not animations or confirmation dialogs), and a RecycleOption value indicating the file should be moved to the recycle bin.

The code then clears the TextBox holding the file’s name and calls the ListFiles method. The ListFiles method uses Shell32.Shell, which is described shortly in the section “Using Shell32.Shell.”

Using API Functions

The FileIO.FileSystem class lets you easily move directories and files into the recycle bin, but it doesn’t give you any other tools for working with the recycle bin. It doesn’t let you determine the number or sizes of the items in the recycle bin, restore items from the recycle bin, or empty the recycle bin.

Fortunately, you can use the SHEmptyRecycleBin API function to empty the recycle bin relatively easily. This API function takes a parameter that is of the RecycleFlags enumerated type. (Actually, the function itself takes a uint as a parameter, but the enumeration makes it easier for your code to specify the wanted options.) The following code shows the enumeration’s definition.

[Flags]
private enum RecycleFlags : uint
{
    SHERB_NOCONFIRMATION = 0x1,
    SHERB_NOPROGRESSUI = 0x2,
    SHERB_NOSOUND = 0x4
}

The following code shows the API function’s declaration.

[DllImport("shell32.dll")]
static extern int SHEmptyRecycleBin(
    IntPtr hWnd, string pszRootPath, uint dwFlags);

Here shell32.dll is the library that contains the SHEmptyRecycleBin API function. This is different from the Shell32.Shell techniques described in the next section.

The ManageRecycleBin program uses the following EmptyRecycleBin method, which wraps the call to SHEmptyRecycleBin.

public static void EmptyRecycleBin(bool showProgress, bool playSound,
    bool confirm)
{
    RecycleFlags options = 0;
    if (!showProgress) options |= RecycleFlags.SHERB_NOPROGRESSUI;
    if (!playSound) options |= RecycleFlags.SHERB_NOSOUND;
    if (!confirm) options |= RecycleFlags.SHERB_NOCONFIRMATION;

    SHEmptyRecycleBin(IntPtr.Zero, null, (uint)options);
}

This method uses its parameters to create an appropriate RecycleFlags value. It then simply invokes the API function.

When you click the Empty button, the program uses the following code to invoke the EmptyRecycleBin method.

// Empty the recycle bin.
private void emptyButton_Click(object sender, EventArgs e)
{
    // Empty with sounds and making the user confirm.
    EmptyRecycleBin(false, true, true);

    // Refresh the list.
    ListFiles();
}

Using Shell32.Shell

Shell32.Shell is an interface for working with the Windows shell. One of the things you can do with the Shell interface is interact with virtual objects representing such things as remote printers and the recycle bin.

The files in the recycle bin are represented by FolderItems. To work with the files, the ManageRecycleBin program needs to keep track of those FolderItems. To do so, it stores information about the files in the following RecycleItemInfo class.

// A class to hold a FolderItem and return its name.
private class RecycleItemInfo
{
    public FolderItem Item;
    public RecycleItemInfo(FolderItem item)
    {
        Item = item;
    }
    public override string ToString()
    {
        return Item.Name;
    }
}

This class simply holds a FolderItem. It provides a constructor for easy initialization and overrides its ToString method to return the name of the file it represents.

The following code shows the ManageRecycleBin program’s ListFiles method.

// List the files in the recycle bin.
private void ListFiles()
{
    const int RECYCLE_BIN_NAMESPACE = 10;

    Shell shell = new Shell();
    Folder bin = shell.NameSpace(RECYCLE_BIN_NAMESPACE);

    // List the files.
    filesListBox.Items.Clear();
    foreach (FolderItem item in bin.Items())
    {
        filesListBox.Items.Add(new RecycleItemInfo(item));
    }
}

The method creates a new Shell interface and uses its NameSpace method to get a Folder interface representing the recycle bin. The parameter, which has value 10, is simply the “magic number” that represents the recycle bin.

Next, the method empties the file ListBox and loops through the FolderItems returned by the recycle Folder’s Items method. For each FolderItem, the program creates a RecycleItemInfo object and adds it to the ListBox.

Because the RecycleItemInfo class’s ToString method returns the FolderItem’s Name property, that is what is displayed by the ListBox.

The following code shows how the program responds when you right-click a file’s entry in the ListBox.

// On right-mouse down, display the item's verbs in a menu.
private void filesListBox_MouseDown(object sender, MouseEventArgs e)
{
    // Make sure it's the right button.
    if (e.Button != MouseButtons.Right) return;

    // Find the item under the mouse.
    int index = filesListBox.IndexFromPoint(e.Location);
    if (index < 0) return;

    // Select that item.
    filesListBox.SelectedIndex = index;

    // Get the item's RecycleItemInfo.
    RecycleItemInfo info = filesListBox.SelectedItem as RecycleItemInfo;

    // Get the item's FolderInfo object.
    FolderItem item = info.Item;

    // Make the context menu.
    ContextMenu menu = new ContextMenu();
    foreach (FolderItemVerb verb in item.Verbs())
    {
        MenuItem menuItem = new MenuItem(verb.Name, ContextMenuItem_Click);
        menuItem.Tag = verb;
        menu.MenuItems.Add(menuItem);
    }
    menu.Show(filesListBox, e.Location);
}

This code creates a context menu appropriate for the item that the user right-clicked. First, the method exits if the button pressed isn’t the right mouse button.

Next, the program uses the ListBox’s IndexFromPoint method to get the index of the item under the mouse. If there is no item there, the method exits. If there is an item below the mouse, the code selects it.

The code then converts the selected item into the RecycleItemInfo object that is stored in the ListBox and gets the FolderItem stored inside the object.

The method then creates a ContextMenu and loops through the list returned by the FolderItem’s Verbs method. Each of those items is a FolderItemVerb interface that represents something the FolderItem can do.

The code creates a new MenuItem representing each verb. The MenuItem displays its verb’s name and is associated with the ContextMenuItem_Click event handler. The code stores the FolderItemVerb in the MenuItem’s Tag property.

After it has created the ContextMenu and the verbs’ MenuItems, the program displays the ContextMenu.

The following code shows the ContextMenuItem_Click event handler.

// Perform some action on a file.
private void ContextMenuItem_Click(object sender, EventArgs e)
{
    // Get the MenuItem.
    MenuItem menuItem = sender as MenuItem;

    // Get the verb.
    FolderItemVerb verb = menuItem.Tag as FolderItemVerb;

    // Invoke the verb.
    verb.DoIt();

    // Redisplay the files.
    ListFiles();
}

First, this code gets the MenuItem that was clicked. It gets the corresponding FolderItemVerb from the MenuItem’s Tag property. The code invokes the FolderItemVerb’s DoIt method to make it perform whatever action it should take. It finishes by calling ListFiles to refresh the file list in case the verb changed the files in the recycle bin, for example, by restoring a file.

Download the ManageRecycleBin program to see additional details. The program isn’t exactly simple, but it does demonstrate techniques you can use to work with the recycle bin.

Summary

The System.IO namespace offers many classes that let you manipulate files and directories. Classes such as Directory, DirectoryInfo, File, and FileInfo make it easy to create, examine, move, rename, and delete directories and files. The File class’s ReadAllText and WriteAllText methods make it particularly easy to read or write an entire file.

The FileSystemWatcher class lets an application keep an eye on a file or directory and take action when it is changed. For example, a program can watch a spooling directory and take action when a new file appears in it.

The Path class provides miscellaneous support for working with paths. For example, it provides methods you can use to combine paths and resolve relative paths.

There is considerable overlap among these tools, so you don’t need to feel that you have to use them all. Take a good look so that you know what’s there, and then pick the tools that you find the most comfortable.

Finally this chapter explained techniques you can use to manage the recycle bin. Some of them are fairly complex, but at least the FileIO.FileSystem class makes moving a file or directory into the recycle reasonably simple.

So far the chapters in this book have explained how to do things locally on the user’s computer. The next chapter explains how a program can move off of the local computer to download files from the Internet.

Exercises

1. Write a program that lets the user select a directory and displays its creation, last access, and last write times.
2. Write a program that lets the user select a file and displays its creation, last access, and last write times. Let the user change the times and then set them for the file.
3. Write a program that lets the user get and set a file’s attributes. Use CheckBoxes to display and let the user specify attributes.
4. Write a program that uses File.ReadAllText and File.WriteAllText to save and restore the contents of a text file when it starts and stops. Compare your solution to the solution for Exercise 18-3.
5. Write a program that sorts the lines in a file. (Hint: Use File.ReadAllLines to get the lines, sort them, and then use File.WriteAllLines to write them back into the file.)
6. Write a program that lists the computer’s drives and whatever drive information is available from the DriveInfo class.
7. Modify the program you wrote for Exercise 6 so that it displays sizes in KB, MB, GB, or TB as appropriate.
8. Write a program that displays the name of the directory two levels higher than the directory where the program is executing. What happens if you run the program near the top of the directory hierarchy, for example, in C:?
9. Write a program that lets the user enter a directory path and a pattern. When the user clicks the Search button, the program should search the directory and its subdirectories for files matching the pattern.
10. Modify the program you wrote for Exercise 9 so that it shows the selected filenames (without paths) and their sizes.
11. Write a program that uses a FileSystemWatcher to watch the directory where the program is executing for changes. When a change occurs, the program should display the date and time, the type of change, and the changing file’s name.
12. Write a program that lets the user enter a filename and then uses the FileIO class to move the file into the recycle bin. (That’s all many programs need to do anyway. You can use the recycle bin on your desktop to manage its contents.)