Monitorizar varias carpetas usando FileSystemWatcher

Question

¿Cuál es la mejor manera de controlar varias carpetas (no subdirectorios) usando FileSystemWatcher en C#?

Answer 1

No creo que FSW sea compatible con la supervisión de varias carpetas, así que solo instale una por cada carpeta que desee supervisar. Sin embargo, puedes apuntar a los manejadores de eventos con los mismos métodos, que deberían terminar funcionando como yo creo que quieres.

Answer 2

¿Puede simplemente usar varias instancias de FileSystemWatcher, una para cada directorio?

Answer 3

La manera más fácil es crear varias instancias del objeto FileSystemWatcher.

http://www.c-sharpcorner.com/UploadFile/mokhtarb2005/FSWatcherMB12052005063103AM/FSWatcherMB.aspx

Vas a tener que asegurarse de que el gestionar eventos entre las dos carpetas correctamente:

Aunque algunas ocurrencias comunes, tales como copiar o mover un archivo, no lo hacen corresponden directamente a un evento, estas ocurrencias hacen que los eventos sean planteados. Cuando copia un archivo, el sistema genera un evento Creado en el directorio al que se copió el archivo pero no genera ningún evento en el directorio original . Cuando mueve un archivo , el servidor genera dos eventos: un evento eliminado en el directorio de origen, seguido de un evento Creado en el directorio de destino .

Por ejemplo, crea dos instancias de FileSystemWatcher. FileSystemWatcher1 está configurado para ver "C: \ My Documents" y FileSystemWatcher2 está configurado para ver "C: \ Your Documents". Ahora, si copia un archivo de "Mis documentos" en "Sus documentos ", un evento Creado será provocado por FileSystemWatcher2, pero no se generará ningún evento FileSystemWatcher1. A diferencia de la copia, mover un archivo o directorio elevaría dos eventos. A partir del ejemplo anterior, al mover un archivo desde "Mis documentos" a "Sus documentos", un Evento creado sería levantado por FileSystemWatcher2 y un evento eliminados sería levantado por FileSystemWatcher

Enlace a FileSystemEventArgs

Answer 4

Fuera de la caja, FileSystemWatcher solo es compatible con la supervisión de un solo directorio principal. Para supervisar varios directorios hermanos, deberá crear varias instancias de FileSystemWatcher.

Puede intentar copiar este comportamiento, sin embargo, aprovechando la capacidad de FileSystemWatcher para incluir subdirectorios. Puede crear un punto de unión NTFS (también conocido como enlace simbólico) como un subdirectorio del directorio que está viendo. Mark Russinovich de la fama de Sysinternals tiene una utilidad llamada Junction para simplificar la creación y administración de enlaces simbólicos.

Tenga en cuenta que solo puede crear enlaces simbólicos a directorios en su máquina local.

Answer 5

Debería instanciar varias instancias del objeto FileSystemWatcher. Aunque puede vincular los eventos al mismo método y usar el objeto emisor para determinar qué FileSystemWatcher activó el evento.

 var fsw1 = new FileSystemWatcher(); 
     var fsw2 = new FileSystemWatcher(); 
     FileSystemEventHandler fsw_changed = delegate(object sender, FileSystemEventArgs e) 
     { 
      Console.WriteLine("{0} - {1}", (sender as FileSystemWatcher).Path, e.ChangeType); 
     }; 
     fsw1.Changed += fsw_changed; 
     fsw2.Changed += fsw_changed; 

Answer 6

o puede pasar a los caminos de código, para marcar un cierto rango del dominio visto como en este:

multiple monitor link

esperanza esto ayuda.

Answer 7

Aunque esta es una vieja pregunta, decidí responder, porque no pude encontrar una buena respuesta en ninguna parte.

Entonces, el objetivo era monitorear varias carpetas (no subdirectorios) usando FileSystemWatcher? Aquí está mi sugerencia:

using System; 
using System.IO; 
using System.Security.Permissions; 
using System.Collections.Generic; 

namespace MultiWatcher 
// ConsoleApplication, which monitors TXT-files in multiple folders. 
// Inspired by: 
// http://msdn.microsoft.com/en-us/library/system.io.filesystemeventargs(v=vs.100).aspx 

{ 
    public class Watchers 
    { 
     public static void Main() 
     { 
      Run(); 

     } 

     [PermissionSet(SecurityAction.Demand, Name = "FullTrust")] 
     public static void Run() 
     { 
      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 PATH [...] [PATH]"; 
       return; 
      } 
      List<string> list = new List<string>(); 
      for (int i = 1; i < args.Length; i++) 
      { 
       list.Add(args[i]); 
      } 
      foreach (string my_path in list) 
      { 
       Watch(my_path); 
      } 

      // Wait for the user to quit the program. 
      Console.WriteLine("Press \'q\' to quit the sample."); 
      while (Console.Read() != 'q') ; 
     } 
     private static void Watch(string watch_folder) 
     { 
      // Create a new FileSystemWatcher and set its properties. 
      FileSystemWatcher watcher = new FileSystemWatcher(); 
      watcher.Path = watch_folder; 
      /* 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 += new FileSystemEventHandler(OnChanged); 
      watcher.Created += new FileSystemEventHandler(OnChanged); 
      watcher.Deleted += new FileSystemEventHandler(OnChanged); 
      watcher.Renamed += new RenamedEventHandler(OnRenamed); 

      // Begin watching. 
      watcher.EnableRaisingEvents = true; 
     } 

     // 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: {0} renamed to {1}", e.OldFullPath, e.FullPath); 
     } 
    } 
}