Implementazione multi-gerarchia IDisposable per DbContext in C #

Classe base:

public abstract class Repository : IDisposable
{
    private bool _disposed;
    private DbContext _context;
    public Repository(DbContext context)
    {
        _context = context;
    }

    public void SetSomething()
    {
        //...Access the database and set something for tracing
        _context.Database.SqlQuery(....);
    }

    public void UnSetSomething()
    {
        //...Access the database and cancel something for tracing
        _context.Database.SqlQuery(....);
    }

    #region Object Disposal
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    ~Repository()
    {
        Dispose(false);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (_disposed)
            return;

        if (disposing)
        {
            // free other managed objects that implement IDisposable only
            if (_context != null)
            {
                _context.Dispose();
                _context = null;
            }
        }

        _disposed = true;
    }
    #endregion
}

Sottoclasse:

public class ScheduleRepository : Repository
{
    private AppContext _context;

    public ScheduleRepository(DbContext context)
        : base(context)
    {
        _context = (AppContext)context;
    }

    #region Object Disposal
    bool _disposed;
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    ~ScheduleRepository()
    {
        Dispose(false);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (_disposed)
            return;

        if (disposing)
        {
            // free other managed objects that implement IDisposable only
            if (_context != null)
            {
                _context.Dispose();
                _context = null;
            }
        }

        _disposed = true;

        base.Dispose(disposing);
    }
    #endregion
}

Classe logica:

public class ScheduleFacade
{
    private ScheduleRepository _repository;
    public ScheduleFacade()
    {
        _repository = new ScheduleRepository(AppContext.Create());
    }

    public ScheduleSetting GetScheduleById(string scheduleId)
    {
        if (!string.IsNullOrEmpty(scheduleId))
        {
            _repository.SetSomething();

            ScheduleSetting settings = _repository.GetScheduleById(scheduleId);

            _repository.UnSetSomething();

            return LoadScheduleSettings(settings);
        }
        else
        {
            throw new ArgumentException("The scheduleId parameter cannot be empty.");
        }
    }

    private ScheduleSetting LoadScheduleSettings(ScheduleSetting settings)
    {
        //...code ....
    }
}

È questo il modo corretto di implementare IDisposable su IDisposable astratta della classe? Questo non sta seguendo i principali DRY come dovrebbe, ma non sono chiaro come farlo correttamente.

Voglio assicurarmi che sto pulendo il mio DbContext appropriato.

EDIT: Sembra che siano necessarie maggiori informazioni per chiarire cosa sto facendo e perché sto passando in DbContext nel costruttore (ho aggiunto altro codice sopra per favore rileggere). Avevo bisogno del DbContext nella classe abstract per accedere al database e fare un po 'di lavoro. Non è questo il modo in cui utilizzerei una classe astratta condivisa tra più sottoclassi e quindi mi consente di aderire al principale di DRY e centralizzare la manutenzione futura?

Come potrei passare il DbContext alla classe abastract se non lo passo attraverso il contstructor (viene in mente l'iniezione del metodo ma ciò richiederebbe che gli sviluppatori dei futuri repository possano dimenticare di passare il contesto alla classe base).