FileSystemWatcher跳过一些事件

Question

如果你谷歌FileSystemWatcher问题,你会发现很多关于FileSystemWatcher跳过一些事件的文章(没有解雇所有事件).基本上,如果您更改了监视文件夹中的大量文件,其中一些文件将不会被处理FileSystemWatcher.

为什么会这样,我怎样才能避免错过事件？

Answer 1

原因

FileSystemWatcher正在观察某些文件夹中发生的变化.更改文件(例如,创建文件)时,FileSystemWatcher会引发相应的事件.事件处理程序可能会解压缩文件,读取其内容以决定如何进一步处理它,在数据库日志表中写入它的记录并将文件移动到另一个文件夹.处理文件可能需要一些时间.

在此期间,可能会在监视文件夹中创建另一个文件.由于FileSystemWatcher事件处理程序正在处理第一个文件,因此它无法处理第二个文件的创建事件.所以,错过了第二个文件FileSystemWatcher.

解

由于文件处理可能需要一些时间并且其他文件的创建可能未被检测到FileSystemWatcher,因此文件处理应与文件更改检测分开,文件更改检测应该非常短,以至于它永远不会错过单个文件更改.文件处理可以分为两个线程:一个用于文件更改检测,另一个用于文件处理.当文件被更改并被检测到时FileSystemWatcher,相应的事件处理程序应该只读取其路径,将其转发到文件处理线程并关闭自身,以便FileSystemWatcher检测另一个文件更改并使用相同的事件处理程序.处理线程可能需要花费尽可能多的时间来处理文件.队列用于将文件路径从事件处理程序线程转发到处理线程.

这是典型的生产者 - 消费者问题.更多关于生产者-消费者队列可以发现在这里.

码

using System;
using System.IO;
using System.Threading;
using System.Collections.Generic;

namespace FileSystemWatcherExample {
    class Program {
        static void Main(string[] args) {
            // If a directory and filter are not specified, exit program
            if (args.Length !=2) {
                // Display the proper way to call the program
                Console.WriteLine("Usage: Watcher.exe \"directory\" \"filter\"");
                return;
            }

            FileProcessor fileProcessor = new FileProcessor();

            // Create a new FileSystemWatcher
            FileSystemWatcher fileSystemWatcher1 = new FileSystemWatcher();

            // Set FileSystemWatcher's properties
            fileSystemWatcher1.Path = args[0];
            fileSystemWatcher1.Filter = args[1];
            fileSystemWatcher1.IncludeSubdirectories = false;

            // Add event handlers
            fileSystemWatcher1.Created += new System.IO.FileSystemEventHandler(this.fileSystemWatcher1_Created);

            // Start to watch
            fileSystemWatcher1.EnableRaisingEvents = true;

            // Wait for the user to quit the program
            Console.WriteLine("Press \'q\' to quit the program.");
            while(Console.Read()!='q');

            // Turn off FileSystemWatcher
            if (fileSystemWatcher1 != null) {
                fileSystemWatcher1.EnableRaisingEvents = false;
                fileSystemWatcher1.Dispose();
                fileSystemWatcher1 = null;
            }

            // Dispose fileProcessor
            if (fileProcessor != null)
                fileProcessor.Dispose();
        }

        // Define the event handler
        private void fileSystemWatcher1_Created(object sender, FileSystemEventArgs e) {
            // If file is created...
            if (e.ChangeType == WatcherChangeTypes.Created) {
                // ...enqueue it's file name so it can be processed...
                fileProcessor.EnqueueFileName(e.FullPath);
            }
            // ...and immediately finish event handler
        }
    }


    // File processor class
    class FileProcessor : IDisposable {
        // Create an AutoResetEvent EventWaitHandle
        private EventWaitHandle eventWaitHandle = new AutoResetEvent(false);
        private Thread worker;
        private readonly object locker = new object();
        private Queue<string> fileNamesQueue = new Queue<string>();

        public FileProcessor() {
            // Create worker thread
            worker = new Thread(Work);
            // Start worker thread
            worker.Start();
        }

        public void EnqueueFileName(string FileName) {
            // Enqueue the file name
            // This statement is secured by lock to prevent other thread to mess with queue while enqueuing file name
            lock (locker) fileNamesQueue.Enqueue(FileName);
            // Signal worker that file name is enqueued and that it can be processed
            eventWaitHandle.Set();
        }

        private void Work() {
            while (true) {
                string fileName = null;

                // Dequeue the file name
                lock (locker)
                    if (fileNamesQueue.Count > 0) {
                        fileName = fileNamesQueue.Dequeue();
                        // If file name is null then stop worker thread
                        if (fileName == null) return;
                    }

                if (fileName != null) {
                    // Process file
                    ProcessFile(fileName);
                } else {
                    // No more file names - wait for a signal
                    eventWaitHandle.WaitOne();
                }
            }
        }

        private ProcessFile(string FileName) {
            // Maybe it has to wait for file to stop being used by process that created it before it can continue
            // Unzip file
            // Read its content
            // Log file data to database
            // Move file to archive folder
        }


        #region IDisposable Members

        public void Dispose() {
            // Signal the FileProcessor to exit
            EnqueueFileName(null);
            // Wait for the FileProcessor's thread to finish
            worker.Join();
            // Release any OS resources
            eventWaitHandle.Close();
        }

        #endregion
    }
}