我必须在所有类上实现IDisposable，还是基类足够？

Question

I am told I need to dispose of instances of my Entity Framework repository classes and I created a base class to enforce this implementation.

I need to check with the experts: is it acceptable to implement IDisposable through a base class?

Note that the repository class has no class member variables.

/// Sample repository.  Note that I return List<T> as IEnumerable, 
/// and I use IDisposable 
///
public class CompanyRepository : DisposableBase, ICompanyRepository
{
    public IEnumerable<CompanyDetail> GetOneCompany(int? CompanyID)
    {
        var t = from c in _entities.CompanyDetail
                where c.CompanyID == CompanyID.Value
                select c;
        return t.ToList();
    }
}

/// <summary>
/// Disposable implementation based on advice from this link:
/// from Http://www.asp.net/entity-framework/tutorials/implementing-the-repository-and-unit-of-work-patterns-in-an-asp-net-mvc-application
/// </summary>
public class DisposableBase : IDisposable
{
    protected TLSAdminEntities1 _entities;

    public DisposableBase()
    {
        _entities = new TLSAdminEntities1();
        disposed = false;
    }

    private bool disposed ;
    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                _entities.Dispose();
            }
        }
        this.disposed = true;
    }
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
}

Answer 1

The answer is "it depends".

If the "Dispose()" method in some superclass is sufficient, you certainly don't need to reimplement it in each and every subclass.

The "superclass" might be the base class; it might be one or more subclasses.

It depends on what you allocate, and what needs to be cleaned up.

IMHO...

Here is what MSDN has to say:

http://msdn.microsoft.com/en-us/magazine/cc163392.aspx

When you derive from a disposable type, and that derived type does not introduce any new resources, then nothing special needs to be done. The base type IDisposable implementation will take care of cleaning up its resources and your subclass can be blissfully ignorant of the details.

<= In other words, you DON'T necessarily have to re-implement Dispose over and over

... but ...

However, it's also common to have a subclass that does contain new resources that need to be cleaned up. In this case, your class needs to release its resources, while making sure that the base type's resources also get released. Do this by overriding the cleanup method, releasing your resources, and then calling the base type to clean up its resources, as in Figure 6.

Answer 2

It depends on whether you have resources in the derived class that need to be disposed. If there are resources specific to the derived class, implementing IDisposable only on the base class will not be sufficient.

Answer 3

Generaly spoken, you have to implement IDispoable in every class, where you have private members which themselves implement IDisposable. Those resources have to be "freed". I strongly advise you to read this very good paper on CodeProject about the IDisposable pattern.

Answer 4

NO . you have also in sub classes.

if you wont , the GC still need to map its child's as un-referenced - and THEN to collect them... so you didn't earn nothing.

Answer 5

it is fine to dispose using a base class. the important thing here is cleaning up unmanaged resources, which in this case means closing database connections. i'd argue that you'd be better off hooking into asp.net with things like httpmodules or action filters to handle your unit of work and do the dispose for a unit-of-work-per-request type of setup, but if you are instead just making sure to call dispose on your repository instances, having a base class that disposes entity framework context is fine (and you could still use the base class for these repositories even with disposing them with a filter/module).