(转)

最近要用到FileSystemWatcher来监控某个目录中的文件是否发生改变，如果改变就执行相应的操作（具体操作如：打开文档，添加一行，保存）。但在开发过程中，发现FileSystemWatcher在文件创建或修改后，会触发多个Created或Changed事件，具体原因就是处理文件的过程中执行了多次文件系统操作，触发了多次事件。具体可以参看微软的关于FileSystemWatcher这方面的解释：Troubleshooting FileSystemWatcher
Components，另外我在网上发现 Consolidate Multiple FileSystemWatcher
Events 关于这方面的解决办法，比较实用，方便快速引入到项目中。

来自MSDN的问题说明

Troubleshooting FileSystemWatcher Components

Visual
Studio .NET 2003

其他版本

此主题尚未评级 - 评价此主题

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.

解决方案

The
.NET framework provides a FileSystemWatcher class
that can be used to monitor the file system for changes. My requirements were to
monitor a directory for new files or changes to existing files. When a change
occurs, the application needs to read the file and immediately perform some
operation based on the contents of the file.

While
doing some manual testing of my initial implementation it was very obvious that
theFileSystemWatcher was
firing multiple events whenever I made a change to a file or copied a file into
the directory being monitored. I came across the following in the MSDNdocumentation’s Troubleshooting
FileSystemWatcher Components

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 a FileSystemWatcher 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 the Archived attribute for the file during this operation.

I
did some searching and was surprised that .NET did not provide any kind of
wrapper around the FileSystemWatcher to make it a bit more user friendly. I
ended up writing my own wrapper that would monitor a directory and only throw
one event when a new file was created, or an existing file was changed.

In
order to consolidate the multiple FileSystemWatcher events down to a single
event, I save the timestamp when each event is received, and I check back every
so often (using a Timer) to find paths that have not caused additional events in
a while. When one of these paths is ready, a single Changed event
is fired. An additional benefit of this technique is that the event from the
FileSystemWatcher is handled very quickly, which could help prevent its internal
buffer from filling up.

Here
is the code for a DirectoryMonitor class
that consolidates multiple Win32 events into a single Change event
for each change:

解决方案代码

[csharp] view plaincopy

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. namespace ShareReadFile


8. {


9. public delegate void FileSystemEvent(String path);
10. public interface IDirectoryMonitor


11. {


12. event FileSystemEvent Change;


13. void Start();


14. }
15. public class DirectoryMonitor : IDirectoryMonitor


16. {


17. private readonly FileSystemWatcher m_fileSystemWatcher = new FileSystemWatcher();


18. private readonly Dictionary<string, DateTime> m_pendingEvents = new Dictionary<string, DateTime>();


19. private readonly Timer m_timer;


20. private bool m_timerStarted = false;
21. public DirectoryMonitor(string dirPath)


22. {


23. m_fileSystemWatcher.Path = dirPath;


24. m_fileSystemWatcher.IncludeSubdirectories = false;


25. m_fileSystemWatcher.Created += new FileSystemEventHandler(OnChange);


26. m_fileSystemWatcher.Changed += new FileSystemEventHandler(OnChange);
27. m_timer = new Timer(OnTimeout, null, Timeout.Infinite, Timeout.Infinite);


28. }
29. public event FileSystemEvent Change;
30. public void Start()


31. {


32. m_fileSystemWatcher.EnableRaisingEvents = true;


33. }
34. private void OnChange(object sender, FileSystemEventArgs e)


35. {


36. // Don‘t want other threads messing with the pending events right now


37. lock (m_pendingEvents)


38. {


39. // Save a timestamp for the most recent event for this path


40. m_pendingEvents[e.FullPath] = DateTime.Now;
41. // Start a timer if not already started


42. if (!m_timerStarted)


43. {


44. m_timer.Change(100, 100);


45. m_timerStarted = true;


46. }


47. }


48. }
49. private void OnTimeout(object state)


50. {


51. List<string> paths;
52. // Don‘t want other threads messing with the pending events right now


53. lock (m_pendingEvents)


54. {


55. // Get a list of all paths that should have events thrown


56. paths = FindReadyPaths(m_pendingEvents);
57. // Remove paths that are going to be used now


58. paths.ForEach(delegate(string path)


59. {


60. m_pendingEvents.Remove(path);


61. });
62. // Stop the timer if there are no more events pending


63. if (m_pendingEvents.Count == 0)


64. {


65. m_timer.Change(Timeout.Infinite, Timeout.Infinite);


66. m_timerStarted = false;


67. }


68. }
69. // Fire an event for each path that has changed


70. paths.ForEach(delegate(string path)


71. {


72. FireEvent(path);


73. });


74. }
75. private List<string> FindReadyPaths(Dictionary<string, DateTime> events)


76. {


77. List<string> results = new List<string>();


78. DateTime now = DateTime.Now;
79. foreach (KeyValuePair<string, DateTime> entry in events)


80. {


81. // If the path has not received a new event in the last 75ms


82. // an event for the path should be fired


83. double diff = now.Subtract(entry.Value).TotalMilliseconds;


84. if (diff >= 75)


85. {


86. results.Add(entry.Key);


87. }


88. }
89. return results;


90. }
91. private void FireEvent(string path)


92. {


93. FileSystemEvent evt = Change;


94. if (evt != null)


95. {


96. evt(path);


97. }


98. }


99. }


100. }

FileSystemWatcher触发多次Change事件的解决办法