web-dev-qa-db-fra.com

Comment surveiller les modifications d'un répertoire Windows?

Lorsqu'une modification est effectuée dans un répertoire sur un système Windows, j'ai besoin qu'un programme soit immédiatement informé de la modification.

Existe-t-il un moyen d'exécuter un programme lorsqu'un changement se produit?

Je ne suis pas un programmeur C/C++ /. NET, donc si je pouvais configurer quelque chose pour que la modification puisse déclencher un fichier batch, ce serait l'idéal.

windowsdirectorymonitoring
32
Liam

Utilisez un FileSystemWatcher comme ci-dessous pour créer un événement WatcherCreated ().

J'ai utilisé cela pour créer un service Windows qui surveille un dossier réseau, puis envoie un e-mail à un groupe spécifié à l'arrivée de nouveaux fichiers.

    // Declare a new FILESYSTEMWATCHER
    protected FileSystemWatcher watcher;
    string pathToFolder = @"YourDesired Path Here";

    // Initialize the New FILESYSTEMWATCHER
    watcher = new FileSystemWatcher {Path = pathToFolder, IncludeSubdirectories = true, Filter = "*.*"};
    watcher.EnableRaisingEvents = true;
    watcher.Created += new FileSystemEventHandler(WatcherCreated);

    void WatcherCreated(object source , FileSystemEventArgs e)
    {
      //Code goes here for when a new file is detected
    }
25
Refracted Paladin

FileSystemWatcher est la bonne réponse sauf qu'il était autrefois que FileSystemWatcher ne fonctionnait que pour "quelques" modifications à la fois. C'était à cause d'un tampon de système d'exploitation. En pratique, chaque fois que de nombreux petits fichiers sont copiés, le tampon contenant les noms de fichiers modifiés est saturé. Ce tampon n'est pas vraiment le bon moyen de garder une trace des modifications récentes, car le système d'exploitation devrait arrêter d'écrire lorsque le tampon est plein pour éviter les dépassements.

Microsoft propose à la place d'autres fonctionnalités (EDIT: comme les journaux des modifications) pour capturer véritablement toutes les modifications. Ce sont essentiellement les installations que les systèmes de sauvegarde utilisent et sont complexes sur les événements qui sont enregistrés. Et sont également peu documentés.

Un test simple consiste à générer un grand nombre de petits fichiers et à voir s'ils sont tous signalés par FileSystemWatcher. Si vous avez un problème, je vous suggère de contourner tout le problème et d'analyser le système de fichiers pour les modifications à un intervalle de temps.

9
Arturo Hernandez

Si vous voulez quelque chose de non programmatique, essayez GiPo @ FileUtilities ... mais dans ce cas, la question n'aurait pas sa place ici!

6
Rob Walker

Utilisez un FileSystemWatcher

3
SQLMenace

Je suis venu sur cette page en cherchant un moyen de surveiller l'activité du système de fichiers. J'ai pris le message de Refrerred Paladin et le FileSystemWatcher qu'il a partagé et écrit une implémentation C # rapide et sale:

using System;
using System.IO;

namespace Folderwatch
{
    class Program
    {
        static void Main(string[] args)
        {

            //Based on http://stackoverflow.com/questions/760904/how-can-i-monitor-a-windows-directory-for-changes/27512511#27512511
            //and http://msdn.Microsoft.com/en-us/library/system.io.filesystemwatcher.aspx

            string pathToFolder = string.Empty;
            string filterPath = string.Empty;
            const string USAGE = "USAGE: Folderwatch.exe PATH FILTER \n\n e.g.:\n\n Folderwatch.exe c:\\windows *.dll";

            try
            {
                pathToFolder = args[0];

            }
            catch (Exception)
            {
                Console.WriteLine("Invalid path!");
                Console.WriteLine(USAGE);
                return;
            }

            try
            {
                filterPath = args[1];
            }
            catch (Exception)
            {
                Console.WriteLine("Invalid filter!");
                Console.WriteLine(USAGE);
                return;

            }

            FileSystemWatcher watcher = new FileSystemWatcher();

            watcher.Path = pathToFolder;
            watcher.Filter = filterPath;

            watcher.NotifyFilter = NotifyFilters.Attributes | NotifyFilters.CreationTime | 
                NotifyFilters.DirectoryName | NotifyFilters.FileName | NotifyFilters.LastAccess | 
                NotifyFilters.LastWrite | NotifyFilters.Security | NotifyFilters.Size;

            // 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;

            // Wait for the user to quit the program.
            Console.WriteLine("Monitoring File System Activity on {0}.", pathToFolder);
            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: {0} renamed to {1}", e.OldFullPath, e.FullPath);
        }
    }
}

Pour l'utiliser, téléchargez Visual Studio (Express fera l'affaire). Le créer une nouvelle application console C # appelée Folderwatch et copier et coller mon code dans votre Program.cs.

Comme alternative, vous pouvez utiliser Sys Internals Process Monitor: Process Monitor Il peut surveiller le système de fichiers et bien plus encore.

3
Eric

Il n'y a aucun utilitaire ou programme fourni avec Windows pour le faire. Une programmation requise.

Comme indiqué dans une autre réponse, FileSystemWatcher de .NET est l'approche la plus simple.

L'API native ReadDirectoryChangesW est plutôt difficile à utiliser (nécessite une compréhension des ports d'achèvement).

2
Richard

Cette question m'a beaucoup aidé à comprendre le système File Watcher. J'ai implémenté ReadDirectoryChangesW pour surveiller un répertoire et tous ses sous-répertoires et obtenir les informations sur les changements dans ces répertoires.

J'ai écrit un blog sur le même sujet, et je voudrais le partager afin qu'il puisse aider quelqu'un qui atterrit ici pour le même problème.

Win32 File Watcher Api pour surveiller les changements de répertoire .

1
Neha