我有一个应用程序，我正在寻找一个文本文件，如果对文件做了任何更改，我使用OnChanged事件处理程序来处理事件。我正在使用NotifyFilters。LastWriteTime，但是事件仍然被触发两次。这是代码。
public void Initialize()
{
FileSystemWatcher _fileWatcher = new FileSystemWatcher();
_fileWatcher.Path = "C:\\Folder";
_fileWatcher.NotifyFilter = NotifyFilters.LastWrite;
_fileWatcher.Filter = "Version.txt";
_fileWatcher.Changed += new FileSystemEventHandler(OnChanged);
_fileWatcher.EnableRaisingEvents = true;
}
private void OnChanged(object source, FileSystemEventArgs e)
{
.......
}
在我的情况下，OnChanged被调用两次，当我改变文本文件version.txt并保存它。
解决方案实际上取决于用例。您是否在注意不更改的新文件，或每隔一段时间更改一次的文件或经常更改的文件?在我的情况下，它的变化不太频繁，我不想错过任何这些变化。
但是我也不想在写入过程尚未完成写入的地方发生更改事件。
在我的情况下，我注意到6 (6 !!)onchange事件写一个125字符的txt文件。
我的解决方案是民意调查和改变事件的混合，民意调查经常被消极地看待。正常轮询比较慢，比如每10秒一次，以防FileSystemWatcher (FSW)“错过”一个事件。轮询立即响应FSW更改事件。
关键是在FSW。更改事件时，轮询速度加快，例如每100毫秒，并等待直到文件稳定。因此我们有了“两阶段轮询”:阶段1比较慢，但在FSW文件更改事件时立即响应。第二阶段是快速的，等待一个稳定的文件。
如果FSW检测到多个文件更改，每个事件都会加速轮询循环，并有效地启动一个新的短等待周期。只有在轮询循环检测到上次写入时文件没有进一步的变化之后，它才假定文件是稳定的，并且您的代码可以处理更改后的文件。
我选择了10秒和100毫秒的超时，但是您的用例可能需要不同的超时值。
这里是轮询，其中AppConfig。fiIO是要注意的FileInfo:
private readonly EventWaitHandle ewhTimeout = new AutoResetEvent(false);
private void TwoPhasedPolling()
{
bool WaitForChange = true; //false: wait until stable
DateTime LastWriteTime = DateTime.MinValue;
while (true)
{
// wait for next poll (timeout), or FSW event
bool GotOne = ewhTimeout.WaitOne(WaitForChange ? 10 * 1000 : 100);
if (GotOne)
{
// WaitOne interrupted: end of Phase1: FSW detected file change
WaitForChange = false;
}
else
{
// WaitOne timed out: Phase2: check file write time for change
if (AppConfig.fiIO.LastWriteTime > LastWriteTime)
{
LastWriteTime = AppConfig.fiIO.LastWriteTime;
}
else
{
// End of Phase2: file has changed and is stable
WaitForChange = true;
// action on changed file
... your code here ...
}}}}
private void fileSystemWatcher1_Changed(object sender, FileSystemEventArgs e)
{
ewhTimeout.Set();
}
NB:是的，我也不喜欢}}}}，但它使列表更短，这样你就不必滚动了:-)
很抱歉挖了坟墓，但我已经与这个问题斗争了一段时间，终于想出了一种方法来处理这些多重发射事件。我想要感谢这篇文章中的每一个人，因为我在与这个问题作斗争时已经在许多参考文献中使用了它。
这是我的完整代码。它使用字典来跟踪文件最后一次写入的日期和时间。它比较该值，如果值相同，则抑制事件。然后在启动新线程后设置该值。
using System.Threading; // used for backgroundworker
using System.Diagnostics; // used for file information
private static IDictionary<string, string> fileModifiedTable = new Dictionary<string, string>(); // used to keep track of our changed events
private void fswFileWatch_Changed( object sender, FileSystemEventArgs e )
{
try
{
//check if we already have this value in our dictionary.
if ( fileModifiedTable.TryGetValue( e.FullPath, out sEmpty ) )
{
//compare timestamps
if ( fileModifiedTable[ e.FullPath ] != File.GetLastWriteTime( e.FullPath ).ToString() )
{
//lock the table
lock ( fileModifiedTable )
{
//make sure our file is still valid
if ( File.Exists( e.FullPath ) )
{
// create a new background worker to do our task while the main thread stays awake. Also give it do work and work completed handlers
BackgroundWorker newThreadWork = new BackgroundWorker();
newThreadWork.DoWork += new DoWorkEventHandler( bgwNewThread_DoWork );
newThreadWork.RunWorkerCompleted += new RunWorkerCompletedEventHandler( bgwNewThread_RunWorkerCompleted );
// capture the path
string eventFilePath = e.FullPath;
List<object> arguments = new List<object>();
// add arguments to pass to the background worker
arguments.Add( eventFilePath );
arguments.Add( newEvent.File_Modified );
// start the new thread with the arguments
newThreadWork.RunWorkerAsync( arguments );
fileModifiedTable[ e.FullPath ] = File.GetLastWriteTime( e.FullPath ).ToString(); //update the modified table with the new timestamp of the file.
FILE_MODIFIED_FLAG.WaitOne(); // wait for the modified thread to complete before firing the next thread in the event multiple threads are being worked on.
}
}
}
}
}
catch ( IOException IOExcept )
{
//catch any errors
postError( IOExcept, "fswFileWatch_Changed" );
}
}
我的场景是，我有一个虚拟机，其中有一个Linux服务器。我正在Windows主机上开发文件。当我在主机上的一个文件夹中更改某些内容时，我希望所有的更改都被上传，并通过Ftp同步到虚拟服务器上。这是我如何消除重复更改事件当我写入一个文件(这标志着包含文件要修改的文件夹):
private Hashtable fileWriteTime = new Hashtable();
private void fsw_sync_Changed(object source, FileSystemEventArgs e)
{
string path = e.FullPath.ToString();
string currentLastWriteTime = File.GetLastWriteTime( e.FullPath ).ToString();
// if there is no path info stored yet
// or stored path has different time of write then the one now is inspected
if ( !fileWriteTime.ContainsKey(path) ||
fileWriteTime[path].ToString() != currentLastWriteTime
)
{
//then we do the main thing
log( "A CHANGE has occured with " + path );
//lastly we update the last write time in the hashtable
fileWriteTime[path] = currentLastWriteTime;
}
}
我主要创建一个哈希表来存储文件写时间信息。然后，如果哈希表有被修改的文件路径，并且它的时间值与当前通知的文件更改相同，那么我就知道它是事件的副本，并忽略它。
解决方案实际上取决于用例。您是否在注意不更改的新文件，或每隔一段时间更改一次的文件或经常更改的文件?在我的情况下，它的变化不太频繁，我不想错过任何这些变化。
但是我也不想在写入过程尚未完成写入的地方发生更改事件。
在我的情况下，我注意到6 (6 !!)onchange事件写一个125字符的txt文件。
我的解决方案是民意调查和改变事件的混合，民意调查经常被消极地看待。正常轮询比较慢，比如每10秒一次，以防FileSystemWatcher (FSW)“错过”一个事件。轮询立即响应FSW更改事件。
关键是在FSW。更改事件时，轮询速度加快，例如每100毫秒，并等待直到文件稳定。因此我们有了“两阶段轮询”:阶段1比较慢，但在FSW文件更改事件时立即响应。第二阶段是快速的，等待一个稳定的文件。
如果FSW检测到多个文件更改，每个事件都会加速轮询循环，并有效地启动一个新的短等待周期。只有在轮询循环检测到上次写入时文件没有进一步的变化之后，它才假定文件是稳定的，并且您的代码可以处理更改后的文件。
我选择了10秒和100毫秒的超时，但是您的用例可能需要不同的超时值。
这里是轮询，其中AppConfig。fiIO是要注意的FileInfo:
private readonly EventWaitHandle ewhTimeout = new AutoResetEvent(false);
private void TwoPhasedPolling()
{
bool WaitForChange = true; //false: wait until stable
DateTime LastWriteTime = DateTime.MinValue;
while (true)
{
// wait for next poll (timeout), or FSW event
bool GotOne = ewhTimeout.WaitOne(WaitForChange ? 10 * 1000 : 100);
if (GotOne)
{
// WaitOne interrupted: end of Phase1: FSW detected file change
WaitForChange = false;
}
else
{
// WaitOne timed out: Phase2: check file write time for change
if (AppConfig.fiIO.LastWriteTime > LastWriteTime)
{
LastWriteTime = AppConfig.fiIO.LastWriteTime;
}
else
{
// End of Phase2: file has changed and is stable
WaitForChange = true;
// action on changed file
... your code here ...
}}}}
private void fileSystemWatcher1_Changed(object sender, FileSystemEventArgs e)
{
ewhTimeout.Set();
}
NB:是的，我也不喜欢}}}}，但它使列表更短，这样你就不必滚动了:-)
