FileSystemWatcher.Path FileSystemWatcher.Path FileSystemWatcher.Path FileSystemWatcher.Path Property

Definition

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

public:
 property System::String ^ Path { System::String ^ get(); void set(System::String ^ value); };
[System.ComponentModel.TypeConverter("System.Diagnostics.Design.StringValueConverter, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
[System.IO.IODescription("The directory to monitor")]
[System.ComponentModel.TypeConverter("System.Diagnostics.Design.StringValueConverter, System.Design, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
[System.IO.IODescription("FSW_Path")]
[System.ComponentModel.TypeConverter("System.Diagnostics.Design.StringValueConverter, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
[System.ComponentModel.SettingsBindable(true)]
public string Path { get; set; }
member this.Path : string with get, set
Public Property Path As String

Eigenschaftswert

Der zu überwachende Pfad.The path to monitor. Der Standardwert ist eine leere Zeichenfolge ("").The default is an empty string ("").

Ausnahmen

Der angegebene Pfad ist nicht vorhanden oder konnte nicht gefunden werden.The specified path does not exist or could not be found.

- oder --or-

Der angegebene Pfad enthält Platzhalterzeichen.The specified path contains wildcard characters.

- oder --or-

Der angegebene Pfad enthält ungültige Zeichen.The specified path contains invalid path characters.

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 Sie LastWrite Änderungen LastAccess in und 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.

#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

Dabei handelt es sich um einen voll qualifizierten Pfad zu einem Verzeichnis.This is a fully qualified path to a directory. Wenn die IncludeSubdirectories -Eigenschaft trueist, ist dieses Verzeichnis das Stammverzeichnis, in dem das System auf Änderungen überwacht wird. andernfalls ist es das einzige Verzeichnis, das überwacht wird.If the IncludeSubdirectories property is true, this directory is the root at which the system watches for changes; otherwise it is the only directory watched. Um eine bestimmte Datei zu beobachten, legen Path Sie die-Eigenschaft auf das voll qualifizierte, korrekte Verzeichnis Filter und die-Eigenschaft auf den Dateinamen fest.To watch a specific file, set the Path property to the fully qualified, correct directory, and the Filter property to the file name.

Die Path -Eigenschaft unterstützt Universal Naming Convention (UNC)-Pfade.The Path property supports Universal Naming Convention (UNC) paths.

Hinweis

Diese Eigenschaft muss festgelegt werden, bevor die Komponente Änderungen überwachen kann.This property must be set before the component can watch for changes.

Wenn ein Verzeichnis umbenannt wird, wird FileSystemWatcher das automatisch an das neu umbenannte Element angefügt.When a directory is renamed, the FileSystemWatcher automatically reattaches itself to the newly renamed item. Wenn Sie z. b. die Path -Eigenschaft auf "c:\Eigene Dokumente" festlegen und dann das Verzeichnis manuell in "c:\Your Documents" umbenennen, lauscht die Komponente weiterhin auf Änderungs Benachrichtigungen für das neu umbenannte Verzeichnis.For example, if you set the Path property to "C:\My Documents" and then manually rename the directory to "C:\Your Documents", the component continues listening for change notifications on the newly renamed directory. Wenn Sie jedoch nach der Path -Eigenschaft Fragen, enthält Sie den alten Pfad.However, when you ask for the Path property, it contains the old path. Dies liegt daran, dass die Komponente bestimmt, welche Verzeichnisse auf der Grundlage des Handles überwacht werden, und nicht auf den Namen des Verzeichnisses.This happens because the component determines what directory watches based on the handle, rather than the name of the directory. Das Umbenennen wirkt sich nicht auf das Handle aus.Renaming does not affect the handle. Wenn Sie also die Komponente zerstören und dann neu erstellen, ohne die Path Eigenschaft zu aktualisieren, schlägt die Anwendung fehl, da das Verzeichnis nicht mehr vorhanden ist.So, if you destroy the component, and then recreate it without updating the Path property, your application will fail because the directory no longer exists.

Gilt für:

Siehe auch