FileSystemWatcher Classe

Définition

Espace de noms:

System.IO

Assemblys:

netstandard.dll, System.IO.FileSystem.Watcher.dll

Source:

FileSystemWatcher.cs

Écoute les notifications de modification du système de fichiers et déclenche des événements lorsqu’un répertoire ou un fichier dans un répertoire change.

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

Héritage

Object

MarshalByRefObject

Component

FileSystemWatcher

Implémente

ISupportInitialize

Exemples

L’exemple suivant crée un FileSystemWatcher répertoire pour regarder le répertoire spécifié au moment de l’exécution. Le composant est défini pour surveiller les modifications dans LastWrite le LastAccess temps, la création, la suppression ou le renommage des fichiers texte dans le répertoire. Si un fichier est modifié, créé ou supprimé, le chemin d’accès au fichier s’imprime dans la console. Lorsqu’un fichier est renommé, les anciens chemins d’accès s’impriment dans la console.

using System;
using System.IO;

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

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

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

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

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

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

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

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

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

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

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

Imports System.IO

Namespace MyNamespace

    Class MyClassVB

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

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

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

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

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

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

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

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

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

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

    End Class

End Namespace

Remarques

Permet FileSystemWatcher de surveiller les modifications dans un répertoire spécifié. Vous pouvez surveiller les modifications apportées aux fichiers et sous-répertoires du répertoire spécifié. Vous pouvez créer un composant pour surveiller les fichiers sur un ordinateur local, un lecteur réseau ou un ordinateur distant.

Pour surveiller les modifications apportées à tous les fichiers, définissez la Filter propriété sur une chaîne vide ("") ou utilisez des caractères génériques ("*.*"). Pour surveiller un fichier spécifique, définissez la Filter propriété sur le nom du fichier. Par exemple, pour surveiller les modifications apportées au fichier MyDoc.txt, définissez la Filter propriété "MyDoc.txt"sur . Vous pouvez également surveiller les modifications apportées à un certain type de fichier. Par exemple, pour surveiller les modifications apportées aux fichiers texte, définissez la Filter propriété "*.txt"sur .

Il existe plusieurs types de modifications que vous pouvez observer dans un répertoire ou un fichier. Par exemple, vous pouvez surveiller les modifications de Attributes, la date et l’heure LastWrite, ou les éléments Size des fichiers ou répertoires. Pour ce faire, définissez la NotifyFilter propriété sur l’une des NotifyFilters valeurs. Pour plus d’informations sur le type de modifications que vous pouvez observer, consultez NotifyFilters.

Vous pouvez surveiller le changement de nom, la suppression ou la création de fichiers ou de répertoires. Par exemple, pour surveiller le changement de nom des fichiers texte, définissez la Filter propriété sur « *.txt» et appelez la WaitForChanged méthode avec un Renamed paramètre spécifié.

Le système d’exploitation Windows avertit votre composant des modifications de fichier dans une mémoire tampon créée par le FileSystemWatcher. S’il existe de nombreuses modifications dans un court délai, la mémoire tampon peut déborder. Cela entraîne la perte du suivi des modifications dans le répertoire et ne fournit qu’une notification globale. Augmenter la taille du tampon avec la propriété InternalBufferSize est coûteux, car elle provient de la mémoire non paginée qui ne peut pas être échangée sur le disque. Gardez donc le tampon suffisamment petit mais assez grand pour ne pas manquer d’événements de modification de fichier. Pour éviter un dépassement de mémoire tampon, utilisez les propriétés NotifyFilter et IncludeSubdirectories afin de filtrer les notifications de modification indésirables.

Pour obtenir la liste des valeurs de propriété initiales d’une instance de FileSystemWatcher, consultez le FileSystemWatcher constructeur.

Tenez compte des faits suivants lorsque vous utilisez la FileSystemWatcher classe :

• Les fichiers masqués ne sont pas ignorés.
• Dans certains systèmes, FileSystemWatcher signale les modifications apportées aux fichiers en utilisant le format court 8.3 pour les noms de fichiers. Par exemple, une modification de « LongFileName.LongExtension » peut être signalée comme « LongFil~. Lon".
• La taille maximale que vous pouvez définir pour la propriété pour surveiller InternalBufferSize un répertoire sur le réseau est de 64 Ko.

Copier et déplacer des dossiers

Le système d’exploitation et l'objet FileSystemWatcher interprètent une action couper-coller ou une action de déplacement en tant qu’action de renommage pour un dossier et son contenu. Si vous coupez et collez un dossier contenant des fichiers dans un dossier surveillé, l’objet FileSystemWatcher signale uniquement le dossier comme nouveau, mais pas son contenu, car ils sont essentiellement renommés uniquement.

Pour être averti que le contenu des dossiers a été déplacé ou copié dans un dossier surveillé, fournissez les méthodes de gestionnaire d’événements OnChanged et OnRenamed comme suggéré dans le tableau suivant.

Gestionnaire d'événements	Événements gérés	Exécute
OnChanged	Changed, , CreatedDeleted	Signaler les modifications apportées aux attributs de fichier, aux fichiers créés et aux fichiers supprimés.
OnRenamed	Renamed	Répertoriez les anciens et nouveaux chemins d’accès des fichiers et dossiers renommés, en développant de manière récursive si nécessaire.

Événements et tailles des mémoires tampons

Notez que plusieurs facteurs peuvent affecter les événements de modification du système de fichiers déclenchés, comme décrit par les éléments suivants :

• Les opérations courantes du système de fichiers peuvent déclencher plusieurs événements. Par exemple, lorsqu’un fichier est déplacé d’un répertoire à un autre, plusieurs événements OnChanged et certains événements OnCreated et OnDeleted peuvent être générés. Le déplacement d’un fichier est une opération complexe qui se compose de plusieurs opérations simples, ce qui déclenche plusieurs événements. De même, certaines applications (par exemple, les logiciels antivirus) peuvent entraîner des événements de système de fichiers supplémentaires détectés par FileSystemWatcher.
• Le FileSystemWatcher peut surveiller les disques tant qu’ils ne sont pas basculés ou supprimés. Le FileSystemWatcher n’organise pas d’événements pour les CD et les DVD, parce que les horodatages et les propriétés ne peuvent pas changer. Les ordinateurs distants doivent disposer de l’une des plateformes requises installées pour que le composant fonctionne correctement.

Notez qu’un FileSystemWatcher peut manquer un événement lorsque la taille de la mémoire tampon est dépassée. Pour éviter les événements manquants, suivez ces instructions :

• Augmentez la taille de la mémoire tampon en définissant la InternalBufferSize propriété.
• Évitez de surveiller les fichiers avec des noms de fichiers longs, car un nom de fichier long contribue à remplir la mémoire tampon. Envisagez de renommer ces fichiers à l’aide de noms plus courts.
• Conservez votre code de gestion des événements aussi court que possible.

Constructeurs

Nom	Description
FileSystemWatcher()	Initialise une nouvelle instance de la classe FileSystemWatcher.
FileSystemWatcher(String, String)	Initialise une nouvelle instance de la FileSystemWatcher classe, en fonction du répertoire et du type de fichiers spécifiés à surveiller.
FileSystemWatcher(String)	Initialise une nouvelle instance de la FileSystemWatcher classe, en fonction du répertoire spécifié à surveiller.

Propriétés

Nom	Description
CanRaiseEvents	Obtient une valeur indiquant si le composant peut déclencher un événement. (Hérité de Component)
Container	Obtient le IContainer fichier qui contient le Component. (Hérité de Component)
DesignMode	Obtient une valeur qui indique si la Component valeur est actuellement en mode création. (Hérité de Component)
EnableRaisingEvents	Obtient ou définit une valeur indiquant si le composant est activé.
Events	Obtient la liste des gestionnaires d’événements qui sont attachés à ce Component. (Hérité de Component)
Filter	Obtient ou définit la chaîne de filtre utilisée pour déterminer les fichiers surveillés dans un répertoire.
Filters	Obtient la collection de tous les filtres utilisés pour déterminer les fichiers analysés dans un répertoire.
IncludeSubdirectories	Obtient ou définit une valeur indiquant si les sous-répertoires dans le chemin spécifié doivent être surveillés.
InternalBufferSize	Obtient ou définit la taille (en octets) de la mémoire tampon interne.
NotifyFilter	Obtient ou définit le type de modifications à surveiller.
Path	Obtient ou définit le chemin d’accès du répertoire à surveiller.
Site	Obtient ou définit un ISite pour le FileSystemWatcher.
SynchronizingObject	Obtient ou définit l’objet utilisé pour marshaler les appels du gestionnaire d’événements émis suite à une modification d’annuaire.

Méthodes

Nom	Description
BeginInit()	Commence l’initialisation d’un FileSystemWatcher formulaire ou utilisé par un autre composant. L’initialisation se produit au moment de l’exécution.
Dispose()	Libère toutes les ressources utilisées par le Component. (Hérité de Component)
Dispose(Boolean)	Libère les ressources non managées utilisées par les FileSystemWatcher ressources gérées et libère éventuellement les ressources managées.
EndInit()	Termine l’initialisation d’un FileSystemWatcher formulaire ou utilisé par un autre composant. L’initialisation se produit au moment de l’exécution.
Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
GetHashCode()	Sert de fonction de hachage par défaut. (Hérité de Object)
GetLifetimeService()	Obsolète. Récupère l’objet de service de durée de vie actuel qui contrôle la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
GetService(Type)	Retourne un objet qui représente un service fourni par le Component ou par son Container. (Hérité de Component)
GetType()	Obtient la Type de l’instance actuelle. (Hérité de Object)
InitializeLifetimeService()	Obsolète. 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)
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
MemberwiseClone(Boolean)	Crée une copie superficielle de l’objet actuel MarshalByRefObject . (Hérité de MarshalByRefObject)
OnChanged(FileSystemEventArgs)	Déclenche l’événement Changed.
OnCreated(FileSystemEventArgs)	Déclenche l’événement Created.
OnDeleted(FileSystemEventArgs)	Déclenche l’événement Deleted.
OnError(ErrorEventArgs)	Déclenche l’événement Error.
OnRenamed(RenamedEventArgs)	Déclenche l’événement Renamed.
ToString()	Retourne un String nom contenant le nom du Component, le cas échéant. Cette méthode ne doit pas être remplacée. (Hérité de Component)
WaitForChanged(WatcherChangeTypes, Int32)	Méthode synchrone qui retourne une structure qui contient des informations spécifiques sur la modification qui s’est produite, en fonction du type de modification que vous souhaitez surveiller et de l’heure (en millisecondes) à attendre avant l’expiration du délai d’attente.
WaitForChanged(WatcherChangeTypes, TimeSpan)	Retourne de façon synchrone une structure qui contient des informations spécifiques sur la modification qui s’est produite, en fonction du type de modification à surveiller.
WaitForChanged(WatcherChangeTypes)	Méthode synchrone qui retourne une structure qui contient des informations spécifiques sur la modification qui s’est produite, en fonction du type de modification que vous souhaitez surveiller.

Événements

Nom	Description
Changed	Se produit lorsqu’un fichier ou un répertoire dans le fichier spécifié Path est modifié.
Created	Se produit lorsqu’un fichier ou un répertoire dans le fichier spécifié Path est créé.
Deleted	Se produit lorsqu’un fichier ou un répertoire dans le fichier spécifié Path est supprimé.
Disposed	Se produit lorsque le composant est supprimé par un appel à la Dispose() méthode. (Hérité de Component)
Error	Se produit lorsque l’instance de n’est pas en mesure de FileSystemWatcher continuer à surveiller les modifications ou lorsque la mémoire tampon interne dépasse.
Renamed	Se produit lorsqu’un fichier ou un répertoire dans le fichier spécifié Path est renommé.

Voir aussi

• NotifyFilter
• NotifyFilters
• FileSystemEventArgs
• FileSystemEventHandler
• Filter
• IncludeSubdirectories
• InternalBufferOverflowException
• RenamedEventArgs
• RenamedEventHandler
• WaitForChangedResult
• WatcherChangeTypes
• Utilisant un composant FileSystemWatcher dans un formulaire Windows