如何处置具有无法实现IDisposable的属性的类？

Question

Not sure how to go about disposing this class as I need to free up resources due to a memory leak in the application causing it to slow down. I am not sure how to go about disposing the class below as some of the properties don't implement IDisposable. I am fairly new to c# so try not to over complicate responses.

public class CellItem: IDisposable
    {
        private Timer foo = new Timer();

        public int MedicationDispenseId { get; set; }
        public Enumerations.Timeslot Timeslot { get; set; }
        public DateTime DateAdministered { get; set; }

        protected override void Dispose(bool disposing)
        {
            disposing = true;
            Dispose(disposing);
        }

    }

Answer 1

There's a bug in the code in that:

protected override void Dispose(bool disposing)
{
            disposing = true;
            Dispose(disposing);
}

is recursive and if just going to sit there for a few moments before running out of stack space.

To answer you're question: If it's your code then just change the Dispose method to release the appropriate resources. If it's not then you'll have to ask whoever wrote it to fix it or think about writing your own (bug free) version.

Answer 2

    protected override void Dispose(bool disposing)

You didn't implement the IDisposable.Dispose() method so this code won't compile. The protected Dispose(bool) method is an artifact of the disposable pattern. It is only used when your class has a finalizer or when your class derives from a base class that implements the disposable pattern. Neither is the case.

So keep it simple and just implement Dispose():

    public void Dispose()
    {
        foo.Dispose();
    }

Answer 3

Try reading these resources to get you started:

IDisposable

http://msdn.microsoft.com/en-us/library/system.idisposable.aspx

Using Keyword

http://msdn.microsoft.com/en-us/library/yh598w02.aspx

Answer 4

The Disposing flag is not a field which says whether the disposal has started for the class, but should instead be regarded as a dummy parameter to which the value true should be passed when the protected virtual method is called from the parameterless Dispose method which implements the interface. The parameter was originally designed so as to allow a common "patch point" for derived classes which want to add functionality to both Dispose and Finalize (destructor) methods, but in practice it's almost never appropriate for a derived or unsealed class to implement Finalize code unless the class is derived directly from Object or from a class whose whole purpose centers around such cleanup .

Note that unlike most interfaces, the IDisposable "contract" doesn't impose any obligations on the class which implements it , but instead exists as a standard means via which many types of classes can impose certain transferable contractual obligations on code which requests their construction. A typical IDisposable object will ask some other entity to do something on its behalf until further notice, will promise that other entity that it will be informed when its services are no longer required, and will use its Dispose method for the purpose of giving such notice. The constructor contract for many classes which implement IDisposable will require that the caller either ensure that before it abandons the object it will either Dispose it or give it to some other entity that promises to do so.