FileSystemWatcher Changed event is raised twice

Question

I have an application where I am looking for a text file and if there are any changes made to the file I am using the OnChanged eventhandler to handle the event  I am using the NotifyFilters LastWriteTime but still the event is getting fired twice  Here is the code   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                   In my case the OnChanged is called twice  when I change the text file version txt and save it

User · Answer

The solution really depends on the use case. Are you watching out for new files that don't change, or one file that changes every once in a while, of changes very often? In my case, it changes not too often, and I don't want to miss any of these changes.

But I also do not want the change event where the writing process is not yet done writing.

In my case, I noticed 6 (six!!) onchange events on writing a 125 char txt file.

My solution is a mix of polling, that is often looked negatively at, and the change-event. Normal polling is slow, say every 10 seconds, just in case the FileSystemWatcher (FSW) "misses" an event. The polling responds immediately to a FSW change event.

The trick is that at a FSW.Change event, the polling goes faster, say every 100 ms, and waits until the file is stable. So we have "two phased polling": phase 1 is slow, but responds immediately on a FSW file change event. Phase 2 is fast, waiting for a stable file.

If the FSW detects multiple file changes, each of those events speeds up the polling loop, and will effectively start a new, short, waiting cycle. Only after the polling loop detects no further change in file last write time, it assumes that the file is stable, and your code may handle the changed file.

I chose timeouts of 10 seconds and 100 ms, but your use case may need different timeout values.

Here is the polling, where AppConfig.fiIO is the FileInfo to watch for:

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: yes, I don't like }}}} either, but it makes the listing shorter so that you don't have to scroll :-)

User · Answer

Make it simple define one global variable var1   true   Private Sub FileWatchman Changed ByVal sender As System Object  ByVal e As System IO FileSystemEventArgs  Handles FileWatchman Changed    If var1   true         your logic goes here        var1   false    Else        var1   true     End If End Sub

User · Answer

Sorry for the grave dig  but I ve been battling this issue for a while now and finally came up with a way to handle these multiple fired events  I would like to thank everyone in this thread as I have used it in many references when battling this issue   Here is my complete code  It uses a dictionary to track the date and time of the last write of the file  It compares that value  and if it is the same  it suppresses the events  It then sets the value after starting the new thread   using System Threading     used for backgroundworker using System Diagnostics     used for file information private static IDictionary lt string  string gt  fileModifiedTable   new Dictionary lt string  string gt        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 lt object gt  arguments   new List lt object gt                                     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

User · Answer

Try with this code   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

User · Answer

One possible  hack  would be to throttle the events using Reactive Extensions for example   var watcher   new FileSystemWatcher         Observable FromEventPattern lt FileSystemEventArgs gt  watcher   Changed                Throttle new TimeSpan 500000                Subscribe HandleChangeEvent    watcher EnableRaisingEvents   true    In this case I m throttling to 50ms  on my system that was enough  but higher values should be safer   And like I said  it s still a  hack

User · Answer

FileReadTime   DateTime Now   private void File Changed object sender  FileSystemEventArgs e                    var lastWriteTime   File GetLastWriteTime e FullPath       if  lastWriteTime Subtract FileReadTime  Ticks  gt  0                   code         FileReadTime   DateTime Now

User · Answer

I ve  fixed  that problem using the following strategy in my delegate      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

User · Answer

I know this is an old issue  but had the same problem and none of the above solution really did the trick for the problem I was facing  I have created a dictionary which maps the file name with the LastWriteTime  So if the file is not in the dictionary will go ahead with the process other wise check to see when was the last modified time and if is different from what it is in the dictionary run the code       Dictionary lt string  DateTime gt  dateTimeDictionary   new Dictionary lt string  DateTime gt               private void OnChanged object source  FileSystemEventArgs e                                if   dateTimeDictionary ContainsKey e FullPath      dateTimeDictionary ContainsKey e FullPath   amp  amp  System IO File GetLastWriteTime e FullPath     dateTimeDictionary e FullPath                                          dateTimeDictionary e FullPath    System IO File GetLastWriteTime e FullPath                          your code here

User · Answer

I had to combine several ideas from the posts above and add file locking check to get it working for me   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 lt String gt  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  lt  timeoutMS          private static Dictionary lt String  DateTime gt  DirectoryWatcher fileLastWriteTimeCache   new Dictionary lt String  DateTime gt      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   gt   lastWriteTime                      return         file was already handled                            DirectoryWatcher fileLastWriteTimeCache ev FullPath    lastWriteTime                     Task Run      gt  WaitUntilFileIsUnlocked ev FullPath  fullPath   gt                           do the job with fullPath                            catch  Exception e                   handle exception

User · Answer

Well  here is my solution how to raise an event only once   FileSystemWatche  watcher   new FileSystemWatcher        path  - path to the file that has been modified  watcher Changed     s  e    gt  FileChanged path     here is implementation of FileChanged    count is our counter to triger when we can raise and when not  private int count   0  private void FileChanged string path       if  count   2    0                  code here              count

User · Answer

mostly for future me     I wrote a wrapper using Rx    public class WatcherWrapper   IDisposable       private readonly FileSystemWatcher  fileWatcher      private readonly Subject lt FileSystemEventArgs gt   infoSubject      private Subject lt FileSystemEventArgs gt   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 lt FileSystemEventArgs gt              eventSubject   new Subject lt FileSystemEventArgs gt              Observable FromEventPattern lt FileSystemEventArgs gt   fileWatcher   Changed   Select e   gt  e EventArgs               Subscribe  infoSubject OnNext           Observable FromEventPattern lt FileSystemEventArgs gt   fileWatcher   Created   Select e   gt  e EventArgs               Subscribe  infoSubject OnNext           Observable FromEventPattern lt FileSystemEventArgs gt   fileWatcher   Deleted   Select e   gt  e EventArgs               Subscribe  infoSubject OnNext           Observable FromEventPattern lt FileSystemEventArgs gt   fileWatcher   Renamed   Select e   gt  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   gt  x GroupBy z   gt  z FullPath  Select z   gt  z LastOrDefault    Subscribe                  infos   gt                                        if  infos    null                          foreach  var info in infos                                                                                           eventSubject OnNext info                                                                                         fileWatcher EnableRaisingEvents   true             public IObservable lt FileSystemEventArgs gt  FileEvents   gt   eventSubject        public void Dispose                  fileWatcher  Dispose             eventSubject Dispose             infoSubject Dispose              Usage   var watcher   new WatcherWrapper  path     info       all more complicated and scenario specific filtering of events can be done here     watcher FileEvents Where x   gt  x ChangeType    WatcherChangeTypes Deleted  Subscribe x   gt    do stuff

User · Answer

In my case need to get the last line of a text file that is inserted by other application  as soon as insertion is done  Here is my solution  When the first event is raised  i disable the watcher from raising others  then i call the timer TimeElapsedEvent because when my handle function OnChanged is called i need the size of the text file  but the size at that time is not the actual size  it is the size of the file imediatelly before the insertion  So i wait for a while to proceed with the right file size        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    gt  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

User · Answer

Here s my approach       Consider having a List lt String gt  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    gt                lock   changedFiles                         changedFiles Remove e FullPath                       timer Start        This is the solution I used to solve this issue on a project where I was sending the file as attachment in a mail  It will easily avoid the twice fired event even with a smaller timer interval but in my case 1000 was alright since I was happier with missing few changes than with flooding the mailbox with   1 message per second  At least it works just fine in case several files are changed at the exact same time   Another solution I ve thought of would be to replace the list with a dictionary mapping files to their respective MD5  so you wouldn t have to choose an arbitrary interval since you wouldn t have to delete the entry but update its value  and cancel your stuff if it hasn t changed  It has the downside of having a Dictionary growing in memory as files are monitored and eating more and more memory  but I ve read somewhere that the amount of files monitored depends on the FSW s internal buffer  so maybe not that critical  Dunno how MD5 computing time would affect your code s performances either  careful

User · Answer

Try this  It s working fine    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

User · Answer

I think the best solution to solve the issue is to use reactive extensions When you transform event into observable  then you can just add Throttling       originally called Debounce       Sample code here          var templatesWatcher   new FileSystemWatcher settingsSnapshot Value TemplatesDirectory                        NotifyFilter   NotifyFilters LastWrite              IncludeSubdirectories   true                     templatesWatcher EnableRaisingEvents   true           Observable FromEventPattern lt FileSystemEventHandler  FileSystemEventArgs gt                   addHandler   gt  templatesWatcher Changed    addHandler                  removeHandler   gt  templatesWatcher Changed -  removeHandler               Throttle TimeSpan FromSeconds 5                Subscribe args   gt                                 logger LogInformation   Template file  args EventArgs Name  has changed                      TODO do something

User · Answer

I have created a Git repo with a class that extends FileSystemWatcher to trigger the events only when copy is done  It discards all the changed events exept the last and it raise it only when the file become available for read   Download FileSystemSafeWatcher and add it to your project   Then use it as a normal FileSystemWatcher and monitor when the events are triggered   var fsw   new FileSystemSafeWatcher file   fsw EnableRaisingEvents   true     Add event handlers here fsw Created    fsw Created

User · Answer

I have a very quick and simple workaround here  it does work for me  and no matter the event would be triggered once or twice or more times occasionally  check it out   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

User · Answer

I am afraid that this is a well-known bug feature of the FileSystemWatcher class  This is from the documentation of the class      You may notice in certain situations that a single creation event generates multiple Created events that are handled by your component  For example  if you use a FileSystemWatcher component to monitor the creation of new files in a directory  and then test it by using Notepad to create a file  you may see two Created events generated even though only a single file was created  This is because Notepad performs multiple file system actions during the writing process  Notepad writes to the disk in batches that create the content of the file and then the file attributes  Other applications may perform in the same manner  Because FileSystemWatcher monitors the operating system activities  all events that these applications fire will be picked up    Now this bit of text is about the Created event  but the same thing applies to other file events as well  In some applications you might be able to get around this by using the NotifyFilter property  but my experience is says that sometimes you have to do some manual duplicate filtering  hacks  as well   A while ago I bookedmarked a page with a few FileSystemWatcher tips  You might want to check it out

User · Answer

You could try to open it for write  and if successful then you could assume the other application is done with the file   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           Just opening it for write appears not to raise the changed event  So it should be safe

User · Answer

This code worked for me           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

User · Answer

I simple add a dupe check as follows    private void OnChanged object source  FileSystemEventArgs e                string sTabName   Path GetFileNameWithoutExtension e Name           string sLastLine   ReadLastLine e FullPath           if sLastLine     dupeCheck                        TabPage tp   tcLogs TabPages sTabName               TextBox tbLog    TextBox tp Controls 0  as TextBox               tbLog Invoke new Action      gt  tbLog AppendText sLastLine   Environment NewLine                 tbLog Invoke new Action      gt  tbLog SelectionStart   tbLog Text Length                tbLog Invoke new Action      gt  tbLog ScrollToCaret                   dupeCheck   sLastLine                       public static String ReadLastLine string path                return ReadLastLine path  Encoding Default    n               public static String ReadLastLine string path  Encoding encoding  string newline                int charsize   encoding GetByteCount   n            byte   buffer   encoding GetBytes newline           using  FileStream stream   new FileStream path  FileMode Open  FileAccess Read  FileShare ReadWrite                         long endpos   stream Length   charsize              for  long pos   charsize  pos  lt  endpos  pos    charsize                                stream Seek -pos  SeekOrigin End                   stream Read buffer  0  buffer Length                   if  encoding GetString buffer     newline                                        buffer   new byte stream Length - stream Position                       stream Read buffer  0  buffer Length                       return encoding GetString buffer                                                     return null              DllImport  user32 dll   CharSet   CharSet Auto       private static extern int SendMessage IntPtr hWnd  int wMsg  IntPtr wParam  IntPtr lParam        private const int WM VSCROLL   0x115      private const int SB BOTTOM   7            lt summary gt          Scrolls the vertical scroll bar of a multi-line text box to the bottom           lt  summary gt           lt param name  tb  gt The text box to scroll lt  param gt      public static void ScrollToBottom TextBox tb                SendMessage tb Handle  WM VSCROLL   IntPtr SB BOTTOM  IntPtr Zero

User · Answer

Here is a new solution you can try  Works well for me  In the event handler for the changed event programmatically remove the handler from the designer output a message if desired then programmatically add the handler back  example    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

User · Answer

I approached the double create issue like this  which ignores the first event   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

User · Answer

The main reason was  first event s last access time was current time file write or changed time   then second event was file s original last access time  I solve under code           var lastRead   DateTime MinValue           Watcher   new FileSystemWatcher                            NotifyFilter   NotifyFilters FileName   NotifyFilters LastWrite              Filter      dll               IncludeSubdirectories   false                     Watcher Changed     senderObject  ea    gt                        var now   DateTime Now              var lastWriteTime   File GetLastWriteTime ea FullPath                if  now    lastWriteTime                                return                             if  lastWriteTime    lastRead                                   do something                    lastRead   lastWriteTime                                    Watcher EnableRaisingEvents   true

User · Answer

Here is my solution which helped me to stop the event being raised twice   watcher NotifyFilter   NotifyFilters FileName   NotifyFilters Size    Here I have set the NotifyFilter property with only Filename and size  watcher is my object of FileSystemWatcher  Hope this will help

User · Answer

Been searching for answer but I came up with a dirty solution  Since my event fires twice  second action does nothing           count   1         action                  if  count -eq 1                                      DO SOMETHING                  count   2               else                   count   1

User · Answer

This solution worked for me on production application   Environment   VB Net Framework 4 5 2  Set manually object properties  NotifyFilter   Size  Then use this code   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

User · Answer

Well  This question is old  i was here today   but in the end i used an way simpler approach    Boolean - if something is being done  true  When it ends  false  Before processing   add it to a HashSet  This way i won t be repeating elements  Every 30 minutes the elapsed event of an timer runs  and if there s no job being executed it will clear the list  just hashset   new hashset     I hope i contributed with something

User · Answer

Code with customizable disabling of the time interval of blocking the second watcher raising and without blocking over watchers if they exist       namespace Watcher               class Static                       public static DateTime lastDomain   get  set                public static string lastDomainStr   get  set                      public partial class Form1   Form                      int minMs   20   time for blocking in ms             public Form1                                 InitializeComponent                    Static lastDomain   new DateTime 1970  1  1  0  0  0                   Static lastDomainStr                         Start                               private void Start    Start watcher                                                      domain Changed    new FileSystemEventHandler Domain                   domain EnableRaisingEvents   true                       you second unblocked watchers                 second Changed    new FileSystemEventHandler Second                   second EnableRaisingEvents   true                              private void Domain object source  FileSystemEventArgs e                                 if  now Subtract Static lastDomain  TotalMilliseconds  lt  minMs  amp  amp  Static lastDomainStr    e FullPath return                        you code here                     if you need form access                  this Invoke new MethodInvoker      gt   textBox1 Text                                                   Static lastDomain   DateTime Now                   Static lastDomainStr   e FullPath                              private void Second object source  FileSystemEventArgs e                                        Second rised

User · Answer

I was able to do this by added a function that checks for duplicates in an buffer array    Then perform the action after the array has not been modified for X time using a timer   - Reset timer every time something is written to the buffer  - Perform action on tick  This also catches another duplication type   If you modify a file inside a folder  the folder also throws a Change event   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  lt  gt  str1 AndAlso compStr parentDir  lt  gt  str1  amp      Then             Return False         Else             Return True         End If     End If End Function  Public Module extentions  lt Extension   gt  Public Function parentDir ByVal aString As String  As String     Return aString Substring 0  CInt InStrRev aString       aString Length - 1    End Function End Module

User · Answer

Try this   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       amp  amp  temp    e name         do thing you want     temp   e name   name of text file   else       second fire ignored

User · Answer

if you register to the OnChanged event  then by deleting the monitored file before changing it might work  as long as you only need to monitor the OnChange event

User · Answer

Event if not asked  it is a shame there are no ready solution samples for F    To fix this here is my recipe  just because I can and F  is a wonderful  NET language   Duplicated events are filtered out using FSharp Control Reactive package  which is just a F  wrapper for reactive extensions  All that can be targeted to full framework or 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   gt  IObservable lt   gt         fsWatcher Deleted   gt  IObservable lt   gt         fsWatcher Created   gt  IObservable lt   gt           fsWatcher Renamed   gt  Observable map renamedToNeeded          fsWatcher Error     gt  Observable map errorToNeeded          gt  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       gt  Observable distinctUntilChanged        filter out multiple Changed       gt  Observable throttle throttleTime       gt  Observable subscribe handle    lt EntryPoint gt   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     gt  ignore     0    return an integer exit code

User · Answer

After struggling with the Changed event firing twice as well  I found that the easiest solution is to compare the byte   contents of the file before and after the event fires  then only execute your code if the contents of the file actually changed   The basic problem is this same event is fired for each specific type of change to a file  besides just content changes  Just saving a change to the file contents fires the event multiple times  due to a change in the file date  attributes  or whatever else it is detecting    The FileSystemWatcher class SHOULD be providing a lot more events for all the various changes a file or directory can experience  This is an annoying oversight by the  NET team  It s absurd that a single action within the system or by a user would result in firing a single event in  NET more than once  This is an incredibly dumb design   And before one of you apologists makes up some absolutely ridiculous excuses why WE are all capable of writing custom code to prevent an event from firing multiple times but the developers at Microsoft are not  save your time  This has become the worst part of the StackOverflow experience  all the butt-kissing apologists that refuse to admit that there are design flaws in software all around us that we use every day that could be corrected if the publisher would simply invest the time and expense

User · Answer

My scenario is that I have a virtual machine with a Linux server in it  I am developing files on the Windows host  When I change something in a folder on the host I want all the changes to be uploaded  synced onto the virtual server via Ftp  This is how I do eliminate the duplicate change event when I write to a file   which flags the folder containing the file to be modified as well      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            Mainly I create a hashtable to store file write time information  Then if the hashtable has the filepath that is modified and it s time value is the same as the currently notified file s change then I know it is the duplicate of the event and ignore it

User · Answer

I spent some significant amount of time using the FileSystemWatcher  and some of the approaches here will not work  I really liked the disabling events approach  but unfortunately  it doesn t work if there is  1 file being dropped  second file will be missed most if not all times   So I use the following approach   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

User · Answer

Any duplicated OnChanged events from the FileSystemWatcher can be detected and discarded by checking the File GetLastWriteTime timestamp on the file in question  Like so    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

User · Answer

Here is another approach  Instead of propagating the first event of a quick succession of events and suppressing all that follow  now all are suppressed except from the last one  I think that the scenarios that can benefit from this approach are more common   To make this happen we must use a sliding delay  Every incoming event cancels the timer that would fire the previous event  and restarts the timer  This opens the possibility that a never-ending series of events will delay the propagation forever  To keep things simple  there is no provision for this abnormal case in the extension methods below   public static class FileSystemWatcherExtensions       public static IDisposable OnAnyEvent this FileSystemWatcher source          WatcherChangeTypes changeTypes  FileSystemEventHandler handler  int delay                var cancellations   new Dictionary lt string  CancellationTokenSource gt               StringComparer OrdinalIgnoreCase           var locker   new object            if  changeTypes HasFlag WatcherChangeTypes Created               source Created    FileSystemWatcher Event          if  changeTypes HasFlag WatcherChangeTypes Deleted               source Deleted    FileSystemWatcher Event          if  changeTypes HasFlag WatcherChangeTypes Changed               source Changed    FileSystemWatcher Event          if  changeTypes HasFlag WatcherChangeTypes Renamed               source Renamed    FileSystemWatcher Event          return new Disposable      gt                        source Created -  FileSystemWatcher Event              source Deleted -  FileSystemWatcher Event              source Changed -  FileSystemWatcher Event              source Renamed -  FileSystemWatcher Event                       async void FileSystemWatcher Event object sender  FileSystemEventArgs e                        var key   e FullPath              var cts   new CancellationTokenSource                lock  locker                                if  cancellations TryGetValue key  out var existing                                         existing Cancel                                      cancellations key    cts                            try                               await Task Delay delay  cts Token                      Omitting ConfigureAwait false  is intentional here                     Continuing in the captured context is desirable                            catch  TaskCanceledException                                return                            lock  locker                                if  cancellations TryGetValue key  out var existing                       amp  amp  existing    cts                                        cancellations Remove key                                               cts Dispose                handler sender  e                        public static IDisposable OnAllEvents this FileSystemWatcher source          FileSystemEventHandler handler  int delay            gt  OnAnyEvent source  WatcherChangeTypes All  handler  delay        public static IDisposable OnCreated this FileSystemWatcher source          FileSystemEventHandler handler  int delay            gt  OnAnyEvent source  WatcherChangeTypes Created  handler  delay        public static IDisposable OnDeleted this FileSystemWatcher source          FileSystemEventHandler handler  int delay            gt  OnAnyEvent source  WatcherChangeTypes Deleted  handler  delay        public static IDisposable OnChanged this FileSystemWatcher source          FileSystemEventHandler handler  int delay            gt  OnAnyEvent source  WatcherChangeTypes Changed  handler  delay        public static IDisposable OnRenamed this FileSystemWatcher source          FileSystemEventHandler handler  int delay            gt  OnAnyEvent source  WatcherChangeTypes Renamed  handler  delay        private struct Disposable   IDisposable               private readonly Action  action          internal Disposable Action action    gt   action   action          public void Dispose     gt   action  Invoke              Usage example   myWatcher OnAnyEvent WatcherChangeTypes Created   WatcherChangeTypes Changed      MyFileSystemWatcher Event  100     This line combines the subscription to two events  the Created and the Changed  So it is roughly equivalent to these   myWatcher Created    MyFileSystemWatcher Event  myWatcher Changed    MyFileSystemWatcher Event    The difference is that the two events are regarded as a single type of event  and in case of a quick succession of these events only the last one will be propagated  For example if a Created event is followed by two Changed events  and there is no time gap larger than 100 msec between these three events  only the second Changed event will be propagated by invoking the MyFileSystemWatcher Event handler  and the previous ones will be discarded

User · Answer

I have changed the way I monitor files in directories   Instead of using the FileSystemWatcher I poll locations on another thread and then look at the LastWriteTime of the file   DateTime lastWriteTime   File GetLastWriteTime someFilePath     Using this information and keeping an index of a file path and it s latest write time I can determine files that have changed or that have been created in a particular location   This removes me from the oddities of the FileSystemWatcher   The main downside is that you need a data structure to store the LastWriteTime and the reference to the file  but it is reliable and easy to implement

User · Answer

Alot of these answers are shocking  really  Heres some code from my XanderUI Control library that fixes this   private void OnChanged object sender  FilesystemEventArgs e        if  FSWatcher IncludeSubdirectories    true                if  File Exists e FullPath     DO YOUR FILE CHANGE STUFF HERE                else DO YOUR DIRECTORY CHANGE STUFF HERE

User · Answer

I wanted to react only on the last event  just in case  also on a linux file change it seemed that the file was empty on the first call and then filled again on the next and did not mind loosing some time just in case the OS decided to do some file attribute change   I am using  NET async here to help me do the 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

[c#] FileSystemWatcher Changed event is raised twice

Examples related to c#

Examples related to filesystemwatcher