FileSystemWatcher Clase

Definición

Espacio de nombres:

System.IO

Ensamblado:

System.IO.FileSystem.Watcher.dll

Source:

FileSystemWatcher.cs

Escucha las notificaciones de cambio del sistema de archivos y genera eventos cuando cambia un directorio o un archivo de un directorio.

public ref class FileSystemWatcher : System::ComponentModel::Component, System::ComponentModel::ISupportInitialize

public class FileSystemWatcher : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize

type FileSystemWatcher = class
    inherit Component
    interface ISupportInitialize

Public Class FileSystemWatcher
Inherits Component
Implements ISupportInitialize

Herencia

Object

MarshalByRefObject

Component

FileSystemWatcher

Implementaciones

ISupportInitialize

Ejemplos

En el ejemplo siguiente se crea un FileSystemWatcher objeto para watch el directorio especificado en tiempo de ejecución. El componente se establece en watch para los cambios en LastWrite y LastAccess el tiempo, la creación, eliminación o cambio de nombre de los archivos de texto en el directorio. Si se cambia, crea o elimina un archivo, la ruta de acceso al archivo se imprime en la consola. Cuando se cambia el nombre de un archivo, las rutas de acceso antiguas y nuevas se imprimen en la consola.

#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

Comentarios

Para obtener más información sobre esta API, consulte Comentarios complementarios de api para FileSystemWatcher.

Constructores

FileSystemWatcher()	Inicializa una nueva instancia de la clase FileSystemWatcher.
FileSystemWatcher(String)	Inicializa una nueva instancia de la clase FileSystemWatcher, dado el directorio especificado que se va a supervisar.
FileSystemWatcher(String, String)	Inicializa una nueva instancia de la clase FileSystemWatcher, dado el directorio especificado y el tipo de archivos que se van a supervisar.

Propiedades

CanRaiseEvents	Obtiene un valor que indica si el componente puede generar un evento. (Heredado de Component)
Container	Obtiene la interfaz IContainer que contiene la clase Component. (Heredado de Component)
DesignMode	Obtiene un valor que indica si Component está actualmente en modo de diseño. (Heredado de Component)
EnableRaisingEvents	Obtiene o establece un valor que indica si el componente está habilitado.
Events	Obtiene la lista de controladores de eventos asociados a Component. (Heredado de Component)
Filter	Obtiene o establece la cadena de filtro utilizada para determinar qué archivos se supervisan en un directorio.
Filters	Obtiene la colección de todos los filtros usada para determinar qué archivos se supervisan en un directorio.
IncludeSubdirectories	Obtiene o establece un valor que indica si se deben supervisar los subdirectorios de la ruta de acceso especificada.
InternalBufferSize	Obtiene o establece el tamaño (en bytes) del búfer interno.
NotifyFilter	Obtiene o establece el tipo de cambios que se van a inspeccionar.
Path	Obtiene o establece la ruta de acceso del directorio que se va a inspeccionar.
Site	Obtiene o establece una interfaz ISite para el objeto FileSystemWatcher.
SynchronizingObject	Obtiene o establece el objeto utilizado para serializar las llamadas del controlador de eventos emitidas como consecuencia de un cambio de directorio.

Métodos

BeginInit()	Comienza la inicialización de un objeto FileSystemWatcher empleado en un formulario o utilizado por otro componente. La inicialización se produce en tiempo de ejecución.
CreateObjRef(Type)	Crea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto. (Heredado de MarshalByRefObject)
Dispose()	Libera todos los recursos que usa Component. (Heredado de Component)
Dispose(Boolean)	Libera los recursos no administrados que usa FileSystemWatcher y, de forma opcional, libera los recursos administrados.
EndInit()	Termina la inicialización de un objeto FileSystemWatcher empleado en un formulario o utilizado por otro componente. La inicialización se produce en tiempo de ejecución.
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetLifetimeService()	Obsoletos. Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia. (Heredado de MarshalByRefObject)
GetService(Type)	Devuelve un objeto que representa el servicio suministrado por Component o por Container. (Heredado de Component)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
InitializeLifetimeService()	Obsoletos. Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia. (Heredado de MarshalByRefObject)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
MemberwiseClone(Boolean)	Crea una copia superficial del objeto MarshalByRefObject actual. (Heredado de MarshalByRefObject)
OnChanged(FileSystemEventArgs)	Genera el evento Changed.
OnCreated(FileSystemEventArgs)	Genera el evento Created.
OnDeleted(FileSystemEventArgs)	Genera el evento Deleted.
OnError(ErrorEventArgs)	Genera el evento Error.
OnRenamed(RenamedEventArgs)	Genera el evento Renamed.
ToString()	Devuelve una String que contiene el nombre del Component, si existe. Este método no se debe invalidar. (Heredado de Component)
WaitForChanged(WatcherChangeTypes)	Un método sincrónico que devuelve una estructura que contiene información específica acerca del cambio que se ha producido, dado el tipo de cambio que desea supervisar.
WaitForChanged(WatcherChangeTypes, Int32)	Método sincrónico que devuelve una estructura que contiene información específica acerca del cambio que se ha producido, dado el tipo de cambio que desea supervisar y el tiempo (en milisegundos) que se va a esperar antes de que se agote el tiempo de espera.
WaitForChanged(WatcherChangeTypes, TimeSpan)	Devuelve de forma sincrónica una estructura que contiene información específica sobre el cambio que se produjo, dado el tipo de cambio que se va a supervisar.

Eventos

Changed	Se produce cuando cambia un archivo o un directorio en la ruta de acceso Path especificada.
Created	Se produce cuando se crea un archivo o un directorio en la ruta de acceso Path especificada.
Deleted	Se produce cuando se elimina un archivo o un directorio en la ruta de acceso Path especificada.
Disposed	Tiene lugar cuando una llamada elimina el componente mediante una llamada al método Dispose(). (Heredado de Component)
Error	Se produce cuando la instancia de FileSystemWatcher no puede continuar supervisando los cambios o cuando el búfer interno se desborda.
Renamed	Se produce cuando se cambia de nombre un archivo o un directorio de la ruta de acceso Path especificada.

Consulte también

• NotifyFilter
• NotifyFilters
• FileSystemEventArgs
• FileSystemEventHandler
• Filter
• IncludeSubdirectories
• InternalBufferOverflowException
• RenamedEventArgs
• RenamedEventHandler
• WaitForChangedResult
• WatcherChangeTypes
• Usar un componente FileSystemWatcher en un formulario Windows Forms