FileSystemWatcher Sınıf

Tanım

Dosya sistemi değişiklik bildirimlerini dinler ve bir dizin veya dizindeki dosya değiştiğinde olayları başlatır.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
Devralma
FileSystemWatcher
Devralma
FileSystemWatcher
Öznitelikler
Uygulamalar

Örnekler

Aşağıdaki örnek, FileSystemWatcher çalışma zamanında belirtilen dizini izlemek için bir oluşturur.The following example creates a FileSystemWatcher to watch the directory specified at run time. Bileşen, LastWrite LastAccess dizindeki metin dosyalarının oluşturulması, silinmesi veya yeniden adlandırılması için ve zaman içindeki değişiklikleri izlemek üzere ayarlanır.The component is set to watch for changes in LastWrite and LastAccess time, the creation, deletion, or renaming of text files in the directory. Bir dosya değiştirildiğinde, oluşturulduysa veya silinirse dosyanın yolu konsola yazdırılır.If a file is changed, created, or deleted, the path to the file prints to the console. Bir dosya yeniden adlandırıldığında, eski ve yeni yollar konsola yazdırılır.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

Açıklamalar

FileSystemWatcherBelirtilen dizindeki değişiklikleri izlemek için kullanın.Use FileSystemWatcher to watch for changes in a specified directory. Belirtilen dizinin dosya ve alt dizinlerindeki değişiklikler için izleyebilirsiniz.You can watch for changes in files and subdirectories of the specified directory. Dosyaları yerel bir bilgisayarda, ağ sürücüsünde veya uzak bir bilgisayarda izlemek için bir bileşen oluşturabilirsiniz.You can create a component to watch files on a local computer, a network drive, or a remote computer.

Tüm dosyalardaki değişiklikleri izlemek için, Filter özelliği boş bir dize ("") olarak ayarlayın veya joker karakterler kullanın ("*. * ").To watch for changes in all files, set the Filter property to an empty string ("") or use wildcards ("*.*"). Belirli bir dosyayı izlemek için, Filter özelliği dosya adı olarak ayarlayın.To watch a specific file, set the Filter property to the file name. Örneğin, MyDoc.txt dosyadaki değişiklikleri izlemek için, Filter özelliği "MyDoc.txt" olarak ayarlayın.For example, to watch for changes in the file MyDoc.txt, set the Filter property to "MyDoc.txt". Ayrıca belirli bir dosya türünde değişiklik izleyebilirsiniz.You can also watch for changes in a certain type of file. Örneğin, metin dosyalarındaki değişiklikleri izlemek için, Filter özelliği " * . txt" olarak ayarlayın.For example, to watch for changes in text files, set the Filter property to "*.txt".

Bir dizin veya dosyada izleyebilmeniz için birkaç değişiklik türü vardır.There are several types of changes you can watch for in a directory or file. Örneğin, içindeki değişiklikleri Attributes , LastWrite Tarih ve saati veya Size dosya ya da dizinleri izleyebilirsiniz.For example, you can watch for changes in Attributes, the LastWrite date and time, or the Size of files or directories. Bu, NotifyFilter özelliği değerlerden birine ayarlanarak yapılır NotifyFilters .This is done by setting the NotifyFilter property to one of the NotifyFilters values. İzleyebileceği değişikliklerin türü hakkında daha fazla bilgi için bkz NotifyFilters ..For more information on the type of changes you can watch, see NotifyFilters.

Dosya veya dizinlerin yeniden adlandırılması, silinmesi veya oluşturulması için izleyebilirsiniz.You can watch for renaming, deletion, or creation of files or directories. Örneğin, metin dosyalarını yeniden adlandırmayı izlemek için, Filter özelliği "*. txt" olarak ayarlayın ve WaitForChanged Renamed parametresi için belirtilen ile yöntemi çağırın.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.

Windows işletim sistemi, tarafından oluşturulan bir arabellekte dosya değişiklikleri bileşeninizi bilgilendirir FileSystemWatcher .The Windows operating system notifies your component of file changes in a buffer created by the FileSystemWatcher. Kısa bir süre içinde çok sayıda değişiklik varsa, arabellek taşalabilir.If there are many changes in a short time, the buffer can overflow. Bu, bileşenin dizindeki değişikliklerin izlenmesini kaybetmesine ve yalnızca paket bildirimi sağlamasına neden olur.This causes the component to lose track of changes in the directory, and it will only provide blanket notification. Arabellek boyutunu özelliği ile artırmak InternalBufferSize , diske alınmayan disk belleğine alınmayan bellekten geldiği için pahalıdır, bu nedenle arabelleği dosya değişikliği olaylarını kaçırmayacak kadar küçük bir boyutta tutun.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. Arabellek taşmasını önlemek için, NotifyFilter ve özelliklerini kullanarak IncludeSubdirectories istenmeyen değişiklik bildirimlerine filtre uygulayabilirsiniz.To avoid a buffer overflow, use the NotifyFilter and IncludeSubdirectories properties so you can filter out unwanted change notifications.

Bir örneğinin ilk özellik değerlerinin listesi için FileSystemWatcher , FileSystemWatcher oluşturucuya bakın.For a list of initial property values for an instance of FileSystemWatcher, see the FileSystemWatcher constructor.

Sınıfı kullanırken lütfen aşağıdakileri unutmayın FileSystemWatcher .Please note the following when using the FileSystemWatcher class.

  • Gizli dosyalar yok sayılır.Hidden files are not ignored.

  • Bazı sistemlerde, FileSystemWatcher kısa 8,3 dosya adı biçimini kullanarak dosyalara değişiklikler bildirir.In some systems, FileSystemWatcher reports changes to files using the short 8.3 file name format. Örneğin, "LongFileName. LongExtension" değişikliği "LongFil ~" olarak bildirilebilir. Lon ".For example, a change to "LongFileName.LongExtension" could be reported as "LongFil~.Lon".

  • Bu sınıf, bir bağlantı talebi ve tüm üyeler için geçerli olan sınıf düzeyinde devralma talebi içerir.This class contains a link demand and an inheritance demand at the class level that applies to all members. SecurityExceptionTek bir çağıran veya türetilmiş sınıf tam güven iznine sahip olmadığında bir oluşturulur.A SecurityException is thrown when either the immediate caller or the derived class does not have full-trust permission. Güvenlik talepleri hakkında daha fazla bilgi için bkz. bağlantı talepleri.For details about security demands, see Link Demands.

  • InternalBufferSizeAğ üzerinden bir dizin izlemeye yönelik özellik için ayarlayabileceğiniz en büyük boyut 64 KB 'tır.The maximum size you can set for the InternalBufferSize property for monitoring a directory over the network is 64 KB.

Klasörleri kopyalama ve taşımaCopying and moving folders

İşletim sistemi ve nesne, bir FileSystemWatcher klasör ve içeriği için bir yeniden adlandırma eylemi olarak kes ve Yapıştır eylemini veya bir Move eylemini yorumlayın.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. Dosya içeren bir klasörü, izlenmekte olan bir klasöre kesip yapıştırdıysanız, FileSystemWatcher aslında yalnızca yeniden adlandırılacağından, nesne yalnızca yeni bir klasör olarak rapor, içeriği değil.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.

Klasörler içeriğinin izlenen bir klasöre taşındığını veya kopyalandığını, OnChanged OnRenamed Aşağıdaki tabloda önerildiği gibi, ve olay işleyicisi yöntemlerini sağlamanız gerekir.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.

Olay IşleyicisiEvent Handler Işlenen olaylarEvents Handled ServislePerforms
OnChanged Changed, Created, DeletedChanged, Created, Deleted Dosya öznitelikleri, oluşturulan dosyalar ve silinen dosyalardaki değişiklikleri rapor edin.Report changes in file attributes, created files, and deleted files.
OnRenamed Renamed Yeniden adlandırılmış dosya ve klasörlerin eski ve yeni yollarını listeleyin ve gerekirse yinelemeli olarak genişleterek.List the old and new paths of renamed files and folders, expanding recursively if needed.

Olaylar ve Arabellek BoyutlarıEvents and Buffer Sizes

Çeşitli faktörler, aşağıda açıklandığı gibi hangi dosya sistemi değişiklik olaylarının gerçekleştiğini etkileyebileceğini unutmayın:Note that several factors can affect which file system change events are raised, as described by the following:

  • Ortak dosya sistemi işlemleri birden fazla olay oluşturabilir.Common file system operations might raise more than one event. Örneğin, bir dosya bir dizinden diğerine taşındığında, birkaç OnChanged ve bazı OnCreated ve OnDeleted olaylar ortaya çıkabilir.For example, when a file is moved from one directory to another, several OnChanged and some OnCreated and OnDeleted events might be raised. Bir dosyanın taşınması, birden çok basit işlemden oluşan karmaşık bir işlemdir ve bu nedenle birden çok olayı ortaya koyar.Moving a file is a complex operation that consists of multiple simple operations, therefore raising multiple events. Benzer şekilde, bazı uygulamalar (örneğin, virüsten koruma yazılımı) tarafından algılanan ek dosya sistemi olaylarına neden olabilir FileSystemWatcher .Likewise, some applications (for example, antivirus software) might cause additional file system events that are detected by FileSystemWatcher.

  • , FileSystemWatcher Kapalı veya kaldırılmadığı sürece diskleri izleyebilir.The FileSystemWatcher can watch disks as long as they are not switched or removed. , FileSystemWatcher Zaman damgaları ve Özellikler değiştiremediğinden CD ve DVD 'ler için olay oluşturmaz.The FileSystemWatcher does not raise events for CDs and DVDs, because time stamps and properties cannot change. Bileşenin düzgün çalışması için uzak bilgisayarlarda gerekli platformlardan biri yüklü olmalıdır.Remote computers must have one of the required platforms installed for the component to function properly.

FileSystemWatcherArabellek boyutu aşıldığında bir olayı kaçırmadığını unutmayın.Note that a FileSystemWatcher may miss an event when the buffer size is exceeded. Eksik olayları önlemek için aşağıdaki yönergeleri izleyin:To avoid missing events, follow these guidelines:

  • Özelliği ayarlayarak arabellek boyutunu artırın InternalBufferSize .Increase the buffer size by setting the InternalBufferSize property.

  • Uzun bir dosya adı arabelleği doldurmaya katkıda bulunduğundan, uzun dosya adlarıyla dosya seyreden kaçının.Avoid watching files with long file names, because a long file name contributes to filling up the buffer. Daha kısa adlar kullanarak bu dosyaları yeniden adlandırmayı düşünün.Consider renaming these files using shorter names.

  • Olay işleme kodunuzu olabildiğince kısa tutun.Keep your event handling code as short as possible.

Oluşturucular

FileSystemWatcher()

FileSystemWatcher sınıfının yeni bir örneğini başlatır.Initializes a new instance of the FileSystemWatcher class.

FileSystemWatcher(String)

FileSystemWatcherİzlemek için belirtilen dizin verildiğinde, sınıfının yeni bir örneğini başlatır.Initializes a new instance of the FileSystemWatcher class, given the specified directory to monitor.

FileSystemWatcher(String, String)

FileSystemWatcherBelirtilen dizin ve izlenecek dosya türleri verildiğinde, sınıfının yeni bir örneğini başlatır.Initializes a new instance of the FileSystemWatcher class, given the specified directory and type of files to monitor.

Özellikler

CanRaiseEvents

Bileşenin bir olay yapıp yapamayacağını gösteren bir değer alır.Gets a value indicating whether the component can raise an event.

(Devralındığı yer: Component)
Container

Öğesini içeren öğesini alır IContainer Component .Gets the IContainer that contains the Component.

(Devralındığı yer: Component)
DesignMode

Şu anda Tasarım modunda olup olmadığını gösteren bir değer alır Component .Gets a value that indicates whether the Component is currently in design mode.

(Devralındığı yer: Component)
EnableRaisingEvents

Bileşenin etkinleştirilip etkinleştirilmeyeceğini gösteren bir değer alır veya ayarlar.Gets or sets a value indicating whether the component is enabled.

Events

Bu öğesine eklenen olay işleyicilerinin listesini alır Component .Gets the list of event handlers that are attached to this Component.

(Devralındığı yer: Component)
Filter

Bir dizinde hangi dosyaların izleneceğini belirlemek için kullanılan filtre dizesini alır veya ayarlar.Gets or sets the filter string used to determine what files are monitored in a directory.

Filters

Bir dizinde hangi dosyaların izleneceğini belirlemek için kullanılan tüm filtrelerin koleksiyonunu alır.Gets the collection of all the filters used to determine what files are monitored in a directory.

IncludeSubdirectories

Belirtilen yoldaki alt dizinlerin izlenmesi gerekip gerekmediğini gösteren bir değer alır veya ayarlar.Gets or sets a value indicating whether subdirectories within the specified path should be monitored.

InternalBufferSize

İç arabelleğin boyutunu (bayt cinsinden) alır veya ayarlar.Gets or sets the size (in bytes) of the internal buffer.

NotifyFilter

İçin izlenecek değişikliklerin türünü alır veya ayarlar.Gets or sets the type of changes to watch for.

Path

İzlenecek dizinin yolunu alır veya ayarlar.Gets or sets the path of the directory to watch.

Site

İçin bir alır veya ayarlar ISite FileSystemWatcher .Gets or sets an ISite for the FileSystemWatcher.

SynchronizingObject

Bir dizin değişikliğinin sonucu olarak verilen olay işleyicisi çağrılarını sıralamak için kullanılan nesneyi alır veya ayarlar.Gets or sets the object used to marshal the event handler calls issued as a result of a directory change.

Yöntemler

BeginInit()

Bir FileSystemWatcher form üzerinde kullanılan veya başka bir bileşen tarafından kullanılan bir şekilde başlatmayı başlatır.Begins the initialization of a FileSystemWatcher used on a form or used by another component. Başlatma, çalışma zamanında olur.The initialization occurs at run time.

CreateObjRef(Type)

Uzak bir nesneyle iletişim kurmak için kullanılan bir ara sunucu oluşturmak için gereken tüm bilgileri içeren bir nesne oluşturur.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Devralındığı yer: MarshalByRefObject)
Dispose()

Tarafından kullanılan yönetilmeyen kaynakları serbest bırakır FileSystemWatcher .Releases the unmanaged resources used by the FileSystemWatcher.

Dispose()

Component tarafından kullanılan tüm kaynakları serbest bırakır.Releases all resources used by the Component.

(Devralındığı yer: Component)
Dispose(Boolean)

FileSystemWatcher tarafından kullanılan yönetilmeyen kaynakları serbest bırakır ve yönetilen kaynakları isteğe bağlı olarak serbest bırakır.Releases the unmanaged resources used by the FileSystemWatcher and optionally releases the managed resources.

EndInit()

Bir FileSystemWatcher form üzerinde kullanılan veya başka bir bileşen tarafından kullanılan başlatmayı sonlandırır.Ends the initialization of a FileSystemWatcher used on a form or used by another component. Başlatma, çalışma zamanında olur.The initialization occurs at run time.

Equals(Object)

Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler.Determines whether the specified object is equal to the current object.

(Devralındığı yer: Object)
Finalize()

Geçerli örnek tarafından tutulan kaynakları serbest bırakır.Releases the resources held by the current instance.

GetHashCode()

Varsayılan karma işlevi olarak işlev görür.Serves as the default hash function.

(Devralındığı yer: Object)
GetLifetimeService()
Kullanımdan kalktı.

Bu örnek için ömür ilkesini denetleyen geçerli ömür hizmeti nesnesini alır.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Devralındığı yer: MarshalByRefObject)
GetService(Type)

Veya tarafından belirtilen bir hizmeti temsil eden bir nesne döndürür Component Container .Returns an object that represents a service provided by the Component or by its Container.

(Devralındığı yer: Component)
GetType()

TypeGeçerli örneği alır.Gets the Type of the current instance.

(Devralındığı yer: Object)
InitializeLifetimeService()
Kullanımdan kalktı.

Bu örnek için ömür ilkesini denetlemek üzere bir ömür hizmeti nesnesi alır.Obtains a lifetime service object to control the lifetime policy for this instance.

(Devralındığı yer: MarshalByRefObject)
MemberwiseClone()

Geçerli bir basit kopyasını oluşturur Object .Creates a shallow copy of the current Object.

(Devralındığı yer: Object)
MemberwiseClone(Boolean)

Geçerli nesnenin basit bir kopyasını oluşturur MarshalByRefObject .Creates a shallow copy of the current MarshalByRefObject object.

(Devralındığı yer: MarshalByRefObject)
OnChanged(FileSystemEventArgs)

Olayını oluşturur Changed .Raises the Changed event.

OnCreated(FileSystemEventArgs)

Olayını oluşturur Created .Raises the Created event.

OnDeleted(FileSystemEventArgs)

Olayını oluşturur Deleted .Raises the Deleted event.

OnError(ErrorEventArgs)

Olayını oluşturur Error .Raises the Error event.

OnRenamed(RenamedEventArgs)

Olayını oluşturur Renamed .Raises the Renamed event.

ToString()

Varsa, String varsa adını içeren bir döndürür Component .Returns a String containing the name of the Component, if any. Bu yöntem geçersiz kılınmamalıdır.This method should not be overridden.

(Devralındığı yer: Component)
ToString()

Geçerli nesneyi temsil eden dizeyi döndürür.Returns a string that represents the current object.

(Devralındığı yer: Object)
WaitForChanged(WatcherChangeTypes)

İzlemek istediğiniz değişikliğin türü verildiğinde, gerçekleşen değişiklik hakkında belirli bilgiler içeren bir yapıyı döndüren zaman uyumlu bir yöntem.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)

, İzlemek istediğiniz değişikliğin türü ve zaman aşımından önce beklenecek süre (milisaniye olarak) verilen değişiklik hakkında belirli bilgileri içeren bir yapı döndüren zaman uyumlu bir yöntem.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.

Ekinlikler

Changed

Belirtilen bir dosya veya dizin Path değiştirildiğinde gerçekleşir.Occurs when a file or directory in the specified Path is changed.

Created

Belirtilen bir dosya veya dizin Path oluşturulduğunda gerçekleşir.Occurs when a file or directory in the specified Path is created.

Deleted

Belirtilen bir dosya veya dizin Path silindiğinde gerçekleşir.Occurs when a file or directory in the specified Path is deleted.

Disposed

Bileşen yönteme bir çağrı tarafından bırakıldığında gerçekleşir Dispose() .Occurs when the component is disposed by a call to the Dispose() method.

(Devralındığı yer: Component)
Error

Örneği FileSystemWatcher değişiklikleri izlemeye devam edemediğinde veya iç arabellek taştığında gerçekleşir.Occurs when the instance of FileSystemWatcher is unable to continue monitoring changes or when the internal buffer overflows.

Renamed

Belirtilen bir dosya veya dizin Path yeniden adlandırıldığında gerçekleşir.Occurs when a file or directory in the specified Path is renamed.

Şunlara uygulanır

Ayrıca bkz.