Should I implement IDisposable when class has IDisposable member but no unmanaged resources?

Question

The MSDN documentation and many answers here on StackOverflow go to lengths to disucss correctly implementing IDisposable, e.g. MSDN IDisposable, MSDN Implementing IDisposable, An excellent StackOverflow Q&A

However none of them seem to cover a more common use-case I have: what to do when my class has an IDisposable member that lives longer than one method? For example

  class FantasticFileService   {     private FileSystemWatcher fileWatch; // FileSystemWatcher is IDisposable      public FantasticFileService(string path)     {       fileWatch = new FileSystemWatcher(path);       fileWatch.Changed += OnFileChanged;     }      private void OnFileChanged(object sender, FileSystemEventArgs e)     {       // blah blah     }   } 

The closest MSDN gets to addressing this problem only covers the use-case when the instance of IDisposable is short lived so says call Dispose e.g. by using using:

Implement IDisposable only if you are using unmanaged resources directly. If your app simply uses an object that implements IDisposable, don't provide an IDisposable implementation. Instead, you should call the object's IDisposable.Dispose implementation when you are finished using it.

of course that is not possible here where we need the instance to survive longer than a method call!?

I suspect the correct way to do this would be to implement IDisposable (passing the responsibility to creator of my class to dispose it) but without all finalizer and protected virtual void Dispose(bool disposing) logic becuase I don't have any unmanged resources, i.e.:

  class FantasticFileService : IDisposable   {     private FileSystemWatcher fileWatch; // FileSystemWatcher is IDisposable      public FantasticFileService(string watch)     {       fileWatch = new FileSystemWatcher(watch);       fileWatch.Changed += OnFileChanged;     }      public void Dispose()     {       fileWatch.Dispose();     }   } 

But why is this use-case not explicitly covered in any official documentation? And the fact it explicitly says do not implement IDisposable if your class does not have unmanaged resources makes me hesitant to do so... What is a poor programmer to do?

Answer 1

It looks like your case is indeed covered by some documentation, namely the design warning CA1001: Types that own disposable fields should be disposable.

That link has an example of what your IDisposable implementation should look like. It will be something like as follows. Eventual design guidelines can be found at CA1063: Implement IDisposable correctly.

  class FantasticFileService : IDisposable   {     private FileSystemWatcher fileWatch; // FileSystemWatcher is IDisposable      public FantasticFileService(string watch)     {       fileWatch = new FileSystemWatcher(watch);       fileWatch.Changed += OnFileChanged;     }      ~FantasticFileService()     {       Dispose(false);     }      protected virtual void Dispose(bool disposing)     {       if (disposing && fileWatch != null)       {         fileWatch.Dispose();         fileWatch = null;       }     }      public void Dispose()     {       Dispose(true);       GC.SuppressFinalize(this);     }   }