Esistono scenari in cui il 'Dispose Pattern' non deve essere utilizzato su un oggetto che contiene risorse gestite e non gestite?

MSDN dice che per pulire correttamente un oggetto che contiene risorse gestite e non gestite, è necessario implementare il 'Dispose Pattern'.

Dato che la classe implementa l'interfaccia IDisposable e sovrascrive il metodo Object.Finalize () (ha un distruttore), c'è qualche ragione per cui il compilatore non dovrebbe implementare automaticamente il pattern per te? Ad esempio, compilando:

public class Example : IDisposable
{
    public void Dispose() {
        //Disposing managed objects implementation
    }

    ~Example() {
        //Disposing unmanaged objects implementation
    }
}

Come se fosse stato digitato come segue:

public class Example : IDisposable
{
    private bool previouslyDisposed = false;

    private void CleanResources(bool safeToCleanManagedResources)
    {
        if (!this.previouslyDisposed)
        {
            _finalize();
            if (safeToCleanManagedResources) {
                _dispose();
            }
            this.previouslyDisposed = true;
        }
    }

    public void Dispose() {
        CleanResources(true);
        GC.SuppressFinalize(this);
    }

    ~Example() {
        CleanResources(false);
    }

    private void _dispose() {
        //The contents of the Dispose() method are moved here.
    }

    private void _finalize() {
        //The contents of the ~Example() method are moved here.
    }
}

Da quanto ho capito, questo dovrebbe essere sempre sicuro e valido . Non riesco a pensare a scenari in cui queste regole dovrebbero essere infranse. So che questa non è la funzione più urgente su cui il team C # sta lavorando, ma a parte questo:

Esistono scenari in cui un oggetto contenente risorse gestite e non gestite non vorrebbe seguire il "Dispose Pattern"?

Sto parlando del compilatore che genera un metodo che funziona come CleanResources() e sposta i metodi Dispose() e ~Example() in metodi di backing anonimi (simile a come le proprietà auto generano campi di backing privati). Ciò significherebbe che eventuali chiamate a Dispose() o ~Example() implementerebbero automaticamente il "Dispose Pattern".