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

Exemplos

O exemplo a seguir cria um FileSystemWatcher para watch o diretório especificado em tempo de execução. O componente é definido como watch para alterações no e LastAccess no LastWrite tempo, na criação, exclusão ou 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

Para obter mais informações sobre essa API, consulte Comentários da API complementar para FileSystemWatcher.

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)
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.

WaitForChanged(WatcherChangeTypes, TimeSpan)

Retorna de forma síncrona uma estrutura que contém informações específicas sobre a alteração que ocorreu, dado o tipo de alteração a ser monitorada.

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