FileSystemWatcher Klasse

Referenz

Definition

Namespace:: System.IO

Assembly:: System.IO.FileSystem.Watcher.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Ü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: Object

MarshalByRefObject

Component
FileSystemWatcher

Vererbung: Object
FileSystemWatcher

Attribute: IODescriptionAttribute

Implementiert: ISupportInitialize IDisposable

Beispiele

Im folgenden Beispiel wird ein FileSystemWatcher Verzeichnis erstellt, das zur Laufzeit angegeben ist. Die Komponente wird auf Änderungen LastWrite und LastAccess Uhrzeit, erstellung, Löschung oder Umbenennen von Textdateien im Verzeichnis festgelegt. Wenn eine Datei geändert, erstellt oder gelöscht wird, wird der Pfad zur Datei in der Konsole gedruckt. Wenn eine Datei umbenannt wird, werden die alten und neuen Pfade in der 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 die Verwendung FileSystemWatcher , 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.

Um nach Änderungen in allen Dateien zu suchen, legen Sie die Filter Eigenschaft auf eine leere Zeichenfolge ("") fest, oder verwenden Sie Wildcards ("*.*"). Um eine bestimmte Datei zu überwachen, legen Sie die Filter Eigenschaft auf den Dateinamen fest. Wenn Sie z. B. nach Änderungen in der Datei MyDoc.txt suchen 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 nach Änderungen in Textdateien suchen 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, Datum LastWrite und Uhrzeit oder Size dateien oder Verzeichnissen überwachen. Dies erfolgt durch Festlegen der NotifyFilter Eigenschaft auf einen der NotifyFilters Werte. Weitere Informationen zum Typ von Änderungen, die Sie überwachen können, finden Sie unter NotifyFilters.

Sie können auf das Umbenennen, Löschen oder Erstellen von Dateien oder Verzeichnissen achten. Wenn Sie beispielsweise auf das Umbenennen von Textdateien achten 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 puffer erstellten Puffer FileSystemWatcher. Wenn es in kurzer Zeit viele Änderungen gibt, kann der Puffer überlaufen. Dies bewirkt, dass die Komponente die Nachverfolgung von Änderungen im Verzeichnis verliert, und sie stellt nur eine deckende Benachrichtigung bereit. Das Erhöhen der Größe des Puffers mit der InternalBufferSize Eigenschaft ist teuer, da sie aus nicht seitenseitigem Arbeitsspeicher stammt, der nicht auf dem Datenträger ausgetauscht werden kann, sodass der Puffer so klein wie groß genug ist, um keine Dateiänderungsereignisse zu verpassen. Um einen Pufferüberlauf zu vermeiden, verwenden Sie die und IncludeSubdirectories die NotifyFilter Eigenschaften, damit Sie unerwünschte Änderungsbenachrichtigungen herausfiltern können.

Eine Liste der anfänglichen Eigenschaftswerte 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 mithilfe des kurzen 8.3-Dateinamenformats gemeldet. Beispielsweise könnte eine Änderung in "LongFileName.LongExtension" als "LongFil~" gemeldet werden. Lon".
Diese Klasse enthält eine Linknachfrage und eine Vererbungsnachfrage auf Klassenebene, die für alle Mitglieder gilt. Ein Wird SecurityException ausgelöst, wenn entweder der sofortige Aufrufer 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 Aus- und FileSystemWatcher Einfügeaktion oder eine Verschiebungsaktion als Umbenennungsaktion für einen Ordner und dessen Inhalt. Wenn Sie einen Ordner mit Dateien ausschneiden und in einen überwachten Ordner einfügen, meldet das FileSystemWatcher Objekt nur den Ordner als neu, aber nicht seinen Inhalt, da er im Wesentlichen nur umbenannt wird.

Um benachrichtigt zu werden, dass der Inhalt von Ordnern verschoben oder in einen überwachten Ordner kopiert wurde, stellen Sie OnChanged methoden bereit, und OnRenamed Ereignishandlermethoden 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	Listet die alten und neuen Pfade von umbenannten Dateien und Ordnern auf, die bei Bedarf rekursiv erweitert werden.

Ereignisse und Puffergrößen

Beachten Sie, dass mehrere Faktoren beeinflussen können, welche Dateisystemänderungsereignisse ausgelöst werden, wie in den folgenden Beschreibungen 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 von FileSystemWatcher.
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 auslösen, da Zeitstempel und Eigenschaften nicht geändert werden können. Remotecomputer müssen über eine der erforderlichen Plattformen verfügen, damit die Komponente ordnungsgemäß funktioniert.

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

Erhöhen Sie die Puffergröße, indem Sie die InternalBufferSize Eigenschaft festlegen.
Vermeiden Sie das Überwachen von Dateien mit langen Dateinamen, da ein langer Dateiname zum Ausfüllen des Puffers beiträgt. Erwägen 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)	Gibt synchron eine Struktur zurück, die bestimmte Informationen zu der änderung enthält, die aufgetreten ist, da der Typ der Änderung zum Überwachen angegeben ist.

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