FileSystemWatcher Klas

Definitie

public ref class FileSystemWatcher : System::ComponentModel::Component, System::ComponentModel::ISupportInitialize

public ref class FileSystemWatcher : IDisposable

public class FileSystemWatcher : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize

public class FileSystemWatcher : IDisposable

[System.IO.IODescription("FileSystemWatcherDesc")]
public class FileSystemWatcher : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize

type FileSystemWatcher = class
    inherit Component
    interface ISupportInitialize

type FileSystemWatcher = class
    interface IDisposable

[<System.IO.IODescription("FileSystemWatcherDesc")>]
type FileSystemWatcher = class
    inherit Component
    interface ISupportInitialize

Public Class FileSystemWatcher
Inherits Component
Implements ISupportInitialize

Public Class FileSystemWatcher
Implements IDisposable

Overname

Object

MarshalByRefObject

Component

FileSystemWatcher

Overname

Object

FileSystemWatcher

Kenmerken

IODescriptionAttribute

Implementeringen

ISupportInitialize IDisposable

Voorbeelden

In het volgende voorbeeld wordt een FileSystemWatcher map gemaakt die tijdens de runtime is opgegeven. Het onderdeel is ingesteld om te kijken naar wijzigingen in LastWrite en LastAccess tijd, het maken, verwijderen of hernoemen van tekstbestanden in de map. Als een bestand wordt gewijzigd, gemaakt of verwijderd, wordt het pad naar het bestand afgedrukt naar de console. Wanneer de naam van een bestand wordt gewijzigd, worden de oude en nieuwe paden afgedrukt naar de console.

using System;
using System.IO;

namespace MyNamespace
{
    class MyClassCS
    {
        static void Main()
        {
            using var watcher = new FileSystemWatcher(@"C:\path\to\folder");

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

            watcher.Changed += OnChanged;
            watcher.Created += OnCreated;
            watcher.Deleted += OnDeleted;
            watcher.Renamed += OnRenamed;
            watcher.Error += OnError;

            watcher.Filter = "*.txt";
            watcher.IncludeSubdirectories = true;
            watcher.EnableRaisingEvents = true;

            Console.WriteLine("Press enter to exit.");
            Console.ReadLine();
        }

        private static void OnChanged(object sender, FileSystemEventArgs e)
        {
            if (e.ChangeType != WatcherChangeTypes.Changed)
            {
                return;
            }
            Console.WriteLine($"Changed: {e.FullPath}");
        }

        private static void OnCreated(object sender, FileSystemEventArgs e)
        {
            string value = $"Created: {e.FullPath}";
            Console.WriteLine(value);
        }

        private static void OnDeleted(object sender, FileSystemEventArgs e) =>
            Console.WriteLine($"Deleted: {e.FullPath}");

        private static void OnRenamed(object sender, RenamedEventArgs e)
        {
            Console.WriteLine($"Renamed:");
            Console.WriteLine($"    Old: {e.OldFullPath}");
            Console.WriteLine($"    New: {e.FullPath}");
        }

        private static void OnError(object sender, ErrorEventArgs e) =>
            PrintException(e.GetException());

        private static void PrintException(Exception? ex)
        {
            if (ex != null)
            {
                Console.WriteLine($"Message: {ex.Message}");
                Console.WriteLine("Stacktrace:");
                Console.WriteLine(ex.StackTrace);
                Console.WriteLine();
                PrintException(ex.InnerException);
            }
        }
    }
}

Imports System.IO

Namespace MyNamespace

    Class MyClassVB

        Shared Sub Main()
            Using watcher = New FileSystemWatcher("C:\path\to\folder")
                watcher.NotifyFilter = NotifyFilters.Attributes Or
                                       NotifyFilters.CreationTime Or
                                       NotifyFilters.DirectoryName Or
                                       NotifyFilters.FileName Or
                                       NotifyFilters.LastAccess Or
                                       NotifyFilters.LastWrite Or
                                       NotifyFilters.Security Or
                                       NotifyFilters.Size

                AddHandler watcher.Changed, AddressOf OnChanged
                AddHandler watcher.Created, AddressOf OnCreated
                AddHandler watcher.Deleted, AddressOf OnDeleted
                AddHandler watcher.Renamed, AddressOf OnRenamed
                AddHandler watcher.Error, AddressOf OnError

                watcher.Filter = "*.txt"
                watcher.IncludeSubdirectories = True
                watcher.EnableRaisingEvents = True

                Console.WriteLine("Press enter to exit.")
                Console.ReadLine()
            End Using
        End Sub

        Private Shared Sub OnChanged(sender As Object, e As FileSystemEventArgs)
            If e.ChangeType <> WatcherChangeTypes.Changed Then
                Return
            End If
            Console.WriteLine($"Changed: {e.FullPath}")
        End Sub

        Private Shared Sub OnCreated(sender As Object, e As FileSystemEventArgs)
            Dim value As String = $"Created: {e.FullPath}"
            Console.WriteLine(value)
        End Sub

        Private Shared Sub OnDeleted(sender As Object, e As FileSystemEventArgs)
            Console.WriteLine($"Deleted: {e.FullPath}")
        End Sub

        Private Shared Sub OnRenamed(sender As Object, e As RenamedEventArgs)
            Console.WriteLine($"Renamed:")
            Console.WriteLine($"    Old: {e.OldFullPath}")
            Console.WriteLine($"    New: {e.FullPath}")
        End Sub

        Private Shared Sub OnError(sender As Object, e As ErrorEventArgs)
            PrintException(e.GetException())
        End Sub

        Private Shared Sub PrintException(ex As Exception)
            If ex IsNot Nothing Then
                Console.WriteLine($"Message: {ex.Message}")
                Console.WriteLine("Stacktrace:")
                Console.WriteLine(ex.StackTrace)
                Console.WriteLine()
                PrintException(ex.InnerException)
            End If
        End Sub

    End Class

End Namespace

Opmerkingen

Hiermee FileSystemWatcher kunt u controleren op wijzigingen in een opgegeven map. U kunt zoeken naar wijzigingen in bestanden en submappen van de opgegeven map. U kunt een onderdeel maken om bestanden op een lokale computer, een netwerkstation of een externe computer te bekijken.

Als u wilt controleren op wijzigingen in alle bestanden, stelt u de Filter eigenschap in op een lege tekenreeks ("") of gebruikt u jokertekens ("*.*"). Als u een specifiek bestand wilt bekijken, stelt u de Filter eigenschap in op de bestandsnaam. Als u bijvoorbeeld wilt controleren op wijzigingen in het bestand MyDoc.txt, stelt u de Filter eigenschap in op "MyDoc.txt". U kunt ook letten op wijzigingen in een bepaald type bestand. Als u bijvoorbeeld wilt kijken naar wijzigingen in tekstbestanden, stelt u de Filter eigenschap in op "*.txt".

Er zijn verschillende soorten wijzigingen die u in een map of bestand kunt bekijken. U kunt bijvoorbeeld zoeken naar wijzigingen in Attributes, de LastWrite datum en tijd, of de Size bestanden of mappen. Dit wordt gedaan door de NotifyFilter eigenschap in te stellen op een van de NotifyFilters waarden. Zie voor meer informatie over het type wijzigingen dat u kunt bekijken NotifyFilters.

U kunt kijken naar het wijzigen van de naam, verwijdering of het maken van bestanden of mappen. Als u bijvoorbeeld wilt kijken naar het hernoemen van tekstbestanden, stelt u de Filter-eigenschap in op '*.txt' en roept u de WaitForChanged-methode aan met een opgegeven Renamed voor de parameter.

Het Windows-besturingssysteem informeert uw component over bestandswijzigingen in een buffer die is aangemaakt door de FileSystemWatcher. Als er in korte tijd veel wijzigingen zijn, kan de buffer overlopen. Dit zorgt ervoor dat het onderdeel wijzigingen in de map niet meer kan bijhouden en er wordt alleen een dekenmelding weergegeven. Het vergroten van de grootte van de buffer met de InternalBufferSize eigenschap is duur, omdat het afkomstig is van niet-paginageheugen dat niet naar schijf kan worden verwisseld, dus zorg ervoor dat de buffer zo klein maar groot genoeg is om geen bestandswijzigingsgebeurtenissen te missen. Als u een bufferoverloop wilt voorkomen, gebruikt u de NotifyFilter en IncludeSubdirectories eigenschappen, zodat u ongewenste wijzigingsmeldingen kunt filteren.

Zie de FileSystemWatcher constructor voor een lijst met initiële eigenschapswaarden voor een exemplaar vanFileSystemWatcher.

Houd rekening met de volgende feiten wanneer u de FileSystemWatcher klasse gebruikt:

• Verborgen bestanden worden niet genegeerd.
• In sommige systemen FileSystemWatcher worden wijzigingen in bestanden gerapporteerd met behulp van de korte 8.3-bestandsindeling. Een wijziging in 'LongFileName.LongExtension' kan bijvoorbeeld worden gerapporteerd als 'LongFil~. Lon".
• De maximale grootte die u kunt instellen voor de eigenschap voor het InternalBufferSize bewaken van een map via het netwerk is 64 kB.

Mappen kopiëren en verplaatsen

Het besturingssysteem en FileSystemWatcher object interpreteren een knip- en plakactie of een verplaatsingsactie als een naamswijzigingsactie voor een map en de inhoud ervan. Als u een map knipt en plakt met bestanden in een map die wordt bekeken, rapporteert het FileSystemWatcher object alleen de map als nieuw, maar niet de inhoud, omdat ze in wezen alleen de naam hebben gewijzigd.

Om op de hoogte te worden gesteld dat de inhoud van mappen is verplaatst of gekopieerd naar een bewaakte map, kunt u de gebeurtenishandler-methoden OnChanged en OnRenamed opgeven zoals voorgesteld in de volgende tabel.

Gebeurtenissen en buffergrootten

Houd er rekening mee dat verschillende factoren van invloed kunnen zijn op welke gebeurtenissen voor het wijzigen van het bestandssysteem worden gegenereerd, zoals wordt beschreven door het volgende:

• Veelvoorkomende bestandssysteembewerkingen kunnen meerdere gebeurtenissen veroorzaken. Wanneer een bestand bijvoorbeeld van de ene map naar de andere wordt verplaatst, kunnen er meerdere OnChanged en enkele OnCreated gebeurtenissen OnDeleted worden gegenereerd. Het verplaatsen van een bestand is een complexe bewerking die bestaat uit meerdere eenvoudige bewerkingen, waardoor meerdere gebeurtenissen worden gegenereerd. Op dezelfde manier kunnen sommige toepassingen (bijvoorbeeld antivirussoftware) aanvullende bestandssysteem-gebeurtenissen veroorzaken die worden gedetecteerd door FileSystemWatcher.
• De FileSystemWatcher kan schijven bekijken zolang ze niet zijn overgeschakeld of verwijderd. De FileSystemWatcher gebeurtenis genereert geen gebeurtenissen voor cd's en dvd's, omdat tijdstempels en eigenschappen niet kunnen worden gewijzigd. Op externe computers moet een van de vereiste platformen zijn geïnstalleerd om het onderdeel goed te laten functioneren.

Houd er rekening mee dat een FileSystemWatcher gebeurtenis mogelijk ontbreekt wanneer de buffergrootte wordt overschreden. Volg deze richtlijnen om ontbrekende gebeurtenissen te voorkomen:

• Verhoog de buffergrootte door de InternalBufferSize eigenschap in te stellen.
• Vermijd het bekijken van bestanden met lange bestandsnamen, omdat een lange bestandsnaam bijdraagt aan het vullen van de buffer. Overweeg de naam van deze bestanden te wijzigen met kortere namen.
• Houd de code voor het afhandelen van gebeurtenissen zo kort mogelijk.

Zie ook

• NotifyFilter
• NotifyFilters
• FileSystemEventArgs
• FileSystemEventHandler
• Filter
• IncludeSubdirectories
• InternalBufferOverflowException
• RenamedEventArgs
• RenamedEventHandler
• WaitForChangedResult
• WatcherChangeTypes
• Using a FileSystemWatcher Component in a Windows Form