Algo que eu costumava usar em C ++ era deixar uma aulaA manipular uma condição de entrada e saída de estado para outra classeB, através doA construtor e destruidor, para garantir que, se algo nesse escopo gerasse uma exceção, B tivesse um estado conhecido quando o escopo fosse encerrado. Isso não é puro RAII no que diz respeito à sigla, mas é um padrão estabelecido.

Em c #, muitas vezes eu quero fazer

class FrobbleManager
{
    ...

    private void FiddleTheFrobble()
    {
        this.Frobble.Unlock();
        Foo();                  // Can throw
        this.Frobble.Fiddle();  // Can throw
        Bar();                  // Can throw
        this.Frobble.Lock();
    }
}

O que precisa ser feito assim

private void FiddleTheFrobble()
{
    this.Frobble.Unlock();

    try
    {            
        Foo();                  // Can throw
        this.Frobble.Fiddle();  // Can throw
        Bar();                  // Can throw
    }
    finally
    {
        this.Frobble.Lock();
    }
}

se eu quiser garantir oFrobble declarar quandoFiddleTheFrobble retorna. O código seria melhor com

private void FiddleTheFrobble()
{
    using (var janitor = new FrobbleJanitor(this.Frobble))
    {            
        Foo();                  // Can throw
        this.Frobble.Fiddle();  // Can throw
        Bar();                  // Can throw
    }
}

OndeFrobbleJanitor pareceaproximadamente gostar

class FrobbleJanitor : IDisposable
{
    private Frobble frobble;

    public FrobbleJanitor(Frobble frobble)
    {
        this.frobble = frobble;
        this.frobble.Unlock();
    }

    public void Dispose()
    {
        this.frobble.Lock();
    }
}

E é assim que eu quero fazer. Agora a realidade alcança, já que o que euquer usarrequer que oFrobbleJanitor é usadocom using. Eu poderia considerar isso um problema de revisão de código, mas algo está me incomodando.

Pergunta, questão: O acima exposto seria considerado como uso abusivo deusing eIDisposable?