Question

I have the following class

public class Presenter: IDisposable
{
   public IView View
   {get;private set;}

   //snip other object reference, all managed
   public Presenter(IView view)
  {
     View=view;
     View.MouseUp += MouseUpEvent;
  }

  public void MouseUpEvent()
  {
    //do whatever you want to do on mouse up
  }

  public void Dispose()
  {
    View.MouseUp -= MouseUpEvent;
    // no more manual disposing
  }
}

The question now is, am I implement Dispose() method correctly? Or do I need to manually dispose all the other managed objects just because I have explicilty define Dispose()?

I reckon that the GC is smart enough to do its own disposing ( except the event subscription) even without me manually doing it. Am I right?

Answer 1

If you go with the choice of subscribing in the constructor, then this looks reasonable. I would echo Josh’s sentiments that it may not be the best approach. On the other hand, it may be the simplest way of achieving your goal, which is always a good thing. I’m not going to pretend to be an expert on UI patterns: having raised the concern, I’ll assume that this is the way you want to work, and address the question itself 🙂

I personally find Josh’s prescribed pattern¹ overly complex for simple scenarios – your approach is fine, with just one change: make your class sealed. If you don’t want to seal the class, you should go for the Dispose(bool) option (but without the finalizer) because subclasses may also need to dispose of things, and may need a finalizer. Without the possibility of a derived type, life is simpler (as it so often is).

You don’t need to do anything with other members just because you now implement IDiposable for that one reason.

So, do you need to derive any further from this class?

---

¹ I do understand that this is the standard recommended pattern, although I’d recommend that you read the advice of Joe Duffy et al for even more details – it can all get very complicated.