Come utilizzare FileSystemWatcher in C# per segnalare le modifiche ai file su disco

Una caratteristica utile fornita in .NET è l'oggetto FileSystemWatcher. Se hai bisogno di sapere quando vengono apportate modifiche a una directory (ad es. file aggiunti, modificati o eliminati), questo oggetto ti consente di acquisire un evento che descrive le differenze subito dopo la modifica.

Perché è utile?

Ci sono una serie di scenari, un paio sono:

• Potresti voler controllare le modifiche apportate a una directory;
• Dopo che i file sono stati copiati in una directory, potresti voler elaborarli automaticamente in base a una proprietà di quel file (ad es. un utente potrebbe scansionare file e salvare tali scansioni in una directory condivisa sulla tua rete, e questo processo potrebbe essere elaborazione dei file quando vengono rilasciati in una directory dallo scanner;

Ho visto casi in cui gli sviluppatori consentono a un utente di caricare un file tramite un sito Web e hanno un sacco di codice di elaborazione dei file all'interno della loro applicazione Web. Un modo per rendere l'applicazione più pulita sarebbe stato quello di separare il problema dell'elaborazione dei file dal sito Web.

Come lo usi?

È abbastanza semplice usare questa classe. Ho scritto un programma di esempio e l'ho incollato di seguito:

using System.IO;
using static System.Console;
using static System.ConsoleColor;
 
namespace FileSystemWatcherSample
{
    class Program
    {
        static void Main(string[] args)
        {
            // instantiate the object
            var fileSystemWatcher = new FileSystemWatcher();
 
            // Associate event handlers with the events
            fileSystemWatcher.Created += FileSystemWatcher_Created;
            fileSystemWatcher.Changed += FileSystemWatcher_Changed;
            fileSystemWatcher.Deleted += FileSystemWatcher_Deleted;
            fileSystemWatcher.Renamed += FileSystemWatcher_Renamed;
 
            // tell the watcher where to look
            fileSystemWatcher.Path = @"C:\Users\Jeremy\Pictures\Screenshots\";
 
            // You must add this line - this allows events to fire.
            fileSystemWatcher.EnableRaisingEvents = true;
 
            WriteLine("Listening...");
            WriteLine("(Press any key to exit.)");
            
            ReadLine();
        }
 
        private static void FileSystemWatcher_Renamed(object sender, RenamedEventArgs e)
        {
            ForegroundColor = Yellow;
            WriteLine($"A new file has been renamed from {e.OldName} to {e.Name}");
        }
 
        private static void FileSystemWatcher_Deleted(object sender, FileSystemEventArgs e)
        {
            ForegroundColor = Red;
            WriteLine($"A new file has been deleted - {e.Name}");
        }
 
        private static void FileSystemWatcher_Changed(object sender, FileSystemEventArgs e)
        {
            ForegroundColor = Green;
            WriteLine($"A new file has been changed - {e.Name}");
        }
 
        private static void FileSystemWatcher_Created(object sender, FileSystemEventArgs e)
        {
            ForegroundColor = Blue;
            WriteLine($"A new file has been created - {e.Name}");
        }
    }
}

Ci sono problemi?

Beh, forse non li chiamerei problemi, ma ci sono sicuramente alcune cose che mi hanno sorpreso quando stavo usando questa utility.

Ad esempio, quando ho fatto uno screenshot e l'ho salvato nella mia cartella Screenshot, mi aspettavo che venisse chiamato un solo evento:l'evento Creato. Ma l'immagine qui sotto mostra tutti gli eventi che sono stati effettivamente chiamati.

Diamo un'occhiata a cosa succede:

• Prima viene creato un file;
• Poi è in qualche modo cambiato tre volte;
• Poi viene rinominato;
• Poi viene creato e modificato un altro file;
• E infine, il file originale viene eliminato.

Questo mi dice qualcosa di interessante su come funziona il mio programma di cattura degli screenshot, ma mi dice anche di aspettarmi che l'evento Created venga attivato due volte quando faccio un singolo screenshot, quindi dovrei programmare per prepararmi.

Ashutosh Nilkanth ha scritto sul blog con altri suggerimenti e note sull'utilizzo di questa classe.

Riepilogo

La classe FileSystemWatcher è un utile strumento .NET per osservare le modifiche a una struttura di directory. Poiché questo controlla le modifiche a livello di sistema operativo, gli eventi potrebbero essere chiamati in modi imprevisti. Pertanto ha senso comprendere correttamente gli eventi del sistema operativo chiamati quando vengono apportate modifiche alla directory che stai monitorando e progettare la tua soluzione per gestire gli eventi reali (piuttosto che quelli che potresti logicamente aspettarti).