FileSystemWatcher Klasa

Definicja

Nasłuchuje powiadomień o zmianie systemu plików i zgłasza zdarzenia, gdy katalog lub plik w katalogu ulegnie zmianie.Listens to the file system change notifications and raises events when a directory, or file in a directory, changes.

public ref class FileSystemWatcher : IDisposable
public ref class FileSystemWatcher : System::ComponentModel::Component, System::ComponentModel::ISupportInitialize
public ref class FileSystemWatcher : System::ComponentModel::Component, IDisposable, System::ComponentModel::ISupportInitialize
public class FileSystemWatcher : IDisposable
public class FileSystemWatcher : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize
[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
    interface IDisposable
type FileSystemWatcher = class
    inherit Component
    interface ISupportInitialize
type FileSystemWatcher = class
    inherit Component
    interface IDisposable
    interface ISupportInitialize
Public Class FileSystemWatcher
Implements IDisposable
Public Class FileSystemWatcher
Inherits Component
Implements ISupportInitialize
Public Class FileSystemWatcher
Inherits Component
Implements IDisposable, ISupportInitialize
Dziedziczenie
FileSystemWatcher
Dziedziczenie
FileSystemWatcher
Atrybuty
Implementuje

Przykłady

Poniższy przykład tworzy FileSystemWatcher, aby obejrzeć katalog określony w czasie wykonywania.The following example creates a FileSystemWatcher to watch the directory specified at run time. Składnik jest ustawiony do śledzenia zmian w LastWrite i LastAccess czasu, tworzenia, usuwania lub zmieniania nazw plików tekstowych w katalogu.The component is set to watch for changes in LastWrite and LastAccess time, the creation, deletion, or renaming of text files in the directory. Jeśli plik zostanie zmieniony, utworzony lub usunięty, ścieżka do pliku zostanie wydrukowana do konsoli programu.If a file is changed, created, or deleted, the path to the file prints to the console. Po zmianie nazwy pliku stare i nowe ścieżki są drukowane do konsoli programu.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

Uwagi

Użyj FileSystemWatcher, aby obejrzeć zmiany w określonym katalogu.Use FileSystemWatcher to watch for changes in a specified directory. Możesz obejrzeć zmiany w plikach i podkatalogach określonego katalogu.You can watch for changes in files and subdirectories of the specified directory. Można utworzyć składnik do oglądania plików na komputerze lokalnym, dysku sieciowym lub komputerze zdalnym.You can create a component to watch files on a local computer, a network drive, or a remote computer.

Aby obejrzeć zmiany we wszystkich plikach, należy ustawić właściwość Filter na pusty ciąg ("") lub użyć symboli wieloznacznych ("*.*").To watch for changes in all files, set the Filter property to an empty string ("") or use wildcards ("*.*"). Aby obejrzeć określony plik, należy ustawić właściwość Filter na nazwę pliku.To watch a specific file, set the Filter property to the file name. Na przykład aby obejrzeć zmiany w pliku MyDoc. txt, ustaw właściwość Filter na "MyDoc. txt".For example, to watch for changes in the file MyDoc.txt, set the Filter property to "MyDoc.txt". Możesz również obejrzeć zmiany w określonym typie pliku.You can also watch for changes in a certain type of file. Na przykład aby obejrzeć zmiany w plikach tekstowych, ustaw właściwość Filter na "*. txt".For example, to watch for changes in text files, set the Filter property to "*.txt".

Istnieje kilka typów zmian, które można obejrzeć w katalogu lub pliku.There are several types of changes you can watch for in a directory or file. Na przykład możesz obejrzeć zmiany w Attributes, LastWrite datę i godzinę lub Size plików lub katalogów.For example, you can watch for changes in Attributes, the LastWrite date and time, or the Size of files or directories. W tym celu należy ustawić właściwość NotifyFilter na jedną z wartości NotifyFilters.This is done by setting the NotifyFilter property to one of the NotifyFilters values. Aby uzyskać więcej informacji na temat typu zmian, które możesz obejrzeć, zobacz NotifyFilters.For more information on the type of changes you can watch, see NotifyFilters.

Można obejrzeć zmiany nazw, usuwania lub tworzenia plików lub katalogów.You can watch for renaming, deletion, or creation of files or directories. Na przykład aby obejrzeć zmiany nazwy plików tekstowych, ustaw właściwość Filter na "*. txt" i Wywołaj metodę WaitForChanged z Renamed określony dla jego parametru.For 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.

System operacyjny Windows powiadamia składnik o zmianach plików w buforze utworzonym przez FileSystemWatcher.The Windows operating system notifies your component of file changes in a buffer created by the FileSystemWatcher. Jeśli w krótkim czasie występuje wiele zmian, bufor może przepełnić.If there are many changes in a short time, the buffer can overflow. Powoduje to, że składnik utraci śledzenie zmian w katalogu i udostępnia tylko powiadomienia zbiorcze.This causes the component to lose track of changes in the directory, and it will only provide blanket notification. Zwiększenie rozmiaru bufora przy użyciu właściwości InternalBufferSize jest kosztowne, ponieważ pochodzi z niestronicowanej pamięci, która nie może zostać zamieniony na dysk, dlatego należy zachować bufor możliwie najmniejszej ilości, aby nie trafiać żadnych zdarzeń zmiany pliku.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. Aby uniknąć przepełnienia buforu, użyj właściwości NotifyFilter i IncludeSubdirectories, aby można było odfiltrować niechciane powiadomienia o zmianach.To avoid a buffer overflow, use the NotifyFilter and IncludeSubdirectories properties so you can filter out unwanted change notifications.

Aby uzyskać listę początkowych wartości właściwości dla wystąpienia FileSystemWatcher, zapoznaj się z konstruktorem FileSystemWatcher.For a list of initial property values for an instance of FileSystemWatcher, see the FileSystemWatcher constructor.

Podczas używania klasy FileSystemWatcher należy pamiętać o następujących kwestiach.Please note the following when using the FileSystemWatcher class.

  • Ukryte pliki nie są ignorowane.Hidden files are not ignored.

  • W niektórych systemach FileSystemWatcher raporty zmian plików przy użyciu krótkiego formatu nazwy pliku 8,3.In some systems, FileSystemWatcher reports changes to files using the short 8.3 file name format. Na przykład zmiana "LongFileName. LongExtension" może być raportowana jako "LongFil ~. Długość ".For example, a change to "LongFileName.LongExtension" could be reported as "LongFil~.Lon".

  • Ta klasa zawiera żądanie łącza i dziedziczenia na poziomie klasy stosowane do wszystkich składowych.This class contains a link demand and an inheritance demand at the class level that applies to all members. SecurityException jest generowany, gdy bezpośredni obiekt wywołujący lub Klasa pochodna nie ma uprawnienia pełnego zaufania.A SecurityException is thrown when either the immediate caller or the derived class does not have full-trust permission. Aby uzyskać szczegółowe informacje o wymaganiach dotyczących zabezpieczeń, zobacz wymagania dotyczące linków.For details about security demands, see Link Demands.

  • Maksymalny rozmiar, który można ustawić dla właściwości InternalBufferSize na potrzeby monitorowania katalogu za pośrednictwem sieci, to 64 KB.The maximum size you can set for the InternalBufferSize property for monitoring a directory over the network is 64 KB.

Uwaga

Uruchamianie FileSystemWatcher w systemie Windows 98 nie jest obsługiwane.Running FileSystemWatcher on Windows 98 is not supported.

Kopiowanie i przenoszenie folderówCopying and moving folders

System operacyjny i obiekt FileSystemWatcher interpretują akcję wycinania i wklejania albo akcję przenoszenia jako akcję zmiany nazwy dla folderu i jego zawartości.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. Jeśli wytniesz i wkleisz folder z plikami w monitorowanym folderze, obiekt FileSystemWatcher będzie zgłaszać tylko folder jako nowy, ale nie jego zawartość, ponieważ zasadniczo zmieniono jego nazwę.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.

Aby otrzymywać powiadomienia o przenoszeniu lub skopiowaniu zawartości folderów do folderu obserwowany, podaj OnChanged i OnRenamed metody obsługi zdarzeń zgodnie z opisem w poniższej tabeli.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.

Program obsługi zdarzeńEvent Handler Zdarzenia obsłużoneEvents Handled WykonywanyPerforms
OnChanged Changed, Created, DeletedChanged, Created, Deleted Raportuj zmiany w atrybutach plików, utworzonych plikach i usuniętych plikach.Report changes in file attributes, created files, and deleted files.
OnRenamed Renamed Wyświetl listę starych i nowych ścieżek plików i folderów, które zostały zmienione, w razie konieczności rozwinięcie rekursywnie.List the old and new paths of renamed files and folders, expanding recursively if needed.

Zdarzenia i rozmiary buforówEvents and Buffer Sizes

Należy zauważyć, że niektóre czynniki mogą wpłynąć na to, które zdarzenia zmiany systemu plików są wywoływane, zgodnie z opisem w następujących tematach:Note that several factors can affect which file system change events are raised, as described by the following:

  • Typowe operacje systemu plików mogą spowodować wystąpienie więcej niż jednego zdarzenia.Common file system operations might raise more than one event. Na przykład gdy plik jest przenoszony z jednego katalogu do innego, mogą zostać zgłoszone kilka OnChanged i zdarzeń OnCreated i OnDeleted.For example, when a file is moved from one directory to another, several OnChanged and some OnCreated and OnDeleted events might be raised. Przeniesienie pliku jest skomplikowaną operacją, która składa się z wielu prostych operacji, a tym samym wywołuje wiele zdarzeń.Moving a file is a complex operation that consists of multiple simple operations, therefore raising multiple events. Podobnie niektóre aplikacje (na przykład oprogramowanie antywirusowe) mogą spowodować dodatkowe zdarzenia systemu plików, które są wykrywane przez FileSystemWatcher.Likewise, some applications (for example, antivirus software) might cause additional file system events that are detected by FileSystemWatcher.

  • FileSystemWatcher może obserwować dyski, o ile nie zostały one przełączone ani usunięte.The FileSystemWatcher can watch disks as long as they are not switched or removed. FileSystemWatcher nie zgłasza zdarzeń dla dysków CD i DVD, ponieważ nie można zmienić sygnatur czasowych i właściwości.The FileSystemWatcher does not raise events for CDs and DVDs, because time stamps and properties cannot change. Aby składnik działał prawidłowo, komputery zdalne muszą mieć zainstalowane jedną z wymaganych platform.Remote computers must have one of the required platforms installed for the component to function properly.

Należy zauważyć, że FileSystemWatcher może pominąć zdarzenie, gdy rozmiar buforu zostanie przekroczony.Note that a FileSystemWatcher may miss an event when the buffer size is exceeded. Aby uniknąć brakujących zdarzeń, postępuj zgodnie z następującymi wskazówkami:To avoid missing events, follow these guidelines:

  • Zwiększ rozmiar buforu, ustawiając właściwość InternalBufferSize.Increase the buffer size by setting the InternalBufferSize property.

  • Unikaj oglądania plików o długich nazwach plików, ponieważ długa nazwa pliku przyczynia się do wypełniania buforu.Avoid watching files with long file names, because a long file name contributes to filling up the buffer. Rozważ zmianę nazwy tych plików przy użyciu krótszych nazw.Consider renaming these files using shorter names.

  • Przechowuj kod obsługi zdarzeń jak najkrótszy, jak to możliwe.Keep your event handling code as short as possible.

Konstruktory

FileSystemWatcher()

Inicjuje nowe wystąpienie klasy FileSystemWatcher.Initializes a new instance of the FileSystemWatcher class.

FileSystemWatcher(String)

Inicjuje nowe wystąpienie klasy FileSystemWatcher, uwzględniając określony katalog do monitorowania.Initializes a new instance of the FileSystemWatcher class, given the specified directory to monitor.

FileSystemWatcher(String, String)

Inicjuje nowe wystąpienie klasy FileSystemWatcher, uwzględniając określony katalog i typ plików do monitorowania.Initializes a new instance of the FileSystemWatcher class, given the specified directory and type of files to monitor.

Właściwości

CanRaiseEvents

Pobiera wartość wskazującą, czy składnik może zgłosić zdarzenie.Gets a value indicating whether the component can raise an event.

(Odziedziczone po Component)
Container

Pobiera IContainer, który zawiera Component.Gets the IContainer that contains the Component.

(Odziedziczone po Component)
DesignMode

Pobiera wartość wskazującą, czy Component jest obecnie w trybie projektowania.Gets a value that indicates whether the Component is currently in design mode.

(Odziedziczone po Component)
EnableRaisingEvents

Pobiera lub ustawia wartość wskazującą, czy składnik jest włączony.Gets or sets a value indicating whether the component is enabled.

Events

Pobiera listę programów obsługi zdarzeń, które są dołączone do tego Component.Gets the list of event handlers that are attached to this Component.

(Odziedziczone po Component)
Filter

Pobiera lub ustawia ciąg filtru używany do określania, które pliki są monitorowane w katalogu.Gets or sets the filter string used to determine what files are monitored in a directory.

Filters

Pobiera kolekcję wszystkich filtrów używanych do określania, które pliki są monitorowane w katalogu.Gets the collection of all the filters used to determine what files are monitored in a directory.

IncludeSubdirectories

Pobiera lub ustawia wartość wskazującą, czy podkatalogi w określonej ścieżce mają być monitorowane.Gets or sets a value indicating whether subdirectories within the specified path should be monitored.

InternalBufferSize

Pobiera lub ustawia rozmiar (w bajtach) bufora wewnętrznego.Gets or sets the size (in bytes) of the internal buffer.

NotifyFilter

Pobiera lub ustawia typ zmian, które mają być obserwowane.Gets or sets the type of changes to watch for.

Path

Pobiera lub ustawia ścieżkę katalogu do obserwowania.Gets or sets the path of the directory to watch.

Site

Pobiera lub ustawia ISite dla FileSystemWatcher.Gets or sets an ISite for the FileSystemWatcher.

SynchronizingObject

Pobiera lub ustawia obiekt używany do organizowania wywołań obsługi zdarzeń, który został wygenerowany w wyniku zmiany katalogu.Gets or sets the object used to marshal the event handler calls issued as a result of a directory change.

Metody

BeginInit()

Rozpoczyna inicjowanie FileSystemWatcher używany w formularzu lub używany przez inny składnik.Begins the initialization of a FileSystemWatcher used on a form or used by another component. Inicjalizacja występuje w czasie wykonywania.The initialization occurs at run time.

CreateObjRef(Type)

Tworzy obiekt, który zawiera wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikacji z obiektem zdalnym.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Odziedziczone po MarshalByRefObject)
Dispose()

Zwalnia niezarządzane zasoby używane przez FileSystemWatcher.Releases the unmanaged resources used by the FileSystemWatcher.

Dispose(Boolean)

Zwalnia zasoby niezarządzane używane przez element FileSystemWatcher i opcjonalnie zwalnia zasoby zarządzane.Releases the unmanaged resources used by the FileSystemWatcher and optionally releases the managed resources.

EndInit()

Przerywa inicjowanie FileSystemWatcher używany w formularzu lub używany przez inny składnik.Ends the initialization of a FileSystemWatcher used on a form or used by another component. Inicjalizacja występuje w czasie wykonywania.The initialization occurs at run time.

Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
Finalize()

Zwalnia zasoby blokowane przez bieżące wystąpienie.Releases the resources held by the current instance.

GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetLifetimeService()

Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
GetService(Type)

Zwraca obiekt, który reprezentuje usługę dostarczoną przez Component lub Container.Returns an object that represents a service provided by the Component or by its Container.

(Odziedziczone po Component)
GetType()

Pobiera Type bieżącego wystąpienia.Gets the Type of the current instance.

(Odziedziczone po Object)
InitializeLifetimeService()

Uzyskuje obiekt usługi istnienia w celu kontrolowania zasad okresu istnienia dla tego wystąpienia.Obtains a lifetime service object to control the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
MemberwiseClone()

Tworzy skróconą kopię bieżącego Object.Creates a shallow copy of the current Object.

(Odziedziczone po Object)
MemberwiseClone(Boolean)

Tworzy skróconą kopię bieżącego obiektu MarshalByRefObject.Creates a shallow copy of the current MarshalByRefObject object.

(Odziedziczone po MarshalByRefObject)
OnChanged(FileSystemEventArgs)

Podnosi zdarzenie Changed.Raises the Changed event.

OnCreated(FileSystemEventArgs)

Podnosi zdarzenie Created.Raises the Created event.

OnDeleted(FileSystemEventArgs)

Podnosi zdarzenie Deleted.Raises the Deleted event.

OnError(ErrorEventArgs)

Podnosi zdarzenie Error.Raises the Error event.

OnRenamed(RenamedEventArgs)

Podnosi zdarzenie Renamed.Raises the Renamed event.

ToString()

Zwraca String zawierający nazwę Component, jeśli istnieje.Returns a String containing the name of the Component, if any. Ta metoda nie powinna być przesłaniana.This method should not be overridden.

(Odziedziczone po Component)
WaitForChanged(WatcherChangeTypes)

Metoda synchroniczna zwracająca strukturę, która zawiera określone informacje dotyczące zmiany, która wystąpiła, przy uwzględnieniu typu zmiany, która ma być monitorowana.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)

Metoda synchroniczna zwracająca strukturę, która zawiera określone informacje dotyczące zmiany, która wystąpiła, w zależności od typu zmiany, która ma być monitorowana, oraz czasu (w milisekundach) oczekiwania przed upływem limitu czasu.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.

Zdarzenia

Changed

Występuje, gdy zostanie zmieniony plik lub katalog w określonym Path.Occurs when a file or directory in the specified Path is changed.

Created

Występuje, gdy zostanie utworzony plik lub katalog w określonym Path.Occurs when a file or directory in the specified Path is created.

Deleted

Występuje, gdy zostanie usunięty plik lub katalog w określonym Path.Occurs when a file or directory in the specified Path is deleted.

Disposed

Występuje, gdy składnik zostanie usunięty przez wywołanie metody Dispose().Occurs when the component is disposed by a call to the Dispose() method.

(Odziedziczone po Component)
Error

Występuje, gdy wystąpienie FileSystemWatcher nie może kontynuować monitorowania zmian lub przepełnienie buforu wewnętrznego.Occurs when the instance of FileSystemWatcher is unable to continue monitoring changes or when the internal buffer overflows.

Renamed

Występuje, gdy zostanie zmieniona nazwa pliku lub katalogu w określonym Path.Occurs when a file or directory in the specified Path is renamed.

Dotyczy

Zobacz też