Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

FileSystemWatcher classe

 

Date de publication : novembre 2016

Écoute les notifications de modifications du système de fichiers et déclenche un événement quand un répertoire ou un fichier d'un répertoire est modifié.

Pour parcourir le code source de .NET Framework pour ce type, consultez la Source de référence.

Espace de noms:   System.IO
Assembly:  System (dans System.dll)

System.Object
  System.MarshalByRefObject
    System.ComponentModel.Component
      System.IO.FileSystemWatcher

[IODescriptionAttribute("FileSystemWatcherDesc")]
[PermissionSetAttribute(SecurityAction.LinkDemand, Name = "FullTrust")]
[PermissionSetAttribute(SecurityAction.InheritanceDemand, Name = "FullTrust")]
public class FileSystemWatcher : Component, ISupportInitialize

NomDescription
System_CAPS_pubmethodFileSystemWatcher()

Initialise une nouvelle instance de la classe FileSystemWatcher.

System_CAPS_pubmethodFileSystemWatcher(String)

Initialise une nouvelle instance de la classe FileSystemWatcher en fonction du répertoire spécifié à surveiller.

System_CAPS_pubmethodFileSystemWatcher(String, String)

Initialise une nouvelle instance de la classe FileSystemWatcher en fonction du répertoire et du type de fichiers à surveiller spécifiés.

NomDescription
System_CAPS_protpropertyCanRaiseEvents

Obtient une valeur indiquant si le composant peut déclencher un événement.(Hérité de Component.)

System_CAPS_pubpropertyContainer

Obtient les IContainer qui contient la Component.(Hérité de Component.)

System_CAPS_protpropertyDesignMode

Obtient une valeur qui indique si la Component est actuellement en mode design.(Hérité de Component.)

System_CAPS_pubpropertyEnableRaisingEvents

Obtient ou définit une valeur indiquant si le composant est activé.

System_CAPS_protpropertyEvents

Obtient la liste des gestionnaires d’événements associés à cette Component.(Hérité de Component.)

System_CAPS_pubpropertyFilter

Obtient ou définit la chaîne de filtrage utilisée pour déterminer les fichiers à surveiller dans un répertoire.

System_CAPS_pubpropertyIncludeSubdirectories

Obtient ou définit une valeur indiquant si les sous-répertoires du chemin d’accès spécifié doivent être surveillés.

System_CAPS_pubpropertyInternalBufferSize

Obtient ou définit la taille (en octets) de la mémoire tampon interne.

System_CAPS_pubpropertyNotifyFilter

Obtient ou définit le type de modifications à surveiller.

System_CAPS_pubpropertyPath

Obtient ou définit le chemin d’accès du répertoire à surveiller.

System_CAPS_pubpropertySite

Obtient ou définit un élément ISite pour l'élément FileSystemWatcher.(Remplace Component.Site.)

System_CAPS_pubpropertySynchronizingObject

Obtient ou définit l'objet utilisé pour rassembler les appels du gestionnaire d'événements consécutifs à un changement de répertoire.

NomDescription
System_CAPS_pubmethodBeginInit()

Lance l'initialisation d'un élément FileSystemWatcher utilisé sur un formulaire ou par un autre composant. L'initialisation se produit au moment de l'exécution.

System_CAPS_pubmethodCreateObjRef(Type)

Crée un objet qui contient toutes les informations requises pour générer un proxy permettant de communiquer avec un objet distant.(Hérité de MarshalByRefObject.)

System_CAPS_pubmethodDispose()

Libère toutes les ressources utilisées par Component.(Hérité de Component.)

System_CAPS_protmethodDispose(Boolean)

Libère les ressources non managées utilisées par FileSystemWatcher et libère éventuellement les ressources managées.(Remplace Component.Dispose(Boolean).)

System_CAPS_pubmethodEndInit()

Termine l'initialisation d'un élément FileSystemWatcher utilisé sur un formulaire ou par un autre composant. L'initialisation se produit au moment de l'exécution.

System_CAPS_pubmethodEquals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.(Hérité de Object.)

System_CAPS_protmethodFinalize()

Libère les ressources non managées et exécute d'autres opérations de nettoyage avant la récupération du Component par le garbage collection.(Hérité de Component.)

System_CAPS_pubmethodGetHashCode()

Fait office de fonction de hachage par défaut.(Hérité de Object.)

System_CAPS_pubmethodGetLifetimeService()

Récupère l’objet de service de durée de vie actuelle qui contrôle la stratégie de durée de vie de cette instance.(Hérité de MarshalByRefObject.)

System_CAPS_protmethodGetService(Type)

Retourne un objet qui représente un service fourni par Component ou par son Container.(Hérité de Component.)

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_pubmethodInitializeLifetimeService()

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.(Hérité de MarshalByRefObject.)

System_CAPS_protmethodMemberwiseClone()

Crée une copie superficielle du Object actuel.(Hérité de Object.)

System_CAPS_protmethodMemberwiseClone(Boolean)

Crée une copie superficielle d’actuel MarshalByRefObject objet.(Hérité de MarshalByRefObject.)

System_CAPS_protmethodOnChanged(FileSystemEventArgs)

Déclenche l'événement Changed.

System_CAPS_protmethodOnCreated(FileSystemEventArgs)

Déclenche l'événement Created.

System_CAPS_protmethodOnDeleted(FileSystemEventArgs)

Déclenche l'événement Deleted.

System_CAPS_protmethodOnError(ErrorEventArgs)

Déclenche l'événement Error.

System_CAPS_protmethodOnRenamed(RenamedEventArgs)

Déclenche l'événement Renamed.

System_CAPS_pubmethodToString()

Retourne un String contenant le nom de la Component, le cas échéant. Cette méthode ne doit pas être remplacée.(Hérité de Component.)

System_CAPS_pubmethodWaitForChanged(WatcherChangeTypes)

Méthode synchrone qui retourne une structure contenant des informations spécifiques sur les modifications apportées, en fonction du type de modifications à surveiller.

System_CAPS_pubmethodWaitForChanged(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).

NomDescription
System_CAPS_pubeventChanged

Se produit quand un fichier ou un répertoire du Path spécifié est modifié.

System_CAPS_pubeventCreated

Se produit quand un fichier ou un répertoire du Path spécifié est créé.

System_CAPS_pubeventDeleted

Se produit quand un fichier ou un répertoire du Path spécifié est supprimé.

System_CAPS_pubeventDisposed

Se produit lorsque le composant est supprimé par un appel à la Dispose (méthode).(Hérité de Component.)

System_CAPS_pubeventError

Se produit quand l'instance de FileSystemWatcher ne peut pas continuer à surveiller des modifications ou quand il y a un dépassement de mémoire tampon interne.

System_CAPS_pubeventRenamed

Se produit quand un fichier ou un répertoire du Path spécifié est renommé.

System_CAPS_noteRemarque

To view the .NET Framework source code for this type, see the Reference Sourcehttp://referencesource.microsoft.com/#System/services/io/system/io/FileSystemWatcher.cs#a9eb0249dc928b09. You can browse through the source code online, download the reference for offline viewing, and step through the sources (including patches and updates) during debugging; see instructionshttp://referencesource.microsoft.com/.

Use T:System.IO.FileSystemWatcher to watch for changes in a specified directory. You can watch for changes in files and subdirectories of the specified directory. You can create a component to watch files on a local computer, a network drive, or a remote computer.

To watch for changes in all files, set the P:System.IO.FileSystemWatcher.Filter property to an empty string ("") or use wildcards ("*.*"). To watch a specific file, set the P:System.IO.FileSystemWatcher.Filter property to the file name. For example, to watch for changes in the file MyDoc.txt, set the P:System.IO.FileSystemWatcher.Filter property to "MyDoc.txt". You can also watch for changes in a certain type of file. For example, to watch for changes in text files, set the P:System.IO.FileSystemWatcher.Filter property to "*.txt".

There are several types of changes you can watch for in a directory or file. For example, you can watch for changes in Attributes, the LastWrite date and time, or the Size of files or directories. This is done by setting the P:System.IO.FileSystemWatcher.NotifyFilter property to one of the T:System.IO.NotifyFilters values. For more information on the type of changes you can watch, see T:System.IO.NotifyFilters.

You can watch for renaming, deletion, or creation of files or directories. For example, to watch for renaming of text files, set the P:System.IO.FileSystemWatcher.Filter property to "*.txt" and call the M:System.IO.FileSystemWatcher.WaitForChanged(System.IO.WatcherChangeTypes) method with a F:System.IO.WatcherChangeTypes.Renamed specified for its parameter.

The Windows operating system notifies your component of file changes in a buffer created by the T:System.IO.FileSystemWatcher. If there are many changes in a short time, the buffer can overflow. This causes the component to lose track of changes in the directory, and it will only provide blanket notification. Increasing the size of the buffer with the P:System.IO.FileSystemWatcher.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. To avoid a buffer overflow, use the P:System.IO.FileSystemWatcher.NotifyFilter and P:System.IO.FileSystemWatcher.IncludeSubdirectories properties so you can filter out unwanted change notifications.

For a list of initial property values for an instance of T:System.IO.FileSystemWatcher, see the M:System.IO.FileSystemWatcher.#ctor constructor.

Please note the following when using the T:System.IO.FileSystemWatcher class.

  • Hidden files are not ignored.

  • In some systems, T:System.IO.FileSystemWatcher reports changes to files using the short 8.3 file name format. For example, a change to "LongFileName.LongExtension" could be reported as "LongFil~.Lon".

  • This class contains a link demand and an inheritance demand at the class level that applies to all members. A T:System.Security.SecurityException is thrown when either the immediate caller or the derived class does not have full-trust permission. For details about security demands, see Link Demands.

  • The maximum size you can set for the P:System.IO.FileSystemWatcher.InternalBufferSize property for monitoring a directory over the network is 64 KB.

System_CAPS_noteRemarque

Running T:System.IO.FileSystemWatcher on Windows 98 is not supported.

The operating system and T:System.IO.FileSystemWatcher object interpret a cut-and-paste action or a move action as a rename action for a folder and its contents. If you cut and paste a folder with files into a folder being watched, the T:System.IO.FileSystemWatcher object reports only the folder as new, but not its contents because they are essentially only renamed.

To be notified that the contents of folders have been moved or copied into a watched folder, provide M:System.IO.FileSystemWatcher.OnChanged(System.IO.FileSystemEventArgs) and M:System.IO.FileSystemWatcher.OnRenamed(System.IO.RenamedEventArgs) event handler methods as suggested in the following table.

Event Handler

Events Handled

Performs

OnChanged

Changed, Created, Deleted

Report changes in file attributes, created files, and deleted files.

OnRenamed

Renamed

List the old and new paths of renamed files and folders, expanding recursively if needed.

Note that several factors can affect which file system change events are raised, as described by the following:

  • Common file system operations might raise more than one event. For example, when a file is moved from one directory to another, several M:System.IO.FileSystemWatcher.OnChanged(System.IO.FileSystemEventArgs) and some M:System.IO.FileSystemWatcher.OnCreated(System.IO.FileSystemEventArgs) and M:System.IO.FileSystemWatcher.OnDeleted(System.IO.FileSystemEventArgs) events might be raised. Moving a file is a complex operation that consists of multiple simple operations, therefore raising multiple events. Likewise, some applications (for example, antivirus software) might cause additional file system events that are detected by T:System.IO.FileSystemWatcher.

  • The T:System.IO.FileSystemWatcher can watch disks as long as they are not switched or removed. The T:System.IO.FileSystemWatcher does not raise events for CDs and DVDs, because time stamps and properties cannot change. Remote computers must have one of the required platforms installed for the component to function properly.

  • If multiple T:System.IO.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. On machines running Windows XP SP1 and newer, Windows 2000 SP3 or newer or Windows Server 2003, all T:System.IO.FileSystemWatcher objects will raise the appropriate events.

Note that a T:System.IO.FileSystemWatcher may miss an event when the buffer size is exceeded. To avoid missing events, follow these guidelines:

  • Increase the buffer size by setting the P:System.IO.FileSystemWatcher.InternalBufferSize property.

  • Avoid watching files with long file names, because a long file name contributes to filling up the buffer. Consider renaming these files using shorter names.

  • Keep your event handling code as short as possible.

The following example creates a T:System.IO.FileSystemWatcher to watch the directory specified at run time. The component is set to watch for changes in LastWrite and LastAccess time, the creation, deletion, or renaming of text files in the directory. If a file is changed, created, or deleted, the path to the file prints to the console. When a file is renamed, the old and new paths print to the console.

Use the N:System.Diagnostics and N:System.IO namespaces for this example.

using System;
using System.IO;
using System.Security.Permissions;

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

SecurityPermission

for calling members of T:System.Diagnostics.ProcessStartInfo. Demand value: F:System.Security.Permissions.SecurityAction.LinkDemand; Named Permission Sets: FullTrust.

For a sample that uses the T:System.IO.FileSystemWatcher class, see Using a FileSystemWatcher Component in a Windows Formhttp://code.msdn.microsoft.com/Using-a-FileSystemWatcher-4bc97af4

SecurityPermission

for deriving from the T:System.Diagnostics.ProcessStartInfo class. Demand value: F:System.Security.Permissions.SecurityAction.InheritanceDemand; Named Permission Sets: FullTrust.

.NET Framework
Disponible depuis 1.1

Tous les membres statiques publics ( Shared en Visual Basic) de ce type sont thread-safe. Les membres d’instance n’ont pas la garantie d’être thread-safe.

Retour au début
Afficher: