Existe-t-il un équivalent au .Net FileSystemWatcher dans le monde Linux ?

Comme cela a déjà été dit, Mono a la classe "System.IO.FileSystemWatcher", c'est le lien pertinent :http://www.go-mono.com/docs/monodoc.ashx?link=T%3aSystem.IO. FileSystemWatcher

"L'implémentation de FileSystemWatcher par Mono a plusieurs backends. Cela est nécessaire car tous les systèmes d'exploitation pris en charge par Mono n'ont pas toutes les fonctionnalités nécessaires pour fournir les fonctionnalités attendues par les applications.

Si le noyau du système d'exploitation prend en charge la surveillance des répertoires (inotify sous Linux, KEvents sous BSD ou OSX), cette fonctionnalité est utilisée ; Sinon, il revient à l'utilisation des bibliothèques Gamin ou FAM (ces bibliothèques fournissent une API pour surveiller les répertoires) et si aucune de ces fonctionnalités n'est disponible, Mono interrogera toutes les 750 millisecondes les répertoires surveillés.

Vous pouvez forcer le comportement d'interrogation (au lieu d'utiliser le support du noyau) en définissant la variable d'environnement MONO_MANAGED_WATCHER avant d'exécuter votre application. Cela peut être utile pour les systèmes de fichiers qui ne prennent pas en charge la notification et nécessitent toujours une interrogation pour détecter les modifications."

Ce serait Gamin the File Alteration Monitor ou Inotify.

Edit :Mono a des liaisons Gamin - en fait, son implémentation de FileSystemWatcher utilise Gamin. https://www.mono-project.com/docs/faq/technical/#what-are-the-issues-with-filesystemwatcher.

Quels sont les problèmes avec FileSystemWatcher ?

L'implémentation Mono de FileSystemWatcher a un certain nombre de backends, le plus optimal, celui avec moins de dépendances est le backend inotify (disponible dans Mono 1.1.17 et les versions plus récentes).

Avec ce backend, le noyau fournit à Mono des mises à jour sur toutes les modifications apportées aux fichiers sur le système de fichiers, mais il nécessite un noyau compatible inotify, que seules les distributions Linux plus récentes sont livrées.

Dans les systèmes Linux plus anciens, vous devez avoir installé FAM ou Gamin (cela fonctionnera avec l'un ou l'autre). Vous devrez peut-être installer les paquets -devel.

Pour la famille *BSD, il existe une implémentation basée sur Kqueue qui sera utilisée lorsqu'elle sera détectée lors de l'exécution.

Si rien de ce qui précède ne fonctionne, Mono revient à interroger les répertoires pour les changements, ce qui est loin d'être optimal.

Je voudrais partager mes observations en utilisant FileSystemWatcher en Mono dans Ubuntu 10.10. Voici une implémentation très simple de FileSystemWatcher en C#

using System;
using System.Collections.Generic;
using System.Collections;
using System.Text;
using System.IO;
using System.Reflection;

namespace FileSystemWatcherSandbox
{
    public class Program
    {
        static void Main(string[] args)
        {
            foreach(DictionaryEntry de in Environment.GetEnvironmentVariables())
            {
                Console.WriteLine("{0} = {1}",de.Key,de.Value);
            }
            string basePath = AppDomain.CurrentDomain.BaseDirectory;
            Console.WriteLine("watching: {0}", basePath);
            FileSystemWatcher fsw = new FileSystemWatcher(basePath);
            fsw.Changed += new FileSystemEventHandler(fsw_Changed);
            fsw.Created += new FileSystemEventHandler(fsw_Created);
            fsw.Deleted += new FileSystemEventHandler(fsw_Deleted);
            fsw.Error += new ErrorEventHandler(fsw_Error);
            fsw.Renamed += new RenamedEventHandler(fsw_Renamed);
            fsw.EnableRaisingEvents = true;
            fsw.IncludeSubdirectories = true;
            while (true)
            {
                WaitForChangedResult result = fsw.WaitForChanged(WatcherChangeTypes.All,10000);
                Console.WriteLine(result.TimedOut ? "Time out" : "hmmm");
            }
        }

        static void fsw_Renamed(object sender, RenamedEventArgs e)
        {
            Console.WriteLine("({0}): {1} | {2}", MethodInfo.GetCurrentMethod().Name, e.ChangeType, e.FullPath);
        }

        static void fsw_Error(object sender, ErrorEventArgs e)
        {
            Console.WriteLine("({0}): {1}", MethodInfo.GetCurrentMethod().Name, e.GetException().Message);
        }

        static void fsw_Deleted(object sender, FileSystemEventArgs e)
        {
            Console.WriteLine("({0}): {1} | {2}", MethodInfo.GetCurrentMethod().Name, e.ChangeType, e.FullPath);
        }

        static void fsw_Created(object sender, FileSystemEventArgs e)
        {
            Console.WriteLine("({0}): {1} | {2}", MethodInfo.GetCurrentMethod().Name, e.ChangeType, e.FullPath);
        }

        static void fsw_Changed(object sender, FileSystemEventArgs e)
        {
            Console.WriteLine("({0}): {1} | {2}", MethodInfo.GetCurrentMethod().Name, e.ChangeType, e.FullPath);
        }
    }
}

Ce code a été testé et fonctionne à la fois sur Windows XP et Ubuntu 10.10. Cependant, je voudrais souligner que sous Ubuntu 10.10 (éventuellement des versions antérieures également), le FileSystemWatcher se comporte de manière unique.
Si le répertoire surveillé ne contient pas de sous-répertoires, l'appel d'un FileSystemWatcher avec la propriété IncludeSubdirectories définie sur true entraînera l'ignorance des événements par FileSystemWatcher. Cependant, s'il existe des sous-répertoires dans le répertoire cible, IncludeSubdirectories défini sur true fonctionnera comme prévu.
Ce qui fonctionnera toujours, c'est si IncludeSubdirectories est défini sur false. Dans ce cas, FileSystemWatcher ne surveillera que le répertoire cible.
J'espère que cela sera utile pour les programmeurs qui souhaitent utiliser Mono sur différents systèmes d'exploitation et invoquer le type FileSystemWatcher.