一个封装好的 FileSystemWatcher 类

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5. using System.IO;
6. using System.Collections;
7. using System.Threading;
9. namespace synchro
10. {
11.     public delegate void Completed(string key);
13.     public class MyFileSystemWather
14.     {
15.         private FileSystemWatcher fsWather;
16.         private Hashtable hstbWather;
17.         public event RenamedEventHandler OnRenamed;
18.         public event FileSystemEventHandler OnChanged;
20.         /// <summary>
21.         /// 构造函数
22.         /// </summary>
23.         /// <param name="path">要监控的路径</param>
24.         public MyFileSystemWather(string path)
25.         {
26.             if (!Directory.Exists(path)) throw new Exception("找不到路径：" + path);
28.             fsWather = new FileSystemWatcher(path);
29.             fsWather.IncludeSubdirectories = true;
30.             fsWather.Filter = "*.*";
32.             fsWather.Changed += new FileSystemEventHandler(fsWather_Changed);
33.             fsWather.Created += new FileSystemEventHandler(fsWather_Changed);
34.             fsWather.Deleted += new FileSystemEventHandler(fsWather_Changed);
35.             fsWather.Renamed += new RenamedEventHandler(fsWather_Renamed);
37.             hstbWather = new Hashtable();
38.         }
40.         /// <summary>
41.         /// 开始监控
42.         /// </summary>
43.         public void start()
44.         {
45.             fsWather.EnableRaisingEvents = true;
46.         }
48.         /// <summary>
49.         /// 停止监控
50.         /// </summary>
51.         public void stop()
52.         {
53.             fsWather.EnableRaisingEvents = false;
54.         }
56.         /// <summary>
57.         /// filesystemWatcher 本身的事件通知处理过程
58.         /// </summary>
59.         /// <param name="sender"></param>
60.         /// <param name="e"></param>
61.         private void fsWather_Renamed(object sender, RenamedEventArgs e)
62.         {
63.             lock (hstbWather) { hstbWather.Add(e.FullPath, e); }
65.             watcherDeal wd = new watcherDeal(sender, e);
66.             wd.OnCompleted += new Completed(wd_OnCompleted);
67.             wd.OnRenamed += new RenamedEventHandler(wd_OnRenamed);
68.             Thread tdDeal = new Thread(wd.dealWith);
69.             tdDeal.Start();
70.         }
72.         void wd_OnRenamed(object sender, RenamedEventArgs e)
73.         {
74.             OnRenamed(sender, e);
75.         }
77.         private void fsWather_Changed(object sender, FileSystemEventArgs e)
78.         {
79.             //File.AppendAllText(@"e:/111.txt",DateTime.Now.ToShortTimeString() + ":" + e.FullPath + "/r/n");
80.             if (e.ChangeType == WatcherChangeTypes.Changed)
81.             {
82.                 if (isFileUsed(e.FullPath)) return;
84.                 if (hstbWather.ContainsKey(e.FullPath))
85.                 {
86.                     WatcherChangeTypes oldType = ((FileSystemEventArgs)hstbWather[e.FullPath]).ChangeType;
87.                     if (oldType == WatcherChangeTypes.Created || oldType == WatcherChangeTypes.Changed) return;
88.                 }
89.             }
91.             while (hstbWather.ContainsKey(e.FullPath)) { }
92.             lock (hstbWather) { hstbWather.Add(e.FullPath, e); }
94.             watcherDeal wd = new watcherDeal(sender, e);
95.             wd.OnCompleted += new Completed(wd_OnCompleted);
96.             wd.OnChanged += new FileSystemEventHandler(wd_OnChanged);
97.             Thread tdDeal = new Thread(wd.dealWith);
98.             tdDeal.Start();
99.         }
101.         void wd_OnChanged(object sender, FileSystemEventArgs e)
102.         {
103.             OnChanged(sender, e);
104.         }
106.         void wd_OnCompleted(string key)
107.         {
108.             lock (hstbWather)
109.             {
110.                 hstbWather.Remove(key);
111.             }
112.         }
114.         private static bool isFileUsed(string fileName)
115.         {
116.             try
117.             {
118.                 FileStream fs = File.Open(fileName, FileMode.Open, FileAccess.Read, FileShare.None);
119.                 fs.Close();
120.                 return false;
121.             }
122.             catch (Exception)
123.             {
124.                 if (!File.Exists(fileName))
125.                     return false;
126.                 else
127.                     return true;
128.             }
129.         }
132.         private class watcherDeal
133.         {
134.             private object sender;
135.             private object eParam;
136.             public event RenamedEventHandler OnRenamed;
137.             public event FileSystemEventHandler OnChanged;
138.             public event Completed OnCompleted;
141.             public watcherDeal(object sender, object eParam)
142.             {
143.                 this.sender = sender;
144.                 this.eParam = eParam;
145.             }
147.             public void dealWith()
148.             {
149.                 if (eParam.GetType() == typeof(RenamedEventArgs))
150.                 {
151.                     OnRenamed(sender, (RenamedEventArgs)eParam);
152.                     OnCompleted(((RenamedEventArgs)eParam).FullPath);
153.                 }
154.                 else
155.                 {
156.                     FileSystemEventArgs e = (FileSystemEventArgs)eParam;
157.                     if (e.ChangeType == WatcherChangeTypes.Created)
158.                     {
159.                         while (isFileUsed(e.FullPath)) { }
160.                     }
162.                     OnChanged(sender, e);
163.                     OnCompleted(e.FullPath);
164.                 }
165.             }
166.         }
167.     }
168. }

可以把 Filter , IncludeSubdirectories 等属性加上。

此类可以排除一个动作引发多个事件的问题。