This question already has answers here:
FileSystemWatcher Changed event is raised twice
(44 answers)
Closed 7 years ago.
I am using the below code to practice FileSystemWatcher.Changed Event from here. It perfectly works fine with .txt extension, but the output is not as I expect to see when I use .pdf. It triggers one "Created" events and multiple "Changed" events.
using System;
using System.IO;
using System.Security.Permissions;
public class Watcher
{
public static void Main()
{
Run();
}
[PermissionSet(SecurityAction.Demand, Name = "FullTrust")]
public static void Run()
{
string[] args = System.Environment.GetCommandLineArgs();
// If a directory is not specified, exit program.
if (args.Length != 2)
{
// Display the proper way to call the program.
Console.WriteLine("Usage: Watcher.exe (directory)");
return;
}
// Create a new FileSystemWatcher and set its properties.
FileSystemWatcher watcher = new FileSystemWatcher();
watcher.Path = args[1];
/* Watch for changes in LastAccess and LastWrite times, and
the renaming of files or directories. */
watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite
| NotifyFilters.FileName | NotifyFilters.DirectoryName;
// Only watch text files.
watcher.Filter = "*.pdf";
// 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;
// Wait for the user to quit the program.
Console.WriteLine("Press \'q\' to quit the sample.");
while (Console.Read() != 'q') ;
}
// Define the event handlers.
private static void OnChanged(object source, FileSystemEventArgs e)
{
// Specify what is done when a file is changed, created, or deleted.
Console.WriteLine("File: " + e.FullPath + " " + e.ChangeType);
}
private static void OnRenamed(object source, RenamedEventArgs e)
{
// Specify what is done when a file is renamed.
Console.WriteLine("File: {0} renamed to {1}", e.OldFullPath, e.FullPath);
}
}
Here is the output when I copy a PDF file to watching folder:
File: c:\test\innovation.pdf Created
File: c:\test\innovation.pdf Changed
File: c:\test\innovation.pdf Changed
File: c:\test\innovation.pdf Changed
File: c:\test\innovation.pdf Changed
Any idea why that happens?
Thanks to Ahmed Ilyas. All I needed to do was to change:
watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite
| NotifyFilters.FileName | NotifyFilters.DirectoryName;
to
watcher.NotifyFilter = NotifyFilters.FileName;
Related
So, I have created a windows service, where I use a FileSystemWatcher to watch different directories. Every time changed files are detected I copy them in a different directory, so I can work with them later.
This works perfectly when I run the program as a Console Application.
When I run it as a service, I can start and stop the service properly, but it won't detect any kind of event. I have tried to debug my service and I found out that the error is coming from the fact that I don't stop the FileSystemWatcher.
For my console App, I have this code for the Watch() method:
public void Watch()
{
using (FileSystemWatcher watcher = new FileSystemWatcher($"C:\\Users\\wost\\AppData\\Roaming\\Sublime", _ext))
{
watcher.NotifyFilter = NotifyFilters.LastAccess
| NotifyFilters.LastWrite
| NotifyFilters.FileName
| NotifyFilters.DirectoryName;
watcher.IncludeSubdirectories = true;
// Add event handlers.
watcher.Changed += OnChanged;
watcher.Created += OnChanged;
watcher.Deleted += OnChanged;
watcher.Renamed += OnRenamed;
// Begin watching.
watcher.EnableRaisingEvents = true;
// Wait for the user to quit the program.
Console.WriteLine("Press 'q' to quit the sample.");
while (Console.Read() != 'q') ;
}
}
So, I stop the program if the user presses 'q'.
For my Windows Service, I have this code for the Watch() method:
public void Watch()
{
using (FileSystemWatcher watcher = new FileSystemWatcher($"C:\\Users\\lashi\\AppData\\Roaming\\Sublime Text 3", _ext))
{
watcher.NotifyFilter = NotifyFilters.LastAccess
| NotifyFilters.LastWrite
| NotifyFilters.FileName
| NotifyFilters.DirectoryName;
watcher.IncludeSubdirectories = true;
// Add event handlers.
watcher.Changed += OnChanged;
watcher.Created += OnChanged;
watcher.Deleted += OnChanged;
watcher.Renamed += OnRenamed;
// Begin watching.
watcher.EnableRaisingEvents = true;
}
}
So, here I don't stop the FileSystemWatcher at all, because as I don't have a direct interaction with the user, I don't know how to stop it. Can you please help me to find a solution to this?
These are the OnStart() and OnStop() methods:
public partial class Service1 : ServiceBase
{
Watcher w;
public Service1()
{
InitializeComponent();
}
protected override void OnStart()
{
w = new Watcher($"C:\\EMMC_CACHE\\expt1-log", $"C:\\EMMC_CACHE\\expt1-file", "lashi");
w.Watch();
}
protected override void OnStop()
{
DirectoryInfo dir = new DirectoryInfo(#"C:\Users\wost\Desktop\FILES");
int count = dir.GetFiles().Length;
// TEST
if (count == 0)
{
StreamWriter writer = new StreamWriter(#"C:\Users\wost\Desktop\Notes.txt");
writer.WriteLine("Service is stopped at: " + DateTime.Now);
writer.Close();
}
}
}
I think you need to make the watcher a field and not to dispose it prematurely. I didn't test this code but you see the relevant changes in 'Watch', i think....
internal class Watcher : IDisposable {
private FileSystemWatcher _watcher;
private string _directoryPath;
private string _ext;
internal Watcher (string directoryPath, string ext) {
_directoryPath = directoryPath;
_ext = ext;
}
~Watcher () {
Dispose();
}
public void Watch()
{
Dispose();
_watcher = new FileSystemWatcher(_directoryPath, _ext);
_watcher.NotifyFilter = NotifyFilters.LastAccess
| NotifyFilters.LastWrite
| NotifyFilters.FileName
| NotifyFilters.DirectoryName;
_watcher.IncludeSubdirectories = true;
// Add event handlers.
_watcher.Changed += OnChanged;
_watcher.Created += OnChanged;
_watcher.Deleted += OnChanged;
_watcher.Renamed += OnRenamed;
// Begin watching.
_watcher.EnableRaisingEvents = true;
}
public void Dispose() {
try {
_watcher?.Dispose();
} catch {
;
}
_watcher = null;
}
//FSW event handlers...
}
I was wondering if there was a way to detect if a process is deleting or encrypting a file. I am trying to make an anti-ransomware application in C# so I was wondering if anyone could help.
Any suggestions?
You want to take a look at the FileSystemWatcher class.
From the MSDN page:
using System;
using System.IO;
using System.Security.Permissions;
public class Watcher
{
public static void Main()
{
Run();
}
[PermissionSet(SecurityAction.Demand, Name="FullTrust")]
public static void Run()
{
string[] args = System.Environment.GetCommandLineArgs();
// If a directory is not specified, exit program.
if(args.Length != 2)
{
// Display the proper way to call the program.
Console.WriteLine("Usage: Watcher.exe (directory)");
return;
}
// Create a new FileSystemWatcher and set its properties.
FileSystemWatcher watcher = new FileSystemWatcher();
watcher.Path = args[1];
/* Watch for changes in LastAccess and LastWrite times, and
the renaming of files or directories. */
watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite
| NotifyFilters.FileName | NotifyFilters.DirectoryName;
// Only watch text files.
watcher.Filter = "*.txt";
// 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;
// Wait for the user to quit the program.
Console.WriteLine("Press \'q\' to quit the sample.");
while(Console.Read()!='q');
}
// Define the event handlers.
private static void OnChanged(object source, FileSystemEventArgs e)
{
// Specify what is done when a file is changed, created, or deleted.
Console.WriteLine("File: " + e.FullPath + " " + e.ChangeType);
}
private static void OnRenamed(object source, RenamedEventArgs e)
{
// Specify what is done when a file is renamed.
Console.WriteLine("File: {0} renamed to {1}", e.OldFullPath, e.FullPath);
}
}
FileSystemWatcher: how to rise events only for new files in directory?
I have a directory, which my service scan. And I use FileSystemWatcher:
constructor:
if(Directory.Exists(_dirPath))
{
_fileSystemWatcher = new FileSystemWatcher(_dirPath);
}
Then, I subscribes on Directory:
public void Subscribe()
{
try
{
//if (_fileSystemWatcher != null)
//{
// _fileSystemWatcher.Created -= FileSystemWatcher_Created;
// _fileSystemWatcher.Dispose();
//}
if (Directory.Exists(_dirPath))
{
_fileSystemWatcher.EnableRaisingEvents = true;
_fileSystemWatcher.Created += FileSystemWatcher_Created;
_fileSystemWatcher.Filter = "*.txt";
}
}
But, the problem is that i want to get events when new files create (or copy).
Instead, i get events from all files in this directory already exists.
How to get event only from new files?
Thank you!
By setting NotifyFilter to NotifyFilters.FileName | NotifyFilters.CreationTime | NotifyFilters.LastWrite you can watch if new files are created.
You also need to check e.ChangeType == WatcherChangeTypes.Created in the raised event after any change occurred.
static void Main(string[] args)
{
FileSystemWatcher watcher = new FileSystemWatcher();
string filePath = #"d:\watchDir";
watcher.Path = filePath;
watcher.EnableRaisingEvents = true;
watcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.CreationTime | NotifyFilters.LastWrite;
watcher.Filter = "*.*";
watcher.IncludeSubdirectories = true;
watcher.Created += new FileSystemEventHandler(OnFileCreated);
new System.Threading.AutoResetEvent(false).WaitOne();
}
private static void OnFileCreated(object sender, FileSystemEventArgs e)
{
if (e.ChangeType == WatcherChangeTypes.Created)
// some code
}
From experience I have noticed that the events that get raised when editing a file can wildly differ depending on the application that edits the the file.
Some applications overwrite, others append.
I found that polling every now and then and keeping a list of files that already existed on the previous poll was more reliable than trying to get the events right.
I am fairly new to C# coding.. I am trying to setup a code that will alert me when there is an inactivity in a folder. We have a current and archive folder. Once the file is processed in the current folder it will move onto the archive folder.
I have the code to check if there are files in the current folder that's the easy part
DirectoryInfo id = new DirectoryInfo(#"C\");
FileInfo[] TXTFiles = id.GetFiles("*.txt");
if (TXTFiles.Length == 0)
{
Console.WriteLine("Files does not ");
Console.WriteLine("Checking the last processed file in the Archive directory");
Console.Read();
}
if (TXTFiles.Length != 0)
{
Console.WriteLine("Files exists ");
Console.Read();
}
So in the logic where the file does not exist I want to have an additional step to get the timestamp of the last text file that was processed. This is to check for how long there hasnt been any activity .
I am not sure how to proceed. Also instead of writing this information to a console can i send a message to a webservice
Thanks
FileSystemWatcher will be your friend :)
https://msdn.microsoft.com/fr-fr/library/system.io.filesystemwatcher(v=vs.110).aspx
using System;
using System.IO;
using System.Security.Permissions;
public class Watcher
{
public static void Main()
{
Run();
}
[PermissionSet(SecurityAction.Demand, Name="FullTrust")]
public static void Run()
{
string[] args = System.Environment.GetCommandLineArgs();
// If a directory is not specified, exit program.
if(args.Length != 2)
{
// Display the proper way to call the program.
Console.WriteLine("Usage: Watcher.exe (directory)");
return;
}
// Create a new FileSystemWatcher and set its properties.
FileSystemWatcher watcher = new FileSystemWatcher();
watcher.Path = args[1];
/* Watch for changes in LastAccess and LastWrite times, and
the renaming of files or directories. */
watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite
| NotifyFilters.FileName | NotifyFilters.DirectoryName;
// Only watch text files.
watcher.Filter = "*.txt";
// 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;
// Wait for the user to quit the program.
Console.WriteLine("Press \'q\' to quit the sample.");
while(Console.Read()!='q');
}
// Define the event handlers.
private static void OnChanged(object source, FileSystemEventArgs e)
{
// Specify what is done when a file is changed, created, or deleted.
Console.WriteLine("File: " + e.FullPath + " " + e.ChangeType);
}
private static void OnRenamed(object source, RenamedEventArgs e)
{
// Specify what is done when a file is renamed.
Console.WriteLine("File: {0} renamed to {1}", e.OldFullPath, e.FullPath);
}
}
Source code from MSDN.
I am using C# 3.5 on Windows 7. We have implemented a program with a FileSystemWatcher. Here, rename event is not raised. But it is working on a few systems.
What could be causing this?
There may be a timing window in your code such that not all filesystem events are properly captured on all your systems. Can you post it?
It is a 'feature' of the underlying Win32 API ReadDirectoryChangesW and hence FileSystemWatcher that under heavy load, events can get missed. There are mitigation suggestions in the MSDN docs.
Make sure that you set your watcher:
fileSystemWatcher.EnableRaisingEvents = true;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Security.AccessControl;
using System.Security.Permissions;
using System.Text;
using System.Windows.Forms;
namespace Watcher
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
FileRenamed();
}
private static string _osLanguage = null;
[PermissionSet(SecurityAction.Demand, Name = "FullTrust")]
private void FileRenamed()
{
MessageBox.Show("Code is Started Now");
// Create a new FileSystemWatcher and set its properties.
FileSystemWatcher watcher = new FileSystemWatcher();
SetDirectoryAccess(#"c:\temp");
watcher.Path = #"C:\Temp";
/* Watch for changes in LastAccess and LastWrite times, and
the renaming of files or directories. */
watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite
| NotifyFilters.FileName | NotifyFilters.DirectoryName;
// Only watch text files.
watcher.Filter = "*.txt";
// Add event handlers.
watcher.Changed += new FileSystemEventHandler(OnChanged);
watcher.Created += new FileSystemEventHandler(OnChanged);
watcher.Deleted += new FileSystemEventHandler(OnChanged);
watcher.Renamed += new RenamedEventHandler(OnRenamed);
watcher.Error += new ErrorEventHandler(OnError);
// Begin watching.
watcher.EnableRaisingEvents = true;
}
// Define the event handlers.
private static void OnChanged(object source, FileSystemEventArgs e)
{
// Specify what is done when a file is changed, created, or deleted.
//Console.WriteLine("File: " + e.FullPath + " " + e.ChangeType);
MessageBox.Show("Something is changed in the File");
}
private static void OnRenamed(object source, RenamedEventArgs e)
{
// Specify what is done when a file is renamed.
MessageBox.Show("File Is Renamed");
//WatcherChangeTypes wct = e.ChangeType;
//Console.WriteLine("File {0} {2} to {1}", e.OldFullPath, e.FullPath, wct.ToString());
}
// This method is called when the FileSystemWatcher detects an error.
private static void OnError(object source, ErrorEventArgs e)
{
MessageBox.Show("Error Trapped");
// Show that an error has been detected.
Console.WriteLine("The FileSystemWatcher has detected an error");
// Give more information if the error is due to an internal buffer overflow.
if (e.GetException().GetType() == typeof(InternalBufferOverflowException))
{
// This can happen if Windows is reporting many file system events quickly
// and internal buffer of the FileSystemWatcher is not large enough to handle this
// rate of events. The InternalBufferOverflowException error informs the application
// that some of the file system events are being lost.
Console.WriteLine(("The file system watcher experienced an internal buffer overflow: " + e.GetException().Message));
}
}
private void button1_Click(object sender, EventArgs e)
{
//File.Move(#"\\NAS\dossier_echange\Carl\temp\Test.txt", #"\\NAS\dossier_echange\Carl\temp\Test007.txt");
File.Move(#"c:\temp\Test.txt", #"c:\temp\Test007.txt");
}
internal static void SetDirectoryAccess(string directoryPathString)
{
string everyoneString;
if (OSLanguage.Equals("en-US"))
everyoneString = "Everyone";
else
everyoneString = "Tout le monde";
//sets the directory access permissions for everyone
DirectorySecurity fileSecurity = Directory.GetAccessControl(directoryPathString);
//creates the access rule for directory
fileSecurity.ResetAccessRule(new FileSystemAccessRule(everyoneString, FileSystemRights.FullControl, AccessControlType.Allow));
//sets the access rules for directory
Directory.SetAccessControl(directoryPathString, fileSecurity);
}
public static string OSLanguage
{
get
{
if (_osLanguage == null)
_osLanguage = CultureInfo.CurrentCulture.Name;
return _osLanguage;
}
set
{
_osLanguage = value;
}
}
}
}