Do you have to dispose of IDisposable objects before you repopulate them?

Question

Assuming I have a method in my command architecture pattern that alters the contents of graphics path like so: (GraphicsPath is IDisposable)

(this is purely an untested, quick example)

public void DoSomething(ref GraphicsPath path) 
{
   if(path != null) 
      {
      List<PointF> pts = new List<PointF>();
      foreach(PointF pt in path.PathPoints) 
      {
         //again, just a silly example.
         float y = pt.X;
         float x = pt.Y;
         pts.Add(new PointF(x, y));
      }
   path.Dispose(); //<-- Do I need this?
   path = new GraphicsPath(pts.ToArray(), path.PathTypes);
  }
}

Do I need to dispose the path before setting the path equal to the new path? If so, why?

Answer 1

Yeah, you probably should.

If the object is disposable, that's basically saying that it has some resources that need to be cleaned up (like maybe a file open or a database or something).

Calling dispose, cleans those up (in an ideal world)

Answer 2

Without discussing the merit of your function, yes - you need to call Dispose so that the object can clean itself up of resources it allocated along the way.

Another reason - at the point you assign anything to it, you are taking responsibility for its lifetime, so you need to make sure whatever it was using before gets cleaned up.

Answer 3

Yes. Since you're passing the path variable by reference you "orphan" the previous instance when you reassign it. Cleaning up with Dispose() is the right thing to do.

Answer 4

This is a difficult question to answer. If the consuming code should be responsible for managing the lifetime of the object, then it should call Dispose(), instead of your code. The reason for this is that the consuming code could be maintaining another reference to the instance, besides the one it has passed to your code, and it may expect to be able to continue using this reference after your method has been called.

Or, if the semantics of your class indicate that it will manage the lifetime of the object once it has been passed, then it should call Dispose() as you've described.

As a general note, whenever an object implements IDisposable, you should always explictly call it's Dipose() method when you have finished with it (or use the reference within a using block).

Having said the above, you may want to revisit your design as the semantics it represents are not intuitive.