FileSystemWatcher-Klasse

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

Namespace: System.IO
Assembly: System (in system.dll)

Syntax

'Declaration
Public Class FileSystemWatcher
    Inherits Component
    Implements ISupportInitialize
'Usage
Dim instance As FileSystemWatcher

public class FileSystemWatcher : Component, ISupportInitialize

public ref class FileSystemWatcher : public Component, ISupportInitialize

public class FileSystemWatcher extends Component implements ISupportInitialize

public class FileSystemWatcher extends Component implements ISupportInitialize

Hinweise

Mit FileSystemWatcher können Sie die Änderungen in einem angegebenen Verzeichnis überwachen lassen. Änderungen in Dateien und Unterverzeichnissen des angegebenen Verzeichnisses können überwacht werden. Sie können eine Komponente zum Überwachen von Dateien auf einem lokalen Computer, einem Netzlaufwerk oder einem Remotecomputer erstellen.

Um Änderungen an allen Dateien mit einer Dateierweiterung zu überwachen, legen Sie die Filter-Eigenschaft auf eine leere Zeichenfolge ("") fest, oder verwenden Sie Platzhalterzeichen ("*.*"). Legen Sie zum Überwachen einer bestimmten Datei die Filter-Eigenschaft auf den Dateinamen fest. Damit z. B. die Datei MyDoc.txt auf Änderungen überwacht wird, legen Sie die Filter-Eigenschaft auf MyDoc.txt fest. Es kann auch ein bestimmten Dateityp auf Änderungen überwacht werden. Damit z. B. Textdateien auf Änderungen überwacht werden, legen Sie die Filter-Eigenschaft auf "*.txt" fest.

Ein Verzeichnis oder eine Datei kann auf verschiedene Arten von Änderungen überwacht werden. Dateien oder Verzeichnisse können z. B. auf Änderungen in Bezug auf Attributes, Datum und Uhrzeit von LastWrite und Size überwacht werden. Legen Sie dafür die NotifyFilter-Eigenschaft auf einen der NotifyFilters-Werte fest. Weitere Informationen darüber, welche Arten von Änderungen überwacht werden können, finden Sie unter NotifyFilters.

Das Umbenennen, Löschen oder Erstellen von Dateien oder Verzeichnissen kann überwacht werden. Das Umbenennen von Textdateien wird z. B. überwacht, wenn Sie die Filter-Eigenschaft auf "*.txt" festlegen und die WaitForChanged-Methode mit dem auf Renamed festgelegten Parameter aufrufen.

Das Betriebssystem Windows meldet der Komponente Änderungen an Dateien, die in einem von FileSystemWatcher erstellten Puffer vorgenommen wurden. Wenn in kurzen Abständen Änderungen vorgenommen werden, kann es zu einem Überlauf des Puffers kommen. Dies führt dazu, dass die Komponente die Änderungen im Verzeichnis nicht mehr verfolgen kann. Die Komponente kann dann nur allgemeine Benachrichtigungen bereitstellen. Das Erhöhen der Puffergröße mit der InternalBufferSize-Eigenschaft ist aufwändig, da Systemspeicher genutzt wird, der nicht auf die Festplatte ausgelagert werden kann. Der Puffer sollte deshalb so klein wie möglich gehalten werden, aber dennoch groß genug, um Dateiänderungsergebnisse erfassen zu können. Um einen Überlauf des Puffers zu vermeiden, verwenden Sie zum Herausfiltern nicht erwünschter Änderungsbenachrichtigungen die NotifyFilter-Eigenschaft und die IncludeSubdirectories-Eigenschaft.

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

Beachten Sie beim Verwenden der FileSystemWatcher-Klasse Folgendes.

• Versteckte Dateien werden nicht ignoriert.

• In einigen Systemen meldet FileSystemWatcher Änderungen an Dateien mit dem kurzen 8.3-Dateinamenformat. Eine Änderung an "LongFileName.LongExtension" würde dann beispielsweise als "LongFi~.Lon" gemeldet werden.

• Diese Klasse enthält auf Klassenebene einen Verknüpfungsaufruf und eine Vererbungsforderung, die für alle Member gelten. Wenn der direkte Aufrufer oder die abgeleitete Klasse nicht über eine Berechtigung mit voller Vertrauenswürdigkeit verfügen, wird eine SecurityException ausgelöst. Ausführliche Informationen über Sicherheitsanforderungen finden Sie unter Verknüpfungsaufrufe.

Kopieren und Verschieben von Ordnern

Das Betriebssystem und das FileSystemWatcher-Objekt interpretieren eine Ausschneide- und Einfügeaktion oder Verschiebeaktion als Umbenennungsaktion für einen Ordner und seinen Inhalt. Wenn Sie einen Ordner mit Dateien ausschneiden und in einen Ordner einfügen, der überwacht wird, wird nur der Ordner vom FileSystemWatcher-Objekt als neu angegeben, nicht aber sein Inhalt, da im Wesentlichen nur eine Umbenennung stattgefunden hat.

Wenn Sie darüber benachrichtigt werden wollen, dass die Inhalte von Ordnern verschoben oder in einen überwachten Ordner kopiert wurden, stellen Sie die OnChanged-Ereignishandlermethode und die OnRenamed-Ereignishandlermethode bereit, wie in der folgenden Tabelle vorgeschlagen.

Ereignishandler	Behandelte Ereignisse	Ausführung
OnChanged	Changed, Created, Deleted	Berichte über Änderungen in Dateiattributen, erstellten und gelöschten Dateien.
OnRenamed	Renamed	Auflistung der alten und neuen Pfade umbenannter Dateien und Ordner, die bei Bedarf rekursiv erweitert werden.

Ereignisse und Puffergrößen

Im Folgenden werden verschiedene Faktoren erläutert, die sich auf die Art des ausgelösten Dateisystemänderungs-Ereignisses auswirken:

• Häufige Vorgänge in Dateisystemen können mehrere Ereignisse auslösen. Wenn eine Datei z. B. von einem Verzeichnis in ein anderes verschoben wird, werden möglicherweise mehrere OnChanged-Ereignisse und einige OnCreated-Ereignisse sowie OnDeleted-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 Ereignisse in Dateisystemen auslösen, die von FileSystemWatcher erkannt werden.

• FileSystemWatcher kann Datenträger nur so lange überwachen, wie diese nicht gewechselt bzw. entfernt werden. Der FileSystemWatcher löst keine Ereignisse für CDs und DVDs aus, da weder Zeitstempel noch Eigenschaften geändert werden können. Auf Remotecomputern muss eine der erforderlichen Plattformen installiert sein, damit die Komponente ordnungsgemäß funktioniert. Es kann aber kein Remotecomputer unter Windows NT 4.0 von einem Computer aus überwacht werden, auf dem ebenfalls Windows NT 4.0 ausgeführt wird.

• Wenn mehrere FileSystemWatcher-Objekte den gleichen UNC-Pfad in Windows XP vor Service Pack 1 oder Windows 2000 SP2 oder früher überwachen, löst nur eins der Objekte ein Ereignis aus. Auf Computern unter Windows XP SP1 und höher, Windows 2000 SP3 oder höher bzw. Windows Server 2003 lösen alle FileSystemWatcher-Objekte die entsprechenden Ereignisse aus.

• Das Festlegen von Filter verringert nicht die in den Puffer geschriebene Datenmenge.

Hinweis: Wenn aufgrund von Abhängigkeiten mit Windows ein Ereignis verpasst oder die Puffergröße überschritten wird, löst ein FileSystemWatcher kein Error-Ereignis aus. Halten Sie die folgenden Richtlinien ein, damit keine Ergebnisse verpasst werden:

• Erhöhen Sie über die InternalBufferSize-Eigenschaft die Puffergröße. Damit können Sie verhindern, dass Dateisystemänderungs-Ereignisse verpasst werden.

• Vermeiden Sie es, Dateien mit langen Dateinamen zu überwachen. Es empfiehlt sich, diese mit kürzeren Namen umzubenennen.

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

Beispiel

Im folgenden Beispiel wird ein FileSystemWatcher erstellt, mit dem das zur Laufzeit angegebene Verzeichnis überwacht wird. In der Komponente wird festgelegt, dass Textdateien im Verzeichnis auf Änderungen in Bezug auf die Uhrzeit von LastWrite und LastAccess sowie das Erstellen, Löschen oder Umbenennen überwacht werden. Beim Ändern, Erstellen oder Löschen einer Datei wird der Dateipfad an die Konsole ausgegeben. Beim Umbenennen einer Datei werden der alte und der neue Pfad an die Konsole ausgegeben.

Verwenden Sie für dieses Beispiel den System.Diagnostics-Namespace und den System.IO-Namespace.

Public Class Watcher
    
    Public Shared Sub Main()
    
         Run()
  
    End Sub

    <PermissionSet(SecurityAction.Demand, Name:="FullTrust")> _
    Private Shared Sub Run

      Dim args() As String = System.Environment.GetCommandLineArgs()
        ' If a directory is not specified, exit the program.
        If args.Length <> 2 Then
            ' Display the proper way to call the program.
            Console.WriteLine("Usage: Watcher.exe (directory)")
            Return
        End If
        
        ' Create a new FileSystemWatcher and set its properties.
        Dim watcher As New FileSystemWatcher()
        watcher.Path = args(1)
        ' Watch for changes in LastAccess and LastWrite times, and
        ' the renaming of files or directories. 
        watcher.NotifyFilter = (NotifyFilters.LastAccess Or NotifyFilters.LastWrite Or NotifyFilters.FileName Or NotifyFilters.DirectoryName)
        ' Only watch text files.
        watcher.Filter = "*.txt"
        
        ' Add event handlers.
        AddHandler watcher.Changed, AddressOf OnChanged
        AddHandler watcher.Created, AddressOf OnChanged
        AddHandler watcher.Deleted, AddressOf OnChanged
        AddHandler watcher.Renamed, AddressOf OnRenamed
        
        ' Begin watching.
        watcher.EnableRaisingEvents = True
        
        ' Wait for the user to quit the program.
        Console.WriteLine("Press 'q' to quit the sample.")
        While Chr(Console.Read()) <> "q"c
        End While
    End Sub
     
    ' Define the event handlers.
    Private Shared Sub OnChanged(source As Object, e As FileSystemEventArgs)
        ' Specify what is done when a file is changed, created, or deleted.
        Console.WriteLine("File: " & e.FullPath & " " & e.ChangeType)
    End Sub    
    
    Private Shared Sub OnRenamed(source As Object, e As RenamedEventArgs)
        ' Specify what is done when a file is renamed.
        Console.WriteLine("File: {0} renamed to {1}", e.OldFullPath, e.FullPath)
    End Sub
    
End Class

public class Watcher
{

    public static void Main()
    {
    Run();

    }

    [PermissionSet(SecurityAction.Demand, Name="FullTrust")]
    public static void Run()
    {
        string[] args = System.Environment.GetCommandLineArgs();
 
        // If a directory is not specified, exit program.
        if(args.Length != 2)
        {
            // Display the proper way to call the program.
            Console.WriteLine("Usage: Watcher.exe (directory)");
            return;
        }

        // Create a new FileSystemWatcher and set its properties.
        FileSystemWatcher watcher = new FileSystemWatcher();
        watcher.Path = args[1];
        /* Watch for changes in LastAccess and LastWrite times, and 
           the renaming of files or directories. */
        watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite 
           | NotifyFilters.FileName | NotifyFilters.DirectoryName;
        // Only watch text files.
        watcher.Filter = "*.txt";

        // Add event handlers.
        watcher.Changed += new FileSystemEventHandler(OnChanged);
        watcher.Created += new FileSystemEventHandler(OnChanged);
        watcher.Deleted += new FileSystemEventHandler(OnChanged);
        watcher.Renamed += new RenamedEventHandler(OnRenamed);

        // Begin watching.
        watcher.EnableRaisingEvents = true;

        // Wait for the user to quit the program.
        Console.WriteLine("Press \'q\' to quit the sample.");
        while(Console.Read()!='q');
    }

    // Define the event handlers.
    private static void OnChanged(object source, FileSystemEventArgs e)
    {
        // Specify what is done when a file is changed, created, or deleted.
       Console.WriteLine("File: " +  e.FullPath + " " + e.ChangeType);
    }

    private static void OnRenamed(object source, RenamedEventArgs e)
    {
        // Specify what is done when a file is renamed.
        Console.WriteLine("File: {0} renamed to {1}", e.OldFullPath, e.FullPath);
    }
}

public ref class Watcher
{
private:
   // Define the event handlers.
   static void OnChanged( Object^ /*source*/, FileSystemEventArgs^ e )
   {
      // Specify what is done when a file is changed, created, or deleted.
      Console::WriteLine( "File: {0} {1}", e->FullPath, e->ChangeType );
   }

   static void OnRenamed( Object^ /*source*/, RenamedEventArgs^ e )
   {
      // Specify what is done when a file is renamed.
      Console::WriteLine( "File: {0} renamed to {1}", e->OldFullPath, e->FullPath );
   }

public:
   [PermissionSet(SecurityAction::Demand, Name="FullTrust")]
   int static run()
   {
      array<String^>^args = System::Environment::GetCommandLineArgs();

      // If a directory is not specified, exit program.
      if ( args->Length != 2 )
      {
         // Display the proper way to call the program.
         Console::WriteLine( "Usage: Watcher.exe (directory)" );
         return 0;
      }

      // Create a new FileSystemWatcher and set its properties.
      FileSystemWatcher^ watcher = gcnew FileSystemWatcher;
      watcher->Path = args[ 1 ];

      /* Watch for changes in LastAccess and LastWrite times, and 
          the renaming of files or directories. */
      watcher->NotifyFilter = static_cast<NotifyFilters>(NotifyFilters::LastAccess |
            NotifyFilters::LastWrite | NotifyFilters::FileName | NotifyFilters::DirectoryName);

      // Only watch text files.
      watcher->Filter = "*.txt";

      // Add event handlers.
      watcher->Changed += gcnew FileSystemEventHandler( Watcher::OnChanged );
      watcher->Created += gcnew FileSystemEventHandler( Watcher::OnChanged );
      watcher->Deleted += gcnew FileSystemEventHandler( Watcher::OnChanged );
      watcher->Renamed += gcnew RenamedEventHandler( Watcher::OnRenamed );

      // Begin watching.
      watcher->EnableRaisingEvents = true;

      // Wait for the user to quit the program.
      Console::WriteLine( "Press \'q\' to quit the sample." );
      while ( Console::Read() != 'q' )
         ;
   }
};

int main() {
   Watcher::run();
}

public class Watcher
{
    public static void main(String[] args1)
    {
    Run();
    } 

    /** @attribute PermissionSet(SecurityAction.Demand, Name="FullTrust")
     */
    public static void Run()
    {
        String args[] = System.Environment.GetCommandLineArgs();

        // If a directory is not specified, exit program.
        if (args.length != 2) {

            // Display the proper way to call the program.
            Console.WriteLine("Usage: Watcher.exe (directory)");
            return;
        }

        // Create a new FileSystemWatcher and set its properties.
        FileSystemWatcher watcher = new FileSystemWatcher();
        watcher.set_Path(args[1]);

        /* Watch for changes in LastAccess and LastWrite times, and 
           the renaming of files or directories.
         */
        watcher.set_NotifyFilter
            (NotifyFilters.LastAccess |NotifyFilters.LastWrite |
            NotifyFilters.FileName | NotifyFilters.DirectoryName);

        // Only watch text files.
        watcher.set_Filter("*.txt");

        // Add event handlers.
        watcher.add_Changed(new FileSystemEventHandler(OnChanged));
        watcher.add_Created(new FileSystemEventHandler(OnChanged));
        watcher.add_Deleted(new FileSystemEventHandler(OnChanged));
        watcher.add_Renamed(new RenamedEventHandler(OnRenamed));

        // Begin watching.
        watcher.set_EnableRaisingEvents(true);

        // Wait for the user to quit the program.
        Console.WriteLine("Press \'q\' to quit the sample.");
        while ((Console.Read() != 'q')) {

        }
    }

    // Define the event handlers.
    private static void OnChanged(Object source,FileSystemEventArgs e)
    {
        // Specify what is done when a file is changed, created, or deleted.
        Console.WriteLine(("File: " + e.get_FullPath() + " " 
            + e.get_ChangeType()));
    } //OnChanged

    private static void OnRenamed(Object source, RenamedEventArgs e)
    {
        // Specify what is done when a file is renamed.
        Console.WriteLine("File: {0} renamed to {1}",
            e.get_OldFullPath(),e.get_FullPath());
    } //OnRenamed
} //Watcher

.NET Framework-Sicherheit

• SecurityPermission  zum Aufrufen von ProcessStartInfo-Membern. Anforderungswert: LinkDemand; Benannte Berechtigungssätze: FullTrust.
• SecurityPermission  zum Ableiten von der ProcessStartInfo-Klasse. Anforderungswert: InheritanceDemand; Benannte Berechtigungssätze: FullTrust.

Vererbungshierarchie

System.Object
   System.MarshalByRefObject
     System.ComponentModel.Component
      System.IO.FileSystemWatcher

Threadsicherheit

Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Plattformen

Windows 98, Windows 2000 SP4, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

Siehe auch

Referenz

FileSystemWatcher-Member
System.IO-Namespace
FileSystemWatcher.NotifyFilter
NotifyFilters
FileSystemEventArgs-Klasse
FileSystemEventHandler-Delegat
Filter
IncludeSubdirectories
InternalBufferOverflowException
RenamedEventArgs
RenamedEventHandler
WaitForChangedResult
WatcherChangeTypes