FileSystemWatcher Classe

Definizione

Spazio dei nomi:

System.IO

Assembly:

System.IO.FileSystem.Watcher.dll

Origine:

FileSystemWatcher.cs

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

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

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

type FileSystemWatcher = class
    inherit Component
    interface ISupportInitialize

Public Class FileSystemWatcher
Inherits Component
Implements ISupportInitialize

Ereditarietà

Object

MarshalByRefObject

Component

FileSystemWatcher

Implementazioni

ISupportInitialize

Esempio

Nell'esempio seguente viene creato un oggetto FileSystemWatcher per watch la directory specificata in fase di esecuzione. Il componente è impostato su watch per le modifiche apportate e in LastWrite tempoLastAccess, 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.

#include "pch.h"

using namespace System;
using namespace System::IO;

class MyClassCPP
{
public:

    int static Run()
    {
        FileSystemWatcher^ watcher = gcnew FileSystemWatcher("C:\\path\\to\\folder");

        watcher->NotifyFilter = static_cast<NotifyFilters>(NotifyFilters::Attributes
                                                         | NotifyFilters::CreationTime
                                                         | NotifyFilters::DirectoryName
                                                         | NotifyFilters::FileName
                                                         | NotifyFilters::LastAccess
                                                         | NotifyFilters::LastWrite
                                                         | NotifyFilters::Security
                                                         | NotifyFilters::Size);

        watcher->Changed += gcnew FileSystemEventHandler(MyClassCPP::OnChanged);
        watcher->Created += gcnew FileSystemEventHandler(MyClassCPP::OnCreated);
        watcher->Deleted += gcnew FileSystemEventHandler(MyClassCPP::OnDeleted);
        watcher->Renamed += gcnew RenamedEventHandler(MyClassCPP::OnRenamed);
        watcher->Error   += gcnew ErrorEventHandler(MyClassCPP::OnError);

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

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

        return 0;
    }

private:

    static void OnChanged(Object^ sender, FileSystemEventArgs^ e)
    {
        if (e->ChangeType != WatcherChangeTypes::Changed)
        {
            return;
        }
        Console::WriteLine("Changed: {0}", e->FullPath);
    }

    static void OnCreated(Object^ sender, FileSystemEventArgs^ e)
    {
        Console::WriteLine("Created: {0}", e->FullPath);
    }

    static void OnDeleted(Object^ sender, FileSystemEventArgs^ e)
    {
        Console::WriteLine("Deleted: {0}", e->FullPath);
    }

    static void OnRenamed(Object^ sender, RenamedEventArgs^ e)
    {
        Console::WriteLine("Renamed:");
        Console::WriteLine("    Old: {0}", e->OldFullPath);
        Console::WriteLine("    New: {0}", e->FullPath);
    }

    static void OnError(Object^ sender, ErrorEventArgs^ e)
    {
        PrintException(e->GetException());
    }

    static void PrintException(Exception^ ex)
    {
        if (ex != nullptr)
        {
            Console::WriteLine("Message: {0}", ex->Message);
            Console::WriteLine("Stacktrace:");
            Console::WriteLine(ex->StackTrace);
            Console::WriteLine();
            PrintException(ex->InnerException);
        }
    }
};


int main()
{
    MyClassCPP::Run();
}

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

Per altre informazioni su questa API, vedere Note sulle API supplementari per FileSystemWatcher.

Costruttori

FileSystemWatcher()	Inizializza una nuova istanza della classe FileSystemWatcher.
FileSystemWatcher(String)	Inizializza una nuova istanza della classe FileSystemWatcher, una volta specificata la directory da monitorare.
FileSystemWatcher(String, String)	Inizializza una nuova istanza della classe FileSystemWatcher, una volta specificati la directory e il tipo di file da monitorare.

Proprietà

CanRaiseEvents	Ottiene un valore che indica se il componente può generare un evento. (Ereditato da Component)
Container	Ottiene l'oggetto IContainer che contiene Component. (Ereditato da Component)
DesignMode	Ottiene un valore che indica se il Component si trova in modalità progettazione. (Ereditato da Component)
EnableRaisingEvents	Ottiene o imposta un valore che indica se il componente è abilitato.
Events	Ottiene l'elenco dei gestori eventi allegati a questo Component. (Ereditato da Component)
Filter	Ottiene o imposta la stringa di filtro usata per determinare quali file vengono monitorati in una directory.
Filters	Ottiene la raccolta di tutti i filtri usati per determinare quali file vengono monitorati in una directory.
IncludeSubdirectories	Ottiene o imposta un valore che indica se le sottodirectory nel percorso specificato devono essere monitorate.
InternalBufferSize	Ottiene o imposta le dimensioni predefinite (in byte) del buffer interno.
NotifyFilter	Ottiene o imposta il tipo di modifiche da controllare.
Path	Ottiene o imposta il percorso della directory da controllare.
Site	Ottiene o imposta un oggetto ISite per l'oggetto FileSystemWatcher.
SynchronizingObject	Ottiene o imposta l'oggetto usato per effettuare il marshalling delle chiamate del gestore eventi eseguite in seguito alla modifica di una directory.

Metodi

BeginInit()	Avvia l'inizializzazione di un oggetto FileSystemWatcher usato in un form o da un altro componente. L'inizializzazione avviene in fase di esecuzione.
CreateObjRef(Type)	Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto. (Ereditato da MarshalByRefObject)
Dispose()	Rilascia tutte le risorse usate da Component. (Ereditato da Component)
Dispose(Boolean)	Rilascia le risorse non gestite usate da FileSystemWatcher e, facoltativamente, le risorse gestite.
EndInit()	Termina l'inizializzazione di un oggetto FileSystemWatcher usato in un form o da un altro componente. L'inizializzazione avviene in fase di esecuzione.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLifetimeService()	Obsoleti. Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza. (Ereditato da MarshalByRefObject)
GetService(Type)	Consente di restituire un oggetto che rappresenta un servizio fornito da Component o dal relativo Container. (Ereditato da Component)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
InitializeLifetimeService()	Obsoleti. Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
MemberwiseClone(Boolean)	Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject)
OnChanged(FileSystemEventArgs)	Genera l'evento Changed.
OnCreated(FileSystemEventArgs)	Genera l'evento Created.
OnDeleted(FileSystemEventArgs)	Genera l'evento Deleted.
OnError(ErrorEventArgs)	Genera l'evento Error.
OnRenamed(RenamedEventArgs)	Genera l'evento Renamed.
ToString()	Restituisce un oggetto String che contiene il nome dell'eventuale oggetto Component. Questo metodo non deve essere sottoposto a override. (Ereditato da Component)
WaitForChanged(WatcherChangeTypes)	Metodo sincrono che restituisce una struttura contenente informazioni specifiche sulle modifica effettuata, una volta definito il tipo di modifica da monitorare.
WaitForChanged(WatcherChangeTypes, Int32)	Metodo sincrono che restituisce una struttura contenente informazioni specifiche sulle modifica effettuata, una volta definiti il tipo di modifica da monitorare e il tempo di attesa espresso in millisecondi prima del timeout.
WaitForChanged(WatcherChangeTypes, TimeSpan)	Restituisce in modo sincrono una struttura che contiene informazioni specifiche sulla modifica che si è verificata, dato il tipo di modifica da monitorare.

Eventi

Changed	Si verifica alla modifica di un file o di una directory nella proprietà Path.
Created	Si verifica alla creazione di un file o di una directory nella proprietà Path.
Deleted	Si verifica all'eliminazione di un file o di una directory nella proprietà Path.
Disposed	Si verifica quando il componente viene eliminato da una chiamata al metodo Dispose(). (Ereditato da Component)
Error	Si verifica quando l'istanza dell'oggetto FileSystemWatcher non è in grado di continuare il monitoraggio delle modifiche o quando si verifica un overflow del buffer interno.
Renamed	Si verifica alla ridenominazione di un file o di una directory nella proprietà Path.

Vedi anche

• NotifyFilter
• NotifyFilters
• FileSystemEventArgs
• FileSystemEventHandler
• Filter
• IncludeSubdirectories
• InternalBufferOverflowException
• RenamedEventArgs
• RenamedEventHandler
• WaitForChangedResult
• WatcherChangeTypes
• Uso di un componente FileSystemWatcher in un Windows Form