How do you design an Undo/Redo functionality? (Command Pattern)

Question

Accepted Answer

I would represent each user operation as a Command containing the information required to execute and undo that operation. The application maintains an undo stack and a redo stack. Executing a new command pushes it onto the undo stack and clears the redo stack. Undo moves the command to the redo stack, while redo executes it again. public interface ICommand
{
 void Execute();
 void Undo();
}

public class InsertTextCommand : ICommand
{
 private readonly Editor editor;
 private readonly string text;

public InsertTextCommand(Editor editor, string text)
 {
 this.editor = editor;
 this.text = text;
 }

public void Execute() => editor.Insert(text);
 public void Undo() => editor.Remove(text);
}

public class CommandManager
{
 private readonly Stack undo = new();
 private readonly Stack redo = new();

public void Execute(ICommand command)
 {
 command.Execute();
 undo.Push(command);
 redo.Clear();
 }

public void Undo()
 {
 if (undo.Count == 0) return;
 var command = undo.Pop();
 command.Undo();
 redo.Push(command);
 }

public void Redo()
 {
 if (redo.Count == 0) return;
 var command = redo.Pop();
 command.Execute();
 undo.Push(command);
 }
} Command encapsulates an action and its inverse operation. Undo and redo stacks maintain operation history. A new command normally invalidates the redo history. For complex applications, commands may need snapshots, event sourcing, or compensating operations. Commands should consider transaction boundaries and failure handling.

How do you design an Undo/Redo functionality? (Command Pattern)

Undo and Redo with the Command Pattern

Scenario Questions

Follow-up Questions