FileSystemWatcher Class

Definition

public ref class FileSystemWatcher : System::ComponentModel::Component, System::ComponentModel::ISupportInitialize

public ref class FileSystemWatcher : IDisposable

public class FileSystemWatcher : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize

public class FileSystemWatcher : IDisposable

[System.IO.IODescription("FileSystemWatcherDesc")]
public class FileSystemWatcher : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize

type FileSystemWatcher = class
 inherit Component
 interface ISupportInitialize

type FileSystemWatcher = class
 interface IDisposable

[<System.IO.IODescription("FileSystemWatcherDesc")>]
type FileSystemWatcher = class
 inherit Component
 interface ISupportInitialize

Public Class FileSystemWatcher
Inherits Component
Implements ISupportInitialize

Public Class FileSystemWatcher
Implements IDisposable

Inheritance

Object

MarshalByRefObject

Component

FileSystemWatcher

Inheritance

Object

FileSystemWatcher

Attributes

IODescriptionAttribute

Implements

ISupportInitialize IDisposable

Examples

The following example creates a FileSystemWatcher to watch the directory specified at run time. The component is set to watch for changes in LastWrite and LastAccess time, the creation, deletion, or renaming of text files in the directory. If a file is changed, created, or deleted, the path to the file prints to the console. When a file is renamed, the old and new paths print to the console.

using System;
using System.IO;

namespace MyNamespace
{
 class MyClassCS
 {
 static void Main()
 {
 using var watcher = new FileSystemWatcher(@"C:\path\to\folder");

 watcher.NotifyFilter = NotifyFilters.Attributes
 | NotifyFilters.CreationTime
 | NotifyFilters.DirectoryName
 | NotifyFilters.FileName
 | NotifyFilters.LastAccess
 | NotifyFilters.LastWrite
 | NotifyFilters.Security
 | NotifyFilters.Size;

 watcher.Changed += OnChanged;
 watcher.Created += OnCreated;
 watcher.Deleted += OnDeleted;
 watcher.Renamed += OnRenamed;
 watcher.Error += OnError;

 watcher.Filter = "*.txt";
 watcher.IncludeSubdirectories = true;
 watcher.EnableRaisingEvents = true;

 Console.WriteLine("Press enter to exit.");
 Console.ReadLine();
 }

 private static void OnChanged(object sender, FileSystemEventArgs e)
 {
 if (e.ChangeType != WatcherChangeTypes.Changed)
 {
 return;
 }
 Console.WriteLine($"Changed: {e.FullPath}");
 }

 private static void OnCreated(object sender, FileSystemEventArgs e)
 {
 string value = $"Created: {e.FullPath}";
 Console.WriteLine(value);
 }

 private static void OnDeleted(object sender, FileSystemEventArgs e) =>
 Console.WriteLine($"Deleted: {e.FullPath}");

 private static void OnRenamed(object sender, RenamedEventArgs e)
 {
 Console.WriteLine($"Renamed:");
 Console.WriteLine($" Old: {e.OldFullPath}");
 Console.WriteLine($" New: {e.FullPath}");
 }

 private static void OnError(object sender, ErrorEventArgs e) =>
 PrintException(e.GetException());

 private static void PrintException(Exception? ex)
 {
 if (ex != null)
 {
 Console.WriteLine($"Message: {ex.Message}");
 Console.WriteLine("Stacktrace:");
 Console.WriteLine(ex.StackTrace);
 Console.WriteLine();
 PrintException(ex.InnerException);
 }
 }
 }
}

Imports System.IO

Namespace MyNamespace

 Class MyClassVB

 Shared Sub Main()
 Using watcher = New FileSystemWatcher("C:\path\to\folder")
 watcher.NotifyFilter = NotifyFilters.Attributes Or
 NotifyFilters.CreationTime Or
 NotifyFilters.DirectoryName Or
 NotifyFilters.FileName Or
 NotifyFilters.LastAccess Or
 NotifyFilters.LastWrite Or
 NotifyFilters.Security Or
 NotifyFilters.Size

 AddHandler watcher.Changed, AddressOf OnChanged
 AddHandler watcher.Created, AddressOf OnCreated
 AddHandler watcher.Deleted, AddressOf OnDeleted
 AddHandler watcher.Renamed, AddressOf OnRenamed
 AddHandler watcher.Error, AddressOf OnError

 watcher.Filter = "*.txt"
 watcher.IncludeSubdirectories = True
 watcher.EnableRaisingEvents = True

 Console.WriteLine("Press enter to exit.")
 Console.ReadLine()
 End Using
 End Sub

 Private Shared Sub OnChanged(sender As Object, e As FileSystemEventArgs)
 If e.ChangeType <> WatcherChangeTypes.Changed Then
 Return
 End If
 Console.WriteLine($"Changed: {e.FullPath}")
 End Sub

 Private Shared Sub OnCreated(sender As Object, e As FileSystemEventArgs)
 Dim value As String = $"Created: {e.FullPath}"
 Console.WriteLine(value)
 End Sub

 Private Shared Sub OnDeleted(sender As Object, e As FileSystemEventArgs)
 Console.WriteLine($"Deleted: {e.FullPath}")
 End Sub

 Private Shared Sub OnRenamed(sender As Object, e As RenamedEventArgs)
 Console.WriteLine($"Renamed:")
 Console.WriteLine($" Old: {e.OldFullPath}")
 Console.WriteLine($" New: {e.FullPath}")
 End Sub

 Private Shared Sub OnError(sender As Object, e As ErrorEventArgs)
 PrintException(e.GetException())
 End Sub

 Private Shared Sub PrintException(ex As Exception)
 If ex IsNot Nothing Then
 Console.WriteLine($"Message: {ex.Message}")
 Console.WriteLine("Stacktrace:")
 Console.WriteLine(ex.StackTrace)
 Console.WriteLine()
 PrintException(ex.InnerException)
 End If
 End Sub

 End Class

End Namespace

Remarks

Use 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 Filter property to an empty string ("") or use wildcards ("*.*"). To watch a specific file, set the Filter property to the file name. For example, to watch for changes in the file MyDoc.txt, set the 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 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 NotifyFilter property to one of the NotifyFilters values. For more information on the type of changes you can watch, see NotifyFilters.

You can watch for renaming, deletion, or creation of files or directories. For example, to watch for renaming of text files, set the Filter property to "*.txt" and call the WaitForChanged method with a Renamed specified for its parameter.

The Windows operating system notifies your component of file changes in a buffer created by the 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 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 NotifyFilter and IncludeSubdirectories properties so you can filter out unwanted change notifications.

For a list of initial property values for an instance of FileSystemWatcher, see the FileSystemWatcher constructor.

Consider the following facts when you use the FileSystemWatcher class:

• Hidden files aren't ignored.
• In some systems, 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".
• The maximum size you can set for the InternalBufferSize property for monitoring a directory over the network is 64 KB.

Copy and move folders

The operating system and 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 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 OnChanged and OnRenamed event handler methods as suggested in the following table.

Events and buffer sizes

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 OnChanged and some OnCreated and OnDeleted 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 FileSystemWatcher.
• The FileSystemWatcher can watch disks as long as they are not switched or removed. The 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.

Note that a 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 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.

See also

• NotifyFilter
• NotifyFilters
• FileSystemEventArgs
• FileSystemEventHandler
• Filter
• IncludeSubdirectories
• InternalBufferOverflowException
• RenamedEventArgs
• RenamedEventHandler
• WaitForChangedResult
• WatcherChangeTypes
• Using a FileSystemWatcher Component in a Windows Form