Sdílet prostřednictvím


FileSystemWatcher Třída

Definice

Naslouchá oznámením o změnách systému souborů a vyvolává události, když se změní adresář nebo soubor v adresáři.

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
Dědičnost
FileSystemWatcher
Dědičnost
FileSystemWatcher
Atributy
Implementuje

Příklady

Následující příklad vytvoří FileSystemWatcher watch adresář zadaný za běhu. Komponenta je nastavená na watch pro změny v LastWrite čase a LastAccess čas, vytváření, odstranění nebo přejmenování textových souborů v adresáři. Pokud se soubor změní, vytvoří nebo odstraní, cesta k souboru se vytiskne do konzoly. Při přejmenování souboru se staré a nové cesty vytisknou do konzoly.

#include "pch.h"

using namespace System;
using namespace System::IO;

class MyClassCPP
{
public:

    int static Run()
    {
        FileSystemWatcher^ watcher = gcnew FileSystemWatcher("C:\\path\\to\\folder");

        watcher->NotifyFilter = static_cast<NotifyFilters>(NotifyFilters::Attributes
                                                         | NotifyFilters::CreationTime
                                                         | NotifyFilters::DirectoryName
                                                         | NotifyFilters::FileName
                                                         | NotifyFilters::LastAccess
                                                         | NotifyFilters::LastWrite
                                                         | NotifyFilters::Security
                                                         | NotifyFilters::Size);

        watcher->Changed += gcnew FileSystemEventHandler(MyClassCPP::OnChanged);
        watcher->Created += gcnew FileSystemEventHandler(MyClassCPP::OnCreated);
        watcher->Deleted += gcnew FileSystemEventHandler(MyClassCPP::OnDeleted);
        watcher->Renamed += gcnew RenamedEventHandler(MyClassCPP::OnRenamed);
        watcher->Error   += gcnew ErrorEventHandler(MyClassCPP::OnError);

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

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

        return 0;
    }

private:

    static void OnChanged(Object^ sender, FileSystemEventArgs^ e)
    {
        if (e->ChangeType != WatcherChangeTypes::Changed)
        {
            return;
        }
        Console::WriteLine("Changed: {0}", e->FullPath);
    }

    static void OnCreated(Object^ sender, FileSystemEventArgs^ e)
    {
        Console::WriteLine("Created: {0}", e->FullPath);
    }

    static void OnDeleted(Object^ sender, FileSystemEventArgs^ e)
    {
        Console::WriteLine("Deleted: {0}", e->FullPath);
    }

    static void OnRenamed(Object^ sender, RenamedEventArgs^ e)
    {
        Console::WriteLine("Renamed:");
        Console::WriteLine("    Old: {0}", e->OldFullPath);
        Console::WriteLine("    New: {0}", e->FullPath);
    }

    static void OnError(Object^ sender, ErrorEventArgs^ e)
    {
        PrintException(e->GetException());
    }

    static void PrintException(Exception^ ex)
    {
        if (ex != nullptr)
        {
            Console::WriteLine("Message: {0}", ex->Message);
            Console::WriteLine("Stacktrace:");
            Console::WriteLine(ex->StackTrace);
            Console::WriteLine();
            PrintException(ex->InnerException);
        }
    }
};


int main()
{
    MyClassCPP::Run();
}
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

Poznámky

Další informace o tomto rozhraní API najdete v tématu Doplňkové poznámky k rozhraní API pro FileSystemWatcher.

Konstruktory

FileSystemWatcher()

Inicializuje novou instanci FileSystemWatcher třídy.

FileSystemWatcher(String)

Inicializuje novou instanci FileSystemWatcher třídy vzhledem k zadanému adresáři k monitorování.

FileSystemWatcher(String, String)

Inicializuje novou instanci FileSystemWatcher třídy vzhledem k zadanému adresáři a typu souborů ke sledování.

Vlastnosti

CanRaiseEvents

Získá hodnotu označující, zda komponenta může vyvolat událost.

(Zděděno od Component)
Container

Získá objekt IContainer , který obsahuje Component.

(Zděděno od Component)
DesignMode

Získá hodnotu, která označuje, zda je aktuálně v režimu návrhu Component .

(Zděděno od Component)
EnableRaisingEvents

Získá nebo nastaví hodnotu označující, zda je komponenta povolena.

Events

Získá seznam obslužných rutin událostí, které jsou připojeny k tomuto Component.

(Zděděno od Component)
Filter

Získá nebo nastaví řetězec filtru, který se používá k určení, které soubory jsou monitorovány v adresáři.

Filters

Získá kolekci všech filtrů použitých k určení, jaké soubory jsou monitorovány v adresáři.

IncludeSubdirectories

Získá nebo nastaví hodnotu určující, zda podadresáře v zadané cestě by měly být monitorovány.

InternalBufferSize

Získá nebo nastaví velikost (v bajtech) vnitřní vyrovnávací paměti.

NotifyFilter

Získá nebo nastaví typ změn watch pro.

Path

Získá nebo nastaví cestu adresáře na watch.

Site

Získá nebo nastaví hodnotu ISite pro FileSystemWatcher.

SynchronizingObject

Získá nebo nastaví objekt použitý k zařazování volání obslužné rutiny události vydané v důsledku změny adresáře.

Metody

BeginInit()

Zahájí inicializaci objektu použitého FileSystemWatcher ve formuláři nebo používaného jinou komponentou. K inicializaci dochází v době běhu.

CreateObjRef(Type)

Vytvoří objekt, který obsahuje všechny relevantní informace potřebné k vygenerování proxy používaného ke komunikaci se vzdáleným objektem.

(Zděděno od MarshalByRefObject)
Dispose()

Uvolní nespravované prostředky používané FileSystemWatchernástrojem .

Dispose()

Uvolní všechny prostředky používané nástrojem Component.

(Zděděno od Component)
Dispose(Boolean)

Uvolní nespravované prostředky používané FileSystemWatcher nástrojem a volitelně uvolní spravované prostředky.

EndInit()

Ukončí inicializaci objektu použitého FileSystemWatcher ve formuláři nebo používaného jinou komponentou. K inicializaci dochází v době běhu.

Equals(Object)

Určí, zda se zadaný objekt rovná aktuálnímu objektu.

(Zděděno od Object)
GetHashCode()

Slouží jako výchozí hashovací funkce.

(Zděděno od Object)
GetLifetimeService()
Zastaralé.

Načte objekt služby aktuální životnosti, který řídí zásady životnosti pro tuto instanci.

(Zděděno od MarshalByRefObject)
GetService(Type)

Vrátí objekt, který představuje službu poskytovanou objektem Component nebo jejím Containerobjektem .

(Zděděno od Component)
GetType()

Získá aktuální Type instanci.

(Zděděno od Object)
InitializeLifetimeService()
Zastaralé.

Získá objekt služby životnosti, který řídí zásady životnosti pro tuto instanci.

(Zděděno od MarshalByRefObject)
MemberwiseClone()

Vytvoří mělkou kopii aktuálního Objectsouboru .

(Zděděno od Object)
MemberwiseClone(Boolean)

Vytvoří mělkou kopii aktuálního MarshalByRefObject objektu.

(Zděděno od MarshalByRefObject)
OnChanged(FileSystemEventArgs)

Changed Vyvolá událost.

OnCreated(FileSystemEventArgs)

Created Vyvolá událost.

OnDeleted(FileSystemEventArgs)

Deleted Vyvolá událost.

OnError(ErrorEventArgs)

Error Vyvolá událost.

OnRenamed(RenamedEventArgs)

Renamed Vyvolá událost.

ToString()

String Vrátí hodnotu obsahující název Component, pokud existuje. Tato metoda by neměla být přepsána.

(Zděděno od Component)
ToString()

Vrátí řetězec, který představuje aktuální objekt.

(Zděděno od Object)
WaitForChanged(WatcherChangeTypes)

Synchronní metoda, která vrací strukturu, která obsahuje konkrétní informace o změně, ke které došlo, vzhledem k typu změny, kterou chcete monitorovat.

WaitForChanged(WatcherChangeTypes, Int32)

Synchronní metoda, která vrací strukturu obsahující konkrétní informace o změně, ke které došlo, s ohledem na typ změny, kterou chcete monitorovat, a dobu čekání (v milisekundách) před vypršením časového limitu.

WaitForChanged(WatcherChangeTypes, TimeSpan)

Synchronně vrátí strukturu, která obsahuje konkrétní informace o změně, ke které došlo, vzhledem k typu změny, kterou chcete monitorovat.

Událost

Changed

Nastane při změně souboru nebo adresáře v zadaném Path souboru.

Created

Nastane při vytvoření souboru nebo adresáře v zadaném Path adresáři.

Deleted

Nastane při odstranění souboru nebo adresáře v zadaném Path adresáři.

Disposed

Nastane, když je komponenta odstraněna voláním Dispose() metody.

(Zděděno od Component)
Error

Nastane, když instance objektu FileSystemWatcher nemůže pokračovat v monitorování změn nebo při přetečení vnitřní vyrovnávací paměti.

Renamed

Nastane při přejmenování souboru nebo adresáře v zadaném Path adresáři.

Platí pro

Viz také