C#的Command模式如何实现UI交互？

System.Windows.Input.ICommand

Execute(object parameter)

CanExecute(object parameter)

CanExecuteChanged

ICommand

// 1. ICommand 接口（或者直接使用 System.Windows.Input.ICommand）
public interface IMyCommand
{
    void Execute();
    bool CanExecute();
    event EventHandler CanExecuteChanged; // 用于通知UI更新CanExecute状态
}

// 2. Receiver 接收者
public class DocumentEditor
{
    public void Save(string content)
    {
        Console.WriteLine($"Saving document with content: '{content}'");
        // 实际的保存逻辑，比如写入文件
    }

    public void Open(string path)
    {
        Console.WriteLine($"Opening document from path: '{path}'");
        // 实际的打开逻辑
    }

    public bool IsDocumentOpen { get; private set; } = false; // 示例状态
    public void SetDocumentOpen(bool isOpen)
    {
        IsDocumentOpen = isOpen;
        OnDocumentStateChanged(); // 触发事件，通知相关命令更新CanExecute状态
    }

    public event EventHandler DocumentStateChanged;
    protected virtual void OnDocumentStateChanged()
    {
        DocumentStateChanged?.Invoke(this, EventArgs.Empty);
    }
}

// 3. ConcreteCommand 具体命令：保存文档
public class SaveDocumentCommand : IMyCommand
{
    private readonly DocumentEditor _editor;
    private readonly string _currentContent;

    public SaveDocumentCommand(DocumentEditor editor, string content)
    {
        _editor = editor;
        _currentContent = content;
        // 订阅接收者的状态变化，以便更新CanExecute
        _editor.DocumentStateChanged += (s, e) => OnCanExecuteChanged();
    }

    public event EventHandler CanExecuteChanged;

    public void Execute()
    {
        _editor.Save(_currentContent);
    }

    public bool CanExecute()
    {
        // 只有当文档是打开状态时，才能保存
        return _editor.IsDocumentOpen && !string.IsNullOrEmpty(_currentContent);
    }

    protected virtual void OnCanExecuteChanged()
    {
        CanExecuteChanged?.Invoke(this, EventArgs.Empty);
    }
}

// 4. 客户端（例如在WinForms的Form类中或WPF的ViewModel中）
public class MyApplication
{
    private DocumentEditor _editor = new DocumentEditor();
    private IMyCommand _saveCommand;

    public MyApplication()
    {
        _saveCommand = new SaveDocumentCommand(_editor, "Hello World!");

        // 假设这是一个按钮的点击事件处理
        // buttonSave.Click += (sender, e) => _saveCommand.Execute();

        // 模拟UI绑定，手动检查CanExecute并执行
        SimulateUIInteraction();
    }

    private void SimulateUIInteraction()
    {
        Console.WriteLine("Initial state: Can Save? " + _saveCommand.CanExecute()); // Should be false

        _editor.SetDocumentOpen(true); // 模拟文档打开
        Console.WriteLine("After opening document: Can Save? " + _saveCommand.CanExecute()); // Should be true

        if (_saveCommand.CanExecute())
        {
            _saveCommand.Execute(); // 模拟点击保存按钮
        }

        _editor.SetDocumentOpen(false); // 模拟文档关闭
        Console.WriteLine("After closing document: Can Save? " + _saveCommand.CanExecute()); // Should be false
    }
}

button.Command = _saveCommand;

CanExecute

CanExecuteChanged

CanExecute

CanExecuteChanged

Execute

// 扩展后的可撤销命令接口
public interface IUndoableCommand : IMyCommand
{
    void Unexecute();
}

// 示例：一个可撤销的文本插入命令
public class InsertTextCommand : IUndoableCommand
{
    private DocumentEditor _editor;
    private string _textToInsert;
    private int _position; // 记录插入位置，以便撤销

    public InsertTextCommand(DocumentEditor editor, string text, int position)
    {
        _editor = editor;
        _textToInsert = text;
        _position = position;
        _editor.DocumentStateChanged += (s, e) => OnCanExecuteChanged();
    }

    public event EventHandler CanExecuteChanged;

    public void Execute()
    {
        // 模拟在特定位置插入文本
        Console.WriteLine($"Executing: Insert '{_textToInsert}' at position {_position}");
        // _editor.InsertText(_textToInsert, _position); // 实际的文本操作
    }

    public void Unexecute()
    {
        // 模拟从特定位置删除文本
        Console.WriteLine($"Unexecuting: Remove '{_textToInsert}' from position {_position}");
        // _editor.DeleteText(_position, _textToInsert.Length); // 实际的文本操作
    }

    public bool CanExecute()
    {
        return _editor.IsDocumentOpen;
    }

    protected virtual void OnCanExecuteChanged()
    {
        CanExecuteChanged?.Invoke(this, EventArgs.Empty);
    }
}

// 命令管理器，负责维护历史
public class CommandManager
{
    private Stack<IUndoableCommand> _undoStack = new Stack<IUndoableCommand>();
    private Stack<IUndoableCommand> _redoStack = new Stack<IUndoableCommand>();

    public void ExecuteCommand(IUndoableCommand command)
    {
        if (command.CanExecute())
        {
            command.Execute();
            _undoStack.Push(command);
            _redoStack.Clear(); // 新操作清空重做历史
            Console.WriteLine($"Command executed. Undo stack size: {_undoStack.Count}");
        }
    }

    public void Undo()
    {
        if (_undoStack.Count > 0)
        {
            IUndoableCommand command = _undoStack.Pop();
            command.Unexecute();
            _redoStack.Push(command);
            Console.WriteLine($"Undo executed. Undo stack size: {_undoStack.Count}, Redo stack size: {_redoStack.Count}");
        }
        else
        {
            Console.WriteLine("Nothing to undo.");
        }
    }

    public void Redo()
    {
        if (_redoStack.Count > 0)
        {
            IUndoableCommand command = _redoStack.Pop();
            command.Execute();
            _undoStack.Push(command);
            Console.WriteLine($"Redo executed. Undo stack size: {_undoStack.Count}, Redo stack size: {_redoStack.Count}");
        }
        else
        {
            Console.WriteLine("Nothing to redo.");
        }
    }
}

Unexecute()

System.Windows.Input.ICommand

Button

MenuItem

Command

ICommand

ICommand