Classe base astratta che implementa un'interfaccia, fornendo una classe diversa alle sue sottoclassi

Diciamo che ho un'interfaccia per il pattern Command con funzionalità di annullamento:

interface ICommand
{
    void Execute();
    void Undo();
}

Questo è accompagnato da un contratto. Fondamentalmente il comando può essere in uno dei due stati - o è stato eseguito o meno, e questo determina l'unico metodo che può essere chiamato.

Per aggiungere un controllo per questo, potrei creare una classe astratta chiamata SafeCommand o semplicemente CommandBase con questa protezione:

abstract class CommandBase : ICommand
{
    private bool executed = false;

    public void Execute()
    {
        if (executed)
            throw new InvalidOperationException();

        ExecuteImpl();
        executed = true;
    }

    public void Undo()
    {
        if (!executed)
            throw new InvalidOperationException();

        UndoImpl();
        executed = false;
    }

    protected abstract void ExecuteImpl();
    protected abstract void UndoImpl();
}

Quando voglio implementare l'effettiva funzionalità di comando, ora devo sostituire i metodi ExecuteImpl e UndoImpl.

Un altro modo per risolvere questo potrebbe essere quello di rendere i metodi virtuali, ma preferisco in questo modo perché non posso dimenticare di implementare i metodi e inoltre non posso omettere la chiamata di base. Inoltre, negli altri casi in cui ho bisogno di avere del codice prima e dopo la chiamata, questa sarà l'unica soluzione.

Ho incontrato questo pattern per la prima volta in WPF, dove è effettivamente usato due volte nella stessa gerarchia di ereditarietà con UIElement Measure, MeasureCore virtuale e FrameworkElement sovrascrivono i metodi MeasureCore e MeasureOverride virtuali.

La mia domanda è, c'è un nome per questo modello? Mi sembra una sorta di adattatore (forzato) che utilizza l'ereditarietà invece della composizione.