Sự kiện thay đổi FileSystemWatcher được nâng lên hai lần

Tôi có một ứng dụng mà tôi đang tìm kiếm một tệp văn bản và nếu có bất kỳ thay đổi nào được thực hiện đối với tệp tôi đang sử dụng OnChangedeventhandler để xử lý sự kiện. Tôi đang sử dụng NotifyFilters.LastWriteTimenhưng sự kiện vẫn bị đuổi việc hai lần. Đây là mã.

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)
{
   .......
}

Trong trường hợp của tôi, OnChangednó được gọi hai lần, khi tôi thay đổi tệp văn bản version.txtvà lưu nó.

Tôi sợ rằng đây là một lỗi / tính năng nổi tiếng của FileSystemWatcherlớp. Đây là từ tài liệu của lớp:

Bạn có thể nhận thấy trong một số trường hợp nhất định rằng một sự kiện tạo duy nhất tạo ra nhiều sự kiện đã tạo được xử lý bởi thành phần của bạn. Ví dụ: nếu bạn sử dụng thành phần FileSystemWatcher để theo dõi việc tạo tệp mới trong thư mục, sau đó kiểm tra nó bằng cách sử dụng Notepad để tạo tệp, bạn có thể thấy hai sự kiện đã tạo được tạo ngay cả khi chỉ tạo một tệp. Điều này là do Notepad thực hiện nhiều hành động hệ thống tệp trong quá trình viết. Notepad ghi vào đĩa theo từng đợt tạo nội dung của tệp và sau đó là thuộc tính tệp. Các ứng dụng khác có thể thực hiện theo cách tương tự. Vì FileSystemWatcher giám sát các hoạt động của hệ điều hành, tất cả các sự kiện mà các ứng dụng này kích hoạt sẽ được chọn.

Bây giờ bit văn bản này là về Createdsự kiện, nhưng điều tương tự cũng áp dụng cho các sự kiện tập tin khác. Trong một số ứng dụng, bạn có thể khắc phục điều này bằng cách sử dụng thuộc NotifyFiltertính, nhưng kinh nghiệm của tôi nói rằng đôi khi bạn cũng phải thực hiện một số bộ lọc trùng lặp thủ công (hack).

Cách đây một thời gian, tôi đã đánh dấu một trang với một vài mẹo FileSystemWatcher . Bạn có thể muốn kiểm tra nó.

Tôi đã "khắc phục" vấn đề đó bằng cách sử dụng chiến lược sau trong đại biểu của mình:

// fsw_ is the FileSystemWatcher instance used by my application.

private void OnDirectoryChanged(...)
{
   try
   {
      fsw_.EnableRaisingEvents = false;

      /* do my stuff once asynchronously */
   }

   finally
   {
      fsw_.EnableRaisingEvents = true;
   }
}

Bất kỳ OnChangedsự kiện trùng lặp nào từ FileSystemWatchercó thể được phát hiện và loại bỏ bằng cách kiểm tra File.GetLastWriteTimedấu thời gian trên tệp đang đề cập. Thích như vậy:

DateTime lastRead = DateTime.MinValue;

void OnChanged(object source, FileSystemEventArgs a)
{
    DateTime lastWriteTime = File.GetLastWriteTime(uri);
    if (lastWriteTime != lastRead)
    {
        doStuff();
        lastRead = lastWriteTime;
    }
    // else discard the (duplicated) OnChanged event
}

Đây là giải pháp giúp tôi ngăn chặn sự kiện được nêu ra hai lần:

watcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.Size;

Ở đây tôi đã đặt thuộc NotifyFiltertính chỉ với Tên tệp và kích thước.
watcherlà đối tượng của FileSystemWatcher. Hy vọng điều này sẽ giúp.

Kịch bản của tôi là tôi có một máy ảo có máy chủ Linux. Tôi đang phát triển các tập tin trên máy chủ Windows. Khi tôi thay đổi một cái gì đó trong một thư mục trên máy chủ, tôi muốn tất cả các thay đổi sẽ được tải lên, được đồng bộ hóa trên máy chủ ảo thông qua Ftp. Đây là cách tôi loại bỏ sự kiện thay đổi trùng lặp khi tôi ghi vào một tệp (cũng đánh dấu thư mục chứa tệp sẽ được sửa đổi):

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;
    }
}

Chủ yếu tôi tạo một hashtable để lưu trữ thông tin thời gian ghi tập tin. Sau đó, nếu hashtable có filepath được sửa đổi và giá trị thời gian của nó giống với thay đổi của tệp được thông báo hiện tại thì tôi biết đó là bản sao của sự kiện và bỏ qua nó.

Hãy thử với mã này:

class WatchPlotDirectory
{
    bool let = false;
    FileSystemWatcher watcher;
    string path = "C:/Users/jamie/OneDrive/Pictures/Screenshots";

    public WatchPlotDirectory()
    {
        watcher = new FileSystemWatcher();
        watcher.Path = path;
        watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite
                               | NotifyFilters.FileName | NotifyFilters.DirectoryName;
        watcher.Filter = "*.*";
        watcher.Changed += new FileSystemEventHandler(OnChanged);
        watcher.Renamed += new RenamedEventHandler(OnRenamed);
        watcher.EnableRaisingEvents = true;
    }



    void OnChanged(object sender, FileSystemEventArgs e)
    {
        if (let==false) {
            string mgs = string.Format("File {0} | {1}",
                                       e.FullPath, e.ChangeType);
            Console.WriteLine("onchange: " + mgs);
            let = true;
        }

        else
        {
            let = false;
        }


    }

    void OnRenamed(object sender, RenamedEventArgs e)
    {
        string log = string.Format("{0} | Renamed from {1}",
                                   e.FullPath, e.OldName);
        Console.WriteLine("onrenamed: " + log);

    }

    public void setPath(string path)
    {
        this.path = path;
    }
}

Đây là cách tiếp cận của tôi:

// Consider having a List<String> named _changedFiles

private void OnChanged(object source, FileSystemEventArgs e)
{
    lock (_changedFiles)
    {
        if (_changedFiles.Contains(e.FullPath))
        {
            return;
        }
        _changedFiles.Add(e.FullPath);
    }

    // do your stuff

    System.Timers.Timer timer = new Timer(1000) { AutoReset = false };
    timer.Elapsed += (timerElapsedSender, timerElapsedArgs) =>
    {
        lock (_changedFiles)
        {
            _changedFiles.Remove(e.FullPath);
        }
    };
   timer.Start();
}

Đây là giải pháp tôi đã sử dụng để giải quyết vấn đề này trong một dự án nơi tôi đang gửi tệp dưới dạng tệp đính kèm trong thư. Nó sẽ dễ dàng tránh được sự kiện bị bắn hai lần ngay cả với khoảng thời gian hẹn giờ nhỏ hơn nhưng trong trường hợp của tôi thì 1000 vẫn ổn vì tôi thấy vui hơn khi bỏ lỡ vài thay đổi so với việc làm ngập hộp thư với> 1 tin nhắn mỗi giây. Ít nhất là nó hoạt động tốt trong trường hợp một số tệp được thay đổi cùng một lúc.

Một giải pháp khác mà tôi nghĩ sẽ là thay thế danh sách bằng các tệp ánh xạ từ điển thành MD5 tương ứng của chúng, vì vậy bạn sẽ không phải chọn một khoảng tùy ý vì bạn sẽ không phải xóa mục nhập mà cập nhật giá trị của nó và hủy bỏ công cụ của bạn nếu nó không thay đổi. Nó có nhược điểm là có một Từ điển phát triển trong bộ nhớ vì các tệp được theo dõi và ăn ngày càng nhiều bộ nhớ, nhưng tôi đã đọc được ở đâu đó rằng lượng tệp được theo dõi phụ thuộc vào bộ đệm bên trong của FSW, vì vậy có lẽ không quá quan trọng. Không biết thời gian tính toán MD5 sẽ ảnh hưởng đến hiệu suất mã của bạn như thế nào, cẩn thận = \

Tôi đã tạo một repo Git với một lớp mở rộng FileSystemWatcherđể kích hoạt các sự kiện chỉ khi sao chép xong. Nó loại bỏ tất cả các sự kiện đã thay đổi ngoại trừ lần cuối cùng và nó chỉ nâng lên khi tệp có sẵn để đọc.

Tải xuống FileSystemSafeWatcher và thêm nó vào dự án của bạn.

Sau đó sử dụng nó như một bình thường FileSystemWatchervà theo dõi khi các sự kiện được kích hoạt.

var fsw = new FileSystemSafeWatcher(file);
fsw.EnableRaisingEvents = true;
// Add event handlers here
fsw.Created += fsw_Created;

Tôi biết đây là một vấn đề cũ, nhưng có cùng một vấn đề và không có giải pháp nào ở trên thực sự làm được mẹo cho vấn đề mà tôi đang gặp phải. Tôi đã tạo một từ điển ánh xạ tên tệp với LastWriteTime. Vì vậy, nếu tệp không có trong từ điển sẽ tiếp tục với quy trình kiểm tra khôn ngoan khác để xem thời điểm sửa đổi lần cuối là khi nào và nếu khác với những gì trong từ điển thì hãy chạy mã.

    Dictionary<string, DateTime> dateTimeDictionary = new Dictionary<string, DateTime>(); 

        private void OnChanged(object source, FileSystemEventArgs e)
            {
                if (!dateTimeDictionary.ContainsKey(e.FullPath) || (dateTimeDictionary.ContainsKey(e.FullPath) && System.IO.File.GetLastWriteTime(e.FullPath) != dateTimeDictionary[e.FullPath]))
                {
                    dateTimeDictionary[e.FullPath] = System.IO.File.GetLastWriteTime(e.FullPath);

                    //your code here
                }
            }

Một 'hack' có thể sẽ là điều tiết các sự kiện bằng cách sử dụng Tiện ích mở rộng phản ứng chẳng hạn:

var watcher = new FileSystemWatcher("./");

Observable.FromEventPattern<FileSystemEventArgs>(watcher, "Changed")
            .Throttle(new TimeSpan(500000))
            .Subscribe(HandleChangeEvent);

watcher.EnableRaisingEvents = true;

Trong trường hợp này, tôi điều chỉnh đến 50ms, trên hệ thống của tôi là đủ, nhưng giá trị cao hơn sẽ an toàn hơn. (Và như tôi đã nói, nó vẫn là một 'hack').

Tôi có một cách giải quyết rất nhanh chóng và đơn giản ở đây, nó hoạt động với tôi và bất kể sự kiện nào sẽ được kích hoạt một hoặc hai lần hoặc nhiều lần, hãy kiểm tra xem:

private int fireCount = 0;
private void inputFileWatcher_Changed(object sender, FileSystemEventArgs e)
    {
       fireCount++;
       if (fireCount == 1)
        {
            MessageBox.Show("Fired only once!!");
            dowork();
        }
        else
        {
            fireCount = 0;
        }
    }
}

Đây là một giải pháp mới bạn có thể thử. Hoạt động tốt cho tôi. Trong trình xử lý sự kiện cho sự kiện đã thay đổi, lập trình loại bỏ trình xử lý khỏi trình thiết kế xuất ra một thông báo nếu muốn, sau đó lập trình thêm trình xử lý trở lại. thí dụ:

public void fileSystemWatcher1_Changed( object sender, System.IO.FileSystemEventArgs e )
    {            
        fileSystemWatcher1.Changed -= new System.IO.FileSystemEventHandler( fileSystemWatcher1_Changed );
        MessageBox.Show( "File has been uploaded to destination", "Success!" );
        fileSystemWatcher1.Changed += new System.IO.FileSystemEventHandler( fileSystemWatcher1_Changed );
    }

Lý do chính là thời gian truy cập cuối cùng của sự kiện đầu tiên là thời gian hiện tại (ghi tập tin hoặc thời gian thay đổi). sau đó sự kiện thứ hai là lần truy cập cuối cùng của tập tin. Tôi giải quyết theo mã.

        var lastRead = DateTime.MinValue;

        Watcher = new FileSystemWatcher(...)
        {
            NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite,
            Filter = "*.dll",
            IncludeSubdirectories = false,
        };
        Watcher.Changed += (senderObject, ea) =>
        {
            var now = DateTime.Now;
            var lastWriteTime = File.GetLastWriteTime(ea.FullPath);

            if (now == lastWriteTime)
            {
                return;
            }

            if (lastWriteTime != lastRead)
            {
                // do something...
                lastRead = lastWriteTime;
            }
        };

        Watcher.EnableRaisingEvents = true;

Tôi đã dành một lượng thời gian đáng kể để sử dụng FileSystemWatcher và một số cách tiếp cận ở đây sẽ không hiệu quả. Tôi thực sự thích cách tiếp cận vô hiệu hóa các sự kiện, nhưng thật không may, nó không hoạt động nếu có> 1 tệp bị bỏ, tệp thứ hai sẽ bị bỏ qua nhiều nhất nếu không phải tất cả các lần. Vì vậy, tôi sử dụng cách tiếp cận sau:

private void EventCallback(object sender, FileSystemEventArgs e)
{
    var fileName = e.FullPath;

    if (!File.Exists(fileName))
    {
        // We've dealt with the file, this is just supressing further events.
        return;
    }

    // File exists, so move it to a working directory. 
    File.Move(fileName, [working directory]);

    // Kick-off whatever processing is required.
}

Mã này làm việc cho tôi.

        private void OnChanged(object source, FileSystemEventArgs e)
    {

        string fullFilePath = e.FullPath.ToString();
        string fullURL = buildTheUrlFromStudyXML(fullFilePath);

        System.Diagnostics.Process.Start("iexplore", fullURL);

        Timer timer = new Timer();
        ((FileSystemWatcher)source).Changed -= new FileSystemEventHandler(OnChanged);
        timer.Interval = 1000;
        timer.Elapsed += new ElapsedEventHandler(t_Elapsed);
        timer.Start();
    }

    private void t_Elapsed(object sender, ElapsedEventArgs e)
    {
        ((Timer)sender).Stop();
        theWatcher.Changed += new FileSystemEventHandler(OnChanged);
    }

chủ yếu là cho tương lai tôi :)

Tôi đã viết một trình bao bọc bằng Rx:

 public class WatcherWrapper : IDisposable
{
    private readonly FileSystemWatcher _fileWatcher;
    private readonly Subject<FileSystemEventArgs> _infoSubject;
    private Subject<FileSystemEventArgs> _eventSubject;

    public WatcherWrapper(string path, string nameFilter = "*.*", NotifyFilters? notifyFilters = null)
    {
        _fileWatcher = new FileSystemWatcher(path, nameFilter);

        if (notifyFilters != null)
        {
            _fileWatcher.NotifyFilter = notifyFilters.Value;
        }

        _infoSubject = new Subject<FileSystemEventArgs>();
        _eventSubject = new Subject<FileSystemEventArgs>();

        Observable.FromEventPattern<FileSystemEventArgs>(_fileWatcher, "Changed").Select(e => e.EventArgs)
            .Subscribe(_infoSubject.OnNext);
        Observable.FromEventPattern<FileSystemEventArgs>(_fileWatcher, "Created").Select(e => e.EventArgs)
            .Subscribe(_infoSubject.OnNext);
        Observable.FromEventPattern<FileSystemEventArgs>(_fileWatcher, "Deleted").Select(e => e.EventArgs)
            .Subscribe(_infoSubject.OnNext);
        Observable.FromEventPattern<FileSystemEventArgs>(_fileWatcher, "Renamed").Select(e => e.EventArgs)
            .Subscribe(_infoSubject.OnNext);

        // this takes care of double events and still works with changing the name of the same file after a while
        _infoSubject.Buffer(TimeSpan.FromMilliseconds(20))
            .Select(x => x.GroupBy(z => z.FullPath).Select(z => z.LastOrDefault()).Subscribe(
                infos =>
                {
                    if (infos != null)
                        foreach (var info in infos)
                        {
                            {
                                _eventSubject.OnNext(info);
                            }
                        }
                });

        _fileWatcher.EnableRaisingEvents = true;
    }

    public IObservable<FileSystemEventArgs> FileEvents => _eventSubject;


    public void Dispose()
    {
        _fileWatcher?.Dispose();
        _eventSubject.Dispose();
        _infoSubject.Dispose();
    }
}

Sử dụng:

var watcher = new WatcherWrapper(_path, "*.info");
// all more complicated and scenario specific filtering of events can be done here    
watcher.FileEvents.Where(x => x.ChangeType != WatcherChangeTypes.Deleted).Subscribe(x => //do stuff)

Tôi đã thay đổi cách tôi theo dõi các tập tin trong thư mục. Thay vì sử dụng FileSystemWatcher, tôi thăm dò các vị trí trên một luồng khác và sau đó xem LastWriteTime của tệp.

DateTime lastWriteTime = File.GetLastWriteTime(someFilePath);

Sử dụng thông tin này và giữ một chỉ mục của đường dẫn tệp và thời gian ghi mới nhất tôi có thể xác định các tệp đã thay đổi hoặc đã được tạo ở một vị trí cụ thể. Điều này loại bỏ tôi khỏi những điều kỳ lạ của FileSystemWatcher. Nhược điểm chính là bạn cần một cấu trúc dữ liệu để lưu trữ LastWriteTime và tham chiếu đến tệp, nhưng nó đáng tin cậy và dễ thực hiện.

Bạn có thể thử mở nó để ghi và nếu thành công thì bạn có thể giả sử ứng dụng khác được thực hiện với tệp.

private void OnChanged(object source, FileSystemEventArgs e)
{
    try
    {
        using (var fs = File.OpenWrite(e.FullPath))
        {
        }
        //do your stuff
    }
    catch (Exception)
    {
        //no write access, other app not done
    }
}

Chỉ cần mở nó để viết dường như không làm tăng sự kiện đã thay đổi. Vì vậy, nó nên được an toàn.

FileReadTime = DateTime.Now;

private void File_Changed(object sender, FileSystemEventArgs e)
{            
    var lastWriteTime = File.GetLastWriteTime(e.FullPath);
    if (lastWriteTime.Subtract(FileReadTime).Ticks > 0)
    {
        // code
        FileReadTime = DateTime.Now;
    }
}

Xin lỗi vì đã đào mộ, nhưng tôi đã chiến đấu với vấn đề này một thời gian và cuối cùng đã tìm ra cách để xử lý nhiều sự kiện bị sa thải này. Tôi muốn cảm ơn tất cả mọi người trong chủ đề này vì tôi đã sử dụng nó trong nhiều tài liệu tham khảo khi chiến đấu với vấn đề này.

Đây là mã hoàn chỉnh của tôi. Nó sử dụng một từ điển để theo dõi ngày và thời gian ghi lần cuối của tập tin. Nó so sánh giá trị đó, và nếu nó giống nhau, nó triệt tiêu các sự kiện. Sau đó, nó đặt giá trị sau khi bắt đầu chuỗi mới.

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" );
        }
    }

Sự kiện nếu không được hỏi, thật xấu hổ vì không có mẫu giải pháp sẵn sàng cho F #. Để khắc phục điều này ở đây là công thức của tôi, chỉ vì tôi có thể và F # là một ngôn ngữ .NET tuyệt vời.

Các sự kiện trùng lặp được lọc ra bằng FSharp.Control.Reactivegói, đây chỉ là một trình bao bọc F # cho các tiện ích mở rộng phản ứng. Tất cả những gì có thể được nhắm mục tiêu đến khung đầy đủ hoặc netstandard2.0:

let createWatcher path filter () =
    new FileSystemWatcher(
        Path = path,
        Filter = filter,
        EnableRaisingEvents = true,
        SynchronizingObject = null // not needed for console applications
    )

let createSources (fsWatcher: FileSystemWatcher) =
    // use here needed events only. 
    // convert `Error` and `Renamed` events to be merded
    [| fsWatcher.Changed :> IObservable<_>
       fsWatcher.Deleted :> IObservable<_>
       fsWatcher.Created :> IObservable<_>
       //fsWatcher.Renamed |> Observable.map renamedToNeeded
       //fsWatcher.Error   |> Observable.map errorToNeeded
    |] |> Observable.mergeArray

let handle (e: FileSystemEventArgs) =
    printfn "handle %A event '%s' '%s' " e.ChangeType e.Name e.FullPath 

let watch path filter throttleTime =
    // disposes watcher if observer subscription is disposed
    Observable.using (createWatcher path filter) createSources
    // filter out multiple equal events
    |> Observable.distinctUntilChanged
    // filter out multiple Changed
    |> Observable.throttle throttleTime
    |> Observable.subscribe handle

[<EntryPoint>]
let main _args =
    let path = @"C:\Temp\WatchDir"
    let filter = "*.zip"
    let throttleTime = TimeSpan.FromSeconds 10.
    use _subscription = watch path filter throttleTime
    System.Console.ReadKey() |> ignore
    0 // return an integer exit code

Trong trường hợp của tôi cần lấy dòng cuối cùng của tệp văn bản được chèn bởi ứng dụng khác, ngay sau khi chèn xong. Đây là giải pháp của tôi. Khi sự kiện đầu tiên được đưa ra, tôi vô hiệu hóa trình theo dõi để tăng người khác, sau đó tôi gọi bộ đếm thời gian TimeElapsedEvent vì khi chức năng xử lý của tôi OnChanged được gọi là tôi cần kích thước của tệp văn bản, nhưng kích thước tại thời điểm đó không phải là kích thước thực tế, nó là kích thước của tập tin trước khi chèn. Vì vậy, tôi chờ một lúc để tiến hành với kích thước tập tin phù hợp.

private FileSystemWatcher watcher = new FileSystemWatcher();
...
watcher.Path = "E:\\data";
watcher.NotifyFilter = NotifyFilters.LastWrite ;
watcher.Filter = "data.txt";
watcher.Changed += new FileSystemEventHandler(OnChanged);
watcher.EnableRaisingEvents = true;

...

private void OnChanged(object source, FileSystemEventArgs e)
   {
    System.Timers.Timer t = new System.Timers.Timer();
    try
    {
        watcher.Changed -= new FileSystemEventHandler(OnChanged);
        watcher.EnableRaisingEvents = false;

        t.Interval = 500;
        t.Elapsed += (sender, args) => t_Elapsed(sender, e);
        t.Start();
    }
    catch(Exception ex) {
        ;
    }
}

private void t_Elapsed(object sender, FileSystemEventArgs e) 
   {
    ((System.Timers.Timer)sender).Stop();
       //.. Do you stuff HERE ..
     watcher.Changed += new FileSystemEventHandler(OnChanged);
     watcher.EnableRaisingEvents = true;
}

Hãy thử nó, nó hoạt động tốt

  private static readonly FileSystemWatcher Watcher = new FileSystemWatcher();
    static void Main(string[] args)
    {
        Console.WriteLine("Watching....");

        Watcher.Path = @"D:\Temp\Watcher";
        Watcher.Changed += OnChanged;
        Watcher.EnableRaisingEvents = true;
        Console.ReadKey();
    }

    static void OnChanged(object sender, FileSystemEventArgs e)
    {
        try
        {
            Watcher.Changed -= OnChanged;
            Watcher.EnableRaisingEvents = false;
            Console.WriteLine($"File Changed. Name: {e.Name}");
        }
        catch (Exception exception)
        {
            Console.WriteLine(exception);
        }
        finally
        {
            Watcher.Changed += OnChanged;
            Watcher.EnableRaisingEvents = true;
        }
    }

Tôi chỉ muốn phản ứng ở sự kiện cuối cùng, chỉ trong trường hợp, cũng là khi thay đổi tệp linux, có vẻ như tệp đó trống trong cuộc gọi đầu tiên và sau đó điền lại vào lần tiếp theo và không ngại mất một thời gian chỉ trong trường hợp HĐH quyết định thực hiện một số thay đổi tập tin / thuộc tính.

Tôi đang sử dụng .NET async ở đây để giúp tôi thực hiện phân luồng.

    private static int _fileSystemWatcherCounts;
    private async void OnChanged(object sender, FileSystemEventArgs e)
    {
        // Filter several calls in short period of time
        Interlocked.Increment(ref _fileSystemWatcherCounts);
        await Task.Delay(100);
        if (Interlocked.Decrement(ref _fileSystemWatcherCounts) == 0)
            DoYourWork();
    }

Tôi nghĩ giải pháp tốt nhất để giải quyết vấn đề là sử dụng các tiện ích mở rộng phản ứng Khi bạn chuyển đổi sự kiện thành có thể quan sát được, thì bạn chỉ cần thêm Throttling (..) (ban đầu được gọi là Debounce (..))

Mã mẫu tại đây

        var templatesWatcher = new FileSystemWatcher(settingsSnapshot.Value.TemplatesDirectory)
        {
            NotifyFilter = NotifyFilters.LastWrite,
            IncludeSubdirectories = true
        };

        templatesWatcher.EnableRaisingEvents = true;

        Observable.FromEventPattern<FileSystemEventHandler, FileSystemEventArgs>(
                addHandler => templatesWatcher.Changed += addHandler,
                removeHandler => templatesWatcher.Changed -= removeHandler)
            .Throttle(TimeSpan.FromSeconds(5))
            .Subscribe(args =>
            {
                _logger.LogInformation($"Template file {args.EventArgs.Name} has changed");
                //TODO do something
            });

Tôi đã có thể làm điều này bằng cách thêm một chức năng kiểm tra các bản sao trong một mảng đệm.

Sau đó thực hiện hành động sau khi mảng không được sửa đổi trong thời gian X bằng cách sử dụng bộ hẹn giờ: - Đặt lại bộ đếm thời gian mỗi khi có gì đó được ghi vào bộ đệm - Thực hiện hành động khi đánh dấu

Điều này cũng bắt một loại trùng lặp khác. Nếu bạn sửa đổi một tệp trong một thư mục, thư mục đó cũng sẽ ném một sự kiện Thay đổi.

Function is_duplicate(str1 As String) As Boolean
    If lb_actions_list.Items.Count = 0 Then
        Return False
    Else
        Dim compStr As String = lb_actions_list.Items(lb_actions_list.Items.Count - 1).ToString
        compStr = compStr.Substring(compStr.IndexOf("-") + 1).Trim

        If compStr <> str1 AndAlso compStr.parentDir <> str1 & "\" Then
            Return False
        Else
            Return True
        End If
    End If
End Function

Public Module extentions
<Extension()>
Public Function parentDir(ByVal aString As String) As String
    Return aString.Substring(0, CInt(InStrRev(aString, "\", aString.Length - 1)))
End Function
End Module

Giải pháp này đã làm việc cho tôi trên ứng dụng sản xuất:

Môi trường:

Khung VB.Net 4.5.2

Đặt thuộc tính đối tượng thủ công: NotifyFilter = Size

Sau đó sử dụng mã này:

Public Class main
    Dim CalledOnce = False
    Private Sub FileSystemWatcher1_Changed(sender As Object, e As IO.FileSystemEventArgs) Handles FileSystemWatcher1.Changed
            If (CalledOnce = False) Then
                CalledOnce = True
                If (e.ChangeType = 4) Then
                    ' Do task...
                CalledOnce = False
            End If
        End Sub
End Sub

Thử cái này!

string temp="";

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)
{
   .......
if(temp=="")
{
   //do thing you want.
   temp = e.name //name of text file.
}else if(temp !="" && temp != e.name)
{
   //do thing you want.
   temp = e.name //name of text file.
}else
{
  //second fire ignored.
}

}

Tôi đã phải kết hợp một số ý tưởng từ các bài đăng ở trên và thêm kiểm tra khóa tệp để làm cho nó hoạt động với tôi:

FileSystemWatcher fileSystemWatcher;

private void DirectoryWatcher_Start()
{
    FileSystemWatcher fileSystemWatcher = new FileSystemWatcher
    {
        Path = @"c:\mypath",
        NotifyFilter = NotifyFilters.LastWrite,
        Filter = "*.*",
        EnableRaisingEvents = true
    };

    fileSystemWatcher.Changed += new FileSystemEventHandler(DirectoryWatcher_OnChanged);
}

private static void WaitUntilFileIsUnlocked(String fullPath, Action<String> callback, FileAccess fileAccess = FileAccess.Read, Int32 timeoutMS = 10000)
{
    Int32 waitMS = 250;
    Int32 currentMS = 0;
    FileInfo file = new FileInfo(fullPath);
    FileStream stream = null;
    do
    {
        try
        {
            stream = file.Open(FileMode.Open, fileAccess, FileShare.None);
            stream.Close();
            callback(fullPath);
            return;
        }
        catch (IOException)
        {
        }
        finally
        {
            if (stream != null)
                stream.Dispose();
        }
        Thread.Sleep(waitMS);
        currentMS += waitMS;
    } while (currentMS < timeoutMS);
}    

private static Dictionary<String, DateTime> DirectoryWatcher_fileLastWriteTimeCache = new Dictionary<String, DateTime>();

private void DirectoryWatcher_OnChanged(Object source, FileSystemEventArgs ev)
{
    try
    {
        lock (DirectoryWatcher_fileLastWriteTimeCache)
        {
            DateTime lastWriteTime = File.GetLastWriteTime(ev.FullPath);
            if (DirectoryWatcher_fileLastWriteTimeCache.ContainsKey(ev.FullPath))
            {
                if (DirectoryWatcher_fileLastWriteTimeCache[ev.FullPath].AddMilliseconds(500) >= lastWriteTime)
                    return;     // file was already handled
            }

            DirectoryWatcher_fileLastWriteTimeCache[ev.FullPath] = lastWriteTime;
        }

        Task.Run(() => WaitUntilFileIsUnlocked(ev.FullPath, fullPath =>
        {
            // do the job with fullPath...
        }));

    }
    catch (Exception e)
    {
        // handle exception
    }
}

Tôi đã tiếp cận vấn đề tạo kép như thế này, mà bỏ qua sự kiện đầu tiên:

Private WithEvents fsw As New System.IO.FileSystemWatcher
Private complete As New List(Of String)

Private Sub fsw_Created(ByVal sender As Object, _
    ByVal e As System.IO.FileSystemEventArgs) Handles fsw.Created

    If Not complete.Contains(e.FullPath) Then
        complete.Add(e.FullPath)

    Else
        complete.Remove(e.FullPath)
        Dim th As New Threading.Thread(AddressOf hprocess)
        th.Start(e)

    End If

End Sub