FileSystemWatcher Třída

Definice

Naslouchat oznámením o změnách systému souborů a vyvolává události při změně adresáře nebo souboru v adresáři.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
Dědičnost
FileSystemWatcher
Dědičnost
FileSystemWatcher
Atributy
Implementuje

Příklady

Následující příklad vytvoří FileSystemWatcher ke sledování adresáře zadaného v době běhu.The following example creates a FileSystemWatcher to watch the directory specified at run time. Tato součást je nastavená tak, aby sledovala změny v LastWrite a LastAccess čas, vytváření, odstraňování nebo přejmenování textových souborů v adresáři.The component is set to watch for changes in LastWrite and LastAccess time, the creation, deletion, or renaming of text files in the directory. Pokud se soubor změní, vytvoří nebo odstraní, cesta k souboru se vytiskne do konzoly.If a file is changed, created, or deleted, the path to the file prints to the console. Při přejmenování souboru se stará a nová cesta vytisknou do konzoly.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

Poznámky

Použijte FileSystemWatcher ke sledování změn v zadaném adresáři.Use FileSystemWatcher to watch for changes in a specified directory. Můžete sledovat změny v souborech a podadresářích v zadaném adresáři.You can watch for changes in files and subdirectories of the specified directory. Můžete vytvořit komponentu pro sledování souborů v místním počítači, síťové jednotce nebo vzdáleném počítači.You can create a component to watch files on a local computer, a network drive, or a remote computer.

Chcete-li sledovat změny ve všech souborech, nastavte vlastnost Filter na prázdný řetězec ("") nebo použijte zástupné znaky ("*".*").To watch for changes in all files, set the Filter property to an empty string ("") or use wildcards ("*.*"). Chcete-li sledovat určitý soubor, nastavte vlastnost Filter na název souboru.To watch a specific file, set the Filter property to the file name. Chcete-li například sledovat změny v souboru MyDoc. txt, nastavte vlastnost Filter na hodnotu "MyDoc. txt".For example, to watch for changes in the file MyDoc.txt, set the Filter property to "MyDoc.txt". Můžete také sledovat změny určitého typu souboru.You can also watch for changes in a certain type of file. Chcete-li například sledovat změny v textových souborech, nastavte vlastnost Filter na hodnotu "*. txt".For example, to watch for changes in text files, set the Filter property to "*.txt".

Existuje několik typů změn, které můžete v adresáři nebo souboru sledovat.There are several types of changes you can watch for in a directory or file. Můžete například sledovat změny v Attributes, LastWrite datum a čas nebo Size souborů nebo adresářů.For example, you can watch for changes in Attributes, the LastWrite date and time, or the Size of files or directories. To se provádí nastavením vlastnosti NotifyFilter na jednu z hodnot NotifyFilters.This is done by setting the NotifyFilter property to one of the NotifyFilters values. Další informace o typu změn, které můžete sledovat, najdete v tématu NotifyFilters.For more information on the type of changes you can watch, see NotifyFilters.

Můžete sledovat přejmenování, odstranění nebo vytváření souborů nebo adresářů.You can watch for renaming, deletion, or creation of files or directories. Chcete-li například sledovat přejmenování textových souborů, nastavte vlastnost Filter na "*. txt" a zavolejte metodu WaitForChanged s Renamed určeným pro svůj parametr.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.

Operační systém Windows upozorňuje vaši komponentu na změny souborů ve vyrovnávací paměti vytvořené FileSystemWatcher.The Windows operating system notifies your component of file changes in a buffer created by the FileSystemWatcher. Pokud je v krátké době mnoho změn, vyrovnávací paměť může přetečení.If there are many changes in a short time, the buffer can overflow. Tím dojde k tomu, že komponenta ztratí sledovat změny v adresáři a bude poskytovat pouze hromadné oznámení.This causes the component to lose track of changes in the directory, and it will only provide blanket notification. Zvětšení velikosti vyrovnávací paměti s vlastností InternalBufferSize je nákladné, protože pochází z nestránkované paměti, kterou nelze odkládací na disk, proto Udržujte vyrovnávací paměť dostatečně velkou, aby nedošlo k žádným událostem změny souborů.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. Chcete-li se vyhnout přetečení vyrovnávací paměti, použijte vlastnosti NotifyFilter a IncludeSubdirectories, abyste mohli vyfiltrovat nežádoucí oznámení o změně.To avoid a buffer overflow, use the NotifyFilter and IncludeSubdirectories properties so you can filter out unwanted change notifications.

Seznam počátečních hodnot vlastností pro instanci FileSystemWatchernaleznete v konstruktoru FileSystemWatcher.For a list of initial property values for an instance of FileSystemWatcher, see the FileSystemWatcher constructor.

Při použití třídy FileSystemWatcher Pamatujte na toto:.Please note the following when using the FileSystemWatcher class.

  • Skryté soubory se neignorují.Hidden files are not ignored.

  • V některých systémech FileSystemWatcher nahlásí změny souborů ve formátu krátkého názvu souboru 8,3.In some systems, FileSystemWatcher reports changes to files using the short 8.3 file name format. Například změna na "LongFileName. LongExtension" může být hlášena jako "LongFil ~. Lon".For example, a change to "LongFileName.LongExtension" could be reported as "LongFil~.Lon".

  • Tato třída obsahuje požadavek na propojení a požadavek dědičnosti na úrovni třídy, který se vztahuje na všechny členy.This class contains a link demand and an inheritance demand at the class level that applies to all members. SecurityException je vyvolána, když buď bezprostřední volající, nebo odvozená třída nemá oprávnění úplného vztahu důvěryhodnosti.A SecurityException is thrown when either the immediate caller or the derived class does not have full-trust permission. Podrobnosti o požadavcích na zabezpečení najdete v tématu požadavky na propojení.For details about security demands, see Link Demands.

  • Maximální velikost, kterou můžete nastavit pro vlastnost InternalBufferSize pro monitorování adresáře přes síť je 64 KB.The maximum size you can set for the InternalBufferSize property for monitoring a directory over the network is 64 KB.

Poznámka

Spouštění FileSystemWatcher v systému Windows 98 není podporováno.Running FileSystemWatcher on Windows 98 is not supported.

Kopírování a přesouvání složekCopying and moving folders

Operační systém a objekt FileSystemWatcher interpretují akci vyjmutí a vložení nebo akci přesunutí jako akci přejmenování složky a jejího obsahu.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. Pokud vyjmete a vložíte složku se soubory do složky, která je sledována, objekt FileSystemWatcher zobrazí pouze složku jako novou, ale ne její obsah, protože jsou v podstatě pouze přejmenovány.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.

Chcete-li být upozorněni na přesunutí nebo zkopírování obsahu složek do sledované složky, poskytněte OnChanged a OnRenamed obslužné rutiny události, jak je navrženo v následující tabulce.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.

Obslužná rutina událostiEvent Handler Zpracované událostiEvents Handled VytvoříPerforms
OnChanged Changed, Created, DeletedChanged, Created, Deleted Vykázat změny atributů souborů, vytvořených souborů a odstraněných souborů.Report changes in file attributes, created files, and deleted files.
OnRenamed Renamed Vypíše staré a nové cesty přejmenovaných souborů a složek a v případě potřeby se rozbalí rekurzivně.List the old and new paths of renamed files and folders, expanding recursively if needed.

Události a velikosti vyrovnávací pamětiEvents and Buffer Sizes

Všimněte si, že některé faktory mohou ovlivnit, které události změny systému souborů jsou vyvolány, jak je popsáno v následujícím tématu:Note that several factors can affect which file system change events are raised, as described by the following:

  • Běžné operace systému souborů mohou vyvolat více než jednu událost.Common file system operations might raise more than one event. Například když je soubor přesunut z jednoho adresáře do jiného, může být vyvoláno několik OnChanged a některé OnCreated a OnDeleted události.For example, when a file is moved from one directory to another, several OnChanged and some OnCreated and OnDeleted events might be raised. Přesunutí souboru je složitá operace, která se skládá z několika jednoduchých operací, a proto vyvolává více událostí.Moving a file is a complex operation that consists of multiple simple operations, therefore raising multiple events. Podobně některé aplikace (například antivirový software) mohou způsobit další události systému souborů, které jsou zjišťovány FileSystemWatcher.Likewise, some applications (for example, antivirus software) might cause additional file system events that are detected by FileSystemWatcher.

  • FileSystemWatcher může sledovat disky, pokud nejsou přepnuty nebo odebrány.The FileSystemWatcher can watch disks as long as they are not switched or removed. FileSystemWatcher nevyvolá události pro disky CD a DVD, protože časová razítka a vlastnosti nelze změnit.The FileSystemWatcher does not raise events for CDs and DVDs, because time stamps and properties cannot change. Aby součást fungovala správně, musí se na vzdálených počítačích nainstalovat jedna z požadovaných platforem.Remote computers must have one of the required platforms installed for the component to function properly.

Všimněte si, že FileSystemWatcher může při překročení velikosti vyrovnávací paměti přijít o událost.Note that a FileSystemWatcher may miss an event when the buffer size is exceeded. Chcete-li se vyhnout chybějícím událostem, postupujte podle těchto pokynů:To avoid missing events, follow these guidelines:

  • Zvětšete velikost vyrovnávací paměti nastavením vlastnosti InternalBufferSize.Increase the buffer size by setting the InternalBufferSize property.

  • Vyhněte se sledování souborů s dlouhými názvy souborů, protože dlouhý název souboru přispívá k naplnění vyrovnávací paměti.Avoid watching files with long file names, because a long file name contributes to filling up the buffer. Zvažte přejmenování těchto souborů s použitím kratších názvů.Consider renaming these files using shorter names.

  • Udržujte kód pro zpracování událostí co nejkratší.Keep your event handling code as short as possible.

Konstruktory

FileSystemWatcher()

Inicializuje novou instanci třídy FileSystemWatcher.Initializes a new instance of the FileSystemWatcher class.

FileSystemWatcher(String)

Inicializuje novou instanci třídy FileSystemWatcher v zadaném adresáři, který se má monitorovat.Initializes a new instance of the FileSystemWatcher class, given the specified directory to monitor.

FileSystemWatcher(String, String)

Inicializuje novou instanci třídy FileSystemWatcher v zadaném adresáři a typu souborů, které se mají monitorovat.Initializes a new instance of the FileSystemWatcher class, given the specified directory and type of files to monitor.

Vlastnosti

CanRaiseEvents

Získá hodnotu, která označuje, zda může komponenta vyvolat událost.Gets a value indicating whether the component can raise an event.

(Zděděno od Component)
Container

Získá IContainer, který obsahuje Component.Gets the IContainer that contains the Component.

(Zděděno od Component)
DesignMode

Získá hodnotu, která označuje, zda je Component aktuálně v režimu návrhu.Gets a value that indicates whether the Component is currently in design mode.

(Zděděno od Component)
EnableRaisingEvents

Získá nebo nastaví hodnotu označující, jestli je součást povolená.Gets or sets a value indicating whether the component is enabled.

Events

Získá seznam obslužných rutin událostí, které jsou připojeny k tomuto Component.Gets the list of event handlers that are attached to this Component.

(Zděděno od Component)
Filter

Získá nebo nastaví řetězec filtru sloužící k určení, které soubory jsou monitorovány v adresáři.Gets or sets the filter string used to determine what files are monitored in a directory.

Filters

Získá kolekci všech filtrů používaných k určení, které soubory jsou monitorovány v adresáři.Gets the collection of all the filters used to determine what files are monitored in a directory.

IncludeSubdirectories

Získá nebo nastaví hodnotu označující, jestli se mají monitorovat podadresáře v zadané cestě.Gets or sets a value indicating whether subdirectories within the specified path should be monitored.

InternalBufferSize

Získá nebo nastaví velikost vnitřní vyrovnávací paměti (v bajtech).Gets or sets the size (in bytes) of the internal buffer.

NotifyFilter

Získá nebo nastaví typ změn, které se mají sledovat.Gets or sets the type of changes to watch for.

Path

Získá nebo nastaví cestu k adresáři, který se má sledovat.Gets or sets the path of the directory to watch.

Site

Získá nebo nastaví ISite pro FileSystemWatcher.Gets or sets an ISite for the FileSystemWatcher.

SynchronizingObject

Získá nebo nastaví objekt použitý k zařazování volání obsluhy události vyvolané v důsledku změny adresáře.Gets or sets the object used to marshal the event handler calls issued as a result of a directory change.

Metody

BeginInit()

Zahájí inicializaci FileSystemWatcher používaného ve formuláři nebo používaného jinou komponentou.Begins the initialization of a FileSystemWatcher used on a form or used by another component. K inicializaci dochází v době běhu.The initialization occurs at run time.

CreateObjRef(Type)

Vytvoří objekt, který obsahuje všechny relevantní informace požadované pro vygenerování proxy serveru, který se používá ke komunikaci se vzdáleným objektem.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Zděděno od MarshalByRefObject)
Dispose()

Uvolní nespravované prostředky, které používá FileSystemWatcher.Releases the unmanaged resources used by the FileSystemWatcher.

Dispose(Boolean)

Uvolní nespravované prostředky používané FileSystemWatcher a volitelně uvolňuje spravované prostředky.Releases the unmanaged resources used by the FileSystemWatcher and optionally releases the managed resources.

EndInit()

Ukončí inicializaci FileSystemWatcher používaného ve formuláři nebo používaného jinou komponentou.Ends the initialization of a FileSystemWatcher used on a form or used by another component. K inicializaci dochází v době běhu.The initialization occurs at run time.

Equals(Object)

Určí, zda se zadaný objekt rovná aktuálnímu objektu.Determines whether the specified object is equal to the current object.

(Zděděno od Object)
Finalize()

Uvolní prostředky držené aktuální instancí.Releases the resources held by the current instance.

GetHashCode()

Slouží jako výchozí funkce hash.Serves as the default hash function.

(Zděděno od Object)
GetLifetimeService()

Načte aktuální objekt služby životnosti, který řídí zásady životního cyklu pro tuto instanci.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Zděděno od MarshalByRefObject)
GetService(Type)

Vrátí objekt, který představuje službu poskytnutou Component nebo jeho Container.Returns an object that represents a service provided by the Component or by its Container.

(Zděděno od Component)
GetType()

Získá Type aktuální instance.Gets the Type of the current instance.

(Zděděno od Object)
InitializeLifetimeService()

Získá objekt služby životnosti, který řídí zásady životního cyklu pro tuto instanci.Obtains a lifetime service object to control the lifetime policy for this instance.

(Zděděno od MarshalByRefObject)
MemberwiseClone()

Vytvoří kopii aktuálního Objectbez podstruktury.Creates a shallow copy of the current Object.

(Zděděno od Object)
MemberwiseClone(Boolean)

Vytvoří kopii aktuálního objektu MarshalByRefObject bez podstruktury.Creates a shallow copy of the current MarshalByRefObject object.

(Zděděno od MarshalByRefObject)
OnChanged(FileSystemEventArgs)

Vyvolá událost Changed.Raises the Changed event.

OnCreated(FileSystemEventArgs)

Vyvolá událost Created.Raises the Created event.

OnDeleted(FileSystemEventArgs)

Vyvolá událost Deleted.Raises the Deleted event.

OnError(ErrorEventArgs)

Vyvolá událost Error.Raises the Error event.

OnRenamed(RenamedEventArgs)

Vyvolá událost Renamed.Raises the Renamed event.

ToString()

Vrátí String obsahující název Component, pokud existuje.Returns a String containing the name of the Component, if any. Tato metoda by neměla být přepsána.This method should not be overridden.

(Zděděno od Component)
WaitForChanged(WatcherChangeTypes)

Synchronní metoda, která vrátí strukturu, která obsahuje konkrétní informace o změně, ke které došlo, podle typu změny, kterou chcete monitorovat.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)

Synchronní metoda, která vrátí strukturu, která obsahuje konkrétní informace o změně, ke které došlo, podle typu změny, kterou chcete monitorovat, a času (v milisekundách), které se má počkat před vypršením časového limitu.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.

Události

Changed

Nastane, pokud se změní soubor nebo adresář v zadaném Path.Occurs when a file or directory in the specified Path is changed.

Created

Vyvolá se při vytvoření souboru nebo adresáře v zadaném Path.Occurs when a file or directory in the specified Path is created.

Deleted

Nastane, pokud se odstraní soubor nebo adresář v zadaném Path.Occurs when a file or directory in the specified Path is deleted.

Disposed

Nastane, pokud je komponenta uvolněna voláním metody Dispose().Occurs when the component is disposed by a call to the Dispose() method.

(Zděděno od Component)
Error

Vyvolá se v případě, že instance FileSystemWatcher nemůže pokračovat v monitorování nebo když dojde k přetečení vnitřní vyrovnávací paměti.Occurs when the instance of FileSystemWatcher is unable to continue monitoring changes or when the internal buffer overflows.

Renamed

Nastane, pokud se přejmenuje soubor nebo adresář v zadaném Path.Occurs when a file or directory in the specified Path is renamed.

Platí pro

Viz také