Why does following Directory.Delete throw IOException The directory is not empty

Question

I am creating a directory and setting up a FileSystemWatcher on it. Then I create a file. All this is done in the form constructor. In a button event handler I delete the directory created above. Sometimes it throws a IOException: The directory is not empty. After this I cannot even access the child directory in explorer. I keep getting Access is Denied Errors. This directory gets deleted after my process exits. AFAIK FileSystemWatcher should not a lock a directory.

        string alphaBeta = @"Alpha\Beta";
        public Form1()
        {
            InitializeComponent();
            Directory.CreateDirectory(alphaBeta);
            FileSystemWatcher watcher = new FileSystemWatcher()
            {
                Path = alphaBeta,
                Filter = "*.dat",
                NotifyFilter = NotifyFilters.FileName
            };
            watcher.EnableRaisingEvents = true;
            File.WriteAllText(alphaBeta + @"\Gamma.dat", "Delta");
        }

        private void btnDelete_Click(object sender, EventArgs e)
        {
            Directory.Delete("Alpha", true);//Recursively Delete
        }

How do I properly delete the directory without getting the directory stuck?

UPDATE: Above is minimal reproducible example

My actual scenario involves a addin loaded in explorer.exe that monitors a config directory for changes. It hooks into create and rename events of FSW.

The delete code runs in the uninstaller. Uninstaller is not supposed to kill explorer. We thought FileSystemWatcher will not lock the Folder and will silently stop monitoring changes once the directory is deleted. But this doesn't seem to be the case.

Answer 1

The problem is caused because the FSW keeps a handle to the directory open as long as events are enabled. The source code shows that disabling events also closes the handle. To delete the directory, the FSW must be disabled.

The second problem though is that FileSystemWatcher watcher is defined as a variable inside the Form1() constructor, which means it's orphaned and immediatelly available for garbage collection before the form is even displayed. The garbage collector runs infrequently though, which means there's no guarantee it will run before Delete is clicked. Since the watcher isn't stored anywhere, iIt's no longer possible to disable it.

At the very least, the FSW needs to be stored in a field and events disabled before deletion. We should also ensure the watcher is disposed when the form itself gets disposed :

public class Form1
{
    FileSystemWatcher _watcher;

    public Form1()
    {
        ...
        _watcher=CreateDormantWatcher(path,pattern);
        _watcher.EnableRaisingEvents=true ;
    }

    private void btnDelete_Click(object sender, EventArgs e)
    {
        _watcher.EnableRaisingEvents =false;
        Directory.Delete("Alpha", true);//Recursively Delete
    }

    protected override void Dispose (bool disposing)
    {
        base.Dispose(disposing);
        if (disposing)
        {
             _watcher.Dispose();
        }
        _watcher=watcher;
    }

    FileSystemWatcher CreateDormantWatcher(string path,string pattern)
    {
        //Don't store to the field until the FSW is 
        //already configured
        var watcher=new FileSystemWatcher()
        {
            Path = path,
            Filter = "pattern,
            NotifyFilter = NotifyFilters.FileName
        };
        watcher.Changed += OnChanged;
        watcher.Created += OnCreated;
        watcher.Deleted += OnChanged;
        watcher.Renamed += OnRenamed;
        return watcher;
    }

Easy fix: Add it as a component

Perhaps a better idea though, would be to add the FileSystemWatcher on the form as a component. FileSystemWatcher inherits from Component, which means that placing it on the form add its creation and configuration code in InitializeComponents(). It will also get disposed when all other components get disposed.

If we do that, we'd just have to toggle EnableRaisingEvents when appropriate.

Assuming the path and pattern are set as properties, and the component's name is the imaginative FileSystemWatcher1 this brings the code down to :

    public Form1()
    {
        InitializeComponent();
        Directory.CreateDirectory(FileSystemWatcher1.Path);
        FileSystemWatcher1.EnableRaisingEvents = true;
        File.WriteAllText(alphaBeta + @"\Gamma.dat", "Delta");
    }

    private void btnDelete_Click(object sender, EventArgs e)
    {
        FileSystemWatcher1.EnableRaisingEvents = false;
        Directory.Delete("Alpha", true);//Recursively Delete
    }

Answer 2

This appears to be an issue with the FileSystemWatcher. If the code for this is commented out then the Exception does not occur.

It would appear that the FileSystemWatcher is not necessarily disposed before the Directory.Delete method is called.

It would be appropriate to handle the FileSystemWatcher in a way that causes it to be disposed before deleting resources that it may have depended upon, but in your example code it's easily achieved by simply adding watcher.Dispose();:

string alphaBeta = @"Alpha\Beta";
public Form1()
{
    InitializeComponent();
    Directory.CreateDirectory(alphaBeta);
    FileSystemWatcher watcher = new FileSystemWatcher()
    {
        Path = alphaBeta,
        Filter = "*.dat",
        NotifyFilter = NotifyFilters.FileName
    };
    watcher.EnableRaisingEvents = true;
    watcher.Dispose();
    File.WriteAllText(alphaBeta + @"\Gamma.dat", "Delta");
}

private void button1_Click(object sender, EventArgs e)
{

    Directory.Delete("Alpha", true);//Recursively Delete
}