C＃实现对文件目录的实时监控

　C＃实现对文件目录的实时监控 主要描述如何通过C＃实现实时监控文件目录下的变化，包括文件和目录的添加，删除，修改和重命名等操作。

　　首先，我们需要对.net提供的FileSystemWatcher类有所了解。我有些懒，找了MSDN对该类的描述。

　　FileSystemWatcher类侦听文件系统更改通知，并在目录或目录中的文件发生更改时引发事件。

　　使用 FileSystemWatcher 监视指定目录中的更改。可监视指定目录中的文件或子目录的更改。可以创建一个组件来监视本地计算机、网络驱动器或远程计算机上的文件。

　　若要监视所有文件中的更改，请将 Filter 属性设置为空字符串 ("") 或使用通配符（“*.*”）。若要监视特定的文件，请将 Filter 属性设置为该文件名。例如，若要监视文件 MyDoc.txt 中的更改，请将 Filter 属性设置为“MyDoc.txt”。也可以监视特定类型文件中的更改。例如，若要监视文本文件中的更改，请将 Filter 属性设置为“*.txt”。

　　可监视目录或文件中的若干种更改。例如，可监视文件或目录的 Attributes、LastWrite 日期和时间或 Size 方面的更改。通过将 NotifyFilter 属性设置为 NotifyFilters 值之一来达到此目的。有关可监视的更改类型的更多信息，请参见 NotifyFilters。

　　可监视文件或目录的重命名、删除或创建。例如，若要监视文本文件的重命名，请将 Filter 属性设置为“*.txt”，并使用为其参数指定的 Renamed 来调用 WaitForChanged 方法。

　　Windows 操作系统在 FileSystemWatcher 创建的缓冲区中通知组件文件发生更改。如果短时间内有很多更改，则缓冲区可能会溢出。这将导致组件失去对目录更改的跟踪，并且它将只提供一般性通知。使用 InternalBufferSize 属性来增加缓冲区大小的开销较大，因为它来自无法换出到磁盘的非页面内存，所以应确保缓冲区大小适中（尽量小，但也要有足够大小以便不会丢失任何文件更改事件）。若要避免缓冲区溢出，请使用 NotifyFilter 和 IncludeSubdirectories 属性，以便可以筛选掉不想要的更改通知。

　　使用 FileSystemWatcher 类时，请注意以下事项。

　　1） 对包括隐藏文件(夹)在内的所有文件(夹)进行监控。

　　2） 您可以为 InternalBufferSize 属性（用于监视网络上的目录）设置的最大大小为 64 KB。

　　FileSystemWatcher的实例监控到文件(夹)的变化后，会触发相应的事件，其中文件(夹)的添加，删除和修改会分别触发Created，Deleted，Changed事件，文件(夹)重命名时触发OnRenamed事件。

　　

　　然后，在熟悉了FileSystemWatcher类后，我们开始自己的程序编写。

　　实例化FileSystemWatcher类，并传入需要监控的目录路径，以及是否制定监控的文件类型（文章前面有所介绍）。

_watcher = new FileSystemWatcher(_path, _filter);

　　注册监听事件，以及编写事件触发后相关的处理逻辑。

_watcher.Created += new FileSystemEventHandler(OnChanged);
            _watcher.Changed += new FileSystemEventHandler(OnChanged);
            _watcher.Deleted += new FileSystemEventHandler(OnChanged);
            _watcher.Renamed += new RenamedEventHandler(OnRenamed);
            _watcher.IncludeSubdirectories = true;
            _watcher.EnableRaisingEvents = true;

　　在本程序中，专门定义了一个FileChangeInformation类来记录文件变化信息，并定义了一个CustomQueue类，该类类似于Queue类，是一个数据先进先出的集合，用来存储所有的文件变化消息，并提供数据持久化功能。

　　监控类 - FileWatcher，代码如下：

  1  /// <summary>
  2     /// 文件监控类，用于监控指定目录下文件以及文件夹的变化
  3     /// </summary>
  4     public class FileWatcher
  5     {
  6         private FileSystemWatcher _watcher = null;
  7         private string _path = string.Empty;
  8         private string _filter = string.Empty;
  9         private bool _isWatch = false;
 10         private CustomQueue<FileChangeInformation> _queue = null;
 11 
 12         /// <summary>
 13         /// 监控是否正在运行
 14         /// </summary>
 15         public bool IsWatch
 16         {
 17             get
 18             {
 19                 return _isWatch;
 20             }
 21         }
 22 
 23         /// <summary>
 24         /// 文件变更信息队列
 25         /// </summary>
 26         public CustomQueue<FileChangeInformation> FileChangeQueue
 27         {
 28             get
 29             {
 30                 return _queue;
 31             }
 32         }
 33 
 34         /// <summary>
 35         /// 初始化FileWatcher类
 36         /// </summary>
 37         /// <param name="path">监控路径</param>
 38         public FileWatcher(string path)
 39         {
 40             _path = path;
 41             _queue = new CustomQueue<FileChangeInformation>();
 42         }
 43         /// <summary>
 44         /// 初始化FileWatcher类，并指定是否持久化文件变更消息
 45         /// </summary>
 46         /// <param name="path">监控路径</param>
 47         /// <param name="isPersistence">是否持久化变更消息</param>
 48         /// <param name="persistenceFilePath">持久化保存路径</param>
 49         public FileWatcher(string path, bool isPersistence, string persistenceFilePath)
 50         {
 51             _path = path;
 52             _queue = new CustomQueue<FileChangeInformation>(isPersistence, persistenceFilePath);
 53         }
 54 
 55         /// <summary>
 56         /// 初始化FileWatcher类，并指定是否监控指定类型文件
 57         /// </summary>
 58         /// <param name="path">监控路径</param>
 59         /// <param name="filter">指定类型文件，格式如:*.txt,*.doc,*.rar</param>
 60         public FileWatcher(string path, string filter)
 61         {
 62             _path = path;
 63             _filter = filter;
 64             _queue = new CustomQueue<FileChangeInformation>();
 65         }
 66 
 67         /// <summary>
 68         /// 初始化FileWatcher类，并指定是否监控指定类型文件，是否持久化文件变更消息
 69         /// </summary>
 70         /// <param name="path">监控路径</param>
 71         /// <param name="filter">指定类型文件，格式如:*.txt,*.doc,*.rar</param>
 72         /// <param name="isPersistence">是否持久化变更消息</param>
 73         /// <param name="persistenceFilePath">持久化保存路径</param>
 74         public FileWatcher(string path, string filter, bool isPersistence, string persistenceFilePath)
 75         {
 76             _path = path;
 77             _filter = filter;
 78             _queue = new CustomQueue<FileChangeInformation>(isPersistence, persistenceFilePath);
 79         }
 80 
 81         /// <summary>
 82         /// 打开文件监听器
 83         /// </summary>
 84         public void Open()
 85         {
 86             if (!Directory.Exists(_path))
 87             {
 88                 Directory.CreateDirectory(_path);
 89             }
 90 
 91             if (string.IsNullOrEmpty(_filter))
 92             {
 93                 _watcher = new FileSystemWatcher(_path);
 94             }
 95             else
 96             {
 97                 _watcher = new FileSystemWatcher(_path, _filter);
 98             }
 99             //注册监听事件
100             _watcher.Created += new FileSystemEventHandler(OnProcess);
101             _watcher.Changed += new FileSystemEventHandler(OnProcess);
102             _watcher.Deleted += new FileSystemEventHandler(OnProcess);
103             _watcher.Renamed += new RenamedEventHandler(OnFileRenamed);
104             _watcher.IncludeSubdirectories = true;
105             _watcher.EnableRaisingEvents = true;
106             _isWatch = true;
107         }
108 
109         /// <summary>
110         /// 关闭监听器
111         /// </summary>
112         public void Close()
113         {
114             _isWatch = false;
115             _watcher.Created -= new FileSystemEventHandler(OnProcess);
116             _watcher.Changed -= new FileSystemEventHandler(OnProcess);
117             _watcher.Deleted -= new FileSystemEventHandler(OnProcess);
118             _watcher.Renamed -= new RenamedEventHandler(OnFileRenamed);
119             _watcher.EnableRaisingEvents = false;
120             _watcher = null;
121         }
122 
123         /// <summary>
124         /// 获取一条文件变更消息
125         /// </summary>
126         /// <returns></returns>
127         public FileChangeInformation Get()
128         {
129             FileChangeInformation info = null;
130             if (_queue.Count > 0)
131             {
132                 lock (_queue)
133                 {
134                     info = _queue.Dequeue();
135                 }
136             }
137             return info;
138         }
139 
140         /// <summary>
141         /// 监听事件触发的方法
142         /// </summary>
143         /// <param name="sender"></param>
144         /// <param name="e"></param>
145         private void OnProcess(object sender, FileSystemEventArgs e)
146         {
147             try
148             {
149                 FileChangeType changeType = FileChangeType.Unknow;
150                 if (e.ChangeType == WatcherChangeTypes.Created)
151                 {
152                     if (File.GetAttributes(e.FullPath) == FileAttributes.Directory)
153                     {
154                         changeType = FileChangeType.NewFolder;
155                     }
156                     else
157                     {
158                         changeType = FileChangeType.NewFile;
159                     }
160                 }
161                 else if (e.ChangeType == WatcherChangeTypes.Changed)
162                 {
163                     //部分文件创建时同样触发文件变化事件，此时记录变化操作没有意义
164                     //如果
165                     if (_queue.SelectAll(
166                         delegate(FileChangeInformation fcm)
167                         {
168                             return fcm.NewPath == e.FullPath && fcm.ChangeType == FileChangeType.Change;
169                         }).Count<FileChangeInformation>() > 0)
170                     {
171                         return;
172                     }
173 
174                     //文件夹的变化，只针对创建，重命名和删除动作，修改不做任何操作。
175                     //因为文件夹下任何变化同样会触发文件的修改操作，没有任何意义.
176                     if (File.GetAttributes(e.FullPath) == FileAttributes.Directory)
177                     {
178                         return;
179                     }
180 
181                     changeType = FileChangeType.Change;
182                 }
183                 else if (e.ChangeType == WatcherChangeTypes.Deleted)
184                 {
185                     changeType = FileChangeType.Delete;
186                 }
187 
188                 //创建消息，并压入队列中
189                 FileChangeInformation info = new FileChangeInformation(Guid.NewGuid().ToString(), changeType, e.FullPath, e.FullPath, e.Name, e.Name);
190                 _queue.Enqueue(info);
191             }
192             catch
193             {
194                 Close();
195             }
196         }
197 
198         /// <summary>
199         /// 文件或目录重命名时触发的事件
200         /// </summary>
201         /// <param name="sender"></param>
202         /// <param name="e"></param>
203         private void OnFileRenamed(object sender, RenamedEventArgs e)
204         {
205             try
206             {
207                 //创建消息，并压入队列中
208                 FileChangeInformation info = new FileChangeInformation(Guid.NewGuid().ToString(), FileChangeType.Rename, e.OldFullPath, e.FullPath, e.OldName, e.Name);
209                 _queue.Enqueue(info);
210             }
211             catch
212             {
213                 Close();
214             }
215         }
216     }

　　最后，功能调用如下：

 1 //初始化监控器
 2                 FileWatcher watcher = new FileWatcher(@"D:");
 3                 watcher.Open();
 4 
 5                 FileChangeInformation fci = null;
 6                 //获取消息
 7                 while (true)
 8                 {
 9                     //如果IsWatch为False，则可能监控内部发生异常终止了监控，需要重新开启监控
10                     if (watcher.IsWatch)
11                     {
12                         //队列顶端的变更消息
13                         fci = watcher.Get();
14                         //处理消息的代码
15                         //Print(fci);
16                     }
17                     else
18                     {
19                         watcher.Open();
20                     }
21                     Thread.Sleep(1000);
22                 }

　　该程序实现了对文件目录下所有子目录和子文件的变化进行监控，并可通过FileChangeQueue属性访问文件变更消息，同时也可以设置其是否需要将数据持久化到磁盘文件中。

　　需要源码的M我：GavinLeeChang@126.com

 

 

 

标签: 文件 目录 变化 监控