Questa documentazione è stata archiviata e non viene gestita.

Classe FileSystemWatcher

Aggiornamento: novembre 2007

Attende le notifiche di modifica del file system e genera eventi quando una directory o un file in una directory viene modificato.

Spazio dei nomi:  System.IO
Assembly:  System (in System.dll)

[IODescriptionAttribute("FileSystemWatcherDesc")]
[PermissionSetAttribute(SecurityAction.LinkDemand, Name = "FullTrust")]
[PermissionSetAttribute(SecurityAction.InheritanceDemand, Name = "FullTrust")]
public class FileSystemWatcher : Component, 
	ISupportInitialize
/** @attribute IODescriptionAttribute("FileSystemWatcherDesc") */
/** @attribute PermissionSetAttribute(SecurityAction.LinkDemand, Name = "FullTrust") */
/** @attribute PermissionSetAttribute(SecurityAction.InheritanceDemand, Name = "FullTrust") */
public class FileSystemWatcher extends Component implements ISupportInitialize
public class FileSystemWatcher extends Component implements ISupportInitialize

Per controllare le modifiche in una directory specifica, utilizzare FileSystemWatcher. È possibile controllare le modifiche nei file e nelle sottodirectory della directory specificata. È possibile creare un componente per controllare i file presenti su un computer locale, su un'unità di rete o su un computer remoto.

Per controllare le modifiche in tutti i file, impostare la proprietà Filter su una stringa vuota ("") o utilizzare i caratteri jolly ("*.*"). Per controllare un file specifico, impostare la proprietà Filter sul nome file. Per controllare ad esempio le modifiche nel file MyDoc.txt, impostare la proprietà Filter su "MyDoc.txt". È inoltre possibile controllare le modifiche in un determinato tipo di file. Per controllare ad esempio le modifiche nei file di testo, impostare la proprietà Filter su "*.txt".

È possibile controllare diversi tipi di modifiche all'interno di una directory o di un file. È ad esempio possibile controllare le modifiche apportate alla proprietà Attributes, alla data e all'ora di LastWrite o alla proprietà Size dei file o delle directory. Questa operazione viene eseguita impostando la proprietà NotifyFilter su uno dei valori di NotifyFilters. Per ulteriori informazioni sul tipo di modifiche che è possibile controllare, vedere NotifyFilters.

È possibile controllare la ridenominazione, l'eliminazione o la creazione di file o directory. Ad esempio, per controllare la ridenominazione dei file di testo, impostare la proprietà Filter su "*.txt" e chiamare il metodo WaitForChanged con un Renamed specificato per il relativo parametro.

Il componente riceve dal sistema operativo Windows una notifica relativa alle modifiche ai file memorizzate in un buffer che la classe FileSystemWatcher ha creato. Se vengono effettuate numerose modifiche in un breve lasso di tempo, potrà verificarsi un overflow del buffer. In tal modo, il componente non terrà traccia delle modifiche nella directory e fornirà unicamente una notifica generica. L'aumento delle dimensioni del buffer con la proprietà InternalBufferSize è dispendioso in quanto proviene da una memoria non di paging di cui non è possibile eseguire lo swapping su disco; quindi, è opportuno limitare le dimensioni del buffer in modo da non perdere gli eventi relativi alle modifiche apportate al file. Per evitare l'overflow del buffer, utilizzare le proprietà NotifyFilter e IncludeSubdirectories per applicare un filtro alle notifiche di modifiche non desiderate.

Per un elenco dei valori iniziali della proprietà per un'istanza dell'oggetto FileSystemWatcher, vedere il costruttore del metodo FileSystemWatcher.

Quando si utilizza la classe FileSystemWatcher, notare le considerazioni riportate di seguito.

  • I file nascosti non vengono ignorati.

  • In alcuni sistemi, FileSystemWatcher segnala le modifiche apportate ai file utilizzando il formato del nome di file 8.3 breve. Ad esempio, è possibile segnalare una modifica a "LongFileName.LongExtension" come "LongFi~.Lon".

  • In questa classe è presente una richiesta di collegamento e una richiesta di ereditarietà al livello di classe che si applica a tutti i membri. Se il chiamante immediato o la classe derivata non dispone di autorizzazione di attendibilità totale, viene generata un'eccezione SecurityException. Per informazioni dettagliate sulle richieste di sicurezza, vedere Richieste di collegamento.

Copia e spostamento di cartelle

Il sistema operativo e l'oggetto FileSystemWatcher interpretano un'operazione di taglia e incolla o un'operazione di spostamento come una ridenominazione di una cartella e relativo contenuto. Se si taglia e si incolla una cartella con file in una cartella controllata, l'oggetto FileSystemWatcher segnala solo la cartella come nuova, ma non il contenuto, in quanto quest'ultimo risulta solo rinominato.

Per ricevere la notifica che il contenuto delle cartelle è stato spostato o copiato in una cartella controllata, fornire i metodi OnChanged e OnRenamed del gestore eventi come indicato nella tabella riportata di seguito.

Gestore eventi

Eventi gestiti

Azione eseguita

OnChanged

Changed, Created, Deleted

Report delle modifiche negli attributi di file, nei file creati e nei file eliminati.

OnRenamed

Renamed

Elenco dei percorsi vecchi e nuovi dei file e delle cartelle rinominati, mediante l'espansione ricorsiva se necessario.

Eventi e dimensioni del buffer

Di seguito sono riportati alcuni dei fattori che possono influire sugli eventi di modifiche del file system generati:

  • È possibile che l'esecuzione di operazioni comuni sui file system comporti la generazione di più eventi. Quando ad esempio un file viene spostato da una directory a un'altra, è possibile che vengano generati diversi eventi OnChanged e alcuni eventi OnCreated e OnDeleted. Lo spostamento di un file è un'operazione complessa costituita da più operazioni semplici che generano più eventi. Analogamente, è possibile che in alcune applicazioni, ad esempio programmi antivirus, vengano generati ulteriori eventi relativi al file system che vengono rilevati da FileSystemWatcher.

  • FileSystemWatcher è in grado di controllare i dischi purché non siano stati commutati o rimossi. FileSystemWatcher non genera eventi per CD e DVD, in quanto non è possibile modificare le proprietà e gli indicatori di data e ora. Per consentire il corretto funzionamento del componente, è necessario che nei computer remoti sia installata la piattaforma richiesta.

  • Se più oggetti FileSystemWatcher sono impegnati nel controllo dello stesso percorso UNC in Windows XP precedente a Service Pack 1 oppure Windows 2000 SP2 o versioni precedenti, soltanto uno degli oggetti genererà un evento. Nei computer con sistema operativo Windows XP SP1 e versioni più recenti, Windows 2000 SP3 o versioni più recenti o Windows Server 2003, tutti gli oggetti FileSystemWatcher genereranno gli eventi appropriati.

  • L'impostazione della proprietà Filter non comporta una riduzione del contenuto del buffer.

Un oggetto FileSystemWatcher non genera un evento Error quando un evento viene perso oppure quando si superano le dimensioni del buffer, a causa delle dipendenze relative al sistema operativo di Windows. Per evitare la perdita di eventi, seguire le indicazioni riportate di seguito:

  • Se si aumentano le dimensioni del buffer con la proprietà InternalBufferSize è possibile evitare la perdita degli eventi relativi alle modifiche apportate al file system.

  • Evitare il controllo di file con nomi lunghi. Eseguire la ridenominazione utilizzando nomi più brevi.

  • Mantenere il codice di gestione dell'evento più breve possibile.

Nell'esempio riportato di seguito viene creato un oggetto FileSystemWatcher per controllare la directory specificata in fase di esecuzione. Il componente è impostato per il controllo delle modifiche apportate alla data e all'ora di LastWrite e di LastAccess, alla creazione, all'eliminazione o all'assegnazione di un nuovo nome ai file di testo nella directory. Se un file viene modificato, creato o eliminato, il percorso del file verrà visualizzato nella console. Quando un file viene rinominato, nella console vengono visualizzati il vecchio e il nuovo percorso.

Per questo esempio, utilizzare gli spazi dei nomi System.Diagnostics e System.IO.

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);
    }
}



public class Watcher
{
    public static void main(String[] args1)
    {
	Run();
    } 

    /** @attribute 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.set_Path(args[1]);

        /* Watch for changes in LastAccess and LastWrite times, and 
           the renaming of files or directories.
         */
        watcher.set_NotifyFilter
            (NotifyFilters.LastAccess |NotifyFilters.LastWrite |
            NotifyFilters.FileName | NotifyFilters.DirectoryName);

        // Only watch text files.
        watcher.set_Filter("*.txt");

        // Add event handlers.
        watcher.add_Changed(new FileSystemEventHandler(OnChanged));
        watcher.add_Created(new FileSystemEventHandler(OnChanged));
        watcher.add_Deleted(new FileSystemEventHandler(OnChanged));
        watcher.add_Renamed(new RenamedEventHandler(OnRenamed));

        // Begin watching.
        watcher.set_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.get_FullPath() + " " 
            + e.get_ChangeType()));
    } //OnChanged

    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.get_OldFullPath(),e.get_FullPath());
    } //OnRenamed
} //Watcher


Qualsiasi membro static (Shared in Visual Basic) pubblico di questo tipo è thread-safe. I membri di istanza non sono garantiti come thread-safe.

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition , Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98

.NET Framework e .NET Compact Framework non supportano tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

.NET Framework

Supportato in: 3.5, 3.0, 2.0, 1.1, 1.0
Mostra: