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.Listens to the file system change notifications and raises events when a directory, or file in a directory, changes.

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 erstellt FileSystemWatcher , um das zur Laufzeit angegebene Verzeichnis zu überwachen.The following example creates a FileSystemWatcher to watch the directory specified at run time. Die Komponente wird so festgelegt, dass Sie Änderungen in LastWrite und LastAccess Uhrzeit, das Erstellen, löschen oder Umbenennen von Textdateien im Verzeichnis überwacht.The component is set to watch for changes in LastWrite and LastAccess time, the creation, deletion, or renaming of text files in the directory. Wenn eine Datei geändert, erstellt oder gelöscht wird, wird der Pfad zur Datei in der Konsole gedruckt.If a file is changed, created, or deleted, the path to the file prints to the console. Wenn eine Datei umbenannt wird, werden die alten und neuen Pfade in der Konsole gedruckt.When a file is renamed, the old and new paths print to the 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

Hinweise

Verwenden Sie FileSystemWatcher , um Änderungen in einem angegebenen Verzeichnis zu überwachen.Use FileSystemWatcher to watch for changes in a specified directory. Sie können Änderungen in Dateien und Unterverzeichnissen des angegebenen Verzeichnisses überwachen.You can watch for changes in files and subdirectories of the specified directory. Sie können eine-Komponente erstellen, um Dateien auf einem lokalen Computer, einem Netzlaufwerk oder einem Remote Computer zu überwachen.You can create a component to watch files on a local computer, a network drive, or a remote computer.

Um Änderungen in allen Dateien zu überwachen, legen Sie die- Filter Eigenschaft auf eine leere Zeichenfolge ("") fest, oder verwenden Sie Platzhalter ("*. * ").To watch for changes in all files, set the Filter property to an empty string ("") or use wildcards ("*.*"). Um eine bestimmte Datei zu beobachten, legen Sie die- Filter Eigenschaft auf den Dateinamen fest.To watch a specific file, set the Filter property to the file name. Wenn Sie z. b. Änderungen in der Datei MyDoc.txt überwachen möchten, legen Sie die- Filter Eigenschaft auf "MyDoc.txt" fest.For example, to watch for changes in the file MyDoc.txt, set the Filter property to "MyDoc.txt". Sie können auch auf Änderungen in einem bestimmten Dateityp achten.You can also watch for changes in a certain type of file. Wenn Sie z. b. Änderungen in Textdateien überwachen möchten, legen Sie die- Filter Eigenschaft auf " * . txt" fest.For example, to watch for changes in text files, set the Filter property to "*.txt".

Es gibt mehrere Arten von Änderungen, die Sie in einem Verzeichnis oder in einer Datei überwachen können.There are several types of changes you can watch for in a directory or file. Beispielsweise können Sie Änderungen in Attributes , das LastWrite Datum und die Uhrzeit oder den Size von Dateien oder Verzeichnissen überwachen.For example, you can watch for changes in Attributes, the LastWrite date and time, or the Size of files or directories. Dies erfolgt durch Festlegen der- NotifyFilter Eigenschaft auf einen der- NotifyFilters Werte.This is done by setting the NotifyFilter property to one of the NotifyFilters values. Weitere Informationen zu den Arten von Änderungen, die Sie überwachen können, finden Sie unter NotifyFilters .For more information on the type of changes you can watch, see NotifyFilters.

Sie können das Umbenennen, löschen oder Erstellen von Dateien oder Verzeichnissen überwachen.You can watch for renaming, deletion, or creation of files or directories. Wenn Sie z. b. das Umbenennen von Textdateien überwachen möchten, legen Sie die Filter -Eigenschaft auf "*. txt" fest, und wenden Sie die- WaitForChanged Methode mit einem Renamed für den Parameter angegebenenFor example, to watch for renaming of text files, set the Filter property to "*.txt" and call the WaitForChanged method with a Renamed specified for its parameter.

Das Windows-Betriebssystem benachrichtigt die Komponente über Dateiänderungen in einem Puffer, der von erstellt wurde FileSystemWatcher .The Windows operating system notifies your component of file changes in a buffer created by the FileSystemWatcher. Wenn in kurzer Zeit viele Änderungen vorgenommen werden, kann der Puffer einen Überlauf verursachen.If there are many changes in a short time, the buffer can overflow. Dies bewirkt, dass die Komponente Änderungen im Verzeichnis nachverfolgt und nur eine Benachrichtigung über eine Benachrichtigung erhält.This causes the component to lose track of changes in the directory, and it will only provide blanket notification. Die Vergrößerung des Puffers mit der- InternalBufferSize Eigenschaft ist teuer, da Sie aus nicht auslagertem Arbeitsspeicher stammt, der nicht auf den Datenträger ausgelagert werden kann, sodass der Puffer so klein ist, dass er keine Datei Änderungs Ereignisse verpasst.Increasing the size of the buffer with the InternalBufferSize property is expensive, as it comes from non-paged memory that cannot be swapped out to disk, so keep the buffer as small yet large enough to not miss any file change events. Um einen Pufferüberlauf zu vermeiden, verwenden NotifyFilter Sie die-Eigenschaft und die-Eigenschaft, IncludeSubdirectories sodass Sie unerwünschte Änderungs Benachrichtigungen herausfiltern können.To avoid a buffer overflow, use the NotifyFilter and IncludeSubdirectories properties so you can filter out unwanted change notifications.

Eine Liste der anfänglichen Eigenschaftswerte für eine Instanz von FileSystemWatcher finden Sie im- FileSystemWatcher Konstruktor.For a list of initial property values for an instance of FileSystemWatcher, see the FileSystemWatcher constructor.

Beachten Sie Folgendes, wenn Sie die- FileSystemWatcher Klasse verwenden.Please note the following when using the FileSystemWatcher class.

  • Ausgeblendete Dateien werden nicht ignoriert.Hidden files are not ignored.

  • In manchen Systemen FileSystemWatcher meldet Änderungen an Dateien mithilfe des kurzen Dateinamen Formats 8,3.In some systems, FileSystemWatcher reports changes to files using the short 8.3 file name format. Beispielsweise könnte eine Änderung an "longfilename. LongExtension" als "longfil ~" gemeldet werden. Lon ".For example, a change to "LongFileName.LongExtension" could be reported as "LongFil~.Lon".

  • Diese Klasse enthält einen Link Aufruf und eine Vererbungs Anforderung auf Klassenebene, die für alle Member gilt.This class contains a link demand and an inheritance demand at the class level that applies to all members. Eine SecurityException wird ausgelöst, wenn der unmittelbare Aufrufer oder die abgeleitete Klasse nicht über die Berechtigung für volle Vertrauenswürdigkeit verfügt.A SecurityException is thrown when either the immediate caller or the derived class does not have full-trust permission. Ausführliche Informationen zu Sicherheitsanforderungen finden Sie unter LinkAufrufe.For details about security demands, see Link Demands.

  • Die maximale Größe, die Sie für die- InternalBufferSize Eigenschaft für die Überwachung eines Verzeichnisses über das Netzwerk festlegen können, beträgt 64 KB.The maximum size you can set for the InternalBufferSize property for monitoring a directory over the network is 64 KB.

Kopieren und Verschieben von OrdnernCopying and moving folders

Das Betriebssystem und das FileSystemWatcher Objekt interpretieren eine Ausschneide-und Einfügeaktion oder eine Verschiebungs Aktion als Umbenennungs Aktion für einen Ordner und seinen Inhalt.The operating system and FileSystemWatcher object interpret a cut-and-paste action or a move action as a rename action for a folder and its contents. Wenn Sie einen Ordner mit Dateien ausschneiden und in einen zu überwachenden Ordner einfügen, FileSystemWatcher meldet das Objekt nur den Ordner als neu, jedoch nicht seinen Inhalt, da Sie im Wesentlichen nur umbenannt werden.If you cut and paste a folder with files into a folder being watched, the FileSystemWatcher object reports only the folder as new, but not its contents because they are essentially only renamed.

Um benachrichtigt zu werden, dass der Inhalt der Ordner verschoben oder in einen überwachten Ordner kopiert wurde, geben Sie die OnChanged -und- OnRenamed Ereignishandlermethoden an, wie in der folgenden Tabelle vorgeschlagen.To be notified that the contents of folders have been moved or copied into a watched folder, provide OnChanged and OnRenamed event handler methods as suggested in the following table.

EreignishandlerEvent Handler Behandelte EreignisseEvents Handled LeistungPerforms
OnChanged Changed, Created, DeletedChanged, Created, Deleted Melden Sie Änderungen in Dateiattributen, erstellten Dateien und gelöschten Dateien.Report changes in file attributes, created files, and deleted files.
OnRenamed Renamed Auflisten der alten und neuen Pfade umbenannter Dateien und Ordner, die bei Bedarf rekursiv erweitert werden.List the old and new paths of renamed files and folders, expanding recursively if needed.

Ereignisse und PuffergrößenEvents and Buffer Sizes

Beachten Sie, dass mehrere Faktoren beeinflussen können, welche Dateisystem Änderungs Ereignisse ausgelöst werden, wie im folgenden beschrieben:Note that several factors can affect which file system change events are raised, as described by the following:

  • Allgemeine Dateisystem Vorgänge können mehr als ein Ereignis hervorrufen.Common file system operations might raise more than one event. Wenn eine Datei z. b. von einem Verzeichnis in ein anderes verschoben wird, OnChanged OnCreated werden möglicherweise mehrere und einige-und- OnDeleted Ereignisse ausgelöst.For example, when a file is moved from one directory to another, several OnChanged and some OnCreated and OnDeleted events might be raised. Das Verschieben einer Datei ist ein komplexer Vorgang, der aus mehreren einfachen Vorgängen besteht, wodurch mehrere Ereignisse erhöht werden.Moving a file is a complex operation that consists of multiple simple operations, therefore raising multiple events. Ebenso können einige Anwendungen (z. b. Antivirussoftware) zusätzliche Dateisystem Ereignisse auslösen, die von erkannt werden FileSystemWatcher .Likewise, some applications (for example, antivirus software) might cause additional file system events that are detected by FileSystemWatcher.

  • Der kann Datenträger überwachen, solange FileSystemWatcher Sie nicht gewechselt oder entfernt werden.The FileSystemWatcher can watch disks as long as they are not switched or removed. Der FileSystemWatcher gibt keine Ereignisse für CDs und DVDs aus, da Zeitstempel und Eigenschaften nicht geändert werden können.The FileSystemWatcher does not raise events for CDs and DVDs, because time stamps and properties cannot change. Auf Remote Computern muss eine der erforderlichen Plattformen installiert sein, damit die Komponente ordnungsgemäß funktioniert.Remote computers must have one of the required platforms installed for the component to function properly.

Beachten Sie, dass ein ein FileSystemWatcher Ereignis übersehen kann, wenn die Puffergröße überschritten wird.Note that a FileSystemWatcher may miss an event when the buffer size is exceeded. Um fehlende Ereignisse zu vermeiden, befolgen Sie die folgenden Richtlinien:To avoid missing events, follow these guidelines:

  • Vergrößern Sie die Puffergröße, indem Sie die- InternalBufferSize Eigenschaft festlegen.Increase the buffer size by setting the InternalBufferSize property.

  • Vermeiden Sie das Überwachen von Dateien mit langen Dateinamen, da ein langer Dateiname zum Auffüllen des Puffers beiträgt.Avoid watching files with long file names, because a long file name contributes to filling up the buffer. Sie sollten diese Dateien unter Verwendung kürzerer Namen umbenennen.Consider renaming these files using shorter names.

  • Halten Sie den Ereignis Behandlungs Code so kurz wie möglich.Keep your event handling code as short as possible.

Konstruktoren

FileSystemWatcher()

Initialisiert eine neue Instanz der FileSystemWatcher-Klasse.Initializes a new instance of the FileSystemWatcher class.

FileSystemWatcher(String)

Initialisiert eine neue Instanz der FileSystemWatcher-Klasse mit dem für die Überwachung angegebenen Verzeichnis.Initializes a new instance of the FileSystemWatcher class, given the specified directory to monitor.

FileSystemWatcher(String, String)

Initialisiert eine neue Instanz der FileSystemWatcher-Klasse mit dem für die Überwachung angegebenen Verzeichnis und Dateityp.Initializes a new instance of the FileSystemWatcher class, given the specified directory and type of files to monitor.

Eigenschaften

CanRaiseEvents

Ruft einen Wert ab, der angibt, ob die Komponente ein Ereignis auslösen kann.Gets a value indicating whether the component can raise an event.

(Geerbt von Component)
Container

Ruft die IContainer ab, die in der Component enthalten ist.Gets the IContainer that contains the Component.

(Geerbt von Component)
DesignMode

Ruft einen Wert ab, der angibt, ob sich Component gegenwärtig im Entwurfsmodus befindet.Gets a value that indicates whether the Component is currently in design mode.

(Geerbt von Component)
EnableRaisingEvents

Ruft einen Wert ab, der angibt, ob die Komponente aktiviert ist, oder legt diesen fest.Gets or sets a value indicating whether the component is enabled.

Events

Ruft die Liste der Ereignishandler ab, die dieser Component angefügt sind.Gets the list of event handlers that are attached to this Component.

(Geerbt von Component)
Filter

Ruft die Filterzeichenfolge ab, mit der die in einem Verzeichnis zu überwachenden Dateien bestimmt werden, oder legt die Filterzeichenfolge fest.Gets or sets the filter string used to determine what files are monitored in a directory.

Filters

Ruft die Auflistung aller Filter ab, mit denen bestimmt wird, welche Dateien in einem Verzeichnis überwacht werden.Gets the collection of all the filters used to determine what files are monitored in a directory.

IncludeSubdirectories

Ruft einen Wert ab, der angibt, ob die Unterverzeichnisse im angegebenen Pfad überwacht werden sollen, oder legt diesen fest.Gets or sets a value indicating whether subdirectories within the specified path should be monitored.

InternalBufferSize

Ruft die Größe (in Byte) des internen Puffers ab oder legt diese fest.Gets or sets the size (in bytes) of the internal buffer.

NotifyFilter

Ruft den Typ der zu überwachenden Änderungen ab oder legt diesen fest.Gets or sets the type of changes to watch for.

Path

Ruft den Pfad des zu überwachenden Verzeichnisses ab oder legt diesen fest.Gets or sets the path of the directory to watch.

Site

Ruft eine ISite für den FileSystemWatcher ab oder legt diese fest.Gets or sets an ISite for the FileSystemWatcher.

SynchronizingObject

Ruft das Objekt ab, das zum Marshallen von Ereignishandleraufrufen verwendet wird, die aufgrund einer Verzeichnisänderung ausgegeben werden, oder legt dieses fest.Gets or sets the object used to marshal the event handler calls issued as a result of a directory change.

Methoden

BeginInit()

Beginnt die Initialisierung von FileSystemWatcher für die Verwendung in einem Formular oder durch eine andere Komponente.Begins the initialization of a FileSystemWatcher used on a form or used by another component. Die Initialisierung erfolgt zur Laufzeit.The initialization occurs at run time.

CreateObjRef(Type)

Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Geerbt von MarshalByRefObject)
Dispose()

Gibt die nicht verwalteten Ressourcen frei, die von FileSystemWatcher verwendet werden.Releases the unmanaged resources used by the FileSystemWatcher.

Dispose()

Gibt alle vom Component verwendeten Ressourcen frei.Releases all resources used by the Component.

(Geerbt von Component)
Dispose(Boolean)

Gibt die von FileSystemWatcher verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.Releases the unmanaged resources used by the FileSystemWatcher and optionally releases the managed resources.

EndInit()

Beendet die Initialisierung von FileSystemWatcher für die Verwendung in einem Formular oder durch eine andere Komponente.Ends the initialization of a FileSystemWatcher used on a form or used by another component. Die Initialisierung erfolgt zur Laufzeit.The initialization occurs at run time.

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.Determines whether the specified object is equal to the current object.

(Geerbt von Object)
Finalize()

Gibt die von der aktuellen Instanz reservierten Ressourcen frei.Releases the resources held by the current instance.

GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Geerbt von Object)
GetLifetimeService()
Veraltet.

Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Geerbt von MarshalByRefObject)
GetService(Type)

Gibt ein Objekt zurück, das einen von der Component oder von deren Container bereitgestellten Dienst darstellt.Returns an object that represents a service provided by the Component or by its Container.

(Geerbt von Component)
GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Geerbt von Object)
InitializeLifetimeService()
Veraltet.

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab.Obtains a lifetime service object to control the lifetime policy for this instance.

(Geerbt von MarshalByRefObject)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Geerbt von Object)
MemberwiseClone(Boolean)

Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts.Creates a shallow copy of the current MarshalByRefObject object.

(Geerbt von MarshalByRefObject)
OnChanged(FileSystemEventArgs)

Löst das Changed-Ereignis aus.Raises the Changed event.

OnCreated(FileSystemEventArgs)

Löst das Created-Ereignis aus.Raises the Created event.

OnDeleted(FileSystemEventArgs)

Löst das Deleted-Ereignis aus.Raises the Deleted event.

OnError(ErrorEventArgs)

Löst das Error-Ereignis aus.Raises the Error event.

OnRenamed(RenamedEventArgs)

Löst das Renamed-Ereignis aus.Raises the Renamed event.

ToString()

Gibt einen String zurück, der den Namen der Component enthält (sofern vorhanden).Returns a String containing the name of the Component, if any. Diese Methode darf nicht überschrieben werden.This method should not be overridden.

(Geerbt von Component)
ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(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.A synchronous method that returns a structure that contains specific information on the change that occurred, given the type of change you want to monitor.

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.A synchronous method that returns a structure that contains specific information on the change that occurred, given the type of change you want to monitor and the time (in milliseconds) to wait before timing out.

Ereignisse

Changed

Tritt ein, wenn im angegebenen Path eine Datei oder ein Verzeichnis geändert wird.Occurs when a file or directory in the specified Path is changed.

Created

Tritt ein, wenn im angegebenen Path eine Datei oder ein Verzeichnis erstellt wird.Occurs when a file or directory in the specified Path is created.

Deleted

Tritt ein, wenn im angegebenen Path eine Datei oder ein Verzeichnis gelöscht wird.Occurs when a file or directory in the specified Path is deleted.

Disposed

Tritt auf, wenn die Komponente von einem Aufruf der Dispose()-Methode verworfen wird.Occurs when the component is disposed by a call to the Dispose() method.

(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.Occurs when the instance of FileSystemWatcher is unable to continue monitoring changes or when the internal buffer overflows.

Renamed

Tritt ein, wenn im angegebenen Path eine Datei oder ein Verzeichnis umbenannt wird.Occurs when a file or directory in the specified Path is renamed.

Gilt für:

Siehe auch