Esiste un equivalente di .Net FileSystemWatcher nel mondo Linux?

Come già detto, Mono ha la classe "System.IO.FileSystemWatcher", questo il relativo link:http://www.go-mono.com/docs/monodoc.ashx?link=T%3aSystem.IO. FileSystemWatcher

"L'implementazione di Mono del FileSystemWatcher ha più backend. Questo è necessario perché non tutti i sistemi operativi supportati da Mono hanno tutte le funzionalità necessarie per fornire la funzionalità prevista dalle applicazioni.

Se il kernel del sistema operativo supporta la visualizzazione delle directory (inotify su Linux, KEvents su BSD o OSX) viene utilizzata quella funzione; Altrimenti ricorre all'utilizzo delle librerie Gamin o FAM (queste librerie forniscono un'API per monitorare le directory) e se nessuna di queste funzionalità è disponibile, Mono eseguirà il polling ogni 750 millisecondi delle directory monitorate.

È possibile forzare il comportamento di polling (invece di utilizzare il supporto del kernel) impostando la variabile di ambiente MONO_MANAGED_WATCHER prima di eseguire l'applicazione. Questo potrebbe essere utile per i filesystem che non supportano la notifica e richiedono comunque il polling per rilevare le modifiche."

Sarebbe Gamin the File Alteration Monitor o Inotify.

Modifica:Mono ha collegamenti Gamin - infatti, la sua implementazione di FileSystemWatcher utilizza Gamin. https://www.mono-project.com/docs/faq/technical/#what-are-the-issues-with-filesystemwatcher.

Quali sono i problemi con FileSystemWatcher?

L'implementazione Mono di FileSystemWatcher ha un numero di backend, quello più ottimale, quello con meno dipendenze è inotify-backend (disponibile in Mono 1.1.17 e versioni successive).

Con questo backend il kernel fornisce a Mono aggiornamenti su qualsiasi modifica ai file sul file system, ma richiede un kernel abilitato per inotify, fornito solo dalle distribuzioni Linux più recenti.

Nei vecchi sistemi Linux, devi aver installato FAM o Gamin (funzionerà con entrambi). Potrebbero essere necessari i pacchetti -devel installati.

Per la famiglia *BSD, esiste un'implementazione basata su Kqueue che verrà utilizzata quando rilevata in fase di esecuzione.

Se nessuna delle soluzioni precedenti funziona, Mono ricorre al polling delle directory per le modifiche, che sono tutt'altro che ottimali.

Vorrei condividere le mie osservazioni utilizzando FileSystemWatcher in Mono in Ubuntu 10.10. Ecco un'implementazione molto semplice di FileSystemWatcher in 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);
        }
    }
}

Questo codice è stato testato e funziona sia su Windows XP che su Ubuntu 10.10. Tuttavia, vorrei sottolineare che sotto Ubuntu 10.10 (possibilmente anche versioni precedenti), FileSystemWatcher si comporta in modo univoco.
Se la directory controllata non contiene sottodirectory, richiamare un FileSystemWatcher con la proprietà IncludeSubdirectories impostata su true farà sì che FileSystemWatcher ignori gli eventi. Tuttavia, se sono presenti sottodirectory nella directory di destinazione, IncludeSubdirectories impostato su true funzionerà come previsto.
Ciò che funzionerà sempre è se IncludeSubdirectories è impostato su false. In questo caso, FileSystemWatcher controllerà solo la directory di destinazione.
Spero che questo sia utile per i programmatori che desiderano utilizzare Mono su diversi sistemi operativi e invocare il tipo FileSystemWatcher.