C# Watch Files in Drive FileSystemWatcher

Thereare many instances that require systems to perform certain tasks when files ordirectories are created or modified. One example of this is an import systemthat pulls flat files into a database. In this instance, a program must monitora directory for newly created files. When a file is created, the program mustpick up the file, parse it, and insert it into the database. Many timesthis type of functionality is accomplished by “polling” the directoryand enumerating any new files that have been created since the last poll. Withthe introduction of the .NETFramework, Microsoft has provided developers with an alternative to constantly polling adirectory for new files–the FileSystemWatcher object.

The FileSystemWatcher object does the work of monitoringa directory for you. When a file is created, updated, or deleted, the FileSystemWatcher fires an event to notify you that achange has occurred. This allows your program to know when a new file isavailable almost immediately after the file is created. Immediatenotification of changes allows your system to work much more efficiently sinceyou’re not constantly polling the directory for changes, and there is no timelapse between scans of the directory.

The FileSystemWatcher basics

There are a few basic properties and events you need to familiarize yourself with before working with the FileSystemWatcher object. Undoubtedly, the mostimportant property of this object is the “EnableRaisingEvents” property. This property determines whether ornot the object will fire events when it receives a change notification. If EnableRaisingEvents is set to false, the object willnot fire the change events. If it is set to true, the events will be fired.Below are several other important properties/events that you will use as youtake advantage of FileSystemWatcher:

Properties:

Path — This property tells the FileSystemWatcher which path it needs to monitor. For example, if we set this property to “C:\Temp\”, all changes in that directory would be monitored.
IncludeSubDirectories — This property indicates whether or not the FileSystemWatcher should monitor subdirectories for changes.
Filter — This property allows you to filter the changes for certain file types. For example, if we wanted to be notified only when TXT files are modified/created/deleted, we would set this property to “*.java”. This property is very handy when working with high-traffic or large directories.
Events:

Changed — This event is fired when a file has been modified in the directory thatis being monitored. It is important to note that this event may be fired multiple times, even when only one change to the content of the file has occurred. This is due to other properties of the file changing as the file is saved.
Created — This event is fired when a file is created in the directory that is being monitored. If you are planning to use this event to move the file that was created, you must write some error handling in your event handler that can handle situations where the file is currently in use by another process. The reason for this is that the Created event can be fired before the process that created the file has released the file. This will cause exceptions to be thrown if you have not prepared the code correctly.
Deleted — This event is fired when a file is deleted in the directory that is being watched.
Renamed — This event is fired when a file is renamed in the directory that is being watched.
Note: None of these events will be firedif you do not have EnableRaisingEvents set to true. If at any point your FileSystemWatcher does not seem to be working, check EnableRaisingEvents first to make sure it is set totrue.

Event processing

Whenan event handler is called by the FileSystemWatcher, it contains two arguments–an object called “sender”,and a FileSystemEventArgs object called “e”. Theargument we’re interested in is the FileSystemEventArgs argument. This object contains information aboutwhat caused the event to be fired. The following is available from the FileSystemEventArgs object:

Properties:

Name — This property contains the name of the file that caused the event to be fired. It DOES NOT contain that path to the file–only the file or directory name that caused the event to be fired.
ChangeType — This is a type of WatcherChangeTypes and indicates which type of event was fired. Valid values are:
Changed
Created
Deleted
Renamed
FullPath — This contains the full path to the file that caused the event to fire. It includes the filename and the directory name.
Example code


using System;
using System.IO;

public class DirectoryChangeListener
{
    public DirectoryChangeListener()
	{
	}
    
    public static void Main(){

       FileSystemWatcher watcher = new FileSystemWatcher();
       Console.WriteLine("Started....");

      //watcher.SynchronizingObject = this;

         watcher.Path =Path.GetDirectoryName(@"C:\Program Files");
         //watcher.Filter = Path.GetFileName(@"c:\a.txt");
         watcher.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.Size;
         watcher.IncludeSubdirectories = true;
          watcher.Deleted += new System.IO.FileSystemEventHandler(OnDelete);
          watcher.Renamed += new System.IO.RenamedEventHandler(OnRenamed);
          watcher.Changed += new System.IO.FileSystemEventHandler(OnChanged);
          watcher.Created += new System.IO.FileSystemEventHandler(OnCreate);
          watcher.EnableRaisingEvents = true;

          Console.ReadLine();
       }
     
      public static void OnChanged(object source, FileSystemEventArgs e) {
         Console.WriteLine("File: {0} {1}", e.FullPath, e.ChangeType.ToString());
      }
 
 
      public static void OnRenamed(object source, RenamedEventArgs e){
         Console.WriteLine("File renamed from {0} to {1}", e.OldName, e.FullPath);
      }
 
 
      public static void OnDelete(object source, FileSystemEventArgs e)
      {
          Console.WriteLine("File: {0} Deleted", e.FullPath);
      }
      public static void OnCreate(object source, FileSystemEventArgs e)
      {
          Console.WriteLine("File: {0} Created", e.FullPath);
      }
  
   }
Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s