FileSystemWatcher Clase

Definición

Escucha las notificaciones de cambio del sistema de archivos y genera eventos cuando cambia un directorio o un archivo de un directorio.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
Herencia
FileSystemWatcher
Atributos
Implementaciones

Ejemplos

En el ejemplo siguiente se FileSystemWatcher crea un para ver el directorio especificado en tiempo de ejecución.The following example creates a FileSystemWatcher to watch the directory specified at run time. El componente se establece para inspeccionar los cambios LastWrite en LastAccess el tiempo y la creación, la eliminación o el cambio de nombre de los archivos de texto en el directorio.The component is set to watch for changes in LastWrite and LastAccess time, the creation, deletion, or renaming of text files in the directory. Si se cambia, crea o elimina un archivo, la ruta de acceso al archivo se imprime en la consola.If a file is changed, created, or deleted, the path to the file prints to the console. Cuando se cambia el nombre de un archivo, las rutas de acceso antiguas y nuevas se imprimen en la consola.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.IO
Imports System.Security.Permissions

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

Comentarios

Se FileSystemWatcher utiliza para inspeccionar los cambios en un directorio especificado.Use FileSystemWatcher to watch for changes in a specified directory. Puede ver los cambios en los archivos y subdirectorios del directorio especificado.You can watch for changes in files and subdirectories of the specified directory. Puede crear un componente para ver los archivos en un equipo local, en una unidad de red o en un equipo remoto.You can create a component to watch files on a local computer, a network drive, or a remote computer.

Para inspeccionar los cambios en todos los archivos, Filter establezca la propiedad en una cadena vacía ("") o use caracteres comodín ("**.").To watch for changes in all files, set the Filter property to an empty string ("") or use wildcards ("*.*"). Para ver un archivo específico, establezca la Filter propiedad en el nombre de archivo.To watch a specific file, set the Filter property to the file name. Por ejemplo, para inspeccionar los cambios en el archivo MyDoc. txt, establezca Filter la propiedad en "MyDoc. txt".For example, to watch for changes in the file MyDoc.txt, set the Filter property to "MyDoc.txt". También puede ver los cambios en un determinado tipo de archivo.You can also watch for changes in a certain type of file. Por ejemplo, para inspeccionar los cambios en los archivos de texto Filter , establezca la*propiedad en ". txt".For example, to watch for changes in text files, set the Filter property to "*.txt".

Hay varios tipos de cambios que puede ver en un directorio o un archivo.There are several types of changes you can watch for in a directory or file. Por ejemplo, puede ver los cambios en Attributes, la LastWrite fecha y la hora, o el Size de los archivos o directorios.For example, you can watch for changes in Attributes, the LastWrite date and time, or the Size of files or directories. Esto se hace estableciendo la NotifyFilter propiedad en uno de los NotifyFilters valores de.This is done by setting the NotifyFilter property to one of the NotifyFilters values. Para obtener más información sobre el tipo de cambios que se pueden ver NotifyFilters, vea.For more information on the type of changes you can watch, see NotifyFilters.

Puede ver el cambio de nombre, la eliminación o la creación de archivos o directorios.You can watch for renaming, deletion, or creation of files or directories. Por ejemplo, para inspeccionar el cambio de nombre de los archivos de Filter texto, establezca la propiedad en "*. txt WaitForChanged " y llame Renamed al método con un especificado para su 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.

El sistema operativo Windows notifica al componente los cambios de archivo en un búfer creado por el FileSystemWatcher.The Windows operating system notifies your component of file changes in a buffer created by the FileSystemWatcher. Si hay muchos cambios en poco tiempo, el búfer se puede desbordar.If there are many changes in a short time, the buffer can overflow. Esto hace que el componente pierda el seguimiento de los cambios en el directorio y solo proporcionará una notificación global.This causes the component to lose track of changes in the directory, and it will only provide blanket notification. Aumentar el tamaño del búfer con la propiedad InternalBufferSize es costoso, ya que proviene de la memoria no paginada que no se puede intercambiar en el disco, por lo que debe mantener el búfer tan pequeño, pero lo suficientemente grande como para no omitir los eventos de cambio de archivo.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 un desbordamiento del búfer, utilice NotifyFilter las IncludeSubdirectories propiedades y para que pueda filtrar las notificaciones de cambio no deseadas.To avoid a buffer overflow, use the NotifyFilter and IncludeSubdirectories properties so you can filter out unwanted change notifications.

Para obtener una lista de los valores de propiedad iniciales de FileSystemWatcheruna instancia de FileSystemWatcher , vea el constructor.For a list of initial property values for an instance of FileSystemWatcher, see the FileSystemWatcher constructor.

Tenga en cuenta lo siguiente al usar FileSystemWatcher la clase.Please note the following when using the FileSystemWatcher class.

  • Los archivos ocultos no se pasan por alto.Hidden files are not ignored.

  • En algunos sistemas, FileSystemWatcher informa de los cambios en los archivos con el formato de nombre de archivo corto 8,3.In some systems, FileSystemWatcher reports changes to files using the short 8.3 file name format. Por ejemplo, un cambio en "LongFileName. LongExtension" podría aparecer como "LongFil ~. LON ".For example, a change to "LongFileName.LongExtension" could be reported as "LongFil~.Lon".

  • Esta clase contiene una petición de vínculo y una petición de herencia en el nivel de clase que se aplica a todos los miembros.This class contains a link demand and an inheritance demand at the class level that applies to all members. Se SecurityException produce una excepción cuando el llamador inmediato o la clase derivada no tienen permiso de plena confianza.A SecurityException is thrown when either the immediate caller or the derived class does not have full-trust permission. Para más información sobre las demandas de seguridad, consulte peticiones de vínculo.For details about security demands, see Link Demands.

  • El tamaño máximo que puede establecer para la InternalBufferSize propiedad para la supervisión de un directorio a través de la red es de 64 KB.The maximum size you can set for the InternalBufferSize property for monitoring a directory over the network is 64 KB.

Nota

No FileSystemWatcher se admite la ejecución en Windows 98.Running FileSystemWatcher on Windows 98 is not supported.

Copiar y mover carpetasCopying and moving folders

El sistema operativo y FileSystemWatcher el objeto interpretan una acción de cortar y pegar o una acción de movimiento como una acción de cambio de nombre para una carpeta y su contenido.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. Si corta y pega una carpeta con archivos en una carpeta que se está inspeccionando FileSystemWatcher , el objeto solo notifica la carpeta como nuevo, pero no su contenido porque básicamente solo se cambia el nombre.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 recibir una notificación de que el contenido de las carpetas se ha migrado o copiado en una OnChanged carpeta OnRenamed inspeccionada, proporcione métodos de controlador de eventos y como se sugiere en la tabla siguiente.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.

Controlador de eventosEvent Handler Eventos controladosEvents Handled ComportaPerforms
OnChanged Changed, Created, DeletedChanged, Created, Deleted Informe de los cambios en los atributos de archivo, los archivos creados y los archivos eliminados.Report changes in file attributes, created files, and deleted files.
OnRenamed Renamed Enumere las rutas de acceso antiguas y nuevas de los archivos y carpetas cuyo nombre ha cambiado y, si es necesario, se expande de forma recursiva.List the old and new paths of renamed files and folders, expanding recursively if needed.

Eventos y tamaños de búferEvents and Buffer Sizes

Tenga en cuenta que algunos factores pueden afectar a los eventos de cambio del sistema de archivos que se generan, como se describe a continuación:Note that several factors can affect which file system change events are raised, as described by the following:

  • Las operaciones comunes del sistema de archivos pueden generar más de un evento.Common file system operations might raise more than one event. Por ejemplo, cuando se mueve un archivo de un directorio a otro, pueden OnChanged generarse OnCreated varios OnDeleted eventos y.For example, when a file is moved from one directory to another, several OnChanged and some OnCreated and OnDeleted events might be raised. Mover un archivo es una operación compleja que consta de varias operaciones simples, por lo que se producen varios eventos.Moving a file is a complex operation that consists of multiple simple operations, therefore raising multiple events. Del mismo modo, algunas aplicaciones (por ejemplo, software antivirus) pueden provocar eventos adicionales del sistema de archivos FileSystemWatcherdetectados por.Likewise, some applications (for example, antivirus software) might cause additional file system events that are detected by FileSystemWatcher.

  • FileSystemWatcher Puede inspeccionar discos siempre y cuando no se cambien o se quiten.The FileSystemWatcher can watch disks as long as they are not switched or removed. No FileSystemWatcher genera eventos para CDs y DVDs, ya que las marcas de tiempo y las propiedades no pueden cambiar.The FileSystemWatcher does not raise events for CDs and DVDs, because time stamps and properties cannot change. Los equipos remotos deben tener una de las plataformas necesarias instaladas para que el componente funcione correctamente.Remote computers must have one of the required platforms installed for the component to function properly.

  • Si hay FileSystemWatcher varios objetos Observando la misma ruta de acceso UNC en Windows XP anterior al Service Pack 1, o Windows 2000 SP2 o anterior, solo uno de los objetos generará un 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. En los equipos que ejecutan Windows XP SP1 y versiones más recientes, Windows 2000 SP3 o posterior o FileSystemWatcher Windows Server 2003, todos los objetos generarán los eventos correspondientes.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.

Tenga en cuenta FileSystemWatcher que puede que se pierda un evento cuando se supere el tamaño del búfer.Note that a FileSystemWatcher may miss an event when the buffer size is exceeded. Para evitar que se produzcan eventos, siga estas instrucciones:To avoid missing events, follow these guidelines:

  • Aumente el tamaño del búfer estableciendo la InternalBufferSize propiedad.Increase the buffer size by setting the InternalBufferSize property.

  • Evite ver archivos con nombres de archivo largos, ya que un nombre de archivo largo contribuye a llenar el búfer.Avoid watching files with long file names, because a long file name contributes to filling up the buffer. Considere la posibilidad de cambiar el nombre de estos archivos con nombres más cortos.Consider renaming these files using shorter names.

  • Mantenga el código de control de eventos lo más corto posible.Keep your event handling code as short as possible.

Constructores

FileSystemWatcher()

Inicializa una nueva instancia de la clase FileSystemWatcher.Initializes a new instance of the FileSystemWatcher class.

FileSystemWatcher(String)

Inicializa una nueva instancia de la clase FileSystemWatcher, dado el directorio especificado que se va a supervisar.Initializes a new instance of the FileSystemWatcher class, given the specified directory to monitor.

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.Initializes a new instance of the FileSystemWatcher class, given the specified directory and type of files to monitor.

Propiedades

CanRaiseEvents

Obtiene un valor que indica si el componente puede generar un evento.Gets a value indicating whether the component can raise an event.

(Heredado de Component)
Container

Obtiene IContainer que contiene Component.Gets the IContainer that contains the Component.

(Heredado de Component)
DesignMode

Obtiene un valor que indica si Component está actualmente en modo de diseño.Gets a value that indicates whether the Component is currently in design mode.

(Heredado de Component)
EnableRaisingEvents

Obtiene o establece un valor que indica si el componente está habilitado.Gets or sets a value indicating whether the component is enabled.

Events

Obtiene la lista de controladores de eventos asociados a Component.Gets the list of event handlers that are attached to this Component.

(Heredado de Component)
Filter

Obtiene o establece la cadena de filtro utilizada para determinar qué archivos se supervisan en un directorio.Gets or sets the filter string used to determine what files are monitored in a directory.

Filters

Obtiene la colección de todos los filtros usada para determinar qué archivos se supervisan en un directorio.Gets the collection of all the filters used to determine what files are monitored in a directory.

IncludeSubdirectories

Obtiene o establece un valor que indica si se deben supervisar los subdirectorios de la ruta de acceso especificada.Gets or sets a value indicating whether subdirectories within the specified path should be monitored.

InternalBufferSize

Obtiene o establece el tamaño (en bytes) del búfer interno.Gets or sets the size (in bytes) of the internal buffer.

NotifyFilter

Obtiene o establece el tipo de cambios que se van a inspeccionar.Gets or sets the type of changes to watch for.

Path

Obtiene o establece la ruta de acceso del directorio que se va a inspeccionar.Gets or sets the path of the directory to watch.

Site

Obtiene o establece una interfaz ISite para el objeto FileSystemWatcher.Gets or sets an ISite for the FileSystemWatcher.

SynchronizingObject

Obtiene o establece el objeto utilizado para calcular las referencias de las llamadas del controlador de eventos emitidas como consecuencia de un cambio de directorio.Gets or sets the object used to marshal the event handler calls issued as a result of a directory change.

Métodos

BeginInit()

Comienza la inicialización de un objeto FileSystemWatcher empleado en un formulario o utilizado por otro componente.Begins the initialization of a FileSystemWatcher used on a form or used by another component. La inicialización se produce en tiempo de ejecución.The initialization occurs at run time.

CreateObjRef(Type)

Crea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Heredado de MarshalByRefObject)
Dispose()

Libera los recursos no administrados que utiliza FileSystemWatcher.Releases the unmanaged resources used by the FileSystemWatcher.

Dispose(Boolean)

Libera los recursos no administrados que usa FileSystemWatcher y, de forma opcional, libera los recursos administrados.Releases the unmanaged resources used by the FileSystemWatcher and optionally releases the managed resources.

EndInit()

Termina la inicialización de un objeto FileSystemWatcher empleado en un formulario o utilizado por otro componente.Ends the initialization of a FileSystemWatcher used on a form or used by another component. La inicialización se produce en tiempo de ejecución.The initialization occurs at run time.

Equals(Object)

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Heredado de Object)
Finalize()

Libera los recursos mantenidos por la instancia actual.Releases the resources held by the current instance.

GetHashCode()

Sirve como función hash predeterminada.Serves as the default hash function.

(Heredado de Object)
GetLifetimeService()

Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Heredado de MarshalByRefObject)
GetService(Type)

Devuelve un objeto que representa el servicio suministrado por Component o por Container.Returns an object that represents a service provided by the Component or by its Container.

(Heredado de Component)
GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Heredado de Object)
InitializeLifetimeService()

Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia.Obtains a lifetime service object to control the lifetime policy for this instance.

(Heredado de MarshalByRefObject)
MemberwiseClone()

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

(Heredado de Object)
MemberwiseClone(Boolean)

Crea una copia superficial del objeto MarshalByRefObject actual.Creates a shallow copy of the current MarshalByRefObject object.

(Heredado de MarshalByRefObject)
OnChanged(FileSystemEventArgs)

Genera el evento Changed.Raises the Changed event.

OnCreated(FileSystemEventArgs)

Genera el evento Created.Raises the Created event.

OnDeleted(FileSystemEventArgs)

Genera el evento Deleted.Raises the Deleted event.

OnError(ErrorEventArgs)

Genera el evento Error.Raises the Error event.

OnRenamed(RenamedEventArgs)

Genera el evento Renamed.Raises the Renamed event.

ToString()

Devuelve una String que contiene el nombre del Component, si existe.Returns a String containing the name of the Component, if any. Este método no se debe invalidar.This method should not be overridden.

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

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 y el tiempo (en milisegundos) que se va a esperar antes de que se agote el tiempo de espera.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

Se produce cuando cambia un archivo o un directorio incluido en la ruta de acceso indicada en la propiedad Path especificada.Occurs when a file or directory in the specified Path is changed.

Created

Se produce cuando se crea un archivo o un directorio en la ruta de acceso indicada en la propiedad Path especificada.Occurs when a file or directory in the specified Path is created.

Deleted

Se produce cuando se elimina un archivo o un directorio de la ruta de acceso indicada en la propiedad Path especificada.Occurs when a file or directory in the specified Path is deleted.

Disposed

Se produce cuando el componente se elimina mediante una llamada al método Dispose().Occurs when the component is disposed by a call to the Dispose() method.

(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.Occurs when the instance of FileSystemWatcher is unable to continue monitoring changes or when the internal buffer overflows.

Renamed

Se produce cuando se cambia de nombre un archivo o un directorio de la ruta de acceso indicada en la propiedad Path especificada.Occurs when a file or directory in the specified Path is renamed.

Seguridad

SecurityPermission
para derivar de la ProcessStartInfo clase.for deriving from the ProcessStartInfo class. Valor de petición InheritanceDemand:; Conjuntos de permisos con FullTrustnombre:.Demand value: InheritanceDemand; Named Permission Sets: FullTrust.

Se aplica a

Consulte también: