FileSystemWatcher Třída

Definice

Obor názvů:

System.IO

Sestavení:

System.IO.FileSystem.Watcher.dll

Zdroj:

FileSystemWatcher.cs

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 class FileSystemWatcher : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize

type FileSystemWatcher = class
    inherit Component
    interface ISupportInitialize

Public Class FileSystemWatcher
Inherits Component
Implements ISupportInitialize

Dědičnost

Object

MarshalByRefObject

Component

FileSystemWatcher

Implementuje

ISupportInitialize

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í 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)
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.

Viz také

• NotifyFilter
• NotifyFilters
• FileSystemEventArgs
• FileSystemEventHandler
• Filter
• IncludeSubdirectories
• InternalBufferOverflowException
• RenamedEventArgs
• RenamedEventHandler
• WaitForChangedResult
• WatcherChangeTypes
• Použití komponenty FileSystemWatcher ve formuláři Windows