FileSystemWatcher FileSystemWatcher FileSystemWatcher FileSystemWatcher Class

Definizione

Attende le notifiche di modifica del file system e genera eventi quando una directory o un file in una directory viene modificato.Listens to the file system change notifications and raises events when a directory, or file in a directory, changes.

public ref class FileSystemWatcher : System::ComponentModel::Component, System::ComponentModel::ISupportInitialize
[System.IO.IODescription("")]
[System.IO.IODescription("FileSystemWatcherDesc")]
public class FileSystemWatcher : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize
type FileSystemWatcher = class
    inherit Component
    interface ISupportInitialize
Public Class FileSystemWatcher
Inherits Component
Implements ISupportInitialize
Ereditarietà
Attributi
Implementazioni

Esempi

L'esempio seguente crea un FileSystemWatcher per controllare la directory specificata in fase di esecuzione.The following example creates a FileSystemWatcher to watch the directory specified at run time. Il componente viene impostato per controllare le modifiche nei LastWrite e LastAccess ora, la creazione, eliminazione o ridenominazione dei file di testo nella directory.The component is set to watch for changes in LastWrite and LastAccess time, the creation, deletion, or renaming of text files in the directory. Se un file viene modificato, creato o eliminato, il percorso del file viene stampato nella console.If a file is changed, created, or deleted, the path to the file prints to the console. Quando un file viene rinominato, il vecchio e nuovo percorso di stampa nella console.When a file is renamed, the old and new paths print to the console.

#using <System.dll>

using namespace System;
using namespace System::IO;
using namespace System::Security::Permissions;

public ref class Watcher
{
private:
   // Define the event handlers.
   static void OnChanged( Object^ /*source*/, FileSystemEventArgs^ e )
   {
      // Specify what is done when a file is changed, created, or deleted.
      Console::WriteLine( "File: {0} {1}", e->FullPath, e->ChangeType );
   }

   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:
   [PermissionSet(SecurityAction::Demand, Name="FullTrust")]
   int static run()
   {
      array<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 0;
      }

      // Create a new FileSystemWatcher and set its properties.
      FileSystemWatcher^ watcher = gcnew FileSystemWatcher;
      watcher->Path = args[ 1 ];

      /* Watch for changes in LastAccess and LastWrite times, and 
          the renaming of files or directories. */
      watcher->NotifyFilter = static_cast<NotifyFilters>(NotifyFilters::LastAccess |
            NotifyFilters::LastWrite | NotifyFilters::FileName | NotifyFilters::DirectoryName);

      // Only watch text files.
      watcher->Filter = "*.txt";

      // Add event handlers.
      watcher->Changed += gcnew FileSystemEventHandler( Watcher::OnChanged );
      watcher->Created += gcnew FileSystemEventHandler( Watcher::OnChanged );
      watcher->Deleted += gcnew FileSystemEventHandler( Watcher::OnChanged );
      watcher->Renamed += gcnew RenamedEventHandler( Watcher::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' );

      return 0;
   }
};

int main() {
   Watcher::run();
}
using System;
using System.IO;
using System.Security.Permissions;

public class Watcher
{
    public static void Main()
    {
        Run();
    }

    [PermissionSet(SecurityAction.Demand, Name = "FullTrust")]
    private static void Run()
    {
        string[] args = 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.
        using (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 += 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') ;
        }
    }

    // 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: {e.OldFullPath} renamed to {e.FullPath}");
}
Imports System
Imports System.IO
Imports System.Security.Permissions
Imports Microsoft.VisualBasic

Public Class Watcher

    Public Shared Sub Main()

        Run()

    End Sub

    <PermissionSet(SecurityAction.Demand, Name:="FullTrust")>
    Private Shared Sub Run()

        Dim args() As String = Environment.GetCommandLineArgs()

        ' If a directory is not specified, exit the program.
        If args.Length <> 2 Then
            ' Display the proper way to call the program.
            Console.WriteLine("Usage: Watcher.exe (directory)")
            Return
        End If

        ' Create a new FileSystemWatcher and set its properties.
        Using watcher As 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 _
                                 Or NotifyFilters.LastWrite _
                                 Or NotifyFilters.FileName _
                                 Or NotifyFilters.DirectoryName)

            ' Only watch text files.
            watcher.Filter = "*.txt"

            ' Add event handlers.
            AddHandler watcher.Changed, AddressOf OnChanged
            AddHandler watcher.Created, AddressOf OnChanged
            AddHandler watcher.Deleted, AddressOf OnChanged
            AddHandler watcher.Renamed, AddressOf OnRenamed

            ' Begin watching.
            watcher.EnableRaisingEvents = True

            ' Wait for the user to quit the program.
            Console.WriteLine("Press 'q' to quit the sample.")
            While Chr(Console.Read()) <> "q"c
            End While
        End Using
    End Sub

    ' Define the event handlers.
    Private Shared Sub OnChanged(source As Object, e As FileSystemEventArgs)
        ' Specify what is done when a file is changed, created, or deleted.
        Console.WriteLine($"File: {e.FullPath} {e.ChangeType}")
    End Sub

    Private Shared Sub OnRenamed(source As Object, e As RenamedEventArgs)
        ' Specify what is done when a file is renamed.
        Console.WriteLine($"File: {e.OldFullPath} renamed to {e.FullPath}")
    End Sub

End Class

Commenti

Usare FileSystemWatcher controllare le modifiche in una directory specificata.Use FileSystemWatcher to watch for changes in a specified directory. È possibile controllare le modifiche nei file e le sottodirectory della directory specificata.You can watch for changes in files and subdirectories of the specified directory. È possibile creare un componente per controllare i file in un computer locale, un'unità di rete o un computer remoto.You can create a component to watch files on a local computer, a network drive, or a remote computer.

Per controllare le modifiche in tutti i file, impostare il Filter proprietà in una stringa vuota ("") o usare caratteri jolly ("*.*").To watch for changes in all files, set the Filter property to an empty string ("") or use wildcards ("*.*"). Per guardare un file specifico, impostare il Filter proprietà sul nome di file.To watch a specific file, set the Filter property to the file name. Ad esempio, per controllare le modifiche apportate al file MyDoc, impostare il Filter proprietà su "MyDoc".For example, to watch for changes in the file MyDoc.txt, set the Filter property to "MyDoc.txt". È anche possibile guardare le modifiche in un determinato tipo di file.You can also watch for changes in a certain type of file. Ad esempio, per controllare le modifiche nei file di testo, impostare il Filter proprietà su "*. txt".For example, to watch for changes in text files, set the Filter property to "*.txt".

Esistono diversi tipi di modifiche per cui è possibile guardare in un file o directory.There are several types of changes you can watch for in a directory or file. Ad esempio, è possibile controllare le modifiche apportate Attributes, il LastWrite data e ora, o il Size di file o directory.For example, you can watch for changes in Attributes, the LastWrite date and time, or the Size of files or directories. Questa operazione viene eseguita impostando il NotifyFilter una delle proprietà il NotifyFilters valori.This is done by setting the NotifyFilter property to one of the NotifyFilters values. Per altre informazioni sul tipo di modifiche è possibile guardare, vedere NotifyFilters.For more information on the type of changes you can watch, see NotifyFilters.

È possibile guardare la ridenominazione, eliminazione o la creazione di file o directory.You can watch for renaming, deletion, or creation of files or directories. Ad esempio, per controllare la ridenominazione dei file di testo, impostare il Filter proprietà su "*. txt" e chiamare il WaitForChanged metodo con un Renamed specificato per il parametro.For example, to watch for renaming of text files, set the Filter property to "*.txt" and call the WaitForChanged method with a Renamed specified for its parameter.

Il sistema operativo Windows invia una notifica di modifiche ai file in un buffer creati dal componente di FileSystemWatcher.The Windows operating system notifies your component of file changes in a buffer created by the FileSystemWatcher. Se sono presenti numerose modifiche in un breve periodo di tempo, il buffer potrà verificarsi un overflow.If there are many changes in a short time, the buffer can overflow. In questo modo il componente non terrà traccia delle modifiche nella directory, e si limiterà a fornire la notifica di copertura.This causes the component to lose track of changes in the directory, and it will only provide blanket notification. Aumento delle dimensioni del buffer con il InternalBufferSize proprietà è dispendiosa, perché proviene da memoria non di paging che non è possibile eseguire lo swapping su disco, in modo che il buffer di piccole dimensioni ma grandi dimensioni sufficienti per non perdere tutti i file degli eventi di modifica.Increasing the size of the buffer with the InternalBufferSize property is expensive, as it comes from non-paged memory that cannot be swapped out to disk, so keep the buffer as small yet large enough to not miss any file change events. Per evitare un sovraccarico del buffer, usare il NotifyFilter e IncludeSubdirectories le notifiche di modifica delle proprietà in modo che è possibile filtrare i indesiderati.To avoid a buffer overflow, use the NotifyFilter and IncludeSubdirectories properties so you can filter out unwanted change notifications.

Per un elenco di valori di proprietà iniziali per un'istanza di FileSystemWatcher, vedere il FileSystemWatcher costruttore.For a list of initial property values for an instance of FileSystemWatcher, see the FileSystemWatcher constructor.

Si noti quanto segue quando si usa il FileSystemWatcher classe.Please note the following when using the FileSystemWatcher class.

  • I file nascosti non vengono ignorati.Hidden files are not ignored.

  • In alcuni sistemi, FileSystemWatcher segnala le modifiche apportate ai file usando il formato del nome di 8.3 file brevi.In some systems, FileSystemWatcher reports changes to files using the short 8.3 file name format. Ad esempio, è stato possibile segnalare una modifica a "Longfilename" come "LONGFI ~. LON".For example, a change to "LongFileName.LongExtension" could be reported as "LongFil~.Lon".

  • Questa classe contiene una richiesta di collegamento e una richiesta di ereditarietà a livello di classe che si applica a tutti i membri.This class contains a link demand and an inheritance demand at the class level that applies to all members. Oggetto SecurityException viene generata quando il chiamante immediato o la classe derivata non dispone dell'autorizzazione di attendibilità.A SecurityException is thrown when either the immediate caller or the derived class does not have full-trust permission. Per informazioni dettagliate sui requisiti di sicurezza, vedere richieste di collegamento.For details about security demands, see Link Demands.

  • La dimensione massima è possibile impostare per il InternalBufferSize proprietà per il monitoraggio di una directory in rete è di 64 KB.The maximum size you can set for the InternalBufferSize property for monitoring a directory over the network is 64 KB.

Nota

Esecuzione FileSystemWatcher in Windows 98 non è supportato.Running FileSystemWatcher on Windows 98 is not supported.

Copiare e spostare cartelleCopying and moving folders

Il sistema operativo e FileSystemWatcher oggetto interpretare una Taglia e Incolla o un'operazione di spostamento come azione di ridenominazione per una cartella e il relativo contenuto.The operating system and FileSystemWatcher object interpret a cut-and-paste action or a move action as a rename action for a folder and its contents. Se si taglia e Incolla di una cartella con i file in una cartella controllata, la FileSystemWatcher oggetto prestazione solo la cartella come nuovo, ma non il relativo contenuto in quanto sono essenzialmente solo rinominati.If you cut and paste a folder with files into a folder being watched, the FileSystemWatcher object reports only the folder as new, but not its contents because they are essentially only renamed.

Per essere notificato che il contenuto delle cartelle è stato spostato o copiato in una cartella controllata, fornire OnChanged e OnRenamed metodi del gestore eventi come indicato nella tabella seguente.To be notified that the contents of folders have been moved or copied into a watched folder, provide OnChanged and OnRenamed event handler methods as suggested in the following table.

Gestore dell'eventoEvent Handler Eventi gestitiEvents Handled EseguePerforms
OnChanged Changed, Created, DeletedChanged, Created, Deleted Segnalare le modifiche in attributi di file, i file creati e i file eliminati.Report changes in file attributes, created files, and deleted files.
OnRenamed Renamed Elencare i percorsi vecchi e nuovi di rinominati i file e cartelle mediante l'espansione ricorsiva se necessario.List the old and new paths of renamed files and folders, expanding recursively if needed.

Dimensioni Buffer e gli eventiEvents and Buffer Sizes

Si noti che alcuni fattori possono influenzare gli eventi di modifica del file system vengono generati, come descritto nel modo seguente:Note that several factors can affect which file system change events are raised, as described by the following:

  • Operazioni comuni del file system potrebbero generare più di un evento.Common file system operations might raise more than one event. Ad esempio, quando un file viene spostato da una directory a un'altra, diversi OnChanged e alcune OnCreated e OnDeleted vengano generati eventi.For example, when a file is moved from one directory to another, several OnChanged and some OnCreated and OnDeleted events might be raised. Lo spostamento di che un file è un'operazione complessa costituito da più operazioni semplici, generano più eventi.Moving a file is a complex operation that consists of multiple simple operations, therefore raising multiple events. Analogamente, alcune applicazioni (ad esempio, il software antivirus) vengano generati eventi di sistema aggiuntive del file che vengono rilevati da FileSystemWatcher.Likewise, some applications (for example, antivirus software) might cause additional file system events that are detected by FileSystemWatcher.

  • Il FileSystemWatcher può controllare i dischi finché non vengono passati o rimosso.The FileSystemWatcher can watch disks as long as they are not switched or removed. Il FileSystemWatcher non genera eventi per CD e DVD, perché non è possibile modificare proprietà e i timbri data / ora.The FileSystemWatcher does not raise events for CDs and DVDs, because time stamps and properties cannot change. Nei computer remoti deve essere una delle piattaforme necessari installate per il componente funzioni correttamente.Remote computers must have one of the required platforms installed for the component to function properly.

  • Se più FileSystemWatcher oggetti vengono monitorato lo stesso percorso UNC in Windows XP precedenti al Service Pack 1 o Windows 2000 SP2 o versioni precedenti, solo uno degli oggetti genera un evento.If multiple FileSystemWatcher objects are watching the same UNC path in Windows XP prior to Service Pack 1, or Windows 2000 SP2 or earlier, then only one of the objects will raise an event. Nei computer che eseguono Windows XP SP1 e versioni successive, Windows 2000 SP3 o versioni successive o Windows Server 2003, tutti FileSystemWatcher oggetti genererà gli eventi appropriati.On machines running Windows XP SP1 and newer, Windows 2000 SP3 or newer or Windows Server 2003, all FileSystemWatcher objects will raise the appropriate events.

Si noti che un FileSystemWatcher potrebbe non essere un evento quando viene superata la dimensione del buffer.Note that a FileSystemWatcher may miss an event when the buffer size is exceeded. Per evitare la perdita di eventi, seguire queste linee guida:To avoid missing events, follow these guidelines:

  • Aumentare le dimensioni del buffer, impostando il InternalBufferSize proprietà.Increase the buffer size by setting the InternalBufferSize property.

  • Evitare il controllo di file con nomi lunghi, poiché un nome di file lungo contribuisce all'esaurimento dello spazio nel buffer.Avoid watching files with long file names, because a long file name contributes to filling up the buffer. Prendere in considerazione la ridenominazione di questi file usando nomi più brevi.Consider renaming these files using shorter names.

  • Mantenere il codice più corte possibili di gestione degli eventi.Keep your event handling code as short as possible.

Costruttori

FileSystemWatcher() FileSystemWatcher() FileSystemWatcher() FileSystemWatcher()

Inizializza una nuova istanza della classe FileSystemWatcher.Initializes a new instance of the FileSystemWatcher class.

FileSystemWatcher(String) FileSystemWatcher(String) FileSystemWatcher(String) FileSystemWatcher(String)

Inizializza una nuova istanza della classe FileSystemWatcher, una volta specificata la directory da controllare.Initializes a new instance of the FileSystemWatcher class, given the specified directory to monitor.

FileSystemWatcher(String, String) FileSystemWatcher(String, String) FileSystemWatcher(String, String) FileSystemWatcher(String, String)

Inizializza una nuova istanza della classe FileSystemWatcher, una volta specificati la directory e il tipo di file da controllare.Initializes a new instance of the FileSystemWatcher class, given the specified directory and type of files to monitor.

Proprietà

CanRaiseEvents CanRaiseEvents CanRaiseEvents CanRaiseEvents

Ottiene un valore che indica se il componente può generare un evento.Gets a value indicating whether the component can raise an event.

(Inherited from Component)
Container Container Container Container

Ottiene il IContainer che contiene il Component.Gets the IContainer that contains the Component.

(Inherited from Component)
DesignMode DesignMode DesignMode DesignMode

Ottiene un valore che indica se il Component si trova in modalità progettazione.Gets a value that indicates whether the Component is currently in design mode.

(Inherited from Component)
EnableRaisingEvents EnableRaisingEvents EnableRaisingEvents EnableRaisingEvents

Ottiene o imposta un valore che indica se il componente è abilitato.Gets or sets a value indicating whether the component is enabled.

Events Events Events Events

Ottiene l'elenco dei gestori eventi allegati a questo Component.Gets the list of event handlers that are attached to this Component.

(Inherited from Component)
Filter Filter Filter Filter

Ottiene o imposta la stringa di filtro utilizzata per determinare quali file vengono controllati in una directory.Gets or sets the filter string used to determine what files are monitored in a directory.

Filters Filters Filters Filters
IncludeSubdirectories IncludeSubdirectories IncludeSubdirectories IncludeSubdirectories

Ottiene o imposta un valore che indica se le sottodirectory nel percorso specificato devono essere controllate.Gets or sets a value indicating whether subdirectories within the specified path should be monitored.

InternalBufferSize InternalBufferSize InternalBufferSize InternalBufferSize

Ottiene o imposta le dimensioni predefinite (in byte) del buffer interno.Gets or sets the size (in bytes) of the internal buffer.

NotifyFilter NotifyFilter NotifyFilter NotifyFilter

Ottiene o imposta il tipo di modifiche da controllare.Gets or sets the type of changes to watch for.

Path Path Path Path

Ottiene o imposta il percorso della directory da controllare.Gets or sets the path of the directory to watch.

Site Site Site Site

Ottiene o imposta un oggetto ISite per l'oggetto FileSystemWatcher.Gets or sets an ISite for the FileSystemWatcher.

SynchronizingObject SynchronizingObject SynchronizingObject SynchronizingObject

Ottiene o imposta l'oggetto utilizzato per effettuare il marshalling delle chiamate del gestore eventi eseguite in seguito alla modifica di una directory.Gets or sets the object used to marshal the event handler calls issued as a result of a directory change.

Metodi

BeginInit() BeginInit() BeginInit() BeginInit()

Avvia l'inizializzazione di un oggetto FileSystemWatcher usato in un form o da un altro componente.Begins the initialization of a FileSystemWatcher used on a form or used by another component. L'inizializzazione avviene in fase di esecuzione.The initialization occurs at run time.

CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type) 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.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Inherited from MarshalByRefObject)
Dispose() Dispose() Dispose() Dispose()
Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Rilascia le risorse non gestite usate da FileSystemWatcher e, facoltativamente, le risorse gestite.Releases the unmanaged resources used by the FileSystemWatcher and optionally releases the managed resources.

EndInit() EndInit() EndInit() EndInit()

Termina l'inizializzazione di un oggetto FileSystemWatcher utilizzato in un form o da un altro componente.Ends the initialization of a FileSystemWatcher used on a form or used by another component. L'inizializzazione avviene in fase di esecuzione.The initialization occurs at run time.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Inherited from Object)
Finalize() Finalize() Finalize() Finalize()
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Inherited from Object)
GetLifetimeService() GetLifetimeService() GetLifetimeService() GetLifetimeService()

Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
GetService(Type) GetService(Type) GetService(Type) GetService(Type)

Consente di restituire un oggetto che rappresenta un servizio fornito da Component o dal relativo Container.Returns an object that represents a service provided by the Component or by its Container.

(Inherited from Component)
GetType() GetType() GetType() GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Inherited from Object)
InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService()

Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza.Obtains a lifetime service object to control the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Inherited from Object)
MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean)

Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente.Creates a shallow copy of the current MarshalByRefObject object.

(Inherited from MarshalByRefObject)
OnChanged(FileSystemEventArgs) OnChanged(FileSystemEventArgs) OnChanged(FileSystemEventArgs) OnChanged(FileSystemEventArgs)

Genera l'evento Changed.Raises the Changed event.

OnCreated(FileSystemEventArgs) OnCreated(FileSystemEventArgs) OnCreated(FileSystemEventArgs) OnCreated(FileSystemEventArgs)

Genera l'evento Created.Raises the Created event.

OnDeleted(FileSystemEventArgs) OnDeleted(FileSystemEventArgs) OnDeleted(FileSystemEventArgs) OnDeleted(FileSystemEventArgs)

Genera l'evento Deleted.Raises the Deleted event.

OnError(ErrorEventArgs) OnError(ErrorEventArgs) OnError(ErrorEventArgs) OnError(ErrorEventArgs)

Genera l'evento Error.Raises the Error event.

OnRenamed(RenamedEventArgs) OnRenamed(RenamedEventArgs) OnRenamed(RenamedEventArgs) OnRenamed(RenamedEventArgs)

Genera l'evento Renamed.Raises the Renamed event.

ToString() ToString() ToString() ToString()

Restituisce un oggetto String che contiene il nome dell'eventuale oggetto Component.Returns a String containing the name of the Component, if any. Questo metodo non deve essere sottoposto a override.This method should not be overridden.

(Inherited from Component)
WaitForChanged(WatcherChangeTypes) WaitForChanged(WatcherChangeTypes) WaitForChanged(WatcherChangeTypes) WaitForChanged(WatcherChangeTypes)

Metodo sincrono che restituisce una struttura contenente informazioni specifiche sulle modifica effettuata, una volta definito il tipo di modifica che si desidera controllare.A synchronous method that returns a structure that contains specific information on the change that occurred, given the type of change you want to monitor.

WaitForChanged(WatcherChangeTypes, Int32) WaitForChanged(WatcherChangeTypes, Int32) WaitForChanged(WatcherChangeTypes, Int32) WaitForChanged(WatcherChangeTypes, Int32)

Metodo sincrono che restituisce una struttura contenente informazioni specifiche sulle modifica effettuata, una volta definiti il tipo di modifica che si desidera controllare e il tempo di attesa espresso in millisecondi prima del timeout.A synchronous method that returns a structure that contains specific information on the change that occurred, given the type of change you want to monitor and the time (in milliseconds) to wait before timing out.

Eventi

Changed Changed Changed Changed

Viene generato alla modifica di un file o di una directory nella proprietà Path specificata.Occurs when a file or directory in the specified Path is changed.

Created Created Created Created

Viene generato alla creazione di un file o di una directory nella proprietà Path specificata.Occurs when a file or directory in the specified Path is created.

Deleted Deleted Deleted Deleted

Viene generato all'eliminazione di un file o di una directory nella proprietà Path specificata.Occurs when a file or directory in the specified Path is deleted.

Disposed Disposed Disposed Disposed

Si verifica quando il componente viene eliminato da una chiamata al metodo Dispose().Occurs when the component is disposed by a call to the Dispose() method.

(Inherited from Component)
Error Error Error Error

Viene generato quando l'istanza dell'oggetto FileSystemWatcher non è in grado di continuare il monitoraggio delle modifiche o quando si verifica un overflow del buffer interno.Occurs when the instance of FileSystemWatcher is unable to continue monitoring changes or when the internal buffer overflows.

Renamed Renamed Renamed Renamed

Viene generato alla ridenominazione di un file o di una directory nella proprietà Path specificata.Occurs when a file or directory in the specified Path is renamed.

Sicurezza

SecurityPermission
per la derivazione da di ProcessStartInfo classe.for deriving from the ProcessStartInfo class. Valore richiesta: InheritanceDemand; Set di autorizzazioni denominati: FullTrust.Demand value: InheritanceDemand; Named Permission Sets: FullTrust.

Si applica a

Vedi anche