FileSystemWatcher: Events werden mehrfach ausgelöst – Lösungsansätze

class Program
{
	private static FileSystemWatcher fsw;
	private static string path = @"C:\Test";

	static void Main(string[] args)
	{
		fsw = new FileSystemWatcher(path);
		fsw.Changed += fsw_Changed;
		fsw.EnableRaisingEvents = true;

		Console.ReadKey();
	}

	static void fsw_Changed(object sender, FileSystemEventArgs e)
	{
		var file = e.Name;
		var changeType = e.ChangeType;
		Console.WriteLine("File '" + file + "' was changed (ChangeType: " + changeType + ")");
	}
}

File 'test.txt' was changed (ChangeType: Changed) 
File 'test.txt' was changed (ChangeType: Changed)

static void fsw_Changed(object sender, FileSystemEventArgs e)
{
	try
	{
		fsw.EnableRaisingEvents = false;
		var file = e.Name;
		var changeType = e.ChangeType;
		Console.WriteLine("File '" + file + "' was changed (ChangeType: " + changeType + ")");
	}
	finally
	{
		fsw.EnableRaisingEvents = true;
	}
}

File 'test.txt' was changed (ChangeType: Changed)

static void fsw_Changed(object sender, FileSystemEventArgs e)
{
	try
	{
		fsw.EnableRaisingEvents = false;
		var file = e.Name;
		var changeType = e.ChangeType;
		Console.WriteLine("File '" + file + "' was changed (ChangeType: " + changeType + ")");
		Thread.Sleep(TimeSpan.FromSeconds(5));
	}
	finally
	{
		fsw.EnableRaisingEvents = true;
	}
}

private static FileSystemWatcher fsw;
private static string path = @"C:\Test";
private static double bufferDelay = 500;
private static IList<string> changedList;

static void Main(string[] args)
{
	changedList = new List<string>();
	fsw = new FileSystemWatcher(path);
	fsw.Changed += fsw_Changed;
	fsw.EnableRaisingEvents = true;

	Console.ReadKey();
}

static void fsw_Changed(object sender, FileSystemEventArgs e)
{
	string fullPath = e.FullPath;

	lock (changedList)
	{
		if (changedList.Contains(fullPath))
			return;
		else
			changedList.Add(fullPath);
	}

	var timer = new Timer(bufferDelay) { AutoReset = false };

	timer.Elapsed += (object elapsedSender, ElapsedEventArgs elapsedArgs) =>
	{
		// Add your logic here.
		var file = e.Name;
		var changeType = e.ChangeType;
		Console.WriteLine("File '" + file + "' was changed (ChangeType: " + changeType + ")");

		lock (changedList)
		{
			changedList.Remove(fullPath);
		}
	};

	timer.Start();
}

/// <summary>
/// Listens to the file system change notifications and raises events when a directory, or file in a directory, changes.
/// The events are not raised immediately, but are buffered so that events which are raised twice by the included FileSystemWatcher are only raised once.
/// </summary>
public class BufferedFileSystemWatcher : FileSystemWatcher
{
	private IList<string> changedList;
	private IList<string> createdList;
	private IList<string> deletedList;
	private IList<string> renamedList;

	private const string StandardFilter = "*.*"; // Standard filter is all files.
	private const double StandardBufferDelay = 500; // Standard buffer delay of 500ms.

	/// <summary>
	/// Occurs when a file or directory in the specified Path is changed.
	/// </summary>
	public new event FileSystemEventHandler Changed;

	/// <summary>
	/// Occurs when a file or directory in the specified Path is created.
	/// </summary>
	public new event FileSystemEventHandler Created;

	/// <summary>
	/// Occurs when a file or directory in the specified Path is deleted.
	/// </summary>
	public new event FileSystemEventHandler Deleted;

	/// <summary>
	/// Occurs when a file or directory in the specified Path is renamed.
	/// </summary>
	public new event FileSystemEventHandler Renamed;

	/// <summary>
	/// Initializes a new instance of the BufferedFileSystemWatcher class.
	/// </summary>
	public BufferedFileSystemWatcher()
		: this(string.Empty, StandardFilter, StandardBufferDelay, BufferedChangeTypes.All)
	{
	}

	/// <summary>
	/// Initializes a new instance of the BufferedFileSystemWatcher class.
	/// </summary>
	/// <param name="bufferedChangeTypes">The BufferedChangeTypes specifying which events should be buffered.</param>
	public BufferedFileSystemWatcher(BufferedChangeTypes bufferedChangeTypes)
		: this(string.Empty, StandardFilter, StandardBufferDelay, bufferedChangeTypes)
	{
	}

	/// <summary>
	/// Initializes a new instance of the BufferedFileSystemWatcher class, given the specifed buffer delay time.
	/// </summary>
	/// <param name="bufferDelay">The time in milliseconds the raised events should be buffered.</param>
	public BufferedFileSystemWatcher(long bufferDelay)
		: this(string.Empty, StandardFilter, bufferDelay, BufferedChangeTypes.All)
	{
	}

	/// <summary>
	/// Initializes a new instance of the BufferedFileSystemWatcher class, given the specifed buffer delay time.
	/// </summary>
	/// <param name="bufferDelay">The time in milliseconds the raised events should be buffered.</param>
	/// <param name="bufferedChangeTypes">The BufferedChangeTypes specifying which events should be buffered.</param>
	public BufferedFileSystemWatcher(long bufferDelay, BufferedChangeTypes bufferedChangeTypes)
		: this(string.Empty, StandardFilter, bufferDelay, bufferedChangeTypes)
	{
	}

	/// <summary>
	/// Initializes a new instance of the BufferedFileSystemWatcher class, given the specified directory to monitor.
	/// </summary>
	/// <param name="path">The directory to monitor, in standard or Universal Naming Convention (UNC) notation.</param>
	public BufferedFileSystemWatcher(string path)
		: this(path, StandardFilter, StandardBufferDelay, BufferedChangeTypes.All)
	{
	}

	/// <summary>
	/// Initializes a new instance of the BufferedFileSystemWatcher class, given the specified directory to monitor.
	/// </summary>
	/// <param name="path">The directory to monitor, in standard or Universal Naming Convention (UNC) notation.</param>
	/// <param name="bufferedChangeTypes">The BufferedChangeTypes specifying which events should be buffered.</param>
	public BufferedFileSystemWatcher(string path, BufferedChangeTypes bufferedChangeTypes)
		: this(path, StandardFilter, StandardBufferDelay, bufferedChangeTypes)
	{
	}

	/// <summary>
	/// Initializes a new instance of the BufferedFileSystemWatcher class, given the specified directory to monitor and buffer delay time.
	/// </summary>
	/// <param name="path">The directory to monitor, in standard or Universal Naming Convention (UNC) notation.</param>
	/// <param name="bufferDelay">The time in milliseconds the raised events should be buffered.</param>
	public BufferedFileSystemWatcher(string path, long bufferDelay)
		: this(path, StandardFilter, bufferDelay, BufferedChangeTypes.All)
	{
	}

	/// <summary>
	/// Initializes a new instance of the BufferedFileSystemWatcher class, given the specified directory and type of files to monitor.
	/// </summary>
	/// <param name="path">The directory to monitor, in standard or Universal Naming Convention (UNC) notation.</param>
	/// <param name="filter">The type of files to watch. For example, "*.txt" watches for changes to all text files.</param>
	public BufferedFileSystemWatcher(string path, string filter)
		: this(path, filter, StandardBufferDelay, BufferedChangeTypes.All)
	{
	}

	/// <summary>
	/// Initializes a new instance of the BufferedFileSystemWatcher class, given the specified directory and type of files to monitor.
	/// </summary>
	/// <param name="path">The directory to monitor, in standard or Universal Naming Convention (UNC) notation.</param>
	/// <param name="filter">The type of files to watch. For example, "*.txt" watches for changes to all text files.</param>
	/// <param name="bufferedChangeTypes">The BufferedChangeTypes specifying which events should be buffered.</param>
	public BufferedFileSystemWatcher(string path, string filter, BufferedChangeTypes bufferedChangeTypes)
		: this(path, filter, StandardBufferDelay, bufferedChangeTypes)
	{
	}

	/// <summary>
	/// Initializes a new instance of the BufferedFileSystemWatcher class, given the specified directory, type of files to monitor, buffer delay time and the types of events which should be handled delayed.
	/// </summary>
	/// <param name="path">The directory to monitor, in standard or Universal Naming Convention (UNC) notation.</param>
	/// <param name="filter">The type of files to watch. For example, "*.txt" watches for changes to all text files.</param>
	/// <param name="bufferDelay">The time in milliseconds the raised events should be buffered.</param>
	/// <param name="bufferedChangeTypes">The BufferedChangeTypes specifying which events should be buffered.</param>
	public BufferedFileSystemWatcher(string path, string filter, double bufferDelay, BufferedChangeTypes bufferedChangeTypes)
		: base(path, filter)
	{
		this.changedList = new List<string>();
		this.createdList = new List<string>();
		this.deletedList = new List<string>();
		this.renamedList = new List<string>();

		this.Path = path;
		this.Filter = filter;
		this.BufferDelay = bufferDelay;
		this.BufferedChangeTypes = BufferedChangeTypes.All;

		base.Changed += BufferedFileSystemWatcher_Changed;
		base.Created += BufferedFileSystemWatcher_Created;
		base.Deleted += BufferedFileSystemWatcher_Deleted;
		base.Renamed += BufferedFileSystemWatcher_Renamed;
	}

	/// <summary>
	/// Gets or sets the buffer delay time in milliseconds, i.e. the time in which the events raised should be buffered.
	/// </summary>
	public double BufferDelay
	{
		get;
		set;
	}

	/// <summary>
	/// Gets or sets the BufferedChangeTypes, i.e. the types of events which should be buffered by the BufferedFileSystemWatcher.
	/// If this property is set to DelayedChangeTypes.None, the BufferedFileSystemWatcher will behave like a normal FileSystemWatcher.
	/// </summary>
	public BufferedChangeTypes BufferedChangeTypes
	{
		get;
		set;
	}

	/// <summary>
	/// Invoked whenever a file or directory in the specified Path is changed (buffered).
	/// </summary>
	/// <param name="e">The FileSystemEventArgs that contains the event data.</param>
	protected virtual void OnBufferedChanged(FileSystemEventArgs e)
	{
		string fullPath = e.FullPath;

		lock (this.changedList)
		{
			if (this.changedList.Contains(fullPath))
				return;
			else
				this.changedList.Add(fullPath);
		}

		var timer = new Timer(this.BufferDelay) { AutoReset = false };

		timer.Elapsed += (object elapsedSender, ElapsedEventArgs elapsedArgs) =>
		{
			FileSystemEventHandler tmp = this.Changed;

			if (tmp != null)
				tmp(this, e);

			lock (this.changedList)
			{
				this.changedList.Remove(fullPath);
			}
		};

		timer.Start();
	}

	/// <summary>
	///  Invoked whenever a file or directory in the specified Path is changed (not buffered).
	/// </summary>
	/// <param name="e">The FileSystemEventArgs that contains the event data.</param>
	protected virtual new void OnChanged(FileSystemEventArgs e)
	{
		FileSystemEventHandler tmp = this.Changed;

		if (tmp != null)
			tmp(this, e);
	}

	/// <summary>
	/// Inviked whenever a file or directory in the specified Path is created (buffered).
	/// </summary>
	/// <param name="e">The FileSystemEventArgs that contains the event data.</param>
	protected virtual void OnBufferedCreated(FileSystemEventArgs e)
	{
		string fullPath = e.FullPath;

		lock (this.createdList)
		{
			if (this.createdList.Contains(fullPath))
				return;
			else
				this.createdList.Add(fullPath);
		}

		var timer = new Timer(this.BufferDelay) { AutoReset = false };

		timer.Elapsed += (object elapsedSender, ElapsedEventArgs elapsedArgs) =>
		{
			FileSystemEventHandler tmp = this.Created;

			if (tmp != null)
				tmp(this, e);

			lock (this.createdList)
			{
				this.createdList.Remove(fullPath);
			}
		};

		timer.Start();
	}

	 /// <summary>
	/// Inviked whenever a file or directory in the specified Path is created (not buffered).
	/// </summary>
	/// <param name="e">The FileSystemEventArgs that contains the event data.</param>
	protected virtual new void OnCreated(FileSystemEventArgs e)
	{
		FileSystemEventHandler tmp = this.Created;

		if (tmp != null)
			tmp(this, e);
	}

	/// <summary>
	/// Invoked whenever a file or directory in the specified Path is deleted (buffered).
	/// </summary>
	/// <param name="e">The FileSystemEventArgs that contains the event data.</param>
	protected virtual void OnBufferedDeleted(FileSystemEventArgs e)
	{
		string fullPath = e.FullPath;

		lock (this.deletedList)
		{
			if (this.deletedList.Contains(fullPath))
				return;
			else
				this.deletedList.Add(fullPath);
		}

		var timer = new Timer(this.BufferDelay) { AutoReset = false };

		timer.Elapsed += (object elapsedSender, ElapsedEventArgs elapsedArgs) =>
		{
			FileSystemEventHandler tmp = this.Deleted;

			if (tmp != null)
				tmp(this, e);

			lock (this.deletedList)
			{
				this.deletedList.Remove(fullPath);
			}
		};

		timer.Start();
	}

	/// <summary>
	/// Invoked whenever a file or directory in the specified Path is deleted (not buffered).
	/// </summary>
	/// <param name="e">The FileSystemEventArgs that contains the event data.</param>
	protected virtual new void OnDeleted(FileSystemEventArgs e)
	{
		FileSystemEventHandler tmp = this.Deleted;

		if (tmp != null)
			tmp(this, e);
	}

	/// <summary>
	/// Invkoed whenever a file or directory in the specified Path is renamed (buffered).
	/// </summary>
	/// <param name="e">The FileSystemEventArgs that contains the event data.</param>
	protected virtual void OnBufferedRenamed(RenamedEventArgs e)
	{
		string fullPath = e.FullPath;

		lock (this.renamedList)
		{
			if (this.renamedList.Contains(fullPath))
				return;
			else
				this.renamedList.Add(fullPath);
		}

		var timer = new Timer(this.BufferDelay) { AutoReset = false };

		timer.Elapsed += (object elapsedSender, ElapsedEventArgs elapsedArgs) =>
		{
			FileSystemEventHandler tmp = this.Renamed;

			if (tmp != null)
				tmp(this, e);

			lock (this.renamedList)
			{
				this.renamedList.Remove(fullPath);
			}
		};

		timer.Start();
	}

	/// <summary>
	/// Invkoed whenever a file or directory in the specified Path is renamed (not buffered).
	/// </summary>
	/// <param name="e">The FileSystemEventArgs that contains the event data.</param>
	protected virtual new void OnRenamed(RenamedEventArgs e)
	{
		FileSystemEventHandler tmp = this.Renamed;

		if (tmp != null)
			tmp(this, e);
	}

	private void BufferedFileSystemWatcher_Changed(object sender, FileSystemEventArgs e)
	{
		if ((this.BufferedChangeTypes & BufferedChangeTypes.Changed) == BufferedChangeTypes.Changed)
			OnBufferedChanged(e);
		else
			OnChanged(e);
	}

	private void BufferedFileSystemWatcher_Created(object sender, FileSystemEventArgs e)
	{
		if ((this.BufferedChangeTypes & BufferedChangeTypes.Created) == BufferedChangeTypes.Created)
			OnBufferedCreated(e);
		else
			OnCreated(e);
	}

	private void BufferedFileSystemWatcher_Deleted(object sender, FileSystemEventArgs e)
	{
		if ((this.BufferedChangeTypes & BufferedChangeTypes.Deleted) == BufferedChangeTypes.Deleted)
			OnBufferedDeleted(e);
		else
			OnDeleted(e);
	}

	private void BufferedFileSystemWatcher_Renamed(object sender, RenamedEventArgs e)
	{
		if ((this.BufferedChangeTypes & BufferedChangeTypes.Renamed) == BufferedChangeTypes.Renamed)
			OnBufferedRenamed(e);
		else
			OnRenamed(e);
	}
}

/// <summary>
/// Enum defining the change types which should be buffered by the BufferedFileSystemWatcher.
/// </summary>
[Flags]
public enum BufferedChangeTypes
{
	/// <summary>
	/// No events should be buffered.
	/// The BufferedFileSystemWatcher will behave like a normal FileSystemWatcher.
	/// </summary>
	None = 0,
	/// <summary>
	/// The changed events should be buffered.
	/// </summary>
	Changed = 1,
	/// <summary>
	/// The created events should be buffered.
	/// </summary>
	Created = 2,
	/// <summary>
	/// The deleted events should be buffered.
	/// </summary>
	Deleted = 4,
	/// <summary>
	/// The renamed events should be buffered.
	/// </summary>
	Renamed = 8,
	/// <summary>
	/// All event types should be buffered.
	/// These are the changed, created, deleted and renamed events.
	/// </summary>
	All = 15
}

private static BufferedFileSystemWatcher bfsw;
private static string path = @"C:\Test";

static void Main(string[] args)
{
	bfsw = new BufferedFileSystemWatcher(path);
	bfsw.BufferedChangeTypes = BufferedChangeTypes.Changed;
	bfsw.Changed += bfsw_Changed;
	bfsw.EnableRaisingEvents = true;

	Console.ReadKey();
}

static void bfsw_Changed(object sender, FileSystemEventArgs e)
{
	var file = e.Name;
	var changeType = e.ChangeType;
	Console.WriteLine("File '" + file + "' was changed (ChangeType: " + changeType + ")");
}