UndoableObjectBase Class

[SerializableAttribute]
public abstract class UndoableObjectBase : PersistableObjectBase, 
	ICanUndoRedo, ICanUndo, IRevertibleChangeTracking, IChangeTracking

<SerializableAttribute>
Public MustInherit Class UndoableObjectBase
	Inherits PersistableObjectBase
	Implements ICanUndoRedo, ICanUndo, IRevertibleChangeTracking, IChangeTracking

[SerializableAttribute]
public ref class UndoableObjectBase abstract : public PersistableObjectBase, 
	ICanUndoRedo, ICanUndo, IRevertibleChangeTracking, IChangeTracking

[<AbstractClassAttribute>]
[<SerializableAttribute>]
type UndoableObjectBase = 
    class
        inherit PersistableObjectBase
        interface ICanUndoRedo
        interface ICanUndo
        interface IRevertibleChangeTracking
        interface IChangeTracking
    end

Inheritance

Object    ObservableObjectBase    PersistableObjectBase    UndoableObjectBase

Implements

ICanUndo, ICanUndoRedo, IChangeTracking, IRevertibleChangeTracking

An object derived from UndoableObjectBase continuously tracks the property changes of properties, which are set through the IPersistableObject implementation and the ObservableObjectBase.Set method.

Differences from EditableObjectBase:
Both UndoableObjectBase and EditableObjectBase can revert changes; however, the aspects of these classes are different.

• An undoable class (which implements ICanUndo or ICanUndoRedo interfaces such as UndoableObjectBase) is able to undo (or redo) any changes made so far either step-by-step or in a single step.
• On the other hand, an editable class (which implements ICanEdit such as EditableObjectBase) is able to start editing sessions by saving a snapshot of its current state, which states are committable and revertible.
• Undo and editing features are independent from each other and a class is allowed to implement both (like the ModelBase class).

IRevertibleChangeTracking support:
UndoableObjectBase implements also the System.ComponentModel.IRevertibleChangeTracking interface, which is the standard way in .NET to support undoing.
This is how the IRevertibleChangeTracking members are mapped in the UndoableObjectBase class:

• IChangeTracking.IsChanged: Returns CanUndo.
• IChangeTracking.AcceptChanges: Calls ClearUndoHistory.
• IRevertibleChangeTracking.RejectChanges: Calls UndoAll.

IsModified vs. CanUndo:

• The IsModified property reflects the object's "dirty" state, meaning, it has been changed since the initialization or last save. The modified state can be cleared by the SetModified method. Clearing the modified state (eg. on saving the object) does not affect the undo capabilities, though.
• The CanUndo property tells whether there are any steps to undo. On saving an object the modified state can be cleared and still there can be undoable steps. And vice versa, undoing all steps will not clear the modified state.

Reference