FileSystemWatcher Klasa

Definicja

Nasłuchuje powiadomień o zmianie systemu plików i zgłasza zdarzenia, gdy katalog lub plik w katalogu ulegnie zmianie.Listens to the file system change notifications and raises events when a directory, or file in a directory, changes.

public ref class FileSystemWatcher : System::ComponentModel::Component, System::ComponentModel::ISupportInitialize
public ref class FileSystemWatcher : IDisposable
public ref class FileSystemWatcher : System::ComponentModel::Component, IDisposable, System::ComponentModel::ISupportInitialize
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
public class FileSystemWatcher : System.ComponentModel.Component, IDisposable, System.ComponentModel.ISupportInitialize
[System.IO.IODescription("")]
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
type FileSystemWatcher = class
    inherit Component
    interface IDisposable
    interface ISupportInitialize
[<System.IO.IODescription("")>]
type FileSystemWatcher = class
    inherit Component
    interface ISupportInitialize
Public Class FileSystemWatcher
Inherits Component
Implements ISupportInitialize
Public Class FileSystemWatcher
Implements IDisposable
Public Class FileSystemWatcher
Inherits Component
Implements IDisposable, ISupportInitialize
Dziedziczenie
FileSystemWatcher
Dziedziczenie
FileSystemWatcher
Atrybuty
Implementuje

Przykłady

Poniższy przykład tworzy, FileSystemWatcher Aby obejrzeć katalog określony w czasie wykonywania.The following example creates a FileSystemWatcher to watch the directory specified at run time. Składnik jest ustawiony do śledzenia zmian w LastWrite LastAccess czasie, tworzenia, usuwania lub zmieniania nazw plików tekstowych w katalogu.The component is set to watch for changes in LastWrite and LastAccess time, the creation, deletion, or renaming of text files in the directory. Jeśli plik zostanie zmieniony, utworzony lub usunięty, ścieżka do pliku zostanie wydrukowana do konsoli programu.If a file is changed, created, or deleted, the path to the file prints to the console. Po zmianie nazwy pliku stare i nowe ścieżki są drukowane do konsoli programu.When a file is renamed, the old and new paths print to the console.

#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

Użyj FileSystemWatcher , aby obejrzeć zmiany w określonym katalogu.Use FileSystemWatcher to watch for changes in a specified directory. Możesz obejrzeć zmiany w plikach i podkatalogach określonego katalogu.You can watch for changes in files and subdirectories of the specified directory. Można utworzyć składnik do oglądania plików na komputerze lokalnym, dysku sieciowym lub komputerze zdalnym.You can create a component to watch files on a local computer, a network drive, or a remote computer.

Aby obejrzeć zmiany we wszystkich plikach, należy ustawić Filter Właściwość na pusty ciąg ("") lub użyć symboli wieloznacznych ("*. * ").To watch for changes in all files, set the Filter property to an empty string ("") or use wildcards ("*.*"). Aby obejrzeć określony plik, należy ustawić Filter Właściwość na nazwę pliku.To watch a specific file, set the Filter property to the file name. Na przykład aby obejrzeć zmiany w pliku MyDoc.txt, należy ustawić Filter Właściwość na "MyDoc.txt".For example, to watch for changes in the file MyDoc.txt, set the Filter property to "MyDoc.txt". Możesz również obejrzeć zmiany w określonym typie pliku.You can also watch for changes in a certain type of file. Na przykład aby obejrzeć zmiany w plikach tekstowych, należy ustawić Filter Właściwość na " * . txt".For example, to watch for changes in text files, set the Filter property to "*.txt".

Istnieje kilka typów zmian, które można obejrzeć w katalogu lub pliku.There are several types of changes you can watch for in a directory or file. Na przykład można obejrzeć zmiany w Attributes , LastWrite dacie i godzinie lub Size plików lub katalogów.For example, you can watch for changes in Attributes, the LastWrite date and time, or the Size of files or directories. Jest to realizowane przez ustawienie NotifyFilter właściwości na jedną z NotifyFilters wartości.This is done by setting the NotifyFilter property to one of the NotifyFilters values. Aby uzyskać więcej informacji na temat typu zmian, które można obejrzeć, zobacz NotifyFilters .For more information on the type of changes you can watch, see NotifyFilters.

Można obejrzeć zmiany nazw, usuwania lub tworzenia plików lub katalogów.You can watch for renaming, deletion, or creation of files or directories. Na przykład aby obejrzeć zmiany nazwy plików tekstowych, należy ustawić Filter Właściwość na "*. txt" i wywołać WaitForChanged metodę z Renamed określonym parametrem.For example, to watch for renaming of text files, set the Filter property to "*.txt" and call the WaitForChanged method with a Renamed specified for its parameter.

System operacyjny Windows powiadamia składnik o zmianach plików w buforze utworzonym przez FileSystemWatcher .The Windows operating system notifies your component of file changes in a buffer created by the FileSystemWatcher. Jeśli w krótkim czasie występuje wiele zmian, bufor może przepełnić.If there are many changes in a short time, the buffer can overflow. Powoduje to, że składnik utraci śledzenie zmian w katalogu i udostępnia tylko powiadomienia zbiorcze.This causes the component to lose track of changes in the directory, and it will only provide blanket notification. Zwiększenie rozmiaru buforu z InternalBufferSize właściwością jest kosztowne, ponieważ pochodzi ona z niestronicowanej pamięci, która nie może zostać zamieniony na dysk, dlatego przechowuj bufor jako mały, który jest wystarczająco duży, aby nie trafiać żadnych zdarzeń zmiany pliku.Increasing the size of the buffer with the InternalBufferSize property is expensive, as it comes from non-paged memory that cannot be swapped out to disk, so keep the buffer as small yet large enough to not miss any file change events. Aby uniknąć przepełnienia buforu, użyj NotifyFilter IncludeSubdirectories właściwości i, aby można było odfiltrować niechciane powiadomienia o zmianach.To avoid a buffer overflow, use the NotifyFilter and IncludeSubdirectories properties so you can filter out unwanted change notifications.

Aby uzyskać listę początkowych wartości właściwości dla wystąpienia FileSystemWatcher , zobacz FileSystemWatcher Konstruktor.For a list of initial property values for an instance of FileSystemWatcher, see the FileSystemWatcher constructor.

Podczas używania klasy należy zwrócić uwagę na następujące kwestie FileSystemWatcher .Please note the following when using the FileSystemWatcher class.

  • Ukryte pliki nie są ignorowane.Hidden files are not ignored.

  • W niektórych systemach program FileSystemWatcher raportuje zmiany w plikach przy użyciu krótkiego formatu nazwy pliku 8,3.In some systems, FileSystemWatcher reports changes to files using the short 8.3 file name format. Na przykład zmiana "LongFileName. LongExtension" może być raportowana jako "LongFil ~. Długość ".For example, a change to "LongFileName.LongExtension" could be reported as "LongFil~.Lon".

  • Ta klasa zawiera żądanie łącza i dziedziczenia na poziomie klasy stosowane do wszystkich składowych.This class contains a link demand and an inheritance demand at the class level that applies to all members. SecurityExceptionWystępuje, gdy bezpośredni obiekt wywołujący lub Klasa pochodna nie ma uprawnienia pełnego zaufania.A SecurityException is thrown when either the immediate caller or the derived class does not have full-trust permission. Aby uzyskać szczegółowe informacje o wymaganiach dotyczących zabezpieczeń, zobacz wymagania dotyczące linków.For details about security demands, see Link Demands.

  • Maksymalny rozmiar, jaki można ustawić dla InternalBufferSize Właściwości monitorowania katalogu za pośrednictwem sieci, to 64 KB.The maximum size you can set for the InternalBufferSize property for monitoring a directory over the network is 64 KB.

Kopiowanie i przenoszenie folderówCopying and moving folders

System operacyjny i FileSystemWatcher obiekt interpretują akcję wycinania i wklejania albo akcję Przenieś jako akcję zmiany nazwy dla folderu i jego zawartości.The operating system and FileSystemWatcher object interpret a cut-and-paste action or a move action as a rename action for a folder and its contents. Jeśli wytniesz i wkleisz folder z plikami w monitorowanym folderze, obiekt będzie FileSystemWatcher zgłaszać tylko folder jako nowy, ale nie jego zawartość, ponieważ zasadniczo zmieniono jego nazwę.If you cut and paste a folder with files into a folder being watched, the FileSystemWatcher object reports only the folder as new, but not its contents because they are essentially only renamed.

Aby otrzymywać powiadomienia o przeniesieniu lub skopiowaniu zawartości folderów do monitorowanego folderu, określ OnChanged OnRenamed metody obsługi zdarzeń i Zaproponuj je w poniższej tabeli.To be notified that the contents of folders have been moved or copied into a watched folder, provide OnChanged and OnRenamed event handler methods as suggested in the following table.

Procedura obsługi zdarzeńEvent Handler Zdarzenia obsłużoneEvents Handled WykonywanyPerforms
OnChanged Changed, Created, DeletedChanged, Created, Deleted Raportuj zmiany w atrybutach plików, utworzonych plikach i usuniętych plikach.Report changes in file attributes, created files, and deleted files.
OnRenamed Renamed Wyświetl listę starych i nowych ścieżek plików i folderów, które zostały zmienione, w razie konieczności rozwinięcie rekursywnie.List the old and new paths of renamed files and folders, expanding recursively if needed.

Zdarzenia i rozmiary buforówEvents and Buffer Sizes

Należy zauważyć, że niektóre czynniki mogą wpłynąć na to, które zdarzenia zmiany systemu plików są wywoływane, zgodnie z opisem w następujących tematach:Note that several factors can affect which file system change events are raised, as described by the following:

  • Typowe operacje systemu plików mogą spowodować wystąpienie więcej niż jednego zdarzenia.Common file system operations might raise more than one event. Na przykład, gdy plik jest przenoszony z jednego katalogu do innego, OnChanged OnCreated OnDeleted mogą zostać zgłoszone kilka i zdarzenia.For example, when a file is moved from one directory to another, several OnChanged and some OnCreated and OnDeleted events might be raised. Przeniesienie pliku jest skomplikowaną operacją, która składa się z wielu prostych operacji, a tym samym wywołuje wiele zdarzeń.Moving a file is a complex operation that consists of multiple simple operations, therefore raising multiple events. Podobnie niektóre aplikacje (na przykład oprogramowanie antywirusowe) mogą spowodować dodatkowe zdarzenia systemu plików, które są wykrywane przez program FileSystemWatcher .Likewise, some applications (for example, antivirus software) might cause additional file system events that are detected by FileSystemWatcher.

  • FileSystemWatcherMoże obserwować dyski, o ile nie zostały one przełączone ani usunięte.The FileSystemWatcher can watch disks as long as they are not switched or removed. FileSystemWatcherProgram nie zgłasza zdarzeń dotyczących dysków CD i DVD, ponieważ nie można zmienić sygnatur czasowych i właściwości.The FileSystemWatcher does not raise events for CDs and DVDs, because time stamps and properties cannot change. Aby składnik działał prawidłowo, komputery zdalne muszą mieć zainstalowane jedną z wymaganych platform.Remote computers must have one of the required platforms installed for the component to function properly.

Należy zauważyć, że w FileSystemWatcher przypadku przekroczenia rozmiaru buforu może wystąpić pominięcie zdarzenia.Note that a FileSystemWatcher may miss an event when the buffer size is exceeded. Aby uniknąć brakujących zdarzeń, postępuj zgodnie z następującymi wskazówkami:To avoid missing events, follow these guidelines:

  • Zwiększ rozmiar buforu przez ustawienie InternalBufferSize właściwości.Increase the buffer size by setting the InternalBufferSize property.

  • Unikaj oglądania plików o długich nazwach plików, ponieważ długa nazwa pliku przyczynia się do wypełniania buforu.Avoid watching files with long file names, because a long file name contributes to filling up the buffer. Rozważ zmianę nazwy tych plików przy użyciu krótszych nazw.Consider renaming these files using shorter names.

  • Przechowuj kod obsługi zdarzeń jak najkrótszy, jak to możliwe.Keep your event handling code as short as possible.

Konstruktory

FileSystemWatcher()

Inicjuje nowe wystąpienie klasy FileSystemWatcher.Initializes a new instance of the FileSystemWatcher class.

FileSystemWatcher(String)

Inicjuje nowe wystąpienie FileSystemWatcher klasy, używając określonego katalogu do monitorowania.Initializes a new instance of the FileSystemWatcher class, given the specified directory to monitor.

FileSystemWatcher(String, String)

Inicjuje nowe wystąpienie FileSystemWatcher klasy, uwzględniając określony katalog i typ plików do monitorowania.Initializes a new instance of the FileSystemWatcher class, given the specified directory and type of files to monitor.

Właściwości

CanRaiseEvents

Pobiera wartość wskazującą, czy składnik może zgłosić zdarzenie.Gets a value indicating whether the component can raise an event.

(Odziedziczone po Component)
Container

Pobiera IContainer , który zawiera Component .Gets the IContainer that contains the Component.

(Odziedziczone po Component)
DesignMode

Pobiera wartość wskazującą, czy Component jest aktualnie w trybie projektowania.Gets a value that indicates whether the Component is currently in design mode.

(Odziedziczone po Component)
EnableRaisingEvents

Pobiera lub ustawia wartość wskazującą, czy składnik jest włączony.Gets or sets a value indicating whether the component is enabled.

Events

Pobiera listę programów obsługi zdarzeń, które są dołączone do tego elementu Component .Gets the list of event handlers that are attached to this Component.

(Odziedziczone po Component)
Filter

Pobiera lub ustawia ciąg filtru używany do określania, które pliki są monitorowane w katalogu.Gets or sets the filter string used to determine what files are monitored in a directory.

Filters

Pobiera kolekcję wszystkich filtrów używanych do określania, które pliki są monitorowane w katalogu.Gets the collection of all the filters used to determine what files are monitored in a directory.

IncludeSubdirectories

Pobiera lub ustawia wartość wskazującą, czy podkatalogi w określonej ścieżce mają być monitorowane.Gets or sets a value indicating whether subdirectories within the specified path should be monitored.

InternalBufferSize

Pobiera lub ustawia rozmiar (w bajtach) bufora wewnętrznego.Gets or sets the size (in bytes) of the internal buffer.

NotifyFilter

Pobiera lub ustawia typ zmian, które mają być obserwowane.Gets or sets the type of changes to watch for.

Path

Pobiera lub ustawia ścieżkę katalogu do obserwowania.Gets or sets the path of the directory to watch.

Site

Pobiera lub ustawia ISite dla elementu FileSystemWatcher .Gets or sets an ISite for the FileSystemWatcher.

SynchronizingObject

Pobiera lub ustawia obiekt używany do organizowania wywołań obsługi zdarzeń, który został wygenerowany w wyniku zmiany katalogu.Gets or sets the object used to marshal the event handler calls issued as a result of a directory change.

Metody

BeginInit()

Rozpoczyna inicjalizację FileSystemWatcher użytą w formularzu lub używaną przez inny składnik.Begins the initialization of a FileSystemWatcher used on a form or used by another component. Inicjalizacja występuje w czasie wykonywania.The initialization occurs at run time.

CreateObjRef(Type)

Tworzy obiekt, który zawiera wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikacji z obiektem zdalnym.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Odziedziczone po MarshalByRefObject)
Dispose()

Zwalnia zasoby niezarządzane używane przez program FileSystemWatcher .Releases the unmanaged resources used by the FileSystemWatcher.

Dispose()

Zwalnia wszelkie zasoby używane przez element Component.Releases all resources used by the Component.

(Odziedziczone po Component)
Dispose(Boolean)

Zwalnia zasoby niezarządzane używane przez element FileSystemWatcher i opcjonalnie zwalnia zasoby zarządzane.Releases the unmanaged resources used by the FileSystemWatcher and optionally releases the managed resources.

EndInit()

Zamyka inicjalizację FileSystemWatcher użytą w formularzu lub używaną przez inny składnik.Ends the initialization of a FileSystemWatcher used on a form or used by another component. Inicjalizacja występuje w czasie wykonywania.The initialization occurs at run time.

Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
Finalize()

Zwalnia zasoby blokowane przez bieżące wystąpienie.Releases the resources held by the current instance.

GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetLifetimeService()
Nieaktualne.

Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
GetService(Type)

Zwraca obiekt, który reprezentuje usługę dostarczoną przez Component lub przez Container .Returns an object that represents a service provided by the Component or by its Container.

(Odziedziczone po Component)
GetType()

Pobiera Type bieżące wystąpienie.Gets the Type of the current instance.

(Odziedziczone po Object)
InitializeLifetimeService()
Nieaktualne.

Uzyskuje obiekt usługi istnienia w celu kontrolowania zasad okresu istnienia dla tego wystąpienia.Obtains a lifetime service object to control the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
MemberwiseClone()

Tworzy skróconą kopię bieżącego elementu Object .Creates a shallow copy of the current Object.

(Odziedziczone po Object)
MemberwiseClone(Boolean)

Tworzy skróconą kopię bieżącego MarshalByRefObject obiektu.Creates a shallow copy of the current MarshalByRefObject object.

(Odziedziczone po MarshalByRefObject)
OnChanged(FileSystemEventArgs)

Podnosi Changed zdarzenie.Raises the Changed event.

OnCreated(FileSystemEventArgs)

Podnosi Created zdarzenie.Raises the Created event.

OnDeleted(FileSystemEventArgs)

Podnosi Deleted zdarzenie.Raises the Deleted event.

OnError(ErrorEventArgs)

Podnosi Error zdarzenie.Raises the Error event.

OnRenamed(RenamedEventArgs)

Podnosi Renamed zdarzenie.Raises the Renamed event.

ToString()

Zwraca wartość String zawierającą nazwę Component (jeśli istnieje).Returns a String containing the name of the Component, if any. Ta metoda nie powinna być przesłaniana.This method should not be overridden.

(Odziedziczone po Component)
ToString()

Zwraca ciąg reprezentujący bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)
WaitForChanged(WatcherChangeTypes)

Metoda synchroniczna zwracająca strukturę, która zawiera określone informacje dotyczące zmiany, która wystąpiła, przy uwzględnieniu typu zmiany, która ma być monitorowana.A synchronous method that returns a structure that contains specific information on the change that occurred, given the type of change you want to monitor.

WaitForChanged(WatcherChangeTypes, Int32)

Metoda synchroniczna zwracająca strukturę, która zawiera określone informacje dotyczące zmiany, która wystąpiła, w zależności od typu zmiany, która ma być monitorowana, oraz czasu (w milisekundach) oczekiwania przed upływem limitu czasu.A synchronous method that returns a structure that contains specific information on the change that occurred, given the type of change you want to monitor and the time (in milliseconds) to wait before timing out.

Zdarzenia

Changed

Występuje, gdy zostanie zmieniony plik lub katalog w określonym pliku Path .Occurs when a file or directory in the specified Path is changed.

Created

Występuje, gdy tworzony jest plik lub katalog w określonym pliku Path .Occurs when a file or directory in the specified Path is created.

Deleted

Występuje, gdy zostanie usunięty plik lub katalog z określonego elementu Path .Occurs when a file or directory in the specified Path is deleted.

Disposed

Występuje, gdy składnik zostanie usunięty przez wywołanie Dispose() metody.Occurs when the component is disposed by a call to the Dispose() method.

(Odziedziczone po Component)
Error

Występuje, gdy wystąpienie programu FileSystemWatcher nie może kontynuować monitorowania zmian lub przepełnienie buforu wewnętrznego.Occurs when the instance of FileSystemWatcher is unable to continue monitoring changes or when the internal buffer overflows.

Renamed

Występuje, gdy zostanie zmieniona nazwa pliku lub katalogu w określonej Path nazwie.Occurs when a file or directory in the specified Path is renamed.

Dotyczy

Zobacz też