FileSystemWatcher Sınıf

Tanım

Ad Alanı:

System.IO

Bütünleştirilmiş Kod:

System.IO.FileSystem.Watcher.dll

Kaynak:

FileSystemWatcher.cs

Dosya sistemi değişiklik bildirimlerini dinler ve dizindeki bir dizin veya dosya değiştiğinde olayları tetikler.

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

Devralma

Object

MarshalByRefObject

Component

FileSystemWatcher

Uygulamalar

ISupportInitialize

Örnekler

Aşağıdaki örnek, çalışma zamanında belirtilen dizini watch için bir FileSystemWatcher oluşturur. Bileşen, dizindeki metin dosyalarının oluşturulması, silinmesi veya yeniden adlandırılması, ve LastAccess zamanındaki LastWrite değişiklikler için watch olarak ayarlanır. Bir dosya değiştirilir, oluşturulur veya silinirse, dosyanın yolu konsola yazdırılır. Dosya yeniden adlandırıldığında, eski ve yeni yollar konsola yazdırılır.

#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

Bu API hakkında daha fazla bilgi için bkz. FileSystemWatcher için ek API açıklamaları.

Oluşturucular

FileSystemWatcher()	FileSystemWatcher sınıfının yeni bir örneğini başlatır.
FileSystemWatcher(String)	İzlenecek belirtilen dizin verilip sınıfının yeni bir örneğini FileSystemWatcher başlatır.
FileSystemWatcher(String, String)	Belirtilen dizin ve izlenecek dosyaların türüne göre sınıfının yeni bir örneğini FileSystemWatcher başlatır.

Özellikler

CanRaiseEvents	Bileşenin bir olay oluşturup oluşturamayacağını belirten bir değer alır. (Devralındığı yer: Component)
Container	öğesini IContainer içeren öğesini Componentalır. (Devralındığı yer: Component)
DesignMode	öğesinin şu anda tasarım modunda olup olmadığını Component gösteren bir değer alır. (Devralındığı yer: Component)
EnableRaisingEvents	Bileşenin etkinleştirilip etkinleştirilmediğini belirten bir değer alır veya ayarlar.
Events	Bu Componentöğesine eklenen olay işleyicilerinin listesini alır. (Devralındığı yer: Component)
Filter	Dizinde hangi dosyaların izleneceğini belirlemek için kullanılan filtre dizesini alır veya ayarlar.
Filters	Bir dizinde hangi dosyaların izlendiğini belirlemek için kullanılan tüm filtrelerin koleksiyonunu alır.
IncludeSubdirectories	Belirtilen yol içindeki alt dizinlerin izlenmesi gerekip gerekmediğini belirten bir değer alır veya ayarlar.
InternalBufferSize	İç arabelleğin boyutunu (bayt cinsinden) alır veya ayarlar.
NotifyFilter	Değişiklik türünü watch alır veya ayarlar.
Path	Dizinin yolunu watch alır veya ayarlar.
Site	için FileSystemWatcherbir ISite alır veya ayarlar.
SynchronizingObject	Dizin değişikliği sonucunda verilen olay işleyici çağrılarını sıralamak için kullanılan nesneyi alır veya ayarlar.

Yöntemler

BeginInit()	Formda kullanılan veya başka bir bileşen tarafından kullanılan bir FileSystemWatcher öğesinin başlatılmasını başlatır. Başlatma, çalışma zamanında olur.
CreateObjRef(Type)	Uzak bir nesneyle iletişim kurmak için kullanılan bir ara sunucu oluşturmak için gereken tüm ilgili bilgileri içeren bir nesne oluşturur. (Devralındığı yer: MarshalByRefObject)
Dispose()	Component tarafından kullanılan tüm kaynakları serbest bırakır. (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.
EndInit()	Formda kullanılan veya başka bir bileşen tarafından kullanılan bir FileSystemWatcher öğesinin başlatılmasını sonlandırır. Başlatma, çalışma zamanında olur.
Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetLifetimeService()	Geçersiz. Bu örnek için yaşam süresi ilkesini denetleen geçerli yaşam süresi hizmet nesnesini alır. (Devralındığı yer: MarshalByRefObject)
GetService(Type)	veya tarafından ComponentContainersağlanan bir hizmeti temsil eden bir nesnesi döndürür. (Devralındığı yer: Component)
GetType()	Type Geçerli örneğini alır. (Devralındığı yer: Object)
InitializeLifetimeService()	Geçersiz. Bu örneğin yaşam süresi ilkesini denetlemek için bir yaşam süresi hizmet nesnesi alır. (Devralındığı yer: MarshalByRefObject)
MemberwiseClone()	Geçerli Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object)
MemberwiseClone(Boolean)	Geçerli MarshalByRefObject nesnenin sığ bir kopyasını oluşturur. (Devralındığı yer: MarshalByRefObject)
OnChanged(FileSystemEventArgs)	Olayı tetikler Changed .
OnCreated(FileSystemEventArgs)	Olayı tetikler Created .
OnDeleted(FileSystemEventArgs)	Olayı tetikler Deleted .
OnError(ErrorEventArgs)	Olayı tetikler Error .
OnRenamed(RenamedEventArgs)	Olayı tetikler Renamed .
ToString()	Varsa, adını Componentiçeren bir String döndürür. Bu yöntem geçersiz kılınmamalıdır. (Devralındığı yer: Component)
WaitForChanged(WatcherChangeTypes)	İzlemek istediğiniz değişiklik türüne göre gerçekleşen değişiklikle ilgili belirli bilgileri içeren bir yapı döndüren zaman uyumlu yöntem.
WaitForChanged(WatcherChangeTypes, Int32)	İzlemek istediğiniz değişiklik türü ve zaman aşımına uğramadan önce beklenecek süre (milisaniye) göz önüne alındığında, gerçekleşen değişiklikle ilgili belirli bilgileri içeren bir yapı döndüren zaman uyumlu yöntem.
WaitForChanged(WatcherChangeTypes, TimeSpan)	İzlenecek değişikliğin türü göz önüne alındığında, gerçekleşen değişiklikle ilgili belirli bilgileri içeren bir yapıyı zaman uyumlu olarak döndürür.

Ekinlikler

Changed	Belirtilen Path içindeki bir dosya veya dizin değiştirildiğinde gerçekleşir.
Created	Belirtilen Path içindeki bir dosya veya dizin oluşturulduğunda gerçekleşir.
Deleted	Belirtilen Path içindeki bir dosya veya dizin silindiğinde gerçekleşir.
Disposed	Bileşen yöntemine Dispose() yapılan bir çağrı tarafından atıldığında gerçekleşir. (Devralındığı yer: Component)
Error	örneği FileSystemWatcher değişiklikleri izlemeye devam edemediğinde veya iç arabellek taştığında gerçekleşir.
Renamed	Belirtilen Path içindeki bir dosya veya dizin yeniden adlandırıldığında gerçekleşir.

Ayrıca bkz.

• NotifyFilter
• NotifyFilters
• FileSystemEventArgs
• FileSystemEventHandler
• Filter
• IncludeSubdirectories
• InternalBufferOverflowException
• RenamedEventArgs
• RenamedEventHandler
• WaitForChangedResult
• WatcherChangeTypes
• Windows Formunda FileSystemWatcher Bileşeni Kullanma