Who Disposes of an IDisposable public property?

by

There is no single answer, it depends on your scenario, and the key point is ownership of the disposable resource represented by the property, as Jon Skeet points out.

It’s sometimes helpful to look at examples from the .NET Framework. Here are three examples that behave differently:

  • Container always disposes. System.IO.StreamReader exposes a disposable property BaseStream. It is considered to own the underlying stream, and disposing the StreamReader always disposes the underlying stream.

  • Container never disposes. System.DirectoryServices.DirectoryEntry exposes a Parent property. It is not considered to own its parent, so disposing the DirectoryEntry never disposes its parent.

    In this case a new DirectoryEntry instance is returned each time the Parent property is dereferenced, and the caller is presumably expected to dispose it. Arguably this breaks the guidelines for properties, and perhaps there should be a GetParent() method instead.

  • Container sometimes disposes. System.Data.SqlClient.SqlDataReader exposes a disposable Connection property, but the caller decides if the reader owns (and therefore disposes) the underlying connection using the CommandBehavior argument of SqlCommand.ExecuteReader.

Another interesting example is System.DirectoryServices.DirectorySearcher, which has a read/write disposable property SearchRoot. If this property is set from outside, then the underlying resource is assumed not to be owned, so isn’t disposed by the container. If it’s not set from outside, a reference is generated internally, and a flag is set to ensure it will be disposed. You can see this with Lutz Reflector.

You need to decide whether or not your container owns the resource, and make sure you document its behavior accurately.

If you do decide you own the resource, and the property is read/write, you need to make sure your setter disposes any reference it’s replacing, e.g.:

public SomeDisposableObject SomeObject    
{        
    get { return m_someObject; }        
    set 
    { 
        if ((m_someObject != null) && 
            (!object.ReferenceEquals(m_someObject, value))
        {
            m_someObject.Dispose();
        }
        m_someObject = value; 
    }    
}
private SomeDisposableObject m_someObject;

UPDATE: GrahamS rightly points out in comments that it’s better to test for m_someObject != value in the setter before disposing: I’ve updated the above example to take account of this (using ReferenceEquals rather than != to be explicit). Although in many real-world scenarios the existence of a setter might imply that the object is not owned by the container, and therefore won’t be disposed.

More Related Contents:

  1. Dispose, when is it called?
  2. What happens if i return before the end of using statement? Will the dispose be called?
  3. Do I need to Dispose a SemaphoreSlim?
  4. Proper use of the IDisposable interface
  5. Use of Finalize/Dispose method in C#
  6. Do you need to dispose of objects and set them to null?
  7. Is it considered acceptable to not call Dispose() on a TPL Task object?
  8. What is the difference between using IDisposable vs a destructor in C#?
  9. Disposing WPF User Controls
  10. Using statement vs. IDisposable.Dispose()
  11. Should you implement IDisposable.Dispose() so that it never throws?
  12. Proper way to dispose a new Form
  13. returning in the middle of a using block
  14. Does garbage collector call Dispose()? [duplicate]
  15. Should IDisposable.Dispose() be made safe to call multiple times?
  16. Difference between destructor, dispose and finalize method
  17. Is IDisposable.Dispose() called automatically? [duplicate]
  18. Implementing IDisposable on a subclass when the parent also implements IDisposable
  19. Is it possible to force the use of “using” for disposable classes?
  20. What does Process.Dispose() actually do?
  21. What is IDisposable for?
  22. When should I use GC.SuppressFinalize()?
  23. Who should call Dispose on IDisposable objects when passed into another object?
  24. Should I always disconnect event handlers in the Dispose method?
  25. When or if to Dispose HttpResponseMessage when calling ReadAsStreamAsync?
  26. Guidelines For Dispose() and Ninject
  27. using statement FileStream and / or StreamReader – Visual Studio 2012 Warnings
  28. What’s the purpose of GC.SuppressFinalize(this) in Dispose() method?
  29. Determining if IDisposable should extend an interface or be implemented on a class implementing said interface
  30. Is it necessary to dispose System.Timers.Timer if you use one in your application?

Leave a Comment