FileSystemWatcher FileSystemWatcher FileSystemWatcher FileSystemWatcher Class

Definição

Monitora as notificações de alteração do sistema de arquivos e gera eventos quando um diretório, ou um arquivo em um diretório, é alterado.Listens to the file system change notifications and raises events when a directory, or file in a directory, changes.

public ref class FileSystemWatcher : System::ComponentModel::Component, System::ComponentModel::ISupportInitialize
[System.IO.IODescription("")]
[System.IO.IODescription("FileSystemWatcherDesc")]
public class FileSystemWatcher : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize
type FileSystemWatcher = class
    inherit Component
    interface ISupportInitialize
Public Class FileSystemWatcher
Inherits Component
Implements ISupportInitialize
Herança
Atributos
Implementações

Exemplos

O exemplo a seguir cria FileSystemWatcher um para observar o diretório especificado em tempo de execução.The following example creates a FileSystemWatcher to watch the directory specified at run time. O componente é definido para observar as alterações em LastWrite e LastAccess hora, a criação, a exclusão ou a renomeação de arquivos de texto no diretório.The component is set to watch for changes in LastWrite and LastAccess time, the creation, deletion, or renaming of text files in the directory. Se um arquivo for alterado, criado ou excluído, o caminho para o arquivo será impresso no console.If a file is changed, created, or deleted, the path to the file prints to the console. Quando um arquivo é renomeado, os caminhos novos e antigos são impressos no console do.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
Imports System.IO
Imports System.Security.Permissions
Imports Microsoft.VisualBasic

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

Comentários

Use FileSystemWatcher para observar alterações em um diretório especificado.Use FileSystemWatcher to watch for changes in a specified directory. Você pode observar as alterações nos arquivos e subdiretórios do diretório especificado.You can watch for changes in files and subdirectories of the specified directory. Você pode criar um componente para observar arquivos em um computador local, uma unidade de rede ou um computador remoto.You can create a component to watch files on a local computer, a network drive, or a remote computer.

Para observar as alterações em todos os arquivos, defina Filter a propriedade como uma cadeia de caracteres vazia ("") ou use caracteres curinga (*"*.").To watch for changes in all files, set the Filter property to an empty string ("") or use wildcards ("*.*"). Para observar um arquivo específico, defina a Filter Propriedade como o nome do arquivo.To watch a specific file, set the Filter property to the file name. Por exemplo, para observar alterações no arquivo MyDoc. txt, defina a Filter Propriedade como "MyDoc. txt".For example, to watch for changes in the file MyDoc.txt, set the Filter property to "MyDoc.txt". Você também pode observar as alterações em um determinado tipo de arquivo.You can also watch for changes in a certain type of file. Por exemplo, para observar alterações em arquivos de texto, defina a Filter Propriedade como "*. txt".For example, to watch for changes in text files, set the Filter property to "*.txt".

Há vários tipos de alterações que você pode observar em um diretório ou arquivo.There are several types of changes you can watch for in a directory or file. Por exemplo, você pode observar as alterações no Attributes, a LastWrite data e hora ou o Size de arquivos ou diretórios.For example, you can watch for changes in Attributes, the LastWrite date and time, or the Size of files or directories. Isso é feito definindo a NotifyFilter Propriedade como um NotifyFilters dos valores.This is done by setting the NotifyFilter property to one of the NotifyFilters values. Para obter mais informações sobre o tipo de alterações que você pode observar NotifyFilters, consulte.For more information on the type of changes you can watch, see NotifyFilters.

Você pode observar a renomeação, a exclusão ou a criação de arquivos ou diretórios.You can watch for renaming, deletion, or creation of files or directories. Por exemplo, para observar a renomeação de arquivos de texto, Filter defina a propriedade como "*. txt" e WaitForChanged chame o método Renamed com um especificado para seu parâmetro.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.

O sistema operacional Windows notifica seu componente sobre as alterações de arquivo em um buffer criado pelo FileSystemWatcher.The Windows operating system notifies your component of file changes in a buffer created by the FileSystemWatcher. Se houver muitas alterações em um curto período de tempo, o buffer poderá ser estourado.If there are many changes in a short time, the buffer can overflow. Isso faz com que o componente perca o controle das alterações no diretório, e ele só fornecerá uma notificação em forma de cobertura.This causes the component to lose track of changes in the directory, and it will only provide blanket notification. Aumentar o tamanho do buffer com a InternalBufferSize propriedade é caro, pois vem de uma memória não paginável que não pode ser trocada no disco, portanto, mantenha o buffer tão pequeno, mas grande o suficiente para não perder nenhum evento de alteração de arquivo.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. Para evitar um estouro de buffer, use NotifyFilter as IncludeSubdirectories Propriedades e para que você possa filtrar as notificações de alteração indesejadas.To avoid a buffer overflow, use the NotifyFilter and IncludeSubdirectories properties so you can filter out unwanted change notifications.

Para obter uma lista de valores de propriedade inicial para uma FileSystemWatcherinstância do, FileSystemWatcher consulte o construtor.For a list of initial property values for an instance of FileSystemWatcher, see the FileSystemWatcher constructor.

Observe o seguinte ao usar a FileSystemWatcher classe.Please note the following when using the FileSystemWatcher class.

  • Arquivos ocultos não são ignorados.Hidden files are not ignored.

  • Em alguns sistemas, FileSystemWatcher o relata alterações em arquivos usando o formato de nome de arquivo 8,3 curto.In some systems, FileSystemWatcher reports changes to files using the short 8.3 file name format. Por exemplo, uma alteração de "LongFileName. LongExtension" poderia ser relatada como "LongFil ~. Lon ".For example, a change to "LongFileName.LongExtension" could be reported as "LongFil~.Lon".

  • Esta classe contém uma demanda de link e uma demanda de herança no nível de classe que se aplica a todos os membros.This class contains a link demand and an inheritance demand at the class level that applies to all members. Um SecurityException é lançado quando o chamador imediato ou a classe derivada não tem permissão de confiança total.A SecurityException is thrown when either the immediate caller or the derived class does not have full-trust permission. Para obter detalhes sobre as demandas de segurança, consulte demandas de link.For details about security demands, see Link Demands.

  • O tamanho máximo que você pode definir para InternalBufferSize a propriedade para monitorar um diretório pela rede é de 64 KB.The maximum size you can set for the InternalBufferSize property for monitoring a directory over the network is 64 KB.

Observação

Não FileSystemWatcher há suporte para a execução no Windows 98.Running FileSystemWatcher on Windows 98 is not supported.

Copiando e movendo pastasCopying and moving folders

O sistema operacional e FileSystemWatcher o objeto interpretam uma ação de renomeação e colagem ou uma ação de movimentação como uma ação de Rename para uma pasta e seu conteúdo.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. Se você recortar e colar uma pasta com arquivos em uma pasta que está sendo FileSystemWatcher observada, o objeto relatará apenas a pasta como nova, mas não seu conteúdo porque elas são basicamente apenas renomeadas.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.

Para ser notificado de que o conteúdo das pastas foi movido ou copiado para uma pasta monitorada OnRenamed , forneça OnChanged e métodos de manipulador de eventos, conforme sugerido na tabela a seguir.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.

Manipulador de eventosEvent Handler Eventos manipuladosEvents Handled ExecutaPerforms
OnChanged Changed, Created, DeletedChanged, Created, Deleted Relatar alterações em atributos de arquivo, arquivos criados e arquivos excluídos.Report changes in file attributes, created files, and deleted files.
OnRenamed Renamed Liste os caminhos novos e antigos de arquivos e pastas renomeados, expandindo recursivamente se necessário.List the old and new paths of renamed files and folders, expanding recursively if needed.

Eventos e tamanhos de bufferEvents and Buffer Sizes

Observe que vários fatores podem afetar quais eventos de alteração do sistema de arquivos são gerados, conforme descrito pelo seguinte:Note that several factors can affect which file system change events are raised, as described by the following:

  • As operações comuns do sistema de arquivos podem gerar mais de um evento.Common file system operations might raise more than one event. Por exemplo, quando um arquivo é movido de um diretório para outro, vários OnChanged e alguns OnCreated eventos OnDeleted e podem ser gerados.For example, when a file is moved from one directory to another, several OnChanged and some OnCreated and OnDeleted events might be raised. Mover um arquivo é uma operação complexa que consiste em várias operações simples, gerando, portanto, vários eventos.Moving a file is a complex operation that consists of multiple simple operations, therefore raising multiple events. Da mesma forma, alguns aplicativos (por exemplo, software antivírus) podem causar eventos de sistema de arquivos adicionais FileSystemWatcherdetectados pelo.Likewise, some applications (for example, antivirus software) might cause additional file system events that are detected by FileSystemWatcher.

  • O FileSystemWatcher pode observar os discos desde que eles não sejam alternados ou removidos.The FileSystemWatcher can watch disks as long as they are not switched or removed. O FileSystemWatcher não gera eventos para CDs e DVDs, pois carimbos de data/hora e propriedades não podem ser alterados.The FileSystemWatcher does not raise events for CDs and DVDs, because time stamps and properties cannot change. Os computadores remotos devem ter uma das plataformas necessárias instaladas para que o componente funcione corretamente.Remote computers must have one of the required platforms installed for the component to function properly.

  • Se vários FileSystemWatcher objetos estiverem assistindo ao mesmo caminho UNC no Windows XP antes do Service Pack 1 ou do Windows 2000 SP2 ou anterior, somente um dos objetos gerará um evento.If multiple FileSystemWatcher objects are watching the same UNC path in Windows XP prior to Service Pack 1, or Windows 2000 SP2 or earlier, then only one of the objects will raise an event. Em computadores que executam o Windows XP SP1 e mais recente, o Windows 2000 SP3 ou mais recente FileSystemWatcher ou o Windows Server 2003, todos os objetos gerarão os eventos apropriados.On machines running Windows XP SP1 and newer, Windows 2000 SP3 or newer or Windows Server 2003, all FileSystemWatcher objects will raise the appropriate events.

Observe que um FileSystemWatcher pode perder um evento quando o tamanho do buffer for excedido.Note that a FileSystemWatcher may miss an event when the buffer size is exceeded. Para evitar eventos ausentes, siga estas diretrizes:To avoid missing events, follow these guidelines:

  • Aumente o tamanho do buffer definindo a InternalBufferSize propriedade.Increase the buffer size by setting the InternalBufferSize property.

  • Evite assistir arquivos com nomes de arquivo longos, pois um nome de arquivo longo contribui para preencher o buffer.Avoid watching files with long file names, because a long file name contributes to filling up the buffer. Considere renomear esses arquivos usando nomes mais curtos.Consider renaming these files using shorter names.

  • Mantenha seu código de manipulação de eventos o mais curto possível.Keep your event handling code as short as possible.

Construtores

FileSystemWatcher() FileSystemWatcher() FileSystemWatcher() FileSystemWatcher()

Inicializa uma nova instância da classe FileSystemWatcher.Initializes a new instance of the FileSystemWatcher class.

FileSystemWatcher(String) FileSystemWatcher(String) FileSystemWatcher(String) FileSystemWatcher(String)

Inicializa uma nova instância da classe FileSystemWatcher, conforme o diretório especificado para monitorar.Initializes a new instance of the FileSystemWatcher class, given the specified directory to monitor.

FileSystemWatcher(String, String) FileSystemWatcher(String, String) FileSystemWatcher(String, String) FileSystemWatcher(String, String)

Inicializa uma nova instância da classe FileSystemWatcher, conforme o diretório especificado e os tipos de arquivo a se monitorar.Initializes a new instance of the FileSystemWatcher class, given the specified directory and type of files to monitor.

Propriedades

CanRaiseEvents CanRaiseEvents CanRaiseEvents CanRaiseEvents

Obtém um valor que indica se o componente pode acionar um evento.Gets a value indicating whether the component can raise an event.

(Inherited from Component)
Container Container Container Container

Obtém o IContainer que contém o Component.Gets the IContainer that contains the Component.

(Inherited from Component)
DesignMode DesignMode DesignMode DesignMode

Obtém um valor que indica se o Component está no modo de design no momento.Gets a value that indicates whether the Component is currently in design mode.

(Inherited from Component)
EnableRaisingEvents EnableRaisingEvents EnableRaisingEvents EnableRaisingEvents

Obtém ou define um valor que indica se o componente está habilitado.Gets or sets a value indicating whether the component is enabled.

Events Events Events Events

Obtém a lista de manipuladores de eventos que estão anexados a este Component.Gets the list of event handlers that are attached to this Component.

(Inherited from Component)
Filter Filter Filter Filter

Obtém ou define a cadeia de caracteres de filtro usada para determinar quais arquivos são monitorados em um diretório.Gets or sets the filter string used to determine what files are monitored in a directory.

Filters Filters Filters Filters

Obtém a coleção de todos os filtros usados para determinar quais arquivos são monitorados em um diretório.Gets the collection of all the filters used to determine what files are monitored in a directory.

IncludeSubdirectories IncludeSubdirectories IncludeSubdirectories IncludeSubdirectories

Obtém ou define um valor que indica se as subpastas no caminho especificado devem ser monitoradas.Gets or sets a value indicating whether subdirectories within the specified path should be monitored.

InternalBufferSize InternalBufferSize InternalBufferSize InternalBufferSize

Obtém ou define o tamanho (em bytes) do buffer interno.Gets or sets the size (in bytes) of the internal buffer.

NotifyFilter NotifyFilter NotifyFilter NotifyFilter

Obtém ou define o tipo de alterações a serem observadas.Gets or sets the type of changes to watch for.

Path Path Path Path

Obtém ou define o caminho do diretório a ser inspecionado.Gets or sets the path of the directory to watch.

Site Site Site Site

Obtém ou define um ISite para o FileSystemWatcher.Gets or sets an ISite for the FileSystemWatcher.

SynchronizingObject SynchronizingObject SynchronizingObject SynchronizingObject

Obtém ou define o objeto usado para realizar marshaling das chamadas do manipulador de eventos emitidas como resultado de uma alteração de diretório.Gets or sets the object used to marshal the event handler calls issued as a result of a directory change.

Métodos

BeginInit() BeginInit() BeginInit() BeginInit()

Inicia a inicialização de um FileSystemWatcher usado em um formulário ou por outro componente.Begins the initialization of a FileSystemWatcher used on a form or used by another component. A inicialização ocorre no tempo de execução.The initialization occurs at run time.

CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type)

Cria um objeto que contém todas as informações relevantes necessárias para gerar um proxy usado para se comunicar com um objeto remoto.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Inherited from MarshalByRefObject)
Dispose() Dispose() Dispose() Dispose()

Libera os recursos não gerenciados usados pelo FileSystemWatcher.Releases the unmanaged resources used by the FileSystemWatcher.

Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Libera os recursos não gerenciados usados pelo FileSystemWatcher e opcionalmente libera os recursos gerenciados.Releases the unmanaged resources used by the FileSystemWatcher and optionally releases the managed resources.

EndInit() EndInit() EndInit() EndInit()

Encerra a inicialização de um FileSystemWatcher usado em um formulário ou por outro componente.Ends the initialization of a FileSystemWatcher used on a form or used by another component. A inicialização ocorre no tempo de execução.The initialization occurs at run time.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Inherited from Object)
Finalize() Finalize() Finalize() Finalize()

Libera os recursos mantidos pela instância atual.Releases the resources held by the current instance.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Inherited from Object)
GetLifetimeService() GetLifetimeService() GetLifetimeService() GetLifetimeService()

Recupera o objeto de serviço de tempo de vida atual que controla a política de ciclo de vida para esta instância.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
GetService(Type) GetService(Type) GetService(Type) GetService(Type)

Retorna um objeto que representa um serviço fornecido pelo Component ou pelo seu Container.Returns an object that represents a service provided by the Component or by its Container.

(Inherited from Component)
GetType() GetType() GetType() GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Inherited from Object)
InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService()

Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida para essa instância.Obtains a lifetime service object to control the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Inherited from Object)
MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean)

Cria uma cópia superficial do objeto MarshalByRefObject atual.Creates a shallow copy of the current MarshalByRefObject object.

(Inherited from MarshalByRefObject)
OnChanged(FileSystemEventArgs) OnChanged(FileSystemEventArgs) OnChanged(FileSystemEventArgs) OnChanged(FileSystemEventArgs)

Aciona o evento Changed.Raises the Changed event.

OnCreated(FileSystemEventArgs) OnCreated(FileSystemEventArgs) OnCreated(FileSystemEventArgs) OnCreated(FileSystemEventArgs)

Aciona o evento Created.Raises the Created event.

OnDeleted(FileSystemEventArgs) OnDeleted(FileSystemEventArgs) OnDeleted(FileSystemEventArgs) OnDeleted(FileSystemEventArgs)

Aciona o evento Deleted.Raises the Deleted event.

OnError(ErrorEventArgs) OnError(ErrorEventArgs) OnError(ErrorEventArgs) OnError(ErrorEventArgs)

Aciona o evento Error.Raises the Error event.

OnRenamed(RenamedEventArgs) OnRenamed(RenamedEventArgs) OnRenamed(RenamedEventArgs) OnRenamed(RenamedEventArgs)

Aciona o evento Renamed.Raises the Renamed event.

ToString() ToString() ToString() ToString()

Retorna um String que contém o nome do Component, se houver.Returns a String containing the name of the Component, if any. Esse método não deve ser substituído.This method should not be overridden.

(Inherited from Component)
WaitForChanged(WatcherChangeTypes) WaitForChanged(WatcherChangeTypes) WaitForChanged(WatcherChangeTypes) WaitForChanged(WatcherChangeTypes)

Um método síncrono que retorna uma estrutura que contém informações específicas sobre a alteração ocorrida, considerando o tipo de alteração que você deseja monitorar.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) WaitForChanged(WatcherChangeTypes, Int32) WaitForChanged(WatcherChangeTypes, Int32) WaitForChanged(WatcherChangeTypes, Int32)

Um método síncrono que retorna uma estrutura que contém informações específicas sobre a alteração ocorrida, considerando o tipo de alteração que você deseja monitorar e o tempo (em milissegundos) de espera antes do tempo limite.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.

Eventos

Changed Changed Changed Changed

Ocorre quando um arquivo ou diretório no Path especificado é alterado.Occurs when a file or directory in the specified Path is changed.

Created Created Created Created

Ocorre quando um arquivo ou diretório no Path especificado é criado.Occurs when a file or directory in the specified Path is created.

Deleted Deleted Deleted Deleted

Ocorre quando um arquivo ou diretório no Path especificado é excluído.Occurs when a file or directory in the specified Path is deleted.

Disposed Disposed Disposed Disposed

Ocorre quando o componente é disposto por uma chamada para o método Dispose().Occurs when the component is disposed by a call to the Dispose() method.

(Inherited from Component)
Error Error Error Error

Ocorre quando a instância de FileSystemWatcher não pode continuar a monitorar alterações ou quando o buffer interno estoura.Occurs when the instance of FileSystemWatcher is unable to continue monitoring changes or when the internal buffer overflows.

Renamed Renamed Renamed Renamed

Ocorre quando um arquivo ou diretório no Path especificado é renomeado.Occurs when a file or directory in the specified Path is renamed.

Segurança

SecurityPermission
para derivar da ProcessStartInfo classe.for deriving from the ProcessStartInfo class. Valor de demanda InheritanceDemand:; Conjuntos de permissões nomeadas: FullTrust.Demand value: InheritanceDemand; Named Permission Sets: FullTrust.

Aplica-se a

Veja também