FileSystemWatcher Classe

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.

public ref class FileSystemWatcher : System::ComponentModel::Component, System::ComponentModel::ISupportInitialize
public ref class FileSystemWatcher : IDisposable
public ref class FileSystemWatcher : System::ComponentModel::Component, IDisposable, System::ComponentModel::ISupportInitialize
public class FileSystemWatcher : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize
public class FileSystemWatcher : IDisposable
[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
    inherit Component
    interface ISupportInitialize
type FileSystemWatcher = class
    interface IDisposable
[<System.IO.IODescription("FileSystemWatcherDesc")>]
type FileSystemWatcher = class
    inherit Component
    interface ISupportInitialize
type FileSystemWatcher = class
    inherit Component
    interface IDisposable
    interface ISupportInitialize
[<System.IO.IODescription("")>]
type FileSystemWatcher = class
    inherit Component
    interface ISupportInitialize
Public Class FileSystemWatcher
Inherits Component
Implements ISupportInitialize
Public Class FileSystemWatcher
Implements IDisposable
Public Class FileSystemWatcher
Inherits Component
Implements IDisposable, ISupportInitialize
Herança
FileSystemWatcher
Herança
FileSystemWatcher
Atributos
Implementações

Exemplos

O exemplo a seguir cria um FileSystemWatcher para observar o diretório especificado em tempo de execução. O componente está definido para observar as alterações dentro LastWrite e LastAccess hora, a criação, a exclusão ou a renomeação de arquivos de texto no diretório. Se um arquivo for alterado, criado ou excluído, o caminho para o arquivo será impresso no console. Quando um arquivo é renomeado, os caminhos antigos e novos são impressos no console.

#include "pch.h"

using namespace System;
using namespace System::IO;

class MyClassCPP
{
public:

    int static Run()
    {
        FileSystemWatcher^ watcher = gcnew FileSystemWatcher("C:\\path\\to\\folder");

        watcher->NotifyFilter = static_cast<NotifyFilters>(NotifyFilters::Attributes
                                                         | NotifyFilters::CreationTime
                                                         | NotifyFilters::DirectoryName
                                                         | NotifyFilters::FileName
                                                         | NotifyFilters::LastAccess
                                                         | NotifyFilters::LastWrite
                                                         | NotifyFilters::Security
                                                         | NotifyFilters::Size);

        watcher->Changed += gcnew FileSystemEventHandler(MyClassCPP::OnChanged);
        watcher->Created += gcnew FileSystemEventHandler(MyClassCPP::OnCreated);
        watcher->Deleted += gcnew FileSystemEventHandler(MyClassCPP::OnDeleted);
        watcher->Renamed += gcnew RenamedEventHandler(MyClassCPP::OnRenamed);
        watcher->Error   += gcnew ErrorEventHandler(MyClassCPP::OnError);

        watcher->Filter = "*.txt";
        watcher->IncludeSubdirectories = true;
        watcher->EnableRaisingEvents = true;

        Console::WriteLine("Press enter to exit.");
        Console::ReadLine();

        return 0;
    }

private:

    static void OnChanged(Object^ sender, FileSystemEventArgs^ e)
    {
        if (e->ChangeType != WatcherChangeTypes::Changed)
        {
            return;
        }
        Console::WriteLine("Changed: {0}", e->FullPath);
    }

    static void OnCreated(Object^ sender, FileSystemEventArgs^ e)
    {
        Console::WriteLine("Created: {0}", e->FullPath);
    }

    static void OnDeleted(Object^ sender, FileSystemEventArgs^ e)
    {
        Console::WriteLine("Deleted: {0}", e->FullPath);
    }

    static void OnRenamed(Object^ sender, RenamedEventArgs^ e)
    {
        Console::WriteLine("Renamed:");
        Console::WriteLine("    Old: {0}", e->OldFullPath);
        Console::WriteLine("    New: {0}", e->FullPath);
    }

    static void OnError(Object^ sender, ErrorEventArgs^ e)
    {
        PrintException(e->GetException());
    }

    static void PrintException(Exception^ ex)
    {
        if (ex != nullptr)
        {
            Console::WriteLine("Message: {0}", ex->Message);
            Console::WriteLine("Stacktrace:");
            Console::WriteLine(ex->StackTrace);
            Console::WriteLine();
            PrintException(ex->InnerException);
        }
    }
};


int main()
{
    MyClassCPP::Run();
}
using System;
using System.IO;

namespace MyNamespace
{
    class MyClassCS
    {
        static void Main()
        {
            using var watcher = new FileSystemWatcher(@"C:\path\to\folder");

            watcher.NotifyFilter = NotifyFilters.Attributes
                                 | NotifyFilters.CreationTime
                                 | NotifyFilters.DirectoryName
                                 | NotifyFilters.FileName
                                 | NotifyFilters.LastAccess
                                 | NotifyFilters.LastWrite
                                 | NotifyFilters.Security
                                 | NotifyFilters.Size;

            watcher.Changed += OnChanged;
            watcher.Created += OnCreated;
            watcher.Deleted += OnDeleted;
            watcher.Renamed += OnRenamed;
            watcher.Error += OnError;

            watcher.Filter = "*.txt";
            watcher.IncludeSubdirectories = true;
            watcher.EnableRaisingEvents = true;

            Console.WriteLine("Press enter to exit.");
            Console.ReadLine();
        }

        private static void OnChanged(object sender, FileSystemEventArgs e)
        {
            if (e.ChangeType != WatcherChangeTypes.Changed)
            {
                return;
            }
            Console.WriteLine($"Changed: {e.FullPath}");
        }

        private static void OnCreated(object sender, FileSystemEventArgs e)
        {
            string value = $"Created: {e.FullPath}";
            Console.WriteLine(value);
        }

        private static void OnDeleted(object sender, FileSystemEventArgs e) =>
            Console.WriteLine($"Deleted: {e.FullPath}");

        private static void OnRenamed(object sender, RenamedEventArgs e)
        {
            Console.WriteLine($"Renamed:");
            Console.WriteLine($"    Old: {e.OldFullPath}");
            Console.WriteLine($"    New: {e.FullPath}");
        }

        private static void OnError(object sender, ErrorEventArgs e) =>
            PrintException(e.GetException());

        private static void PrintException(Exception? ex)
        {
            if (ex != null)
            {
                Console.WriteLine($"Message: {ex.Message}");
                Console.WriteLine("Stacktrace:");
                Console.WriteLine(ex.StackTrace);
                Console.WriteLine();
                PrintException(ex.InnerException);
            }
        }
    }
}
Imports System.IO

Namespace MyNamespace

    Class MyClassVB

        Shared Sub Main()
            Using watcher = New FileSystemWatcher("C:\path\to\folder")
                watcher.NotifyFilter = NotifyFilters.Attributes Or
                                       NotifyFilters.CreationTime Or
                                       NotifyFilters.DirectoryName Or
                                       NotifyFilters.FileName Or
                                       NotifyFilters.LastAccess Or
                                       NotifyFilters.LastWrite Or
                                       NotifyFilters.Security Or
                                       NotifyFilters.Size

                AddHandler watcher.Changed, AddressOf OnChanged
                AddHandler watcher.Created, AddressOf OnCreated
                AddHandler watcher.Deleted, AddressOf OnDeleted
                AddHandler watcher.Renamed, AddressOf OnRenamed
                AddHandler watcher.Error, AddressOf OnError

                watcher.Filter = "*.txt"
                watcher.IncludeSubdirectories = True
                watcher.EnableRaisingEvents = True

                Console.WriteLine("Press enter to exit.")
                Console.ReadLine()
            End Using
        End Sub

        Private Shared Sub OnChanged(sender As Object, e As FileSystemEventArgs)
            If e.ChangeType <> WatcherChangeTypes.Changed Then
                Return
            End If
            Console.WriteLine($"Changed: {e.FullPath}")
        End Sub

        Private Shared Sub OnCreated(sender As Object, e As FileSystemEventArgs)
            Dim value As String = $"Created: {e.FullPath}"
            Console.WriteLine(value)
        End Sub

        Private Shared Sub OnDeleted(sender As Object, e As FileSystemEventArgs)
            Console.WriteLine($"Deleted: {e.FullPath}")
        End Sub

        Private Shared Sub OnRenamed(sender As Object, e As RenamedEventArgs)
            Console.WriteLine($"Renamed:")
            Console.WriteLine($"    Old: {e.OldFullPath}")
            Console.WriteLine($"    New: {e.FullPath}")
        End Sub

        Private Shared Sub OnError(sender As Object, e As ErrorEventArgs)
            PrintException(e.GetException())
        End Sub

        Private Shared Sub PrintException(ex As Exception)
            If ex IsNot Nothing Then
                Console.WriteLine($"Message: {ex.Message}")
                Console.WriteLine("Stacktrace:")
                Console.WriteLine(ex.StackTrace)
                Console.WriteLine()
                PrintException(ex.InnerException)
            End If
        End Sub

    End Class

End Namespace

Comentários

Use FileSystemWatcher para observar as alterações em um diretório especificado. Você pode observar as alterações em arquivos e subdiretórios do diretório especificado. Você pode criar um componente para observar arquivos em um computador local, uma unidade de rede ou um computador remoto.

Para observar as alterações em todos os arquivos, defina a Filter propriedade como uma cadeia de caracteres vazia ("") ou use curingas ("*.*"). Para assistir a um arquivo específico, defina a Filter propriedade como o nome do arquivo. Por exemplo, para observar as alterações no MyDoc.txt de arquivo, defina a Filter propriedade como "MyDoc.txt". Você também pode observar as alterações em um determinado tipo de arquivo. Por exemplo, para observar as alterações nos arquivos de texto, defina a Filter propriedade como "*.txt".

Há vários tipos de alterações que você pode observar em um diretório ou arquivo. Por exemplo, você pode observar as alterações na Attributes``LastWrite data e hora ou nos Size arquivos ou diretórios. Isso é feito definindo a NotifyFilter propriedade como um dos NotifyFilters valores. Para obter mais informações sobre o tipo de alterações que você pode assistir, consulte NotifyFilters.

Você pode observar a renomeação, a exclusão ou a criação de arquivos ou diretórios. Por exemplo, para observar a renomeação de arquivos de texto, defina a Filter propriedade como "*.txt" e chame o WaitForChanged método com um Renamed especificado para seu parâmetro.

O sistema operacional Windows notifica seu componente de alterações de arquivo em um buffer criado pelo FileSystemWatcher. Se houver muitas alterações em um curto espaço de tempo, o buffer poderá estourar. Isso faz com que o componente perca o controle das alterações no diretório e só fornecerá uma notificação geral. Aumentar o tamanho do buffer com a InternalBufferSize propriedade é caro, pois ele vem da memória não paged que não pode ser trocada para o disco, portanto, mantenha o buffer tão pequeno, mas grande o suficiente para não perder nenhum evento de alteração de arquivo. Para evitar um estouro de buffer, use e as NotifyFilter IncludeSubdirectories propriedades para que você possa filtrar notificações de alteração indesejadas.

Para obter uma lista de valores de propriedade iniciais de uma instância, FileSystemWatcherconsulte o FileSystemWatcher construtor.

Observe o seguinte ao usar a FileSystemWatcher classe.

  • Os arquivos ocultos não são ignorados.

  • Em alguns sistemas, FileSystemWatcher os relatórios são alterados para arquivos usando o formato curto de nome de arquivo 8.3. Por exemplo, uma alteração em "LongFileName.LongExtension" pode ser relatada como "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. Um SecurityException é lançado quando o chamador imediato ou a classe derivada não tem permissão de confiança total. Para obter detalhes sobre as demandas de segurança, consulte Demandas de link.

  • O tamanho máximo que você pode definir para a InternalBufferSize propriedade para monitorar um diretório na rede é de 64 KB.

Copiando e movendo pastas

O sistema operacional e FileSystemWatcher o objeto interpretam uma ação de recortar e colar ou uma ação de movimentação como uma ação de renomeação para uma pasta e seu conteúdo. Se você cortar e colar uma pasta com arquivos em uma pasta que está sendo observada, o FileSystemWatcher objeto relatará apenas a pasta como nova, mas não seu conteúdo porque elas são basicamente renomeados apenas.

Para ser notificado de que o conteúdo das pastas foi movido ou copiado para uma pasta assistida, forneça e OnRenamed os OnChanged métodos do manipulador de eventos, conforme sugerido na tabela a seguir.

Manipulador de Eventos Eventos Tratados É executado
OnChanged Changed, Created, Deleted Relatar alterações em atributos de arquivo, arquivos criados e arquivos excluídos.
OnRenamed Renamed Liste os caminhos antigos e novos de arquivos e pastas renomeados, expandindo-se recursivamente, se necessário.

Eventos e tamanhos de buffer

Observe que vários fatores podem afetar quais eventos de alteração do sistema de arquivos são gerados, conforme descrito pelo seguinte:

  • Operações comuns do sistema de arquivos podem gerar mais de um evento. Por exemplo, quando um arquivo é movido de um diretório para outro, vários OnChanged e alguns OnCreated e OnDeleted eventos podem ser gerados. Mover um arquivo é uma operação complexa que consiste em várias operações simples, gerando, portanto, vários eventos. Da mesma forma, alguns aplicativos (por exemplo, software antivírus) podem causar eventos adicionais do sistema de arquivos detectados por FileSystemWatcher.

  • Os FileSystemWatcher discos podem ser observados desde que não sejam alternados ou removidos. O FileSystemWatcher não gera eventos para CDs e DVDs, pois carimbos de data/hora e propriedades não podem ser alterados. Os computadores remotos devem ter uma das plataformas necessárias instaladas para que o componente funcione corretamente.

Observe que um FileSystemWatcher evento pode perder quando o tamanho do buffer é excedido. Para evitar eventos ausentes, siga estas diretrizes:

  • Aumente o tamanho do buffer definindo a InternalBufferSize propriedade.

  • Evite observar arquivos com nomes de arquivo longos, pois um nome de arquivo longo contribui para preencher o buffer. Considere renomear esses arquivos usando nomes mais curtos.

  • Mantenha o código de tratamento de eventos o mais curto possível.

Construtores

FileSystemWatcher()

Inicializa uma nova instância da classe FileSystemWatcher.

FileSystemWatcher(String)

Inicializa uma nova instância da classe FileSystemWatcher, conforme o diretório especificado para monitorar.

FileSystemWatcher(String, String)

Inicializa uma nova instância da classe FileSystemWatcher, conforme o diretório especificado e os tipos de arquivo a se monitorar.

Propriedades

CanRaiseEvents

Obtém um valor que indica se o componente pode acionar um evento.

(Herdado de Component)
Container

Obtém o IContainer que contém o Component.

(Herdado de Component)
DesignMode

Obtém um valor que indica se o Component está no modo de design no momento.

(Herdado de Component)
EnableRaisingEvents

Obtém ou define um valor que indica se o componente está habilitado.

Events

Obtém a lista de manipuladores de eventos que estão anexados a este Component.

(Herdado de Component)
Filter

Obtém ou define a cadeia de caracteres de filtro usada para determinar quais arquivos são monitorados em um diretório.

Filters

Obtém a coleção de todos os filtros usados para determinar quais arquivos são monitorados em um diretório.

IncludeSubdirectories

Obtém ou define um valor que indica se as subpastas no caminho especificado devem ser monitoradas.

InternalBufferSize

Obtém ou define o tamanho (em bytes) do buffer interno.

NotifyFilter

Obtém ou define o tipo de alterações a serem observadas.

Path

Obtém ou define o caminho do diretório a ser inspecionado.

Site

Obtém ou define um ISite para o FileSystemWatcher.

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.

Métodos

BeginInit()

Inicia a inicialização de um FileSystemWatcher usado em um formulário ou por outro componente. A inicialização ocorre no tempo de execução.

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.

(Herdado de MarshalByRefObject)
Dispose()

Libera os recursos não gerenciados usados pelo FileSystemWatcher.

Dispose()

Libera todos os recursos usados pelo Component.

(Herdado de Component)
Dispose(Boolean)

Libera os recursos não gerenciados usados pelo FileSystemWatcher e opcionalmente libera os recursos gerenciados.

EndInit()

Encerra a inicialização de um FileSystemWatcher usado em um formulário ou por outro componente. A inicialização ocorre no tempo de execução.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.

(Herdado de Object)
Finalize()

Libera os recursos mantidos pela instância atual.

GetHashCode()

Serve como a função de hash padrão.

(Herdado de Object)
GetLifetimeService()
Obsoleto.

Recupera o objeto de serviço de tempo de vida atual que controla a política de ciclo de vida para esta instância.

(Herdado de MarshalByRefObject)
GetService(Type)

Retorna um objeto que representa um serviço fornecido pelo Component ou pelo seu Container.

(Herdado de Component)
GetType()

Obtém o Type da instância atual.

(Herdado de Object)
InitializeLifetimeService()
Obsoleto.

Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida para essa instância.

(Herdado de MarshalByRefObject)
MemberwiseClone()

Cria uma cópia superficial do Object atual.

(Herdado de Object)
MemberwiseClone(Boolean)

Cria uma cópia superficial do objeto MarshalByRefObject atual.

(Herdado de MarshalByRefObject)
OnChanged(FileSystemEventArgs)

Aciona o evento Changed.

OnCreated(FileSystemEventArgs)

Aciona o evento Created.

OnDeleted(FileSystemEventArgs)

Aciona o evento Deleted.

OnError(ErrorEventArgs)

Aciona o evento Error.

OnRenamed(RenamedEventArgs)

Aciona o evento Renamed.

ToString()

Retorna um String que contém o nome do Component, se houver. Esse método não deve ser substituído.

(Herdado de Component)
ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.

(Herdado de Object)
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.

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.

Eventos

Changed

Ocorre quando um arquivo ou diretório no Path especificado é alterado.

Created

Ocorre quando um arquivo ou diretório no Path especificado é criado.

Deleted

Ocorre quando um arquivo ou diretório no Path especificado é excluído.

Disposed

Ocorre quando o componente é disposto por uma chamada ao método Dispose().

(Herdado de Component)
Error

Ocorre quando a instância de FileSystemWatcher não pode continuar a monitorar alterações ou quando o buffer interno estoura.

Renamed

Ocorre quando um arquivo ou diretório no Path especificado é renomeado.

Aplica-se a

Confira também