FileSystemWatcher Classe

Definizione

public ref class FileSystemWatcher : System::ComponentModel::Component, System::ComponentModel::ISupportInitialize

public ref class FileSystemWatcher : IDisposable

public class FileSystemWatcher : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize

public class FileSystemWatcher : IDisposable

[System.IO.IODescription("FileSystemWatcherDesc")]
public class FileSystemWatcher : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize

type FileSystemWatcher = class
    inherit Component
    interface ISupportInitialize

type FileSystemWatcher = class
    interface IDisposable

[<System.IO.IODescription("FileSystemWatcherDesc")>]
type FileSystemWatcher = class
    inherit Component
    interface ISupportInitialize

Public Class FileSystemWatcher
Inherits Component
Implements ISupportInitialize

Public Class FileSystemWatcher
Implements IDisposable

Ereditarietà

Object

MarshalByRefObject

Component

FileSystemWatcher

Ereditarietà

Object

FileSystemWatcher

Attributi

IODescriptionAttribute

Implementazioni

ISupportInitialize IDisposable

Esempio

Nell'esempio seguente viene creato un oggetto FileSystemWatcher per controllare la directory specificata in fase di esecuzione. Il componente è impostato per controllare le modifiche apportate e in LastWrite tempo LastAccess , la creazione, l'eliminazione o la ridenominazione dei file di testo nella directory. Se un file viene modificato, creato o eliminato, il percorso del file viene stampato nella console. Quando un file viene rinominato, i percorsi precedenti e nuovi vengono stampati nella console.

using System;
using System.IO;

namespace MyNamespace
{
    class MyClassCS
    {
        static void Main()
        {
            using var watcher = new FileSystemWatcher(@"C:\path\to\folder");

            watcher.NotifyFilter = NotifyFilters.Attributes
                                 | NotifyFilters.CreationTime
                                 | NotifyFilters.DirectoryName
                                 | NotifyFilters.FileName
                                 | NotifyFilters.LastAccess
                                 | NotifyFilters.LastWrite
                                 | NotifyFilters.Security
                                 | NotifyFilters.Size;

            watcher.Changed += OnChanged;
            watcher.Created += OnCreated;
            watcher.Deleted += OnDeleted;
            watcher.Renamed += OnRenamed;
            watcher.Error += OnError;

            watcher.Filter = "*.txt";
            watcher.IncludeSubdirectories = true;
            watcher.EnableRaisingEvents = true;

            Console.WriteLine("Press enter to exit.");
            Console.ReadLine();
        }

        private static void OnChanged(object sender, FileSystemEventArgs e)
        {
            if (e.ChangeType != WatcherChangeTypes.Changed)
            {
                return;
            }
            Console.WriteLine($"Changed: {e.FullPath}");
        }

        private static void OnCreated(object sender, FileSystemEventArgs e)
        {
            string value = $"Created: {e.FullPath}";
            Console.WriteLine(value);
        }

        private static void OnDeleted(object sender, FileSystemEventArgs e) =>
            Console.WriteLine($"Deleted: {e.FullPath}");

        private static void OnRenamed(object sender, RenamedEventArgs e)
        {
            Console.WriteLine($"Renamed:");
            Console.WriteLine($"    Old: {e.OldFullPath}");
            Console.WriteLine($"    New: {e.FullPath}");
        }

        private static void OnError(object sender, ErrorEventArgs e) =>
            PrintException(e.GetException());

        private static void PrintException(Exception? ex)
        {
            if (ex != null)
            {
                Console.WriteLine($"Message: {ex.Message}");
                Console.WriteLine("Stacktrace:");
                Console.WriteLine(ex.StackTrace);
                Console.WriteLine();
                PrintException(ex.InnerException);
            }
        }
    }
}

Imports System.IO

Namespace MyNamespace

    Class MyClassVB

        Shared Sub Main()
            Using watcher = New FileSystemWatcher("C:\path\to\folder")
                watcher.NotifyFilter = NotifyFilters.Attributes Or
                                       NotifyFilters.CreationTime Or
                                       NotifyFilters.DirectoryName Or
                                       NotifyFilters.FileName Or
                                       NotifyFilters.LastAccess Or
                                       NotifyFilters.LastWrite Or
                                       NotifyFilters.Security Or
                                       NotifyFilters.Size

                AddHandler watcher.Changed, AddressOf OnChanged
                AddHandler watcher.Created, AddressOf OnCreated
                AddHandler watcher.Deleted, AddressOf OnDeleted
                AddHandler watcher.Renamed, AddressOf OnRenamed
                AddHandler watcher.Error, AddressOf OnError

                watcher.Filter = "*.txt"
                watcher.IncludeSubdirectories = True
                watcher.EnableRaisingEvents = True

                Console.WriteLine("Press enter to exit.")
                Console.ReadLine()
            End Using
        End Sub

        Private Shared Sub OnChanged(sender As Object, e As FileSystemEventArgs)
            If e.ChangeType <> WatcherChangeTypes.Changed Then
                Return
            End If
            Console.WriteLine($"Changed: {e.FullPath}")
        End Sub

        Private Shared Sub OnCreated(sender As Object, e As FileSystemEventArgs)
            Dim value As String = $"Created: {e.FullPath}"
            Console.WriteLine(value)
        End Sub

        Private Shared Sub OnDeleted(sender As Object, e As FileSystemEventArgs)
            Console.WriteLine($"Deleted: {e.FullPath}")
        End Sub

        Private Shared Sub OnRenamed(sender As Object, e As RenamedEventArgs)
            Console.WriteLine($"Renamed:")
            Console.WriteLine($"    Old: {e.OldFullPath}")
            Console.WriteLine($"    New: {e.FullPath}")
        End Sub

        Private Shared Sub OnError(sender As Object, e As ErrorEventArgs)
            PrintException(e.GetException())
        End Sub

        Private Shared Sub PrintException(ex As Exception)
            If ex IsNot Nothing Then
                Console.WriteLine($"Message: {ex.Message}")
                Console.WriteLine("Stacktrace:")
                Console.WriteLine(ex.StackTrace)
                Console.WriteLine()
                PrintException(ex.InnerException)
            End If
        End Sub

    End Class

End Namespace

Commenti

Usare FileSystemWatcher per controllare le modifiche in una directory specificata. È possibile controllare le modifiche apportate ai file e alle sottodirectory della directory specificata. È possibile creare un componente per controllare i file in un computer locale, in un'unità di rete o in un computer remoto.

Per controllare le modifiche in tutti i file, impostare la Filter proprietà su una stringa vuota ("") o usare caratteri jolly ("*.*"). Per controllare un file specifico, impostare la Filter proprietà sul nome del file. Ad esempio, per controllare le modifiche nel file MyDoc.txt, impostare la Filter proprietà su "MyDoc.txt". È anche possibile controllare le modifiche in un determinato tipo di file. Ad esempio, per controllare le modifiche apportate ai file di testo, impostare la Filter proprietà su "*.txt".

Esistono diversi tipi di modifiche che è possibile controllare in una directory o in un file. Ad esempio, è possibile controllare le modifiche in Attributes, la data e l'ora LastWrite o i Size file o le directory. Questa operazione viene eseguita impostando la NotifyFilter proprietà su uno dei NotifyFilters valori . Per ulteriori informazioni sul tipo di modifiche che è possibile monitorare, 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 Filter proprietà su "*.txt" e chiamare il WaitForChanged metodo con un Renamed specificato per il relativo parametro.

Il sistema operativo Windows notifica al componente le modifiche apportate ai file in un buffer creato da FileSystemWatcher. Se sono presenti molte modifiche in breve tempo, il buffer può andare in overflow. In questo modo il componente perde la traccia delle modifiche nella directory e fornisce solo una notifica coperta. L'aumento delle dimensioni del buffer con la InternalBufferSize proprietà è costoso, perché proviene da memoria non paginata che non può essere scambiata su disco, quindi mantenere il buffer il più piccolo possibile ma abbastanza grande da non perdere alcun evento di modifica del file. Per evitare un overflow del buffer, usare le NotifyFilter proprietà e IncludeSubdirectories in modo da filtrare le notifiche di modifica indesiderate.

Per un elenco dei valori iniziali delle proprietà per un'istanza di FileSystemWatcher, vedere il costruttore FileSystemWatcher.

Quando si usa la FileSystemWatcher classe , tenere presenti i fatti seguenti:

• I file nascosti non vengono ignorati.
• In alcuni sistemi, FileSystemWatcher segnala le modifiche ai file usando il formato breve del nome file 8.3. Ad esempio, una modifica a "LongFileName.LongExtension" potrebbe essere segnalata come "LongFil~. Lon".
• La dimensione massima che è possibile impostare per la proprietà per il InternalBufferSize monitoraggio di una directory in rete è di 64 KB.

Copiare e spostare cartelle

Il sistema operativo e FileSystemWatcher l'oggetto interpretano un'azione taglia e incolla o un'azione di spostamento come azione di ridenominazione per una cartella e il relativo contenuto. Se si taglia e incolla una cartella con i file in una cartella che viene osservata, l'oggetto FileSystemWatcher segnala solo la cartella come nuova, ma non il relativo contenuto perché sono essenzialmente rinominati solo.

Per essere notificati che il contenuto delle cartelle è stato spostato o copiato in una cartella monitorata, specificare OnChanged e OnRenamed i metodi del gestore eventi come suggerito nella tabella seguente.

Eventi e dimensioni del buffer

Si noti che diversi fattori possono influire sugli eventi di modifica del file system generati, come descritto di seguito:

• Le operazioni comuni del file system possono generare più eventi. Ad esempio, quando un file viene spostato da una directory a un'altra, potrebbero essere generati diversi OnChanged e alcuni OnCreated e OnDeleted eventi. Lo spostamento di un file è un'operazione complessa costituita da più operazioni semplici, generando quindi più eventi. Analogamente, alcune applicazioni (ad esempio, il software antivirus) potrebbero causare eventi aggiuntivi del file system rilevati da FileSystemWatcher.
• Può FileSystemWatcher controllare i dischi purché non vengano spostati o rimossi. Non FileSystemWatcher genera eventi per CD e DVD, perché i timestamp e le proprietà non possono essere modificati. Per il corretto funzionamento del componente, è necessario che nei computer remoti sia installata una delle piattaforme necessarie.

Si noti che una FileSystemWatcher potrebbe perdere un evento quando la dimensione del buffer viene superata. Per evitare eventi mancanti, seguire queste linee guida:

• Aumentare le dimensioni del buffer impostando la InternalBufferSize proprietà .
• Evitare di guardare i file con nomi di file lunghi, perché un nome di file lungo contribuisce a riempire il buffer. Prendere in considerazione la ridenominazione di questi file usando nomi più brevi.
• Mantenere il codice di gestione degli eventi il più breve possibile.

Vedi anche

• NotifyFilter
• NotifyFilters
• FileSystemEventArgs
• FileSystemEventHandler
• Filter
• IncludeSubdirectories
• InternalBufferOverflowException
• RenamedEventArgs
• RenamedEventHandler
• WaitForChangedResult
• WatcherChangeTypes
• Using a FileSystemWatcher Component in a Windows Form