FileSystemWatcher Classe

Définition

Espace de noms:

System.IO

Assembly:

System.IO.FileSystem.Watcher.dll

Source:

FileSystemWatcher.cs

É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 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 pour watch le répertoire spécifié au moment de l’exécution. Le composant est défini sur watch pour les modifications dans et LastAccess le LastWrite 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’affiche dans 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

Pour plus d’informations sur cette API, consultez Remarques supplémentaires sur l’API pour FileSystemWatcher.

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 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)
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)
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).
WaitForChanged(WatcherChangeTypes, TimeSpan)	Retourne de manière synchrone une structure qui contient des informations spécifiques sur la modification qui s’est produite, en fonction du type de modification à surveiller.

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

Voir aussi

• NotifyFilter
• NotifyFilters
• FileSystemEventArgs
• FileSystemEventHandler
• Filter
• IncludeSubdirectories
• InternalBufferOverflowException
• RenamedEventArgs
• RenamedEventHandler
• WaitForChangedResult
• WatcherChangeTypes
• Utilisation d’un composant FileSystemWatcher dans un Windows Form