FileSystemWatcher Classe

Définition

É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é.

public ref class FileSystemWatcher : System::ComponentModel::Component, System::ComponentModel::ISupportInitialize
public ref class FileSystemWatcher : IDisposable
public ref class FileSystemWatcher : System::ComponentModel::Component, IDisposable, System::ComponentModel::ISupportInitialize
public class FileSystemWatcher : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize
public class FileSystemWatcher : IDisposable
[System.IO.IODescription("FileSystemWatcherDesc")]
public class FileSystemWatcher : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize
public class FileSystemWatcher : System.ComponentModel.Component, IDisposable, System.ComponentModel.ISupportInitialize
[System.IO.IODescription("")]
public class FileSystemWatcher : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize
type FileSystemWatcher = class
    inherit Component
    interface ISupportInitialize
type FileSystemWatcher = class
    interface IDisposable
[<System.IO.IODescription("FileSystemWatcherDesc")>]
type FileSystemWatcher = class
    inherit Component
    interface ISupportInitialize
type FileSystemWatcher = class
    inherit Component
    interface IDisposable
    interface ISupportInitialize
[<System.IO.IODescription("")>]
type FileSystemWatcher = class
    inherit Component
    interface ISupportInitialize
Public Class FileSystemWatcher
Inherits Component
Implements ISupportInitialize
Public Class FileSystemWatcher
Implements IDisposable
Public Class FileSystemWatcher
Inherits Component
Implements IDisposable, ISupportInitialize
Héritage
FileSystemWatcher
Héritage
FileSystemWatcher
Attributs
Implémente

Exemples

L’exemple suivant crée un FileSystemWatcher pour surveiller le répertoire spécifié au moment de l’exécution. Le composant est défini pour surveiller les modifications apportées à LastWrite et à LastAccess l’heure, la création, la suppression ou le changement de nom des fichiers texte dans le répertoire. Si un fichier est modifié, créé ou supprimé, le chemin d’accès au fichier s’imprime sur la console. Lorsqu’un fichier est renommé, l’ancien et le nouveau chemin d’accès s’impriment sur la console.

#include "pch.h"

using namespace System;
using namespace System::IO;

class MyClassCPP
{
public:

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

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

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

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

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

        return 0;
    }

private:

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

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

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

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

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

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


int main()
{
    MyClassCPP::Run();
}
using System;
using System.IO;

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

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

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

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

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

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

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

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

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

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

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

Namespace MyNamespace

    Class MyClassVB

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

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

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

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

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

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

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

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

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

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

    End Class

End Namespace

Remarques

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

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

Il existe plusieurs types de modifications que vous pouvez surveiller dans un répertoire ou un fichier. Par exemple, vous pouvez surveiller les modifications dans Attributes , la LastWrite date et l’heure, ou la Size de fichiers ou de répertoires. Pour ce faire, affectez NotifyFilter à la propriété 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 l’attribution d’un nouveau nom aux fichiers texte, affectez la valeur Filter « * .txt » à la propriété et appelez la WaitForChanged méthode avec un Renamed spécifié pour son paramètre.

le système d’exploitation Windows avertit votre composant des modifications apportées aux fichiers dans une mémoire tampon créée par le FileSystemWatcher . S’il y a de nombreuses modifications dans une brève période, la mémoire tampon peut provoquer un dépassement de capacité. En conséquence, le composant perd le suivi des modifications dans l’annuaire, et il fournit uniquement une notification permanente. L’extension de la taille de la mémoire tampon avec la InternalBufferSize propriété est coûteuse, étant donné qu’elle provient d’une mémoire non paginée qui ne peut pas être permutée sur le disque, laissez la mémoire tampon aussi petite, mais suffisamment grande pour ne pas manquer d’événements de modification de fichier. Pour éviter un dépassement de mémoire tampon, utilisez les NotifyFilter IncludeSubdirectories Propriétés et afin de filtrer les notifications de modifications indésirables.

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

Notez les points 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 à l’aide du format de nom de fichier short 8,3. Par exemple, une modification de « LongFileName. LongExtension » peut être signalée comme «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. Une SecurityException exception est levée lorsque l’appelant immédiat ou la classe dérivée ne dispose pas d’une autorisation de confiance totale. Pour plus d’informations sur les demandes de sécurité, consultez demandes de liaison.

  • La taille maximale que vous pouvez définir pour la InternalBufferSize propriété pour la surveillance d’un répertoire sur le réseau est de 64 Ko.

Copie et déplacement de dossiers

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

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

Gestionnaire d'événements Événements gérés Performances
OnChanged Changed, Created, Deleted 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 aux fichiers et dossiers renommés, en développant de manière récursive, si nécessaire.

Tailles des événements et des mémoires tampons

Notez que plusieurs facteurs peuvent affecter les événements de modification du système de fichiers qui sont déclenchés, comme décrit dans les rubriques suivantes :

  • 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 OnChanged OnCreated événements et OnDeleted peuvent être déclenchés. Le déplacement d’un fichier est une opération complexe qui se compose de plusieurs opérations simples, déclenchant ainsi plusieurs événements. De même, certaines applications (par exemple, un logiciel antivirus) peuvent provoquer des événements de système de fichiers supplémentaires qui sont détectés par FileSystemWatcher .

  • Le FileSystemWatcher peut surveiller des disques tant qu’ils ne sont pas basculés ou supprimés. Le FileSystemWatcher ne déclenche pas d’événements pour les CD et les DVD, car les horodatages et les propriétés ne peuvent pas être modifiés. L’une des plateformes requises doit être installée sur les ordinateurs distants pour que le composant fonctionne correctement.

Notez qu’un FileSystemWatcher événement peut manquer quand 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 en utilisant des noms plus courts.

  • Conservez votre code de gestion des événements aussi rapidement que possible.

Constructeurs

FileSystemWatcher()

Initialise une nouvelle instance de la classe FileSystemWatcher.

FileSystemWatcher(String)

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

FileSystemWatcher(String, String)

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

Propriétés

CanRaiseEvents

Obtient une valeur qui indique si le composant peut déclencher un événement.

(Hérité de Component)
Container

Obtient le IContainer qui contient la Component.

(Hérité de Component)
DesignMode

Obtient une valeur qui indique si Component est actuellement en mode design.

(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 attachés à ce Component.

(Hérité de Component)
Filter

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

Filters

Obtient ou la collection de tous les filtres utilisés pour déterminer les fichiers à surveiller dans un répertoire.

IncludeSubdirectories

Obtient ou définit une valeur indiquant si les sous-répertoires du chemin d’accès 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 élément ISite pour l'élément FileSystemWatcher.

SynchronizingObject

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

Méthodes

BeginInit()

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.

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.

(Hérité de MarshalByRefObject)
Dispose()

Libère toutes les ressources non managées utilisées par FileSystemWatcher.

Dispose()

Libère toutes les ressources utilisées par Component.

(Hérité de Component)
Dispose(Boolean)

Libère les ressources non managées utilisées par FileSystemWatcher et libère éventuellement les ressources managées.

EndInit()

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.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
Finalize()

Libère les ressources détenues par l’instance actuelle.

GetHashCode()

Fait office 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 en cours 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 Component ou par son Container.

(Hérité de Component)
GetType()

Obtient le 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 Object actuel.

(Hérité de Object)
MemberwiseClone(Boolean)

Crée une copie superficielle de l'objet MarshalByRefObject actuel.

(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 contenant le nom du Component, s’il en existe un. Cette méthode ne doit pas être remplacée.

(Hérité de Component)
ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)
WaitForChanged(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.

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

Événements

Changed

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

Created

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

Deleted

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

Disposed

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

(Hérité de Component)
Error

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.

Renamed

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

S’applique à

Voir aussi