Listens to the file system change notifications and raises events when a directory, or file in a directory, changes.
See Also: FileSystemWatcher Members
Use System.IO.FileSystemWatcher to watch for changes in a specified directory. You can watch for changes in files and subdirectories of the specified directory. You can create a component to watch files on a local computer, a network drive, or a remote computer.
To watch for changes in all files, set the FileSystemWatcher.Filter property to an empty string ("") or use wildcards ("*.*"). To watch a specific file, set the FileSystemWatcher.Filter property to the file name. For example, to watch for changes in the file MyDoc.txt, set the FileSystemWatcher.Filter property to "MyDoc.txt". You can also watch for changes in a certain type of file. For example, to watch for changes in text files, set the FileSystemWatcher.Filter property to "*.txt".
There are several types of changes you can watch for in a directory or file. For example, you can watch for changes in Attributes, the LastWrite date and time, or the Size of files or directories. This is done by setting the FileSystemWatcher.NotifyFilter property to one of the System.IO.NotifyFilters values. For more information on the type of changes you can watch, see System.IO.NotifyFilters.
You can watch for renaming, deletion, or creation of files or directories. For example, to watch for renaming of text files, set the FileSystemWatcher.Filter property to "*.txt" and call the FileSystemWatcher.WaitForChanged(WatcherChangeTypes) method with a WatcherChangeTypes.Renamed specified for its parameter.
The Windows operating system notifies your component of file changes in a buffer created by the System.IO.FileSystemWatcher. If there are many changes in a short time, the buffer can overflow. This causes the component to lose track of changes in the directory, and it will only provide blanket notification. Increasing the size of the buffer with the FileSystemWatcher.InternalBufferSize property is expensive, as it comes from non-paged memory that cannot be swapped out to disk, so keep the buffer as small yet large enough to not miss any file change events. To avoid a buffer overflow, use the FileSystemWatcher.NotifyFilter and FileSystemWatcher.IncludeSubdirectories properties so you can filter out unwanted change notifications.
Please note the following when using the System.IO.FileSystemWatcher class.
Hidden files are not ignored.
In some systems, System.IO.FileSystemWatcher reports changes to files using the short 8.3 file name format. For example, a change to "LongFileName.LongExtension" could be reported as "LongFil~.Lon".
This class contains a link demand and an inheritance demand at the class level that applies to all members. A System.Security.SecurityException is thrown when either the immediate caller or the derived class does not have full-trust permission. For details about security demands, see Link Demands.
The maximum size you can set for the FileSystemWatcher.InternalBufferSize property for monitoring a directory over the network is 64 KB.
Running System.IO.FileSystemWatcher on Windows 98 is not supported.
The operating system and System.IO.FileSystemWatcher object interpret a cut-and-paste action or a move action as a rename action for a folder and its contents. If you cut and paste a folder with files into a folder being watched, the System.IO.FileSystemWatcher object reports only the folder as new, but not its contents because they are essentially only renamed.
To be notified that the contents of folders have been moved or copied into a watched folder, provide FileSystemWatcher.OnChanged(FileSystemEventArgs) and FileSystemWatcher.OnRenamed(RenamedEventArgs) event handler methods as suggested in the following table.
Report changes in file attributes, created files, and deleted files.
List the old and new paths of renamed files and folders, expanding recursively if needed.
Note that several factors can affect which file system change events are raised, as described by the following:
Common file system operations might raise more than one event. For example, when a file is moved from one directory to another, several FileSystemWatcher.OnChanged(FileSystemEventArgs) and some FileSystemWatcher.OnCreated(FileSystemEventArgs) and FileSystemWatcher.OnDeleted(FileSystemEventArgs) events might be raised. Moving a file is a complex operation that consists of multiple simple operations, therefore raising multiple events. Likewise, some applications (for example, antivirus software) might cause additional file system events that are detected by System.IO.FileSystemWatcher.
The System.IO.FileSystemWatcher can watch disks as long as they are not switched or removed. The System.IO.FileSystemWatcher does not raise events for CDs and DVDs, because time stamps and properties cannot change. Remote computers must have one of the required platforms installed for the component to function properly.
If multiple System.IO.FileSystemWatcher objects are watching the same UNC path in Windows XP prior to Service Pack 1, or Windows 2000 SP2 or earlier, then only one of the objects will raise an event. On machines running Windows XP SP1 and newer, Windows 2000 SP3 or newer or Windows Server 2003, all System.IO.FileSystemWatcher objects will raise the appropriate events.
Note that a System.IO.FileSystemWatcher may miss an event when the buffer size is exceeded. To avoid missing events, follow these guidelines:
Increase the buffer size by setting the FileSystemWatcher.InternalBufferSize property.
Avoid watching files with long file names, because a long file name contributes to filling up the buffer. Consider renaming these files using shorter names.
Keep your event handling code as short as possible.