BigBasti's Blog About Me & my Digital Lifestyle

C#: Das Dateisystem mit dem FileSystemWatcher überwachen

Oftmals ist man darauf angewiesen, dein Inhalt von einem oder mehreren Ordnern zu überwachen und auf Änderungen oder Aktionen des Benutzers  zu reagieren.

Dafür gibt es verschiedene Ansätze, ich will euch heute den FileSystemWatcher aus dem .NET Framework vorstellen. Der FileSystemWatcher (FSW) bietet uns eine Reihe von Events mit denen wir das System immer im Blick haben, darunter fallen die Events Changed, Created, Renamed und Deleted.

Da der FSW auch in einem eigenem Thread läuft gibt es auch keine Kollisionen mit der GUI und den anderen Programmabläufen. Hier muss man lediglich darauf achten, dass man keine Exceptions wegen der Threadübergreifenden Aktionen bekommt!

Fangen wir mit der Implementierung an:

            //Eine neue FileSystemWatcher Instanz erstellen
            FileSystemWatcher fw = new FileSystemWatcher("C:\temp");

            //Events regestrieren
            fw.Changed += new FileSystemEventHandler(onChanged);
            fw.Created += new FileSystemEventHandler(onChanged);
            fw.Deleted += new FileSystemEventHandler(onChanged);
            fw.Renamed += new RenamedEventHandler(onRenamed);

            fw.IncludeSubdirectories = true;

            //Überwachung starten
            fw.EnableRaisingEvents = true;

Hier erzeugen wir als erstes eine neues FileSystemWatcher Objekt und geben diesem einen expliziten Pfad als Parameter. Dieser Pfad wird dann vom FSW überwacht.

Als nächstes werden die vier Events registriert über die der FSW uns informieren soll. Zum Schluss sagen wir dem FSW noch, dass er auch die Unterordner des gewählten Pfads mit überwachen soll und starten die Überwachung.

Nun müssen wir noch die Events implementieren:

        private void onChanged(object source, FileSystemEventArgs e)
        {
            if (this.lstEvents.InvokeRequired)
            {
                addItemDel ad = new addItemDel(addItem);
                this.Invoke(ad, new object[] { e.ChangeType + " " + e.FullPath });
            }
            else
            {
                lstEvents.Items.Add(e.ChangeType + " " + e.FullPath);
            }
        }

        private void onRenamed(object source, RenamedEventArgs e)
        {
            if (this.lstEvents.InvokeRequired)
            {
                addItemDel ad = new addItemDel(addItem);
                this.Invoke(ad, new object[] { e.ChangeType + " " + e.OldName + " -> " + e.Name });
            }
            else
            {
                lstEvents.Items.Add(e.ChangeType + " " + e.OldName + " -> " + e.Name);
            }
        }

Da der FSW in einem eigenem Thread läuft müssen wir hier darauf achten und die Werte aus den Events über Delegate Methoden übergeben.

        private delegate void addItemDel(string text);

        private void addItem(string text)
        {
            lstEvents.Items.Add(text);
        }

Aus den übergebenen Event Argumenten können wir alle für uns wichtigen Informationen auslesen, wie den kompletten Pfad und die Dateinamen vor und nach dem umbenennen.

Übrigens nutzen zB. auch Antivieren Programme auch diese Technik für den Liveschutz vom Dateisystem.

Die FSW Klasse bietet noch weitere Möglichkeiten, mehr dazu im MSDN.

Natürlich habe ich hier auch wieder eine kleine Demo vorbereitet:

Bild 1: Events die aus dem überwachten Ordner ausgelesen wurden

Die Demo gibts hier:

Oftmals ist man darauf angewiesen, dein Inhalt von einem oder mehreren Ordnern zu überwachen und auf Änderungen oder Aktionen des Benutzers  zu reagieren. Dafür gibt es verschiedene Ansätze, ich will euch heute den FileSystemWatcher aus dem .NET Framework vorstellen. Der FileSystemWatcher (FSW) bietet uns eine Reihe von Events mit denen wir das System immer im ...