FileSystemWatcher Classe

Definição

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

Object

MarshalByRefObject

Component

FileSystemWatcher

Herança

Object

FileSystemWatcher

Atributos

IODescriptionAttribute

Implementações

ISupportInitialize IDisposable

Exemplos

O exemplo seguinte cria um FileSystemWatcher para observar o diretório especificado em tempo de execução. O componente está configurado para observar alterações no LastWrite tempo LastAccess , criação, eliminação ou renomeação de ficheiros de texto no diretório. Se um ficheiro for alterado, criado ou eliminado, o caminho para o ficheiro é impresso para a consola. Quando um ficheiro é renomeado, os caminhos antigo e novo são impressos na consola.

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

Observações

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

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

Há vários tipos de alterações que você pode observar em um diretório ou arquivo. Por exemplo, pode observar mudanças em Attributes, na data e hora LastWrite, ou no Size de ficheiros ou diretórios. Isso é feito definindo a NotifyFilter propriedade para um dos NotifyFilters valores. Para mais informações sobre o tipo de alterações que pode-se acompanhar, consulte NotifyFilters.

Você pode observar a renomeação, exclusão ou 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 operativo Windows notifica o seu componente sobre alterações de arquivo em um buffer criado pelo FileSystemWatcher. Se houver muitas alterações num curto espaço de tempo, o buffer pode estourar. Isso faz com que o componente perca o controle das alterações no diretório e ele só fornecerá notificação geral. Aumentar o tamanho do buffer com a InternalBufferSize propriedade é caro, pois ele vem de memória não paginada que não pode ser trocada para o disco, portanto, mantenha o buffer pequeno, mas grande o suficiente para não perder nenhum evento de alteração de arquivo. Para evitar um estouro de buffer, use as propriedades NotifyFilter e IncludeSubdirectories para filtrar notificações de alteração indesejadas.

Para obter uma lista de valores das propriedades iniciais de uma instância de FileSystemWatcher, consulte o construtor FileSystemWatcher.

Considere os seguintes factos ao usar a FileSystemWatcher aula:

• Ficheiros ocultos não são ignorados.
• Em alguns sistemas, FileSystemWatcher relata alterações em arquivos usando o formato de nome de arquivo curto 8.3. Por exemplo, uma alteração para "LongFileName.LongExtension" pode ser relatada como "LongFil~.Lon".
• O tamanho máximo que você pode definir para a InternalBufferSize propriedade para monitorar um diretório pela rede é de 64 KB.

Copiar e mover pastas

O sistema operativo e o objeto FileSystemWatcher interpretam uma ação de cortar e colar, ou uma ação de mover, como uma ação de renomeação para uma pasta e o seu conteúdo. Se cortar e colar uma pasta com ficheiros para uma pasta que está a ser monitorizada, o objeto FileSystemWatcher reporta apenas a pasta como nova, mas não o seu conteúdo, porque foram essencialmente apenas renomeados.

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

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 a seguir:

• Operações comuns do sistema de arquivos podem gerar mais de um evento. Por exemplo, quando um ficheiro é movido de uma pasta para outra, podem ser gerados vários eventos OnChanged e alguns OnCreated e OnDeleted. Mover um arquivo é uma operação complexa que consiste em várias operações simples, portanto, gerando vários eventos. Da mesma forma, alguns aplicativos (por exemplo, software antivírus) podem causar eventos adicionais do sistema de arquivos que são detetados pelo FileSystemWatcher.
• O FileSystemWatcher pode vigiar os discos desde que não sejam trocados ou removidos. O FileSystemWatcher não gera eventos para CDs e DVDs, porque 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 pode perder um evento 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, porque um nome de arquivo longo contribui para preencher o buffer. Considere renomear esses arquivos usando nomes mais curtos.
• Mantenha o código de manipulação de eventos o mais curto possível.

Ver também

• NotifyFilter
• NotifyFilters
• FileSystemEventArgs
• FileSystemEventHandler
• Filter
• IncludeSubdirectories
• InternalBufferOverflowException
• RenamedEventArgs
• RenamedEventHandler
• WaitForChangedResult
• WatcherChangeTypes
• Usando um componente FileSystemWatcher numa forma Windows