FileSystemWatcher Klasse

Definition

Namespace:

System.IO

Assembly:

System.IO.FileSystem.Watcher.dll

Quelle:

FileSystemWatcher.cs

Ü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 class FileSystemWatcher : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize

type FileSystemWatcher = class
    inherit Component
    interface ISupportInitialize

Public Class FileSystemWatcher
Inherits Component
Implements ISupportInitialize

Vererbung

Object

MarshalByRefObject

Component

FileSystemWatcher

Implementiert

ISupportInitialize

Beispiele

Im folgenden Beispiel wird ein FileSystemWatcher erstellt, um das zur Laufzeit angegebene Verzeichnis zu watch. Die Komponente ist auf watch für Änderungen in LastWrite und LastAccess zeit, das Erstellen, Löschen 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 ausgegeben. Wenn eine Datei umbenannt wird, werden die alten und neuen Pfade in die Konsole ausgegeben.

#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

Weitere Informationen zu dieser API finden Sie unter Ergänzende API-Hinweise für FileSystemWatcher.

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 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)
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)
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 aufgetretenen Änderung enthält, wobei der Typ der zu überwachenden Änderung 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.

Weitere Informationen

• NotifyFilter
• NotifyFilters
• FileSystemEventArgs
• FileSystemEventHandler
• Filter
• IncludeSubdirectories
• InternalBufferOverflowException
• RenamedEventArgs
• RenamedEventHandler
• WaitForChangedResult
• WatcherChangeTypes
• Verwenden einer FileSystemWatcher-Komponente in einem Windows-Formular