FileSystemWatcher FileSystemWatcher FileSystemWatcher FileSystemWatcher Class

Définition

Écoute les notifications de modifications du système de fichiers et déclenche un événement lorsqu'un répertoire ou un fichier d'un répertoire est modifié.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
Héritage
Attributs
Implémente

Exemples

L’exemple suivant crée un FileSystemWatcher à surveiller le répertoire spécifié au moment de l’exécution.The following example creates a FileSystemWatcher to watch the directory specified at run time. Le composant est défini pour surveiller les modifications de LastWrite et LastAccess du temps, la création, suppression, ou le changement de nom des fichiers texte dans le répertoire.The component is set to watch for changes in LastWrite and LastAccess time, the creation, deletion, or renaming of text files in the directory. Si un fichier est modifié, créé ou supprimé, le chemin d’accès au fichier s’imprime sur la console.If a file is changed, created, or deleted, the path to the file prints to the console. Lorsqu’un fichier est renommé, les chemins d’accès nouvelles et anciennes impriment sur la 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

Remarques

Utilisez FileSystemWatcher pour surveiller les modifications dans un répertoire spécifié.Use FileSystemWatcher to watch for changes in a specified directory. Vous pouvez surveiller les modifications de fichiers et sous-répertoires du répertoire spécifié.You can watch for changes in files and subdirectories of the specified directory. Vous pouvez créer un composant pour regarder les fichiers sur un ordinateur local, un lecteur réseau ou un ordinateur distant.You can create a component to watch files on a local computer, a network drive, or a remote computer.

Pour surveiller les modifications dans tous les fichiers, définissez le Filter propriété sur une chaîne vide (« ») ou utiliser des caractères génériques (« *.*»).To watch for changes in all files, set the Filter property to an empty string ("") or use wildcards ("*.*"). Pour visionner un fichier spécifique, définissez la Filter propriété le nom de fichier.To watch a specific file, set the Filter property to the file name. Par exemple, pour surveiller les modifications apportées au fichier mondoc.txt, définissez le Filter propriété « Doit être mondoc.txt ».For example, to watch for changes in the file MyDoc.txt, set the Filter property to "MyDoc.txt". Vous pouvez également surveiller les modifications apportées à un certain type de fichier.You can also watch for changes in a certain type of file. Par exemple, pour surveiller les modifications apportées aux fichiers de texte, définissez la Filter propriété à «*.txt ».For example, to watch for changes in text files, set the Filter property to "*.txt".

Il existe plusieurs types de modifications que vous pouvez surveiller les dans un fichier ou répertoire.There are several types of changes you can watch for in a directory or file. Par exemple, vous pouvez observer les modifications de Attributes, le LastWrite date et l’heure, ou le Size de fichiers ou répertoires.For example, you can watch for changes in Attributes, the LastWrite date and time, or the Size of files or directories. Cela en définissant le NotifyFilter propriété de la NotifyFilters valeurs.This is done by setting the NotifyFilter property to one of the NotifyFilters values. Pour plus d’informations sur le type de modifications que vous pouvez regarder, consultez NotifyFilters.For more information on the type of changes you can watch, see NotifyFilters.

Vous pouvez regarder de changement de nom, suppression ou la création de fichiers ou répertoires.You can watch for renaming, deletion, or creation of files or directories. Par exemple, pour surveiller le changement de nom des fichiers texte, définissez la Filter propriété « *.txt » et appelez le WaitForChanged méthode avec un Renamed spécifié pour son paramètre.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.

Le système d’exploitation Windows notifie votre composant de modifications de fichiers dans une mémoire tampon créée par le FileSystemWatcher.The Windows operating system notifies your component of file changes in a buffer created by the FileSystemWatcher. Si plusieurs modifications sont apportées dans une courte période, la mémoire tampon peut provoquer un débordement.If there are many changes in a short time, the buffer can overflow. Cela entraîne le composant de perdre la trace des modifications dans le répertoire, et il ne sera qu’une notification standard.This causes the component to lose track of changes in the directory, and it will only provide blanket notification. Augmentation de la taille de la mémoire tampon avec la InternalBufferSize propriété est coûteuse, car elle provient d’une mémoire non paginée ne peut pas être transférée sur le disque, donc conserver la mémoire tampon en tant que petite encore une grande suffisant pour ne manquez pas n’importe quel fichier événements de modification.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. Pour éviter un dépassement de capacité de mémoire tampon, utilisez le NotifyFilter et IncludeSubdirectories notifications de modifications de propriétés afin de filtrer les indésirables.To avoid a buffer overflow, use the NotifyFilter and IncludeSubdirectories properties so you can filter out unwanted change notifications.

Pour obtenir la liste des valeurs initiales des propriétés d’une instance de FileSystemWatcher, consultez le FileSystemWatcher constructeur.For a list of initial property values for an instance of FileSystemWatcher, see the FileSystemWatcher constructor.

Notez les points suivants lorsque vous utilisez la FileSystemWatcher classe.Please note the following when using the FileSystemWatcher class.

  • Fichiers masqués ne sont pas ignorés.Hidden files are not ignored.

  • Dans certains systèmes, FileSystemWatcher signale les modifications apportées aux fichiers à l’aide du format de nom de 8.3 fichier court.In some systems, FileSystemWatcher reports changes to files using the short 8.3 file name format. Par exemple, une modification apportée à « LongFileName.LongExtension » peut être signalée comme « LongFi ~. LON ».For example, a change to "LongFileName.LongExtension" could be reported as "LongFil~.Lon".

  • Cette classe contient une demande de liaison et une demande d’héritage au niveau de la classe qui s’applique à tous les membres.This class contains a link demand and an inheritance demand at the class level that applies to all members. Un SecurityException est levée lorsque l’appelant immédiat ou la classe dérivée n’a pas d’autorisations de confiance totale.A SecurityException is thrown when either the immediate caller or the derived class does not have full-trust permission. Pour plus d’informations sur les demandes de sécurité, consultez demandes de liaison.For details about security demands, see Link Demands.

  • La taille maximale que vous pouvez définir pour le InternalBufferSize propriété pour la surveillance d’un répertoire sur le réseau est de 64 Ko.The maximum size you can set for the InternalBufferSize property for monitoring a directory over the network is 64 KB.

Notes

En cours d’exécution FileSystemWatcher sur Windows 98 n’est pas pris en charge.Running FileSystemWatcher on Windows 98 is not supported.

Copier et déplacer des dossiersCopying and moving folders

Le système d’exploitation et FileSystemWatcher objet interpréter une action Couper-coller ou une action de déplacement comme une action de changement de nom pour un dossier et son contenu.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. Si vous coupez et collez un dossier avec des fichiers dans un dossier suivi, le FileSystemWatcher objet signale uniquement le dossier en tant que nouveau, mais pas son contenu, car ils sont essentiellement renommés.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.

Pour être averti que le contenu des dossiers ont été déplacé ou copié dans un dossier de contrôle, fournir OnChanged et OnRenamed méthodes de gestionnaire d’événements comme indiqué dans le tableau suivant.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.

Gestionnaire d’événementsEvent Handler Événements gérésEvents Handled EffectuePerforms
OnChanged Changed, Created, DeletedChanged, Created, Deleted Signaler les modifications dans les attributs de fichier, les fichiers créés et les fichiers supprimés.Report changes in file attributes, created files, and deleted files.
OnRenamed Renamed Répertorier les anciens et nouveaux chemins d’accès des fichiers renommés et des dossiers, développez de manière récursive si nécessaire.List the old and new paths of renamed files and folders, expanding recursively if needed.

Événements et les tailles de mémoire tamponEvents and Buffer Sizes

Notez que plusieurs facteurs peuvent affecter les événements de changement de système de fichiers sont déclenchés, comme décrit par ce qui suit :Note that several factors can affect which file system change events are raised, as described by the following:

  • Opérations de système de fichiers courantes peuvent déclencher plusieurs événements.Common file system operations might raise more than one event. Par exemple, lorsqu’un fichier est déplacé d’un répertoire à un autre, plusieurs OnChanged et certains OnCreated et OnDeleted événements peuvent être déclenchés.For example, when a file is moved from one directory to another, several OnChanged and some OnCreated and OnDeleted events might be raised. Déplacement de qu'un fichier est une opération complexe qui se compose de plusieurs opérations simples, déclenchant donc plusieurs événements.Moving a file is a complex operation that consists of multiple simple operations, therefore raising multiple events. De même, certaines applications (par exemple, les logiciels antivirus) peuvent entraîner des événements de système de fichiers supplémentaires qui sont détectés par FileSystemWatcher.Likewise, some applications (for example, antivirus software) might cause additional file system events that are detected by FileSystemWatcher.

  • Le FileSystemWatcher peut regarder les disques tant qu’ils ne sont pas basculés ou supprimés.The FileSystemWatcher can watch disks as long as they are not switched or removed. Le FileSystemWatcher ne déclenche pas d’événements pour les CD et DVD, étant donné que les horodatages et les propriétés ne peuvent pas modifier.The FileSystemWatcher does not raise events for CDs and DVDs, because time stamps and properties cannot change. Ordinateurs distants doivent avoir une des plateformes requises installés pour le composant de fonctionner correctement.Remote computers must have one of the required platforms installed for the component to function properly.

  • Si plusieurs FileSystemWatcher objets voient le même chemin d’accès UNC dans XP de Windows antérieure au Service Pack 1 ou Windows 2000 SP2 ou version antérieure, seul un des objets déclenchera un événement.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. Sur les ordinateurs exécutant Windows XP SP1 et versions ultérieures, Windows 2000 SP3 ou version ultérieure ou Windows Server 2003, tous les FileSystemWatcher objets déclenche les événements appropriés.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.

Notez qu’un FileSystemWatcher peut manquer un événement lorsque la taille de mémoire tampon est dépassée.Note that a FileSystemWatcher may miss an event when the buffer size is exceeded. Pour éviter de manquer des événements, suivez ces instructions :To avoid missing events, follow these guidelines:

  • Augmenter la taille du tampon en définissant le InternalBufferSize propriété.Increase the buffer size by setting the InternalBufferSize property.

  • Évitez de regarder les fichiers portant des noms de fichiers longs, car un nom de fichier long contribue au remplissage de la mémoire tampon.Avoid watching files with long file names, because a long file name contributes to filling up the buffer. Pensez à renommer ces fichiers à l’aide des noms plus courts.Consider renaming these files using shorter names.

  • Gardez votre événement aussi court que possible du code de gestion.Keep your event handling code as short as possible.

Constructeurs

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

Initialise une nouvelle instance de la classe FileSystemWatcher.Initializes a new instance of the FileSystemWatcher class.

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

Initialise une nouvelle instance de la classe FileSystemWatcher en fonction du répertoire spécifié à surveiller.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)

Initialise une nouvelle instance de la classe FileSystemWatcher en fonction du répertoire spécifié et du type de fichiers à surveiller.Initializes a new instance of the FileSystemWatcher class, given the specified directory and type of files to monitor.

Propriétés

CanRaiseEvents CanRaiseEvents CanRaiseEvents CanRaiseEvents

Obtient une valeur qui indique si le composant peut déclencher un événement.Gets a value indicating whether the component can raise an event.

(Inherited from Component)
Container Container Container Container

Obtient le IContainer qui contient Component.Gets the IContainer that contains the Component.

(Inherited from Component)
DesignMode DesignMode DesignMode DesignMode

Obtient une valeur qui indique si Component est actuellement en mode design.Gets a value that indicates whether the Component is currently in design mode.

(Inherited from Component)
EnableRaisingEvents EnableRaisingEvents EnableRaisingEvents EnableRaisingEvents

Obtient ou définit une valeur indiquant si le composant est activé.Gets or sets a value indicating whether the component is enabled.

Events Events Events Events

Obtient la liste des gestionnaires d'événements attachés à ce Component.Gets the list of event handlers that are attached to this Component.

(Inherited from Component)
Filter Filter Filter Filter

Obtient ou définit la chaîne de filtrage utilisée pour déterminer les fichiers à surveiller dans un répertoire.Gets or sets the filter string used to determine what files are monitored in a directory.

Filters Filters Filters Filters
IncludeSubdirectories IncludeSubdirectories IncludeSubdirectories IncludeSubdirectories

Obtient ou définit une valeur indiquant si les sous-répertoires du chemin d'accès spécifié doivent être surveillés.Gets or sets a value indicating whether subdirectories within the specified path should be monitored.

InternalBufferSize InternalBufferSize InternalBufferSize InternalBufferSize

Obtient ou définit la taille (en octets) de la mémoire tampon interne.Gets or sets the size (in bytes) of the internal buffer.

NotifyFilter NotifyFilter NotifyFilter NotifyFilter

Obtient ou définit le type de modifications à surveiller.Gets or sets the type of changes to watch for.

Path Path Path Path

Obtient ou définit le chemin d'accès du répertoire à surveiller.Gets or sets the path of the directory to watch.

Site Site Site Site

Obtient ou définit un ISite pour FileSystemWatcher.Gets or sets an ISite for the FileSystemWatcher.

SynchronizingObject SynchronizingObject SynchronizingObject SynchronizingObject

Obtient ou définit l'objet utilisé pour marshaler des appels du gestionnaire d'événements consécutifs à un changement de répertoire.Gets or sets the object used to marshal the event handler calls issued as a result of a directory change.

Méthodes

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

Lance l'initialisation d'un élément FileSystemWatcher utilisé sur un formulaire ou par un autre composant.Begins the initialization of a FileSystemWatcher used on a form or used by another component. L'initialisation se produit au moment de l'exécution.The initialization occurs at run time.

CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type)

Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant.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)

Libère les ressources non managées utilisées par FileSystemWatcher et libère éventuellement les ressources managées.Releases the unmanaged resources used by the FileSystemWatcher and optionally releases the managed resources.

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

Termine l'initialisation d'un FileSystemWatcher qui est utilisé dans un formulaire ou par un autre composant.Ends the initialization of a FileSystemWatcher used on a form or used by another component. L'initialisation se produit au moment de l'exécution.The initialization occurs at run time.

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

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

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

Fait office de fonction de hachage par défaut.Serves as the default hash function.

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

Récupère l'objet de service de durée de vie en cours qui contrôle la stratégie de durée de vie de cette instance.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)

Retourne un objet qui représente un service fourni par Component ou par son Container.Returns an object that represents a service provided by the Component or by its Container.

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

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

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

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.Obtains a lifetime service object to control the lifetime policy for this instance.

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

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

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

Crée une copie superficielle de l'objet MarshalByRefObject actuel.Creates a shallow copy of the current MarshalByRefObject object.

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

Déclenche l'événement Changed.Raises the Changed event.

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

Déclenche l'événement Created.Raises the Created event.

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

Déclenche l'événement Deleted.Raises the Deleted event.

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

Déclenche l'événement Error.Raises the Error event.

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

Déclenche l'événement Renamed.Raises the Renamed event.

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

Retourne un String contenant le nom du Component, s’il en existe un.Returns a String containing the name of the Component, if any. Cette méthode ne doit pas être remplacée.This method should not be overridden.

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

Méthode synchrone qui retourne une structure contenant des informations spécifiques sur les modifications apportées, en fonction des types de modifications à surveiller.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)

Méthode synchrone qui retourne une structure contenant des informations spécifiques sur les modifications apportées, en fonction des types de modifications à surveiller et du délai d'attente (en millisecondes).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.

Événements

Changed Changed Changed Changed

Se produit lorsqu'un fichier ou un répertoire du Path spécifié est modifié.Occurs when a file or directory in the specified Path is changed.

Created Created Created Created

Se produit lorsqu'un fichier ou un répertoire du Path spécifié est créé.Occurs when a file or directory in the specified Path is created.

Deleted Deleted Deleted Deleted

Se produit lorsqu'un fichier ou un répertoire du Path spécifié est supprimé.Occurs when a file or directory in the specified Path is deleted.

Disposed Disposed Disposed Disposed

Se produit lorsque le composant est supprimé par un appel à la méthode Dispose().Occurs when the component is disposed by a call to the Dispose() method.

(Inherited from Component)
Error Error Error Error

Se produit lorsque l'instance de FileSystemWatcher ne peut pas continuer à surveiller des modifications ou lorsque la mémoire tampon interne excède.Occurs when the instance of FileSystemWatcher is unable to continue monitoring changes or when the internal buffer overflows.

Renamed Renamed Renamed Renamed

Se produit lorsqu'un fichier ou un répertoire du Path spécifié est renommé.Occurs when a file or directory in the specified Path is renamed.

Sécurité

SecurityPermission
pour dériver la ProcessStartInfo classe.for deriving from the ProcessStartInfo class. Valeur de la demande : InheritanceDemand; Jeux d’autorisations nommés : FullTrust.Demand value: InheritanceDemand; Named Permission Sets: FullTrust.

S’applique à

Voir aussi