How to detect file system changes in C#

CodeGuru content and product recommendations are editorially independent. We may make money when you click on links to our partners. Learn More.

C# Programming Guide

The C# programming language provides several methods for working with files and directories. For example, you can create, modify, rename, and delete files and directories easily. When working with files, developers might often want to detect changes in the file system so that appropriate action can be taken.

Programmers can take advantage of the FileSystemWatcher class in C# to monitor file system changes and trigger events. You can use it to monitor the file system for changes by monitoring a single file, a directory, or even all files inside a directory.

This C# programming tutorial presents a discussion on the file system, why it is important, file system changes, and how to use the FileSystemWatcher class to detect file system changes with C#.

Read: C# Tools for Code Quality

What is a File System and What are File System Changes?

A file system defines how the operating system organizes the files and folders in a disk. In other words, it represents the basic structure that an operating system uses to store, manage, and keep track of files on a storage device, such as a hard drive. Each file system has its way of organizing files and has different capabilities and features. Many file systems exist, such as FAT, NTFS, Unix, HFS+, etc.

A file system change is an event that occurs when the status of a file system changes. This can happen when a file or a directory is created, modified, or deleted. Changes can also occur in the file system’s structure, such as when a directory is renamed or moved.

Detecting file system changes can be necessary for several reasons. For example, a developer may want to monitor a directory for new files and process them accordingly. Or, you may want to track changes to a configuration file so you can reload it if necessary.

How to Detect File System Changes in C#

There are a few different ways to detect file system changes in C#. One such way is to use the FileSystemWatcher class. This class allows coders to specify which directory they want to monitor and provides events that a programmer can handle when changes occur.

Another option is to use the FindFirstChangeNotification and FindNextChangeNotification methods. These methods provide a lower-level way of monitoring changes and require more manual processing than the FileSystemWatcher class.

Read: Project Management Software for Developers

The FileSystemWatcher Class in C#

As mentioned, you can monitor changes to your file system and take appropriate action using the FileSystem Watcher class; it is a great way to keep track of what’s going on in your file system and ensure that your data is always up-to-date.

The FileSystemWatcher class in C# makes it easy to detect file system changes in your code – all programmers need to do is set up a watcher and handle the Changed, Created, and Deleted events. We demonstrate how to do this in the following sections.

Configuring FileSystemWatcher to Watch for Changes

Once you have an instance of the FileSystemWatcher class, you can configure it to watch for changes to specific files or folders. To do this, you need to set the Path property to the path of the file or folder you want to watch and set the Filter property to the type of file you want to watch. You can also set the IncludeSubdirectories property to true if you are going to watch for changes in subdirectories.

The following code example shows how to configure FileSystemWatcher in C#:

FileSystemWatcher fileSystemWatcher = new FileSystemWatcher();
fileSystemWatcher.Path = @"C:\temp"; 
fileSystemWatcher.Filter = "*.txt";
fileSystemWatcher.IncludeSubdirectories = true;

The NotifyFilter property can be used to specify which types of changes you want to be notified about. The available options are:

  • FileName
  • DirectoryName
  • Attributes
  • Size
  • LastWrite
  • LastAccess
  • CreationTime
  • Security

Note that you can choose to be notified for several changes to the file system as well. For example, to be notified about changes to file names and attributes, you would use the following C# code:

FileSystemWatcher fileSystemWatcher = new FileSystemWatcher();
fileSystemWatcher.Path = @"C:\temp"; 
fileSystemWatcher.Filter = "*.txt";
fileSystemWatcher.IncludeSubdirectories = true;
fileSystemWatcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.Attributes;

Read: How to Work with Serilog in C# and ASP.NET

Working with Events in C#

Now that the FileSystemWatcher is configured, we need to tell it what to do when a change is detected. We do this by subscribing to one of the events that the FileSystemWatcher class exposes. The most common event to subscribe to is the Changed event.

The FileSystemWatcher class raises a number of events, including:

  • Changed: This event is generated when you modify a file or directory in the path being watched.
  • Created: This event occurs whenever you create a file or directory in the path you would like to monitor.
  • Deleted: This event occurs when a file or directory is deleted from the path you would like to monitor.
  • Error: This event is generated if there is an error in the monitored path.
  • Renamed: Whenever you rename a file or directory within the monitored path, this event will be triggered.

The following code snippet illustrates how you can register events using FileSystemWatcher in C#:

FileSystemWatcher fileSystemWatcher = new FileSystemWatcher();
fileSystemWatcher.Path = @ "C:\temp";
fileSystemWatcher.Filter = "*.txt";
fileSystemWatcher.IncludeSubdirectories = true;
fileSystemWatcher.Created += FileSystemWatcherEvent_Created;
fileSystemWatcher.Renamed += FileSystemWatcherEvent_Renamed;
fileSystemWatcher.Deleted += FileSystemWatcherEvent_Deleted;
fileSystemWatcher.EnableRaisingEvents = true;

Note that, for each of the events mentioned here, you should have the corresponding event handler available.

Pros and Cons of Using the FileSystemWatcher Class in C#

There are some pros and cons to using the FileSystemWatcher class in your C# code. Here are some of the pros and cons to consider before using the class:


  • Easy to use and can be set up quickly.
  • Programmers can leverage the FileSystemWatcher class to monitor a folder and its sub-folders at once.
  • Can be used to monitor both local and remote file systems.


  • Can be resource intensive, so it is important to use it wisely.
  • May not work correctly on all file systems.

Final Thoughts on System Changes in C#

The ability to detect file system changes can be a valuable tool in many different situations. This C# programming tutorial discussed how coders could see file system changes using the FileSystemWatcher class in C#. We also learned to filter the events raised and how to respond to them. With this knowledge, you should be able to add file system change detection to your applications as needed.

Read more C# programming tutorials and software development guides.

Joydip Kanjilal
Joydip Kanjilal
A Microsoft Most Valuable Professional in ASP.NET, Speaker, and Author of several books and articles. More than 25 years of experience in IT with more than 18 years in Microsoft .NET and its related technologies. He was selected as a Community Credit Winner at several times. He has authored 8 books and more than 500 articles in some of the most reputed sites worldwide including MSDN, Info World, CodeMag, Tech Beacon, Tech Target, Developer, CodeGuru, and more.

More by Author

Get the Free Newsletter!

Subscribe to Developer Insider for top news, trends & analysis

Must Read