Question

I am writing integration tests that involve FileSystemWatcher objects. To make things easier, I want to unsubscribe everything from an event delegate without having to hunt down every subscription. I already saw related post, Is it necessary to unsubscribe from events?. This is somewhat a duplicate, but I am specifically asking why this doesn’t work with a FileSystemWatcher object.

It would be nice to do something like the following:

private void MethodName()
{
    var watcher = new FileSystemWatcher(@"C:\Temp");
    watcher.Changed += new FileSystemEventHandler(watcher_Changed);

    watcher.Changed = null; // A simple solution that smells of C++.

    // A very C#-ish solution:
    foreach (FileSystemEventHandler eventDelegate in 
             watcher.Changed.GetInvocationList())
        watcher.Changed -= eventDelegate;
}

No matter how the Changed event is referenced, the compiler reports:
The event ‘System.IO.FileSystemWatcher.Changed’ can only appear on the left hand side of += or -=

The above code works just fine, when working with an event in the same class:

public event FileSystemEventHandler MyFileSystemEvent;

private void MethodName()
{
    MyFileSystemEvent += new FileSystemEventHandler(watcher_Changed);

    MyFileSystemEvent = null; // This works.

    // This works, too.
    foreach (FileSystemEventHandler eventDelegate in 
             MyFileSystemEvent.GetInvocationList())
        watcher.Changed -= eventDelegate;
}

So, what am I missing? It seems that I should be able to do the same with the FileSystemWatcher events.

Answer 1

When you declare event in your class, it is an equivalent (almost) of the following code:

private FileSystemEventHandler _eventBackingField;
public event FileSystemEventHandler MyFileSystemEvent
{
    add
    {
        _eventBackingField =
            (FileSystemEventHandler)Delegate.Combine(_eventBackingField, value);
    }
    remove
    {
        _eventBackingField =
            (FileSystemEventHandler)Delegate.Remove(_eventBackingField, value);
    }
}

Notice that there is no set or get accessor for event (like for properties) and you can’t explicitly write them.

When you write MyFileSystemEvent = null in your class, it is actually doing _eventBackingField = null, but outside your class there is no way to directly set this variable, you have only event add & remove accessors.

This might be a confusing behavior, because inside your class you can reference an event handler delegate by event name, and can’t do that outside the class.