EditableObjectBase Class

[SerializableAttribute]
public abstract class EditableObjectBase : PersistableObjectBase, 
	ICanEdit, IEditableObject

<SerializableAttribute>
Public MustInherit Class EditableObjectBase
	Inherits PersistableObjectBase
	Implements ICanEdit, IEditableObject

[SerializableAttribute]
public ref class EditableObjectBase abstract : public PersistableObjectBase, 
	ICanEdit, IEditableObject

[<AbstractClassAttribute>]
[<SerializableAttribute>]
type EditableObjectBase = 
    class
        inherit PersistableObjectBase
        interface ICanEdit
        interface IEditableObject
    end

Inheritance

Object    ObservableObjectBase    PersistableObjectBase    EditableObjectBase

Implements

ICanEdit, IEditableObject

An object derived from EditableObjectBase is able to save a snapshot of its properties (the ones, which are set through the IPersistableObject implementation or the ObservableObjectBase.Set method).

A new snapshot can be saved by the BeginNewEdit method. This can be called by a UI before starting the editing.

Call the CommitLastEdit method to apply the changes since the last BeginNewEdit call.

Call the RevertLastEdit method to discard the changes since the last BeginNewEdit call.

The editing sessions can be nested by calling BeginNewEdit method multiple times. The number of the BeginNewEdit calls without a corresponding CommitLastEdit or RevertLastEdit call is indicated by the EditLevel property.

By calling the TryCommitAllEdits and TryRevertAllEdits methods all of the previous BeginNewEdit calls can be applied or discarded, respectively. These methods return a bool value indicating whether any action occurred.

Differences from UndoableObjectBase:
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).

IEditableObject support:
EditableObjectBase implements also the System.ComponentModel.IEditableObject interface, which is the standard way in .NET to support editing. Several controls of different UI frameworks automatically call its members if an object, which implements it, is bound to a grid control, for example. However, some frameworks (such as Windows Forms) do not always call the begin/end operations the same times, which can cause problems. To handle this, you can override the EditableObjectBehavior property in your class to adjust the editing behavior via the IEditableObject interface. If not overridden, the EditableObjectBehavior returns DisableNesting, which works in most cases.
This is how the IEditableObject members are mapped in the EditableObjectBase class:

• IEditableObject.BeginEdit:
  • If EditableObjectBehavior returns Disabled, then the call is ignored.
  • If EditableObjectBehavior returns DisableNesting, then BeginNewEdit is called only if EditLevel returns 0; otherwise, the call is ignored.
  • If EditableObjectBehavior returns AllowNesting, then BeginNewEdit is called.
• IEditableObject.EndEdit:
  • If EditableObjectBehavior returns Disabled, then the call is ignored.
  • If EditableObjectBehavior returns DisableNesting, then TryCommitAllEdits is called.
  • If EditableObjectBehavior returns AllowNesting, then CommitLastEdit is called.
• IEditableObject.CancelEdit:
  • If EditableObjectBehavior returns Disabled, then the call is ignored.
  • If EditableObjectBehavior returns DisableNesting, then TryRevertAllEdits is called.
  • If EditableObjectBehavior returns AllowNesting, then RevertLastEdit is called.

Reference