CODEWITHSUNDEEP
c#.net.net-4.5filesystemwatcher
ShaneKm
ShaneKm

Reputation: 21338

Disposing of FileSystemWatcher

So my understanding is that whenever using a class that implements IDisposable, it's parent also needs to implement IDisposable interface. (FileWatcher using FileSystemWatcher)

So when using FileSystemWatcher what is the proper way of disposing of FileSystemWatcher? I want FileWatcher not to be disposed/(watching) until application is closed.

Would I use Responsible Owner Pattern?(try/finally) or something else? Should my FileWatcher also implement IDisposable? I won't be able to use using{} since this fileWatcher should be watching the file changes the whole time application runs. What is the proper way of handling this scenario?

public class FileWatcher : IFileWatcher
{
    private FileSystemWatcher watcher;

    public event EventHandler<EventArgs> SettingsChanged;

    public FileWatcher(bool start)
    {
        this.RegisterForChanges();
    }

    public void OnChanged(object source, EventArgs e)
    {
        if (this.SettingsChanged != null)
        {
            this.SettingsChanged(source, new EventArgs());
        }
    }

    private void RegisterForChanges()
    {
        /// more code here etc
        ...
        this.watcher = new FileSystemWatcher
                           {
                               Path = directory, 
                               NotifyFilter =
                                   NotifyFilters.LastAccess | NotifyFilters.LastWrite
                                   | NotifyFilters.FileName | NotifyFilters.DirectoryName, 
                               Filter = fileName
                           };

        // Add event handlers.
        this.watcher.Changed += this.OnChanged;

        // Begin watching.
        this.watcher.EnableRaisingEvents = true;
    }

Upvotes: 8

Views: 10931

Answers (2)

shawn
shawn

Reputation: 113

When shutting down an application, run the dispose method.

According to the method requested, when you want to dispose of something when your shutting down the program.

if you are using a class via, then IDisposable is for disposing the class object, but essentially you still might want to do it when you are shutting down the program

bool myFlag = false;
private FileSystemWatcher watcher;
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
 {
           myFlag = true;
           if(myFlag)
           watcher.Dispose(); //Your FileSystemWatcher object
 }

Upvotes: 2

xxbbcc
xxbbcc

Reputation: 17347

Yes, implementing IDisposable is the right solution in this case (in my opinion). Your object is long-lived and has to live outside the scope of any particular function call so all function-scope level solutions (using, try..finally, etc.) are out.

For this, IDisposable is a standard pattern in .NET and you can easily dispose of the nested object when FileWatcher is disposed of.

Upvotes: 7

Related Questions