This appendix describes the .NET Framework’s filesystem classes. It also summarizes methods you can use to manage the recycle bin.

Framework Classes

The System.IO namespace provides several classes for working with the filesystem. The following sections describe the properties, methods, and events provided by these classes.

Directory

The Directory class provides static methods for working with directories. The following table summarizes those static methods.

File

The File class provides static methods for working with files. The following table summarizes its 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. The final column in the table indicates whether a drive must be ready for the property to work without throwing an exception. Use the IsReady property to see whether the drive is ready before using those properties.

DirectoryInfo

A DirectoryInfo object represents a directory. The following table summarizes its most useful properties and methods.

FileInfo

A FileInfo object represents a file. The following table summarizes its most useful properties and methods.

FileSystemWatcher

The FileSystemWatcher class lets an application watch for changes to a file or directory. The following table summarizes its most useful properties.

The following table summarizes the FileSystemWatcher class’s two most useful methods.

The following table summarizes the class’s events.

Path

The Path class provides static properties and methods that you can use to manipulate paths. The following table summarizes its most useful public properties.

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

Special Folders

The System.Environment.SpecialFolder enumeration defines SpecialFolder objects representing folders such as MyDocuments, History, and CommonProgramFiles. Use a SpecialFolder object’s ToString method to get the folder’s name. Use Environment.GetFolderPath to get the directory’s path.

The following code lists special folders.

foreach (Environment.SpecialFolder folderType
    in Enum.GetValues(typeof(Environment.SpecialFolder)))
{
    Console.WriteLine(
        String.Format("{0,-25}{1}",
            folderType.ToString(),
            Environment.GetFolderPath(folderType)
        )
    );
}

Recycle Bin

C# doesn’t provide tools for working with the recycle bin, but you can manage the recycle bin by using a combination of three techniques: using the FileIO.FileSystem class, using API functions, and using Shell32.Shell.

FileIO.FileSystem

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.)

To use the FileSystem class to move files and directories into the recycle bin, add a reference to the Microsoft.VisualBasic library. Then use the class’s static DeleteFile and DeleteDirectory methods.

API Functions

The SHEmptyRecycleBin API function lets you empty the recycle bin. To use this function, add the following code to a class outside any methods.

[Flags]
private enum RecycleFlags : uint
{
    SHERB_NOCONFIRMATION = 0x1,
    SHERB_NOPROGRESSUI = 0x2,
    SHERB_NOSOUND = 0x4
}
[DllImport("shell32.dll")]
static extern int SHEmptyRecycleBin(
    IntPtr hWnd, string pszRootPath, uint dwFlags);

This code defines the RecycleFlags enumeration and the SHEmptyRecycleBin API function.

Now you can call the function, passing it appropriate parameters. The following EmptyRecycleBin method wraps the call to the API function to make it a bit easier to use.

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 parameter values to compose an appropriate RecycleFlags value and then calls the API function.

Shell32.Shell

Shell32.Shell is an interface for working with the Windows shell. It enables you to interact with virtual objects representing such things as the recycle bin.

To use Shell32.Shell, first add a reference to “Microsoft Shell Controls And Automation” on the Reference Manager’s COM tab. To make using the Shell class easier, add the following using directive to the program.

using Shell32;

Now you can use code similar to the following to enumerate the files in the recycle bin.

const int RECYCLE_BIN_NAMESPACE = 10;

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

// List the files.
foreach (FolderItem item in bin.Items())
{
    Console.WriteLine(item.Name + "
    " + item.Path);
}

This code creates a new Shell object and uses that object’s NameSpace method to get a Folder object representing the recycle bin. It then loops through the items returned by the Folder’s Items method, displaying each item’s name and path.