c# filesystemwatcher如何防止文件创建的多次触发

FileSystemWatcher 的 Created 事件多次触发是一个常见问题，这通常不是代码错误，而是由 Windows 文件系统的底层机制和应用程序的保存方式导致的。例如，许多编辑器会先创建一个临时文件，然后再重命名或覆盖原文件，这个过程就会触发多次事件。

要解决这个问题，可以采用以下几种主流且有效的方案：

方案一：使用计时器进行“去抖动” (Debouncing)

这是最常用和推荐的方法。核心思想是：当事件被触发时，不立即处理，而是启动或重置一个计时器。如果在设定的时间窗口内（例如500毫秒）同一个文件再次触发事件，就重置计时器。只有当计时器成功到期，才认为文件操作已经完成，并进行处理。

这种方法可以有效合并短时间内对同一文件的多次操作。

using System;
using System.Collections.Concurrent;
using System.IO;
using System.Threading;

public class DebouncedFileWatcher
{
    private readonly FileSystemWatcher _watcher;
    // 用于存储每个文件的计时器
    private readonly ConcurrentDictionary<string, Timer> _timers = new ConcurrentDictionary<string, Timer>();
    // 去抖动的时间间隔（毫秒）
    private const int DebounceInterval = 500;

    public DebouncedFileWatcher(string path, string filter = "*.*")
    {
        _watcher = new FileSystemWatcher(path, filter)
        {
            EnableRaisingEvents = true,
            IncludeSubdirectories = true
        };

        _watcher.Created += OnFileEvent;
        _watcher.Changed += OnFileEvent;
    }

    private void OnFileEvent(object sender, FileSystemEventArgs e)
    {
        // 为每个文件路径创建或更新一个计时器
        var timer = _timers.AddOrUpdate(
            e.FullPath,
            // 如果是新事件，创建新计时器
            key => new Timer(ProcessFile, e.FullPath, DebounceInterval, Timeout.Infinite),
            // 如果已存在计时器，则重置它
            (key, existingTimer) =>
            {
                existingTimer.Change(DebounceInterval, Timeout.Infinite);
                return existingTimer;
            });
    }

    private void ProcessFile(object filePath)
    {
        string path = filePath.ToString();
        Console.WriteLine($"文件操作完成，开始处理: {path}");
        
        // 在这里执行你的业务逻辑，例如读取文件内容
        // 注意：处理完成后，从字典中移除该计时器
        _timers.TryRemove(path, out _);
    }
}

方案二：检查文件的最后修改时间

此方法通过记录文件上一次被处理时的 LastWriteTime 来判断当前事件是否是重复的。如果当前事件的 LastWriteTime 与记录的相同，则忽略该事件。

这种方法逻辑简单，但对于快速连续写入的场景可能不如计时器方案稳定。

using System;
using System.Collections.Concurrent;
using System.IO;

public class LastWriteTimeWatcher
{
    private readonly FileSystemWatcher _watcher;
    // 用于存储文件路径和其上次处理的修改时间
    private readonly ConcurrentDictionary<string, DateTime> _lastProcessedTimes = new ConcurrentDictionary<string, DateTime>();

    public LastWriteTimeWatcher(string path, string filter = "*.*")
    {
        _watcher = new FileSystemWatcher(path, filter)
        {
            EnableRaisingEvents = true,
            NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName
        };

        _watcher.Created += OnCreated;
        _watcher.Changed += OnChanged;
    }

    private void OnCreated(object sender, FileSystemEventArgs e)
    {
        HandleFileChange(e.FullPath);
    }

    private void OnChanged(object sender, FileSystemEventArgs e)
    {
        HandleFileChange(e.FullPath);
    }

    private void HandleFileChange(string fullPath)
    {
        // 获取文件当前的最后写入时间
        var currentWriteTime = File.GetLastWriteTimeUtc(fullPath);

        // 尝试获取上次处理的时间
        if (_lastProcessedTimes.TryGetValue(fullPath, out DateTime lastProcessedTime))
        {
            // 如果时间没变，说明是重复事件，直接返回
            if (currentWriteTime == lastProcessedTime)
            {
                return;
            }
        }

        // 这是新的变更，更新记录并处理
        _lastProcessedTimes[fullPath] = currentWriteTime;
        Console.WriteLine($"处理文件变更: {fullPath}");
        // 在这里执行你的业务逻辑
    }
}

方案三：使用生产者-消费者队列

将 FileSystemWatcher 的事件处理与业务逻辑解耦。事件触发时，只负责将文件路径快速放入一个线程安全的队列中。然后由一个独立的后台任务从队列中取出路径进行处理。

这种方法可以防止事件处理阻塞 FileSystemWatcher 的内部缓冲区，避免在高负载下丢失事件。通常可以与“去抖动”或“检查修改时间”的方法结合使用，在入队前或出队后进行判断。

using System;
using System.Collections.Concurrent;
using System.IO;
using System.Threading.Tasks;

public class QueuedFileWatcher
{
    private readonly FileSystemWatcher _watcher;
    private readonly BlockingCollection<string> _queue = new BlockingCollection<string>();

    public QueuedFileWatcher(string path, string filter = "*.*")
    {
        _watcher = new FileSystemWatcher(path, filter)
        {
            EnableRaisingEvents = true
        };

        _watcher.Created += (s, e) => _queue.Add(e.FullPath);
        _watcher.Changed += (s, e) => _queue.Add(e.FullPath);

        // 启动后台消费者任务
        Task.Factory.StartNew(ConsumeQueue, TaskCreationOptions.LongRunning);
    }

    private void ConsumeQueue()
    {
        foreach (var filePath in _queue.GetConsumingEnumerable())
        {
            // 在这里处理文件
            // 可以在此处加入去重逻辑，例如检查文件是否已被处理
            Console.WriteLine($"从队列中取出并处理: {filePath}");
        }
    }
}

总结与建议

| 方案 | 优点 | 缺点 | 适用场景 | | :--- | :--- | :--- | :--- | | 计时器去抖动 | 逻辑清晰，能有效合并短时多次事件，非常可靠。 | 会有轻微的延迟（去抖动时间）。 | 绝大多数场景，尤其是文件写入可能持续一段时间的情况。 | | 检查修改时间 | 实现简单，理论上无延迟。 | 在极高频率的修改下可能失效，需要处理文件被删除的异常。 | 对实时性要求极高，且文件修改不频繁的场景。 | | 生产者-消费者队列 | 解耦事件与处理，防止事件丢失，提高系统吞吐量。 | 实现相对复杂，需要额外的线程管理。 | 文件事件非常频繁，或处理逻辑非常耗时的场景。 |

额外建议：

• 增大缓冲区：可以通过设置 FileSystemWatcher.InternalBufferSize 属性（例如增大到 64KB）来减少因缓冲区溢出而导致的事件丢失。
• 处理异常：在访问文件时，务必使用 try-catch 块来处理 IOException，因为文件可能正被其他进程占用。