You may encounter the following situations while working with the FileSystemWatcher component:

UNC Path Names Not Accepted on Windows NT 4.0 Computers

If you are working with a FileSystemWatcher component on a Windows NT version 4.0 computer and trying to set its path to monitor file system activity on a different Windows NT version 4.0 computer, you will not be able to specify a UNC-based path value in the Path property to point to the computer in question. You can only set UNC-based values when working on Windows 2000 computers.

Cannot Watch Windows 95 or Windows 98 Directories

If you set your FileSystemWatcher component to reference a directory on a Windows 95 or Windows 98 computer, you will receive an error about an invalid directory path when the project runs. When using FileSystemWatcher, you cannot watch directories on computers running Windows 95 or Windows 98.

Multiple Created Events Generated for a Single Action

You may notice in certain situations that a single creation event generates multiple Created events that are handled by your component. For example, if you use aFileSystemWatcher component to monitor the creation of new files in a directory, and then test it by using Notepad to create a file, you may see two Created events generated even though only a single file was created. This is because Notepad performs multiple file system actions during the writing process. Notepad writes to the disk in batches that create the content of the file and then the file attributes. Other applications may perform in the same manner. Because FileSystemWatcher monitors the operating system activities, all events that these applications fire will be picked up.

Note   Notepad may also cause other interesting event generations. For example, if you use the ChangeEventFilter to specify that you want to watch only for attribute changes, and then you write to a file in the directory you are watching using Notepad, you will raise an event . This is because Notepad updates theArchived attribute for the file during this operation.

Unexpected Events Generated on Directories

Changing a file within a directory you are monitoring with a FileSystemWatcher component generates not only a Changed event on the file but also a similar event for the directory itself. This is because the directory maintains several types of information for each file it contains — the names and sizes of files, their modification dates, attributes, and so on. Whenever one of these attributes changes, a change is associated with the directory as well.

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5. using System.IO;  
6. using System.Threading;  
7.   
8. namespace ShareReadFile  
9. {  
10.     public delegate void FileSystemEvent(String path);  
11.   
12.     public interface IDirectoryMonitor  
13.     {  
14.         event FileSystemEvent Change;  
15.         void Start();  
16.     }  
17.   
18.     public class DirectoryMonitor : IDirectoryMonitor  
19.     {  
20.         private readonly FileSystemWatcher m_fileSystemWatcher = new FileSystemWatcher();  
21.         private readonly Dictionary<string, DateTime> m_pendingEvents = new Dictionary<string, DateTime>();  
22.         private readonly Timer m_timer;  
23.         private bool m_timerStarted = false;  
24.   
25.         public DirectoryMonitor(string dirPath)  
26.         {  
27.             m_fileSystemWatcher.Path = dirPath;  
28.             m_fileSystemWatcher.IncludeSubdirectories = false;  
29.             m_fileSystemWatcher.Created += new FileSystemEventHandler(OnChange);  
30.             m_fileSystemWatcher.Changed += new FileSystemEventHandler(OnChange);  
31.   
32.             m_timer = new Timer(OnTimeout, null, Timeout.Infinite, Timeout.Infinite);  
33.         }  
34.   
35.         public event FileSystemEvent Change;  
36.   
37.         public void Start()  
38.         {  
39.             m_fileSystemWatcher.EnableRaisingEvents = true;  
40.         }  
41.   
42.         private void OnChange(object sender, FileSystemEventArgs e)  
43.         {  
44.             // Don‘t want other threads messing with the pending events right now  
45.             lock (m_pendingEvents)  
46.             {  
47.                 // Save a timestamp for the most recent event for this path  
48.                 m_pendingEvents[e.FullPath] = DateTime.Now;  
49.   
50.                 // Start a timer if not already started  
51.                 if (!m_timerStarted)  
52.                 {  
53.                     m_timer.Change(100, 100);  
54.                     m_timerStarted = true;  
55.                 }  
56.             }  
57.         }  
58.   
59.         private void OnTimeout(object state)  
60.         {  
61.             List<string> paths;  
62.   
63.             // Don‘t want other threads messing with the pending events right now  
64.             lock (m_pendingEvents)  
65.             {  
66.                 // Get a list of all paths that should have events thrown  
67.                 paths = FindReadyPaths(m_pendingEvents);  
68.   
69.                 // Remove paths that are going to be used now  
70.                 paths.ForEach(delegate(string path)  
71.                 {  
72.                     m_pendingEvents.Remove(path);  
73.                 });  
74.   
75.                 // Stop the timer if there are no more events pending  
76.                 if (m_pendingEvents.Count == 0)  
77.                 {  
78.                     m_timer.Change(Timeout.Infinite, Timeout.Infinite);  
79.                     m_timerStarted = false;  
80.                 }  
81.             }  
82.   
83.             // Fire an event for each path that has changed  
84.             paths.ForEach(delegate(string path)  
85.             {  
86.                 FireEvent(path);  
87.             });  
88.         }  
89.   
90.         private List<string> FindReadyPaths(Dictionary<string, DateTime> events)  
91.         {  
92.             List<string> results = new List<string>();  
93.             DateTime now = DateTime.Now;  
94.   
95.             foreach (KeyValuePair<string, DateTime> entry in events)  
96.             {  
97.                 // If the path has not received a new event in the last 75ms  
98.                 // an event for the path should be fired  
99.                 double diff = now.Subtract(entry.Value).TotalMilliseconds;  
100.                 if (diff >= 75)  
101.                 {  
102.                     results.Add(entry.Key);  
103.                 }  
104.             }  
105.   
106.             return results;  
107.         }  
108.   
109.         private void FireEvent(string path)  
110.         {  
111.             FileSystemEvent evt = Change;  
112.             if (evt != null)  
113.             {  
114.                 evt(path);  
115.             }  
116.         }  
117.     }  
118. }