FileSystemWatcher Klasse

Definition

Überwacht die Benachrichtigungen über Änderungen im Dateisystem und löst Ereignisse aus, wenn ein Verzeichnis oder eine Datei in einem Verzeichnis geändert werden.

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
Vererbung
FileSystemWatcher
Vererbung
FileSystemWatcher
Attribute
Implementiert

Beispiele

Im folgenden Beispiel wird ein FileSystemWatcher Verzeichnis erstellt, das zur Laufzeit angegeben ist. Die Komponente wird auf Änderungen und LastWrite LastAccess Zeit, die Erstellung, das Löschen oder Umbenennen von Textdateien im Verzeichnis festgelegt. Wenn eine Datei geändert, erstellt oder gelöscht wird, wird der Pfad zur Datei gedruckt. Wenn eine Datei umbenannt wird, werden die alten und neuen Pfade in die Konsole gedruckt.

#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

Hinweise

Verwenden Sie FileSystemWatcher die Verwendung, um Änderungen in einem angegebenen Verzeichnis zu überwachen. Sie können auf Änderungen in Dateien und Unterverzeichnissen des angegebenen Verzeichnisses achten. Sie können eine Komponente erstellen, um Dateien auf einem lokalen Computer, einem Netzwerklaufwerk oder einem Remotecomputer zu überwachen.

Wenn Sie auf Änderungen in allen Dateien achten möchten, legen Sie die Filter Eigenschaft auf eine leere Zeichenfolge ("") fest, oder verwenden Sie Wildcards ("*.*"). Um eine bestimmte Datei zu beobachten, legen Sie die Filter Eigenschaft auf den Dateinamen fest. Wenn Sie beispielsweise auf Änderungen in der Datei MyDoc.txt achten möchten, legen Sie die Filter Eigenschaft auf "MyDoc.txt" fest. Sie können auch auf Änderungen in einem bestimmten Dateityp achten. Wenn Sie beispielsweise auf Änderungen in Textdateien achten möchten, legen Sie die Filter Eigenschaft auf "*.txt" fest.

Es gibt mehrere Arten von Änderungen, die Sie in einem Verzeichnis oder einer Datei ansehen können. Sie können z. B. nach Änderungen in Attributes, dem Datum und der LastWrite Size Uhrzeit oder den Dateien oder Verzeichnissen beobachten. Dies erfolgt durch Festlegen der NotifyFilter Eigenschaft auf einen der NotifyFilters Werte. Weitere Informationen zu der Art der Änderungen, die Sie sehen können, finden Sie unter NotifyFilters.

Sie können auf das Umbenennen, Löschen oder Erstellen von Dateien oder Verzeichnissen achten. Wenn Sie beispielsweise nach dem Umbenennen von Textdateien suchen möchten, legen Sie die Filter Eigenschaft auf "*.txt" fest, und rufen Sie die WaitForChanged Methode mit einem Renamed angegebenen Parameter auf.

Das Windows Betriebssystem benachrichtigt Ihre Komponente von Dateiänderungen in einem von der FileSystemWatcher. Wenn es in kurzer Zeit viele Änderungen gibt, kann der Puffer überlaufen. Dies führt dazu, dass die Komponente die Nachverfolgung von Änderungen im Verzeichnis verliert und nur eine Benachrichtigung über die Gesamtbenachrichtigung bereitstellt. Die Erhöhung der Größe des Puffers mit der InternalBufferSize Eigenschaft ist teuer, da es aus nicht seitenseitigem Arbeitsspeicher stammt, der nicht auf datenträgerseitigen Speicher getauscht werden kann, sodass der Puffer noch klein genug ist, um keine Dateiänderungsereignisse zu verpassen. Verwenden Sie die NotifyFilter Eigenschaften und IncludeSubdirectories Eigenschaften, um einen Pufferüberlauf zu vermeiden, sodass Sie unerwünschte Änderungsbenachrichtigungen filtern können.

Eine Liste der anfänglichen Eigenschaftenwerte für eine Instanz von FileSystemWatcher, finden Sie im FileSystemWatcher Konstruktor.

Bitte beachten Sie folgendes, wenn Sie die FileSystemWatcher Klasse verwenden.

  • Ausgeblendete Dateien werden nicht ignoriert.

  • In einigen Systemen FileSystemWatcher werden Änderungen an Dateien mit dem kurzen Dateinamenformat 8.3 gemeldet. Beispielsweise könnte eine Änderung in "LongFileName.LongExtension" als "LongFil~" gemeldet werden. Lon".

  • Diese Klasse enthält eine Linkanforderungen und eine Vererbungsanforderungen auf Klassenebene, die für alle Mitglieder gelten. Eine SecurityException wird ausgelöst, wenn entweder der sofortige Anrufer oder die abgeleitete Klasse keine voll vertrauenswürdige Berechtigung hat. Ausführliche Informationen zu Sicherheitsanforderungen finden Sie unter Linkanforderungen.

  • Die maximale Größe, die Sie für die Eigenschaft für die InternalBufferSize Überwachung eines Verzeichnisses über das Netzwerk festlegen können, beträgt 64 KB.

Kopieren und Verschieben von Ordnern

Das Betriebssystem und das Objekt interpretieren eine Ausschneiden- und Einfügen-Aktion oder eine Verschiebenaktion als Umbenennungsaktion für einen Ordner und FileSystemWatcher dessen Inhalt. Wenn Sie einen Ordner mit Dateien in einen überwachten Ordner ausschneiden und einfügen, meldet das FileSystemWatcher Objekt nur den Ordner als neu, aber nicht dessen Inhalt, da sie im Wesentlichen nur umbenannt werden.

Um benachrichtigt zu werden, dass der Inhalt von Ordnern verschoben oder in einen überwachten Ordner kopiert wurde, stellen OnChanged Und OnRenamed Ereignishandlermethoden bereit, wie in der folgenden Tabelle vorgeschlagen.

Ereignishandler Behandelte Ereignisse Leistung
OnChanged Changed, Created, Deleted Melden Sie Änderungen an Dateiattributen, erstellten Dateien und gelöschten Dateien.
OnRenamed Renamed Listen Sie die alten und neuen Pfade der umbenannten Dateien und Ordner auf, die bei Bedarf rekursiv erweitert werden.

Ereignisse und Puffergrößen

Beachten Sie, dass mehrere Faktoren sich auf die Auslösen von Änderungsereignissen des Dateisystems auswirken können, wie im Folgenden beschrieben:

  • Allgemeine Dateisystemvorgänge können mehrere Ereignisse auslösen. Wenn eine Datei beispielsweise von einem Verzeichnis in ein anderes verschoben wird, werden möglicherweise mehrere OnChanged und OnDeleted einige OnCreated Ereignisse ausgelöst. Das Verschieben einer Datei ist ein komplexer Vorgang, der aus mehreren einfachen Vorgängen besteht und daher mehrere Ereignisse auslöst. Ebenso können einige Anwendungen (z. B. Antivirensoftware) zusätzliche Dateisystemereignisse verursachen, die durch FileSystemWatchererkannt werden.

  • Die FileSystemWatcher Datenträger können überwacht werden, solange sie nicht gewechselt oder entfernt werden. Die FileSystemWatcher Ereignisse für CDs und DVDs werden nicht erhöht, da Zeitstempel und Eigenschaften nicht geändert werden können. Remotecomputer müssen über eine der erforderlichen Plattformen verfügen, die für die Komponente installiert sind, um ordnungsgemäß zu funktionieren.

Beachten Sie, dass ein FileSystemWatcher Ereignis möglicherweise verpasst wird, wenn die Puffergröße überschritten wird. Um fehlende Ereignisse zu vermeiden, folgen Sie den folgenden Richtlinien:

  • Erhöhen Sie die Puffergröße, indem Sie die InternalBufferSize Eigenschaft festlegen.

  • Vermeiden Sie die Überwachung von Dateien mit langen Dateinamen, da ein langer Dateinamen dazu beiträgt, den Puffer zu füllen. Überlegen Sie, diese Dateien mit kürzeren Namen umzubenennen.

  • Halten Sie ihren Ereignisbehandlungscode so kurz wie möglich.

Konstruktoren

FileSystemWatcher()

Initialisiert eine neue Instanz der FileSystemWatcher-Klasse.

FileSystemWatcher(String)

Initialisiert eine neue Instanz der FileSystemWatcher-Klasse mit dem für die Überwachung angegebenen Verzeichnis.

FileSystemWatcher(String, String)

Initialisiert eine neue Instanz der FileSystemWatcher-Klasse mit dem für die Überwachung angegebenen Verzeichnis und Dateityp.

Eigenschaften

CanRaiseEvents

Ruft einen Wert ab, der angibt, ob die Komponente ein Ereignis auslösen kann.

(Geerbt von Component)
Container

Ruft die IContainer ab, die in der Component enthalten ist.

(Geerbt von Component)
DesignMode

Ruft einen Wert ab, der angibt, ob sich Component gegenwärtig im Entwurfsmodus befindet.

(Geerbt von Component)
EnableRaisingEvents

Ruft einen Wert ab, der angibt, ob die Komponente aktiviert ist, oder legt diesen fest.

Events

Ruft die Liste der Ereignishandler ab, die dieser Component angefügt sind.

(Geerbt von Component)
Filter

Ruft die Filterzeichenfolge ab, mit der die in einem Verzeichnis zu überwachenden Dateien bestimmt werden, oder legt die Filterzeichenfolge fest.

Filters

Ruft die Auflistung aller Filter ab, mit denen bestimmt wird, welche Dateien in einem Verzeichnis überwacht werden.

IncludeSubdirectories

Ruft einen Wert ab, der angibt, ob die Unterverzeichnisse im angegebenen Pfad überwacht werden sollen, oder legt diesen fest.

InternalBufferSize

Ruft die Größe (in Byte) des internen Puffers ab oder legt diese fest.

NotifyFilter

Ruft den Typ der zu überwachenden Änderungen ab oder legt diesen fest.

Path

Ruft den Pfad des zu überwachenden Verzeichnisses ab oder legt diesen fest.

Site

Ruft eine ISite für den FileSystemWatcher ab oder legt diese fest.

SynchronizingObject

Ruft das Objekt ab, das zum Marshallen von Ereignishandleraufrufen verwendet wird, die aufgrund einer Verzeichnisänderung ausgegeben werden, oder legt dieses fest.

Methoden

BeginInit()

Beginnt die Initialisierung von FileSystemWatcher für die Verwendung in einem Formular oder durch eine andere Komponente. Die Initialisierung erfolgt zur Laufzeit.

CreateObjRef(Type)

Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind.

(Geerbt von MarshalByRefObject)
Dispose()

Gibt die nicht verwalteten Ressourcen frei, die von FileSystemWatcher verwendet werden.

Dispose()

Gibt alle vom Component verwendeten Ressourcen frei.

(Geerbt von Component)
Dispose(Boolean)

Gibt die von FileSystemWatcher verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.

EndInit()

Beendet die Initialisierung von FileSystemWatcher für die Verwendung in einem Formular oder durch eine andere Komponente. Die Initialisierung erfolgt zur Laufzeit.

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
Finalize()

Gibt die von der aktuellen Instanz reservierten Ressourcen frei.

GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetLifetimeService()
Veraltet.

Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert.

(Geerbt von MarshalByRefObject)
GetService(Type)

Gibt ein Objekt zurück, das einen von der Component oder von deren Container bereitgestellten Dienst darstellt.

(Geerbt von Component)
GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
InitializeLifetimeService()
Veraltet.

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab.

(Geerbt von MarshalByRefObject)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
MemberwiseClone(Boolean)

Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts.

(Geerbt von MarshalByRefObject)
OnChanged(FileSystemEventArgs)

Löst das Changed-Ereignis aus.

OnCreated(FileSystemEventArgs)

Löst das Created-Ereignis aus.

OnDeleted(FileSystemEventArgs)

Löst das Deleted-Ereignis aus.

OnError(ErrorEventArgs)

Löst das Error-Ereignis aus.

OnRenamed(RenamedEventArgs)

Löst das Renamed-Ereignis aus.

ToString()

Gibt einen String zurück, der den Namen der Component enthält (sofern vorhanden). Diese Methode darf nicht überschrieben werden.

(Geerbt von Component)
ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)
WaitForChanged(WatcherChangeTypes)

Eine synchrone Methode, die eine Struktur mit spezifischen Informationen zur eingetretenen Änderung zurückgibt, sofern diese mit der Art der Änderung übereinstimmt, die überwacht werden soll.

WaitForChanged(WatcherChangeTypes, Int32)

Eine synchrone Methode, die eine Struktur mit spezifischen Informationen zur eingetretenen Änderung zurückgibt, sofern diese mit der Art der zu überwachenden Änderung übereinstimmt und die Zeit (in Millisekunden) bis zum Timeout nicht abgelaufen ist.

WaitForChanged(WatcherChangeTypes, TimeSpan)

Ereignisse

Changed

Tritt ein, wenn im angegebenen Path eine Datei oder ein Verzeichnis geändert wird.

Created

Tritt ein, wenn im angegebenen Path eine Datei oder ein Verzeichnis erstellt wird.

Deleted

Tritt ein, wenn im angegebenen Path eine Datei oder ein Verzeichnis gelöscht wird.

Disposed

Tritt auf, wenn die Komponente von einem Aufruf der Dispose()-Methode verworfen wird.

(Geerbt von Component)
Error

Tritt ein, wenn die Instanz von FileSystemWatcher das Überwachen von Änderungen nicht fortzusetzen kann oder wenn der interne Puffer überläuft.

Renamed

Tritt ein, wenn im angegebenen Path eine Datei oder ein Verzeichnis umbenannt wird.

Gilt für:

Siehe auch