c# Is it possible to ignore all calls to a method while its currently working through itself?

Question

I'm using filesystemwatcher for a program that will run on framework 1.1 and when a change is happened it sends 2 signals saying its changed. From research I'm aware this is just how windows works and theres nothing I can do to stop this with the fsw.

But as a work around I would like to make it so it accepts the first pulse, then locks off so the other one trying to call the method is ignored (or redirected?) as I've got a backup system with it and it is making 2 copies of all the files so it's something I really need to address. Elsewhere in the code is effected and I've managed to use timers to fix this by blocking off the timer as soon as its called however in this instance it'll get quite messy and I'm sure there has to be a cleaner solution.

code:

private static void GetCurrentJob()
        { 
            ///Lots of code that isn't relevant 
        }
private static void ProgramSwapMonitor(string ProgramChange)
        {
            // Create a new FileSystemWatcher and set its properties.
            FileSystemWatcher watcher = new FileSystemWatcher
            {
                Path = ProgramChange,

                /* Watch for changes in LastAccess and LastWrite times, and 
                   the renaming of files or directories. */

                NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite
               | NotifyFilters.FileName | NotifyFilters.DirectoryName,

                // Only watch this specific file
                Filter = "dnocontainer.cfg"
            };

            // Add event handlers.
            watcher.Changed += new FileSystemEventHandler(OnChanged);
            watcher.Created += new FileSystemEventHandler(OnChanged);
            watcher.Deleted += new FileSystemEventHandler(OnChanged);
            watcher.Renamed += new RenamedEventHandler(OnRenamed);

            // Begin watching.
            watcher.EnableRaisingEvents = true;
        }
        // Define the event handlers.
        private static void OnChanged(object source, FileSystemEventArgs e)
        {

            //This disables the directory monitor, then changes the active job in its memory, then restarts the directory monitor so it can now monitor the new location, then removes the old watcherChanged instance so theres no duplicates.
            fileSystemWatcher.EnableRaisingEvents = false;
            GetCurrentJob(); //This is the method that needs to be only running once, but is made to run twice
            MonitorDirectory(path);
            fileSystemWatcher.Changed -= new FileSystemEventHandler(FileSystemWatcher_Changed);
            
        }

Answer 1

A simple way is to use a conditional variable:

static private bool WatcherMutex;

static private void OnChanged(object source, FileSystemEventArgs e)
{
  if ( WatcherMutex ) return;
  WatcherMutex = true;
  try
  {
    ...
  }
  finally
  {
    WatcherMutex = false;
  }
}

Another way is to add and remove the handlers from the watcher to relieve the process of the pool of events but this requires a class field instead of a local var:

static private FileSystemWatcher Watcher = new FileSystemWatcher();

static private void SetWatcherHandlers(bool active)
{
  if ( active )
  {
    Watcher.Changed += OnChanged;
    Watcher.Created += OnChanged;
    Watcher.Deleted += OnChanged;
    Watcher.Renamed += OnRenamed;
  }
  else
  {
    Watcher.Changed -= OnChanged;
    Watcher.Created -= OnChanged;
    Watcher.Deleted -= OnChanged;
    Watcher.Renamed -= OnRenamed;
  }
}

static private void OnChanged(object source, FileSystemEventArgs e)
{
  SetWatcherHandlers(false);
  try
  {
    ...
  }
  finally
  {
    SetWatcherHandlers(true);
  }
}

static private void ProgramSwapMonitor(string ProgramChange)
{
  Watcher = new FileSystemWatcher
  {
    Path = ProgramChange,
    NotifyFilter = NotifyFilters.LastAccess 
                  | NotifyFilters.LastWrite
                  | NotifyFilters.FileName 
                  | NotifyFilters.DirectoryName,
    Filter = "dnocontainer.cfg"
  };
  SetWatcherHandlers(true);
  Watcher.EnableRaisingEvents = true;
}

Or you can simply enable and disable the watcher itself using the same class flield:

static private void OnChanged(object source, FileSystemEventArgs e)
{
  Watcher.EnableRaisingEvents = false;
  try
  {
    ...
  }
  finally
  {
    Watcher.EnableRaisingEvents = true;
  }
}

You can use the way that matches the better to your needs to enable and disable the entire watcher using EnableRaisingEvents or only one or more handler at a time using some conditional variables or some SetWatcherHandlerXXXX one by one or more, or add/remove handler(s) directly in the handler method instead of a conditional variable:

static private void OnChanged(object source, FileSystemEventArgs e)
{
  Watcher.Changed -= OnChanged;
  Watcher.Created -= OnChanged;
  Watcher.Deleted -= OnChanged;
  try
  {
    ...
  }
  finally
  {
    Watcher.Changed += OnChanged;
    Watcher.Created += OnChanged;
    Watcher.Deleted += OnChanged;
  }
}

Thus here we consider OnChanged behavior and OnRenamed as different.

Answer 2

You should use Microsoft's Reactive Framework (aka Rx) - NuGet System.Reactive and add using System.Reactive.Linq; - then you can do this:

IDisposable subscription =
    Observable
        .Merge(
            Observable.FromEventPattern<FileSystemEventHandler, FileSystemEventArgs>(h => watcher.Changed += h, h => watcher.Changed -= h),
            Observable.FromEventPattern<FileSystemEventHandler, FileSystemEventArgs>(h => watcher.Created += h, h => watcher.Created -= h),
            Observable.FromEventPattern<FileSystemEventHandler, FileSystemEventArgs>(h => watcher.Deleted += h, h => watcher.Deleted -= h))
        .GroupBy(x => x.EventArgs.FullPath)
        .Select(gxs => gxs.Throttle(TimeSpan.FromSeconds(0.25)))
        .Merge()
        .Subscribe(x => GetCurrentJob());

Now, what does that do?

• First, it merges all three events (Changed, Created, and Deleted) into a single stream of events.

• Then, it does a GroupBy on the FullName so that each individual change to any file is treated as if that file had its own event.

• Then it throttles the events for each FullName so that any event is ignored if another event for that FullName occurs within 0.25 seconds.

• Then it merges all of the FullName events into a single stream of events.

• Finally, it calls GetCurrentJob on each, one at a time.

This eliminates a lot of your concerns about pausing events, etc.

If you want to stop the events, just call subscription.Dispose().