c# - example - Monitorea múltiples carpetas usando FileSystemWatcher

filesystemwatcher example c#

Question

¿Cuál es la mejor manera de monitorear múltiples carpetas (no subdirectorios) usando FileSystemWatcher en C #?

Answer 1

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

Answer 2

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

Entonces, ¿el objetivo era monitorear múltiples 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);
        }
    }
}

Answer 3

Fuera de la caja, FileSystemWatcher solo admite la supervisión de un único directorio principal. Para monitorear múltiples directorios hermanos, necesitaría crear múltiples instancias de FileSystemWatcher.

Sin embargo, puede intentar engañar a este comportamiento 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 desde el directorio que está viendo. Mark Russinovich de Sysinternals fame 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 4

La forma más sencilla es crear varias instancias del objeto FileSystemWatcher .

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

Tendrá que asegurarse de que maneja los eventos entre las dos carpetas correctamente:

Aunque algunas ocurrencias comunes, como copiar o mover un archivo, no se corresponden directamente con un evento, estas ocurrencias causan que se generen eventos. Cuando copia un archivo, el sistema genera un evento creado en el directorio donde 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, creas dos instancias de FileSystemWatcher. FileSystemWatcher1 está configurado para ver "C: / Mis documentos", y FileSystemWatcher2 está configurado para ver "C: / Sus documentos". Ahora, si copia un archivo de "Mis documentos" en "Sus documentos", FileSystemWatcher2 generará un evento creado, pero no se generará ningún evento para FileSystemWatcher1. A diferencia de la copia, mover un archivo o directorio provocaría dos eventos. Del ejemplo anterior, si movió un archivo de "Mis documentos" a "Sus documentos", FileSystemWatcher2 generará un evento creado y FileSystemWatcher provocará un evento eliminado.

Enlace a FileSystemEventArgs

Answer 5

No creo que FSW admita la supervisión de varias carpetas, así que solo cree una instancia por cada carpeta que desee supervisar. Sin embargo, puede dirigir los controladores de eventos a los mismos métodos, que deberían terminar funcionando como creo que usted desea.

Answer 6

o puede pasar las rutas en el código, para marcar un cierto rango del dominio visto como en esto:

enlace de monitor múltiple

espero que esto ayude.

Answer 7

Tendría que crear instancias múltiples del objeto FileSystemWatcher . Aunque puede vincular los Eventos al mismo método y usar el objeto remitente 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;