.NET FRAMEWORK CLASSES

The System.IO namespace provides several classes for working with the filesystem. The Directory and File classes provide shared methods that you can use to manipulate the filesystem without creating instances of helper objects.

The DirectoryInfo and FileInfo classes let you work with specific relevant 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 following sections describe these and the other classes that the Framework provides to help you work with the filesystem.

Directory

The Directory class provides shared methods for working with directories. These methods let you create, rename, move, and delete directories. They 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 time.

The following table describes the Directory class’s shared methods:

File

The File class provides shared 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 shared 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 Must Be Ready column. If you try to access them when the drive is not ready, Visual Basic throws an exception. The program should check the IsReady property to determine whether the drive is ready before trying to use the AvailableFreeSpace, DriveFormat, TotalFreeSpace, or VolumeLabel properties.

The DriveInfo class also has a public shared method GetDrives 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 filesystem and raises events to let your program know if something changes. For example, you could make a FileSystemWatcher monitor a work directory. When a new file with a .job extension arrives, the watcher could raise an event and your application could 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 might be “*.txt” to watch for changes to text files. The default filter is “*.*”, which catches changes to all files that have an extension. Set the filter to the empty string “” to catch changes to all files including those without extensions.

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

The FileSystemWatcher class provides only two really useful methods. The first method, Dispose, releases resources used by the component. When you are finished using a watcher, call its Dispose method to allow garbage collection to reclaim its resources more efficiently.

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:

The following simple example shows how to use a FileSystemWatcher to look for new files in a directory:

Private WithEvents JobFileWatcher As FileSystemWatcher
 
Private Sub Form1_Load() Handles MyBase.Load
    Dim watch_path As String =
        FileSystem.GetParentPath(Application.StartupPath)
    JobFileWatcher = New FileSystemWatcher(watch_path, "*.job")
    JobFileWatcher.NotifyFilter = NotifyFilters.FileName
    JobFileWatcher.EnableRaisingEvents = True
End Sub
 
Private Sub JobFileWatcher_Created(sender As Object,
 e As FileSystemEventArgs) Handles JobFileWatcher.Created
    ' Process the new file.
    MessageBox.Show("Process new job: " & e.FullPath)
 
    File.Delete(e.FullPath)
End Sub

The program uses the WithEvents keyword to declare a FileSystemWatcher object. When the program’s main form loads, the Form1_Load event handler allocates this object. Its constructor sets the object’s path to the program’s startup directory’s parent. It sets the object’s filter to “*.job” so that the object will watch for changes to files that end with a .job extension.

The event handler sets the watcher’s NotifyFilter to FileName, so it will raise its Created event if a new filename appears in the target directory. Unfortunately, the NotifyFilter values (Attributes, CreationTime, DirectoryName, FileName, LastAccess, LastWrite, Security, and Size) do not match up well with the events provided by the FileSystemWatcher, so you need to figure out which NotifyFilter values to set to raise different kinds of events.

The Form1_Load event handler finishes by setting the watcher’s EnableRaisingEvents property to True so the object starts watching.

When a .job file is created in the watcher’s target directory, the program’s fswJobFiles_Created executes. The program processes and then deletes the file. In this example, the program processes the file by displaying a message giving its fully qualified name. A more realistic example might read the file; parse fields, indicating the type of job this is; assign it to an employee for handling; and then e-mail it to that employee.

The UseFileSystemWatcher example program, which is available for download on the book’s website, uses similar code without the filter to look for any new file in the program’s startup directory.

Path

The Path class provides shared 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.