FileSystemWatcher Changed event dinaikkan dua kali

Saya memiliki aplikasi tempat saya mencari file teks dan jika ada perubahan pada file saya menggunakan OnChangedeventhandler untuk menangani acara tersebut. Saya menggunakan NotifyFilters.LastWriteTimetetapi masih acara dipecat dua kali. Ini kodenya.

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

Dalam kasus saya OnChangeddisebut dua kali, ketika saya mengubah file teks version.txtdan menyimpannya.

Saya takut ini adalah bug / fitur FileSystemWatcherkelas yang terkenal. Ini dari dokumentasi kelas:

Anda mungkin memperhatikan dalam situasi tertentu bahwa satu peristiwa kreasi menghasilkan beberapa peristiwa Dibuat yang ditangani oleh komponen Anda. Misalnya, jika Anda menggunakan komponen FileSystemWatcher untuk memantau pembuatan file baru di direktori, dan kemudian mengujinya dengan menggunakan Notepad untuk membuat file, Anda mungkin melihat dua peristiwa dibuat dihasilkan meskipun hanya satu file dibuat. Ini karena Notepad melakukan beberapa tindakan sistem file selama proses penulisan. Notepad menulis ke disk dalam kumpulan yang membuat konten file dan kemudian atribut file. Aplikasi lain dapat bekerja dengan cara yang sama. Karena FileSystemWatcher memonitor aktivitas sistem operasi, semua peristiwa yang dipicu aplikasi ini akan diambil.

Sekarang ini sedikit teks tentang Createdacara, tetapi hal yang sama berlaku untuk acara file lainnya juga. Dalam beberapa aplikasi Anda mungkin dapat menyiasatinya dengan menggunakan NotifyFilterproperti, tetapi pengalaman saya mengatakan bahwa kadang-kadang Anda harus melakukan beberapa penyaringan duplikat manual (hacks) juga.

Beberapa waktu yang lalu saya memesan halaman dengan beberapa tips FileSystemWatcher . Anda mungkin ingin memeriksanya.

Saya telah "memperbaiki" masalah itu menggunakan strategi berikut dalam delegasi saya:

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

Setiap OnChangedperistiwa yang digandakan dari FileSystemWatcherdapat dideteksi dan dibuang dengan memeriksa File.GetLastWriteTimecap waktu pada file yang dimaksud. Seperti itu:

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
}

Inilah solusi saya yang membantu saya menghentikan acara yang diangkat dua kali:

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

Di sini saya telah menetapkan NotifyFilterproperti hanya dengan Nama file dan ukuran.
watcheradalah objek FileSystemWatcher saya. Semoga ini bisa membantu.

Skenario saya adalah saya memiliki mesin virtual dengan server Linux di dalamnya. Saya mengembangkan file di host Windows. Ketika saya mengubah sesuatu di folder pada host saya ingin semua perubahan diunggah, disinkronkan ke server virtual melalui Ftp. Inilah cara saya menghilangkan peristiwa perubahan duplikat ketika saya menulis ke file (yang menandai folder yang berisi file yang akan dimodifikasi juga):

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

Terutama saya membuat hashtable untuk menyimpan informasi waktu menulis file. Kemudian jika hashtable memiliki filepath yang dimodifikasi dan nilainya waktu sama dengan perubahan file yang diberitahukan saat ini maka saya tahu itu adalah duplikat dari acara tersebut dan mengabaikannya.

Coba dengan kode ini:

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

Inilah pendekatan saya:

// 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();
}

Ini adalah solusi yang saya gunakan untuk menyelesaikan masalah ini pada sebuah proyek di mana saya mengirim file sebagai lampiran dalam surat. Ini akan dengan mudah menghindari peristiwa dua kali dipecat bahkan dengan interval waktu yang lebih kecil tetapi dalam kasus saya 1000 baik-baik saja karena saya lebih bahagia dengan beberapa perubahan yang hilang daripada dengan membanjiri kotak surat dengan> 1 pesan per detik. Setidaknya itu berfungsi dengan baik jika beberapa file diubah pada waktu yang bersamaan.

Solusi lain yang saya pikirkan adalah mengganti daftar dengan file pemetaan kamus ke MD5 masing-masing, sehingga Anda tidak perlu memilih interval sewenang-wenang karena Anda tidak harus menghapus entri tetapi memperbarui nilainya, dan batalkan barang-barang Anda jika belum berubah. Ini memiliki kelemahan memiliki Kamus tumbuh dalam memori sebagai file dipantau dan makan lebih banyak dan lebih banyak memori, tetapi saya telah membaca di suatu tempat bahwa jumlah file yang dipantau tergantung pada buffer internal FSW, jadi mungkin tidak terlalu penting. Entah bagaimana waktu komputasi MD5 akan memengaruhi kinerja kode Anda, hati-hati = \

Saya telah membuat repo Git dengan kelas yang diperluas FileSystemWatcheruntuk memicu peristiwa hanya ketika salinan dilakukan. Ini membuang semua peristiwa yang diubah kecuali yang terakhir dan hanya meningkatkan itu ketika file menjadi tersedia untuk dibaca.

Unduh FileSystemSafeWatcher dan tambahkan ke proyek Anda.

Kemudian gunakan seperti biasa FileSystemWatcherdan pantau saat kejadian dipicu.

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

Saya tahu ini adalah masalah lama, tetapi memiliki masalah yang sama dan tidak ada solusi di atas yang melakukan trik untuk masalah yang saya hadapi. Saya telah membuat kamus yang memetakan nama file dengan LastWriteTime. Jadi jika file tidak ada dalam kamus akan melanjutkan dengan proses lain, periksa bijaksana untuk melihat kapan waktu terakhir dimodifikasi dan jika berbeda dari apa yang ada di kamus jalankan kode.

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

Salah satu 'peretasan' yang mungkin dilakukan adalah mencekik acara menggunakan Ekstensi Reaktif misalnya:

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

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

watcher.EnableRaisingEvents = true;

Dalam hal ini saya membatasi ke 50 ms, pada sistem saya yang cukup, tetapi nilai yang lebih tinggi harus lebih aman. (Dan seperti yang saya katakan, ini masih 'retas').

Saya punya solusi yang sangat cepat dan sederhana di sini, itu bekerja untuk saya, dan tidak peduli peristiwa itu akan dipicu sekali atau dua kali atau lebih sesekali, lihatlah:

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

Inilah solusi baru yang bisa Anda coba. Bekerja dengan baik untuk saya. Dalam event handler untuk event yang diubah secara program, hilangkan handler dari output designer pesan jika diinginkan kemudian secara program menambahkan handler kembali. contoh:

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

Alasan utama adalah waktu akses terakhir acara pertama adalah waktu saat ini (menulis file atau mengubah waktu). kemudian acara kedua adalah waktu akses terakhir asli file. Saya memecahkan kode.

        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;

Saya menghabiskan sejumlah besar waktu menggunakan FileSystemWatcher, dan beberapa pendekatan di sini tidak akan berfungsi. Saya benar-benar menyukai pendekatan penonaktifan acara, tetapi sayangnya, itu tidak berfungsi jika ada> 1 file yang dijatuhkan, file kedua akan paling banyak terlewatkan jika tidak setiap saat. Jadi saya menggunakan pendekatan berikut:

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

Kode ini bekerja untuk saya.

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

sebagian besar untuk masa depan saya :)

Saya menulis pembungkus menggunakan 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();
    }
}

Pemakaian:

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)

Saya telah mengubah cara saya memonitor file dalam direktori. Alih-alih menggunakan FileSystemWatcher saya polling lokasi di utas lain dan kemudian melihat LastWriteTime file.

DateTime lastWriteTime = File.GetLastWriteTime(someFilePath);

Dengan menggunakan informasi ini dan menyimpan indeks jalur file dan ini waktu penulisan terbaru saya dapat menentukan file yang telah berubah atau yang telah dibuat di lokasi tertentu. Ini menghapus saya dari keanehan FileSystemWatcher. Kelemahan utama adalah bahwa Anda memerlukan struktur data untuk menyimpan LastWriteTime dan referensi ke file, tetapi ini dapat diandalkan dan mudah diimplementasikan.

Anda dapat mencoba membukanya untuk menulis, dan jika berhasil maka Anda dapat menganggap aplikasi lain selesai dengan file tersebut.

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

Hanya membukanya untuk menulis tampaknya tidak meningkatkan acara yang diubah. Jadi itu harus aman.

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

Maaf untuk penggalian kubur, tapi saya sudah berjuang untuk masalah ini untuk sementara waktu sekarang dan akhirnya menemukan cara untuk menangani beberapa peristiwa yang dipecat ini. Saya ingin mengucapkan terima kasih kepada semua orang di utas ini karena saya telah menggunakannya dalam banyak referensi saat memerangi masalah ini.

Ini kode lengkap saya. Ini menggunakan kamus untuk melacak tanggal dan waktu penulisan file terakhir. Itu membandingkan nilai itu, dan jika itu sama, itu menekan peristiwa. Ini kemudian menetapkan nilai setelah memulai utas baru.

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

Jika tidak ditanyakan, sayang sekali tidak ada sampel solusi siap untuk F #. Untuk memperbaikinya di sini adalah resep saya, hanya karena saya bisa dan F # adalah bahasa .NET yang bagus.

Acara duplikat disaring menggunakan FSharp.Control.Reactivepaket, yang hanya merupakan pembungkus F # untuk ekstensi reaktif. Semua itu dapat ditargetkan ke kerangka penuh atau 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

Dalam kasus saya perlu mendapatkan baris terakhir dari file teks yang dimasukkan oleh aplikasi lain, segera setelah penyisipan dilakukan. Ini solusinya. Ketika acara pertama dinaikkan, saya menonaktifkan pengamat dari membesarkan orang lain, kemudian saya sebut timer TimeElapsedEvent karena ketika fungsi pegangan saya OnChanged disebut saya perlu ukuran file teks, tetapi ukuran pada waktu itu bukan ukuran sebenarnya, itu adalah ukuran file imediatelly sebelum dimasukkan. Jadi saya menunggu sebentar untuk melanjutkan dengan ukuran file yang tepat.

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

Coba ini, Ini berfungsi dengan baik

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

Saya ingin bereaksi hanya pada acara terakhir, untuk berjaga-jaga, juga pada perubahan file linux tampaknya file itu kosong pada panggilan pertama dan kemudian diisi lagi pada berikutnya dan tidak keberatan kehilangan waktu untuk berjaga-jaga jika OS memutuskan untuk melakukan beberapa perubahan file / atribut.

Saya menggunakan .NET async di sini untuk membantu saya melakukan threading.

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

Saya pikir solusi terbaik untuk mengatasi masalah ini adalah dengan menggunakan ekstensi reaktif Ketika Anda mengubah peristiwa menjadi dapat diamati, maka Anda bisa menambahkan Throttling (..) (awalnya disebut Debounce (..))

Kode contoh di sini

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

Saya bisa melakukan ini dengan menambahkan fungsi yang memeriksa duplikat dalam array buffer.

Kemudian lakukan tindakan setelah array belum dimodifikasi untuk waktu X menggunakan timer: - Atur ulang timer setiap kali ada sesuatu yang ditulis ke buffer - Lakukan tindakan pada centang

Ini juga menangkap tipe duplikasi lain. Jika Anda memodifikasi file di dalam folder, folder itu juga melempar acara Ubah.

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

Solusi ini bekerja untuk saya pada aplikasi produksi:

Lingkungan Hidup:

VB.Net Framework 4.5.2

Setel properti objek secara manual: NotifyFilter = Ukuran

Kemudian gunakan kode ini:

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

Coba ini!

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

}

Saya harus menggabungkan beberapa ide dari posting di atas dan menambahkan cek penguncian file agar berfungsi untuk saya:

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

Saya mendekati masalah buat ganda seperti ini, yang mengabaikan acara pertama:

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