Udostępnij za pośrednictwem


FileSystemWatcher Klasa

Definicja

Nasłuchuje powiadomień o zmianie systemu plików i zgłasza zdarzenia w przypadku zmiany katalogu lub pliku w katalogu.

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
Dziedziczenie
FileSystemWatcher
Dziedziczenie
FileSystemWatcher
Atrybuty
Implementuje

Przykłady

Poniższy przykład tworzy obiekt w FileSystemWatcher celu watch katalogu określonego w czasie wykonywania. Składnik jest ustawiony na watch zmian w LastWrite czasieLastAccess, utworzeniu, usunięciu lub zmianie nazwy plików tekstowych w katalogu. Jeśli plik zostanie zmieniony, utworzony lub usunięty, ścieżka do pliku zostanie wyświetlona w konsoli programu . Po zmianie nazwy pliku stare i nowe ścieżki są drukowane w konsoli programu .

#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

Uwagi

Aby uzyskać więcej informacji na temat tego interfejsu API, zobacz Uwagi dotyczące dodatkowego interfejsu API dla elementu FileSystemWatcher.

Konstruktory

FileSystemWatcher()

Inicjuje nowe wystąpienie klasy FileSystemWatcher.

FileSystemWatcher(String)

Inicjuje FileSystemWatcher nowe wystąpienie klasy, biorąc pod uwagę określony katalog do monitorowania.

FileSystemWatcher(String, String)

Inicjuje FileSystemWatcher nowe wystąpienie klasy, biorąc pod uwagę określony katalog i typ plików do monitorowania.

Właściwości

CanRaiseEvents

Pobiera wartość wskazującą, czy składnik może zgłosić zdarzenie.

(Odziedziczone po Component)
Container

Pobiera element IContainer zawierający element Component.

(Odziedziczone po Component)
DesignMode

Pobiera wartość wskazującą, czy Component element jest obecnie w trybie projektowania.

(Odziedziczone po Component)
EnableRaisingEvents

Pobiera lub ustawia wartość wskazującą, czy składnik jest włączony.

Events

Pobiera listę programów obsługi zdarzeń dołączonych do tego Componentelementu .

(Odziedziczone po Component)
Filter

Pobiera lub ustawia ciąg filtru używany do określania, które pliki są monitorowane w katalogu.

Filters

Pobiera kolekcję wszystkich filtrów używanych do określenia, które pliki są monitorowane w katalogu.

IncludeSubdirectories

Pobiera lub ustawia wartość wskazującą, czy podkatalogi w określonej ścieżce powinny być monitorowane.

InternalBufferSize

Pobiera lub ustawia rozmiar (w bajtach) buforu wewnętrznego.

NotifyFilter

Pobiera lub ustawia typ zmian watch dla.

Path

Pobiera lub ustawia ścieżkę katalogu do watch.

Site

Pobiera lub ustawia element ISite dla elementu FileSystemWatcher.

SynchronizingObject

Pobiera lub ustawia obiekt używany do marshalowania wywołań programu obsługi zdarzeń wystawionych w wyniku zmiany katalogu.

Metody

BeginInit()

Rozpoczyna inicjowanie elementu używanego FileSystemWatcher w formularzu lub używanego przez inny składnik. Inicjowanie odbywa się w czasie wykonywania.

CreateObjRef(Type)

Tworzy obiekt zawierający wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikowania się z obiektem zdalnym.

(Odziedziczone po MarshalByRefObject)
Dispose()

Zwalnia niezarządzane zasoby używane przez FileSystemWatcherprogram .

Dispose()

Zwalnia wszelkie zasoby używane przez element Component.

(Odziedziczone po Component)
Dispose(Boolean)

Zwalnia zasoby niezarządzane używane przez element FileSystemWatcher i opcjonalnie zwalnia zasoby zarządzane.

EndInit()

Kończy inicjowanie elementu używanego FileSystemWatcher w formularzu lub używane przez inny składnik. Inicjowanie odbywa się w czasie wykonywania.

Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.

(Odziedziczone po Object)
GetHashCode()

Służy jako domyślna funkcja skrótu.

(Odziedziczone po Object)
GetLifetimeService()
Przestarzałe.

Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia.

(Odziedziczone po MarshalByRefObject)
GetService(Type)

Zwraca obiekt reprezentujący usługę dostarczaną przez Component obiekt lub przez obiekt Container.

(Odziedziczone po Component)
GetType()

Type Pobiera bieżące wystąpienie.

(Odziedziczone po Object)
InitializeLifetimeService()
Przestarzałe.

Uzyskuje obiekt usługi okresu istnienia, aby kontrolować zasady okresu istnienia dla tego wystąpienia.

(Odziedziczone po MarshalByRefObject)
MemberwiseClone()

Tworzy płytkią kopię bieżącego Objectelementu .

(Odziedziczone po Object)
MemberwiseClone(Boolean)

Tworzy płytkią kopię bieżącego MarshalByRefObject obiektu.

(Odziedziczone po MarshalByRefObject)
OnChanged(FileSystemEventArgs)

Changed Zgłasza zdarzenie.

OnCreated(FileSystemEventArgs)

Created Zgłasza zdarzenie.

OnDeleted(FileSystemEventArgs)

Deleted Zgłasza zdarzenie.

OnError(ErrorEventArgs)

Error Zgłasza zdarzenie.

OnRenamed(RenamedEventArgs)

Renamed Zgłasza zdarzenie.

ToString()

Zwraca wartość String zawierającą nazwę Componentobiektu , jeśli istnieje. Ta metoda nie powinna być zastępowana.

(Odziedziczone po Component)
ToString()

Zwraca ciąg reprezentujący bieżący obiekt.

(Odziedziczone po Object)
WaitForChanged(WatcherChangeTypes)

Metoda synchroniczna, która zwraca strukturę zawierającą określone informacje o zmianie, która wystąpiła, biorąc pod uwagę typ zmiany, którą chcesz monitorować.

WaitForChanged(WatcherChangeTypes, Int32)

Metoda synchroniczna, która zwraca strukturę zawierającą określone informacje na temat zmiany, biorąc pod uwagę typ zmiany, którą chcesz monitorować, oraz czas oczekiwania (w milisekundach) przed przekroczeniem limitu czasu.

WaitForChanged(WatcherChangeTypes, TimeSpan)

Synchronicznie zwraca strukturę zawierającą określone informacje o zmianie, która wystąpiła, biorąc pod uwagę typ zmiany do monitorowania.

Zdarzenia

Changed

Występuje, gdy plik lub katalog w określonym pliku Path zostanie zmieniony.

Created

Występuje po utworzeniu pliku lub katalogu w określonym Path obiekcie.

Deleted

Występuje, gdy plik lub katalog w określonym pliku Path zostanie usunięty.

Disposed

Występuje, gdy składnik jest usuwany przez wywołanie Dispose() metody .

(Odziedziczone po Component)
Error

Występuje, gdy wystąpienie nie FileSystemWatcher może kontynuować monitorowania zmian lub gdy wewnętrzne przepełnienie buforu.

Renamed

Występuje, gdy nazwa pliku lub katalogu w określonym pliku Path jest zmieniana.

Dotyczy

Zobacz też