FileSystemWatcher.NotifyFilter Eigenschaft

Definition

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

public:
 property System::IO::NotifyFilters NotifyFilter { System::IO::NotifyFilters get(); void set(System::IO::NotifyFilters value); };
[System.IO.IODescription("Flag to indicate which change event we want to monitor")]
[System.IO.IODescription("FSW_ChangedFilter")]
public System.IO.NotifyFilters NotifyFilter { get; set; }
member this.NotifyFilter : System.IO.NotifyFilters with get, set
Public Property NotifyFilter As NotifyFilters

Eigenschaftswert

Einer der NotifyFilters-Werte.One of the NotifyFilters values. Der Standardwert ist die bitweise OR-Kombination von LastWrite, FileName und DirectoryName.The default is the bitwise OR combination of LastWrite, FileName, and DirectoryName.

Attribute

Ausnahmen

Der Wert ist keine gültige bitweise OR-Kombination der NotifyFilters-Werte.The value is not a valid bitwise OR combination of the NotifyFilters values.

Der festgelegte Wert ist ungültig.The value that is being set is not valid.

Beispiele

Im folgenden Beispiel wird ein FileSystemWatcher erstellt, 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 Änderungen in LastWrite und LastAccess Zeit, das Erstellen, löschen oder Umbenennen von Textdateien im Verzeichnis überwacht werden.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.

#using <System.dll>

using namespace System;
using namespace System::IO;
using namespace System::Security::Permissions;

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' );

      return 0;
   }
};

int main() {
   Watcher::run();
}
using System;
using System.IO;
using System.Security.Permissions;

public class Watcher
{
    public static void Main()
    {
        Run();
    }

    [PermissionSet(SecurityAction.Demand, Name = "FullTrust")]
    private static void Run()
    {
        string[] args = 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.
        using (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 += OnChanged;
            watcher.Created += OnChanged;
            watcher.Deleted += OnChanged;
            watcher.Renamed += 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: {e.OldFullPath} renamed to {e.FullPath}");
}
Imports System.IO
Imports System.Security.Permissions

Public Class Watcher

    Public Shared Sub Main()

        Run()

    End Sub

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

        Dim args() As String = 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.
        Using 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 Using
    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: {e.OldFullPath} renamed to {e.FullPath}")
    End Sub

End Class

Hinweise

Sie können die Elemente der NotifyFilters Enumeration kombinieren, um mehr als eine Art von Änderung gleichzeitig zu überwachen.You can combine the members of the NotifyFilters enumeration to watch for more than one type of change at a time. Beispielsweise können Sie Änderungen an der Größe einer Datei und auf Änderungen in der LastWrite Zeit überwachen.For example, you can watch for changes in size of a file, and for changes in the LastWrite time. Dies löst immer dann ein Ereignis aus, wenn die Datei-oder Ordner Größe geändert wird, oder eine Änderung der LastWrite Uhrzeit der Datei oder des Ordners.This raises an event anytime there is a change in file or folder size, or a change in the LastWrite time of the file or folder.

Dies ist eine Möglichkeit, unerwünschte Benachrichtigungen herauszufiltern.This is one way to filter out unwanted notifications. Weitere Informationen zum Herausfiltern unerwünschter Benachrichtigungen finden Sie unter den Eigenschaften Filter, IncludeSubdirectoriesund InternalBufferSize.For more information on filtering out unwanted notifications, see the Filter, IncludeSubdirectories, and InternalBufferSize properties.

Gilt für:

Siehe auch