欢迎来到 C# 设计模式 的第十六章！在这一章中，我们将深入探讨 命令模式（Command Pattern）。命令模式是一种行为型设计模式，它允许你将请求封装成对象，从而实现请求的参数化、队列化和可撤销操作等功能。想象一下，你正在玩一个电子游戏，游戏中有各种各样的按钮，每个按钮对应一个特定的操作，比如移动、攻击或使用道具。命令模式正是这样一种模式，它让你可以将这些操作封装成独立的对象，使得你可以轻松地管理、执行和撤销这些操作。

---

第一节：什么是命令模式？

1. 概念

命令模式 是一种行为型设计模式，它允许你将请求封装成对象，从而实现请求的参数化、队列化和可撤销操作等功能。通过命令模式，你可以将发起请求的对象与执行请求的对象解耦，使得系统更加灵活和可扩展。每个命令对象都包含了一个执行操作的方法（通常称为 Execute()），并且可以包含撤销操作的方法（通常称为 Undo()）。这样，你可以在任何时候执行或撤销某个命令，而不需要关心具体的实现细节。

幽默小贴士：

命令模式就像是《哈利·波特》中的魔法咒语，每个咒语都是一个独立的命令，你可以随时施放或撤销它，而不需要知道背后的魔法原理！ 🪄

2. 为什么需要命令模式？

在现实生活中，我们经常遇到这样的情况：我们需要执行某个操作，但又希望能够在以后撤销这个操作，或者将多个操作组合在一起批量执行。例如：

• 在文本编辑器中，用户可以输入文字、删除文字、撤销上一步操作等。命令模式可以帮助你轻松实现撤销功能，而不需要手动记录每一步操作。
• 在游戏开发中，玩家可以执行各种动作，如移动、攻击、使用道具等。命令模式可以帮助你将这些动作封装成独立的对象，使得你可以轻松地管理、执行和撤销这些动作。
• 在自动化控制系统中，用户可以通过按钮或遥控器发送指令，控制设备执行相应的操作。命令模式可以帮助你将这些指令封装成独立的对象，使得你可以轻松地管理和调度这些指令。

如果没有命令模式，我们可能会使用大量的 if-else 或 switch 语句来手动处理每个操作，并且很难实现撤销功能或批量执行多个操作。而通过命令模式，你可以将每个操作封装成独立的对象，使得代码更加简洁、灵活和可扩展。

幽默小贴士：

没有命令模式的世界就像没有遥控器的世界一样，每次想要执行某个操作时，你都需要手动去完成，而不能一键搞定。有了命令模式，你可以像《回到未来》中的时间机器一样，随时撤销或重做任何操作！ ⏳

---

第二节：真实案例

案例 1：文本编辑器

假设你正在开发一个文本编辑器，用户可以输入文字、删除文字、撤销上一步操作等。你可以使用命令模式来实现这些功能，确保每当用户执行某个操作时，系统会自动记录该操作，并提供撤销功能。这样，用户可以随时撤销上一步操作，或者重新执行被撤销的操作。

幽默小贴士：

在文本编辑器中，命令模式就像是“魔法橡皮擦”，用户可以随时撤销或重做任何操作，就像《哈利·波特》中的魔法橡皮擦一样，轻松擦除或恢复任何错误！ ✍️

案例 2：智能家居控制系统

假设你正在开发一个智能家居控制系统，用户可以通过手机应用程序发送指令，控制家中的灯光、空调、电视等设备。你可以使用命令模式来实现这些功能，确保每当用户发送某个指令时，系统会自动执行相应的操作，并提供撤销功能。这样，用户可以随时撤销上一步操作，或者批量执行多个操作。

幽默小贴士：

在智能家居控制系统中，命令模式就像是“魔法遥控器”，用户可以随时发送指令，控制家中的各种设备，就像《回到未来》中的时间机器一样，轻松控制未来的家居生活！ 📺

案例 3：游戏开发

假设你正在开发一个电子游戏，玩家可以执行各种动作，如移动、攻击、使用道具等。你可以使用命令模式来实现这些功能，确保每当玩家执行某个动作时，系统会自动记录该动作，并提供撤销功能。这样，玩家可以随时撤销上一步操作，或者批量执行多个操作。

幽默小贴士：

在游戏开发中，命令模式就像是“魔法技能书”，玩家可以随时学习和使用各种技能，就像《哈利·波特》中的魔法技能书一样，轻松掌握各种强大的能力！ 🎮

---

第三节：实施方法

要实现命令模式，通常需要以下几个步骤：

1. 定义命令接口：命令接口定义了所有命令对象的公共行为，通常包含 Execute() 和 Undo() 方法。
2. 实现具体的命令类：具体的命令类负责实现命令接口，并封装具体的操作逻辑。每个命令类都可以包含一个接收者对象，用于执行实际的操作。
3. 定义接收者类：接收者类负责执行具体的业务逻辑。命令对象会调用接收者类的方法来完成实际的操作。
4. 定义调用者类：调用者类负责维护当前的命令对象，并提供执行和撤销命令的方法。它可以是一个按钮、菜单项或其他用户界面元素。
5. 客户端代码：客户端代码负责创建命令对象、接收者对象和调用者对象，并将它们组合在一起。客户端代码可以通过调用者的 Execute() 和 Undo() 方法来执行和撤销命令。

---

第四节：类之间的关系

为了实现命令模式，我们需要以下几个类：

1. 所需的类

1.1 ICommand 接口

// 定义命令接口
public interface ICommand
{
    void Execute();
    void Undo();
}

• 作用：ICommand 是所有命令对象的公共接口，定义了所有命令对象的公共行为。无论是哪个命令，都必须实现这个接口。
• 优点：通过接口定义公共行为，可以支持多态性，允许客户端代码动态地选择不同的命令对象。

1.2 LightReceiver 类

// 定义接收者类
public class LightReceiver
{
    public void TurnOn()
    {
        Console.WriteLine("灯已打开");
    }

    public void TurnOff()
    {
        Console.WriteLine("灯已关闭");
    }
}

• 作用：LightReceiver 是接收者类，负责执行具体的业务逻辑。在这个例子中，它负责控制灯的开关操作。
• 优点：通过命令模式，LightReceiver 可以被多个命令对象调用，而不需要直接暴露其内部逻辑。

1.3 TurnOnCommand 类

// 实现具体的命令类：打开灯的命令
public class TurnOnCommand : ICommand
{
    private readonly LightReceiver _lightReceiver;

    public TurnOnCommand(LightReceiver lightReceiver)
    {
        _lightReceiver = lightReceiver;
    }

    // 执行命令
    public void Execute()
    {
        _lightReceiver.TurnOn();
    }

    // 撤销命令
    public void Undo()
    {
        _lightReceiver.TurnOff();
    }
}

• 作用：TurnOnCommand 是实现了 ICommand 接口的具体命令类，负责封装打开灯的操作。它会在 Execute() 方法中调用接收者的 TurnOn() 方法，在 Undo() 方法中调用接收者的 TurnOff() 方法。
• 优点：通过命令模式，TurnOnCommand 可以轻松地执行和撤销打开灯的操作，而不需要直接调用接收者的具体方法。

1.4 TurnOffCommand 类

// 实现具体的命令类：关闭灯的命令
public class TurnOffCommand : ICommand
{
    private readonly LightReceiver _lightReceiver;

    public TurnOffCommand(LightReceiver lightReceiver)
    {
        _lightReceiver = lightReceiver;
    }

    // 执行命令
    public void Execute()
    {
        _lightReceiver.TurnOff();
    }

    // 撤销命令
    public void Undo()
    {
        _lightReceiver.TurnOn();
    }
}

• 作用：TurnOffCommand 是实现了 ICommand 接口的具体命令类，负责封装关闭灯的操作。它会在 Execute() 方法中调用接收者的 TurnOff() 方法，在 Undo() 方法中调用接收者的 TurnOn() 方法。
• 优点：通过命令模式，TurnOffCommand 可以轻松地执行和撤销关闭灯的操作，而不需要直接调用接收者的具体方法。

1.5 Invoker 类

// 定义调用者类
public class Invoker
{
    private ICommand _command;

    // 设置命令
    public void SetCommand(ICommand command)
    {
        _command = command;
    }

    // 执行命令
    public void ExecuteCommand()
    {
        if (_command != null)
        {
            _command.Execute();
        }
    }

    // 撤销命令
    public void UndoCommand()
    {
        if (_command != null)
        {
            _command.Undo();
        }
    }
}

• 作用：Invoker 是调用者类，负责维护当前的命令对象，并提供执行和撤销命令的方法。它可以是一个按钮、菜单项或其他用户界面元素。
• 优点：通过命令模式，Invoker 可以轻松地执行和撤销命令，而不需要关心具体的命令实现。

1.6 Client 类（客户端代码）

class Program
{
    static void Main(string[] args)
    {
        // 创建接收者
        LightReceiver lightReceiver = new LightReceiver();

        // 创建命令对象
        ICommand turnOnCommand = new TurnOnCommand(lightReceiver);
        ICommand turnOffCommand = new TurnOffCommand(lightReceiver);

        // 创建调用者
        Invoker invoker = new Invoker();

        // 设置并执行打开灯的命令
        invoker.SetCommand(turnOnCommand);
        invoker.ExecuteCommand();  // 输出：灯已打开

        // 撤销打开灯的命令
        invoker.UndoCommand();  // 输出：灯已关闭

        // 设置并执行关闭灯的命令
        invoker.SetCommand(turnOffCommand);
        invoker.ExecuteCommand();  // 输出：灯已关闭

        // 撤销关闭灯的命令
        invoker.UndoCommand();  // 输出：灯已打开
    }
}

• 作用：Client 是使用命令模式的客户端代码。它创建了一个 LightReceiver 对象，并创建了两个命令对象（TurnOnCommand 和 TurnOffCommand）。然后，它创建了一个 Invoker 对象，并通过 SetCommand() 方法设置当前的命令对象。最后，它通过 ExecuteCommand() 和 UndoCommand() 方法来执行和撤销命令。
• 优点：通过命令模式，客户端代码可以在运行时动态地设置和执行不同的命令，而不需要修改接收者或命令的具体实现。

---

第五节：程序执行与输出

让我们运行上面的代码，看看它的输出结果。

灯已打开
灯已关闭
灯已关闭
灯已打开

代码分析：

1. 创建接收者：首先，客户端代码创建了一个 LightReceiver 对象，用于控制灯的开关操作。

2. 创建命令对象：接下来，客户端代码创建了两个命令对象：TurnOnCommand 和 TurnOffCommand。这两个命令对象分别封装了打开灯和关闭灯的操作。

3. 创建调用者：然后，客户端代码创建了一个 Invoker 对象，用于执行和撤销命令。Invoker 通过 SetCommand() 方法设置当前的命令对象。

4. 执行命令：客户端代码通过 ExecuteCommand() 方法执行当前的命令。第一次执行的是 TurnOnCommand，因此输出 “灯已打开”。

5. 撤销命令：客户端代码通过 UndoCommand() 方法撤销上一步操作。由于 TurnOnCommand 的 Undo() 方法调用了 TurnOff()，因此输出 “灯已关闭”。

6. 再次执行命令：客户端代码再次通过 ExecuteCommand() 方法执行新的命令。这次执行的是 TurnOffCommand，因此输出 “灯已关闭”。

7. 再次撤销命令：客户端代码再次通过 UndoCommand() 方法撤销上一步操作。由于 TurnOffCommand 的 Undo() 方法调用了 TurnOn()，因此输出 “灯已打开”。

幽默小贴士：

命令模式就像是“魔法遥控器”，用户可以随时发送指令，控制家中的各种设备，就像《回到未来》中的时间机器一样，轻松控制未来的家居生活！ 📺

---

示例 2：文本编辑器

除了简单的命令模式示例，我们还可以将其应用于更复杂的场景，比如文本编辑器。假设你正在开发一个文本编辑器，用户可以输入文字、删除文字、撤销上一步操作等。你可以使用命令模式来实现这些功能，确保每当用户执行某个操作时，系统会自动记录该操作，并提供撤销功能。

1. 所需的类

1.1 ITextEditorCommand 接口

// 定义文本编辑器的命令接口
public interface ITextEditorCommand
{
    void Execute();
    void Undo();
}

• 作用：ITextEditorCommand 是所有文本编辑器命令对象的公共接口，定义了所有命令对象的公共行为。无论是哪个命令，都必须实现这个接口。
• 优点：通过接口定义公共行为，可以支持多态性，允许客户端代码动态地选择不同的命令对象。

1.2 TextEditorReceiver 类

// 定义文本编辑器的接收者类
public class TextEditorReceiver
{
    private string _text = "";

    public void InsertText(string text)
    {
        _text += text;
        Console.WriteLine($"插入文本：{_text}");
    }

    public void DeleteText(int length)
    {
        if (length > 0 && _text.Length >= length)
        {
            _text = _text.Substring(0, _text.Length - length);
            Console.WriteLine($"删除文本：{_text}");
        }
    }

    public string GetText()
    {
        return _text;
    }
}

• 作用：TextEditorReceiver 是接收者类，负责执行具体的文本编辑操作。它提供了 InsertText() 和 DeleteText() 方法，用于插入和删除文本。
• 优点：通过命令模式，TextEditorReceiver 可以被多个命令对象调用，而不需要直接暴露其内部逻辑。

1.3 InsertTextCommand 类

// 实现具体的命令类：插入文本的命令
public class InsertTextCommand : ITextEditorCommand
{
    private readonly TextEditorReceiver _textEditor;
    private readonly string _text;

    public InsertTextCommand(TextEditorReceiver textEditor, string text)
    {
        _textEditor = textEditor;
        _text = text;
    }

    // 执行命令
    public void Execute()
    {
        _textEditor.InsertText(_text);
    }

    // 撤销命令
    public void Undo()
    {
        _textEditor.DeleteText(_text.Length);
    }
}

• 作用：InsertTextCommand 是实现了 ITextEditorCommand 接口的具体命令类，负责封装插入文本的操作。它会在 Execute() 方法中调用接收者的 InsertText() 方法，在 Undo() 方法中调用接收者的 DeleteText() 方法。
• 优点：通过命令模式，InsertTextCommand 可以轻松地执行和撤销插入文本的操作，而不需要直接调用接收者的具体方法。

1.4 DeleteTextCommand 类

// 实现具体的命令类：删除文本的命令
public class DeleteTextCommand : ITextEditorCommand
{
    private readonly TextEditorReceiver _textEditor;
    private readonly int _length;
    private string _deletedText;

    public DeleteTextCommand(TextEditorReceiver textEditor, int length)
    {
        _textEditor = textEditor;
        _length = length;
    }

    // 执行命令
    public void Execute()
    {
        _deletedText = _textEditor.GetText().Substring(_textEditor.GetText().Length - _length, _length);
        _textEditor.DeleteText(_length);
    }

    // 撤销命令
    public void Undo()
    {
        _textEditor.InsertText(_deletedText);
    }
}

• 作用：DeleteTextCommand 是实现了 ITextEditorCommand 接口的具体命令类，负责封装删除文本的操作。它会在 Execute() 方法中调用接收者的 DeleteText() 方法，在 Undo() 方法中调用接收者的 InsertText() 方法。
• 优点：通过命令模式，DeleteTextCommand 可以轻松地执行和撤销删除文本的操作，而不需要直接调用接收者的具体方法。

1.5 TextEditorInvoker 类

// 定义文本编辑器的调用者类
public class TextEditorInvoker
{
    private ITextEditorCommand _command;

    // 设置命令
    public void SetCommand(ITextEditorCommand command)
    {
        _command = command;
    }

    // 执行命令
    public void ExecuteCommand()
    {
        if (_command != null)
        {
            _command.Execute();
        }
    }

    // 撤销命令
    public void UndoCommand()
    {
        if (_command != null)
        {
            _command.Undo();
        }
    }
}

• 作用：TextEditorInvoker 是调用者类，负责维护当前的命令对象，并提供执行和撤销命令的方法。它可以是一个按钮、菜单项或其他用户界面元素。
• 优点：通过命令模式，TextEditorInvoker 可以轻松地执行和撤销命令，而不需要关心具体的命令实现。

1.6 Client 类（客户端代码）

class Program
{
    static void Main(string[] args)
    {
        // 创建接收者
        TextEditorReceiver textEditor = new TextEditorReceiver();

        // 创建命令对象
        ITextEditorCommand insertCommand = new InsertTextCommand(textEditor, "Hello, World!");
        ITextEditorCommand deleteCommand = new DeleteTextCommand(textEditor, 13);

        // 创建调用者
        TextEditorInvoker invoker = new TextEditorInvoker();

        // 设置并执行插入文本的命令
        invoker.SetCommand(insertCommand);
        invoker.ExecuteCommand();  // 输出：插入文本：Hello, World!

        // 撤销插入文本的命令
        invoker.UndoCommand();  // 输出：删除文本：

        // 设置并执行删除文本的命令
        invoker.SetCommand(deleteCommand);
        invoker.ExecuteCommand();  // 输出：删除文本：

        // 撤销删除文本的命令
        invoker.UndoCommand();  // 输出：插入文本：Hello, World!
    }
}

• 作用：Client 是使用命令模式的客户端代码。它创建了一个 TextEditorReceiver 对象，并创建了两个命令对象（InsertTextCommand 和 DeleteTextCommand）。然后，它创建了一个 TextEditorInvoker 对象，并通过 SetCommand() 方法设置当前的命令对象。最后，它通过 ExecuteCommand() 和 UndoCommand() 方法来执行和撤销命令。
• 优点：通过命令模式，客户端代码可以在运行时动态地设置和执行不同的命令，而不需要修改接收者或命令的具体实现。

输出结果：

插入文本：Hello, World!
删除文本：
删除文本：
插入文本：Hello, World!

代码分析：

1. 创建接收者：首先，客户端代码创建了一个 TextEditorReceiver 对象，用于执行文本编辑操作。

2. 创建命令对象：接下来，客户端代码创建了两个命令对象：InsertTextCommand 和 DeleteTextCommand。这两个命令对象分别封装了插入文本和删除文本的操作。

3. 创建调用者：然后，客户端代码创建了一个 TextEditorInvoker 对象，用于执行和撤销命令。Invoker 通过 SetCommand() 方法设置当前的命令对象。

4. 执行命令：客户端代码通过 ExecuteCommand() 方法执行当前的命令。第一次执行的是 InsertTextCommand，因此输出 “插入文本：Hello, World!”。

5. 撤销命令：客户端代码通过 UndoCommand() 方法撤销上一步操作。由于 InsertTextCommand 的 Undo() 方法调用了 DeleteText()，因此输出 “删除文本：”。

6. 再次执行命令：客户端代码再次通过 ExecuteCommand() 方法执行新的命令。这次执行的是 DeleteTextCommand，因此输出 “删除文本：”。

7. 再次撤销命令：客户端代码再次通过 UndoCommand() 方法撤销上一步操作。由于 DeleteTextCommand 的 Undo() 方法调用了 InsertText()，因此输出 “插入文本：Hello, World!”。

幽默小贴士：

文本编辑器中的命令模式就像是“魔法橡皮擦”，用户可以随时撤销或重做任何操作，就像《哈利·波特》中的魔法橡皮擦一样，轻松擦除或恢复任何错误！ ✍️

---

第六节：注意事项

虽然命令模式非常强大且灵活，但在使用时也有一些需要注意的地方。为了避免潜在的问题，并确保代码的可维护性和性能，以下是几个关键点：

1. 避免过多的命令对象

• 问题：如果系统中有大量的命令对象，可能会导致内存占用过高，尤其是在长时间运行的应用程序中，未释放的命令对象会一直占用内存，最终导致系统性能下降。

• 解决方案：考虑是否可以复用命令对象，或者在不再需要命令对象时，及时将其释放。例如，可以使用对象池技术来管理命令对象的生命周期，或者在命令执行完毕后，立即将其置为 null，以便垃圾回收机制能够及时回收。

幽默小贴士：

命令模式不应该像《哈利·波特》中的魔法书一样，永远占用你的书架。确保在不再需要命令对象时，及时将其释放，就像整理书架一样，保持系统的整洁和高效！ 📚

2. 处理命令的依赖关系

• 问题：某些命令可能依赖于其他命令的执行结果，或者需要与其他命令协同工作。如果这些依赖关系没有处理好，可能会导致命令执行失败或产生意外的结果。

• 解决方案：确保每个命令对象都独立封装了完整的操作逻辑，尽量减少命令之间的依赖关系。如果确实需要依赖其他命令，可以考虑使用组合模式或状态模式来管理这些依赖关系。

幽默小贴士：

命令模式不应该像《爱丽丝梦游仙境》中的迷宫一样，充满了复杂的关系和依赖。确保每个命令对象都独立封装了完整的操作逻辑，就像遵守交通规则一样，避免事故的发生！ 🕰️

3. 处理命令的撤销操作

• 问题：某些命令可能无法简单地通过调用 Undo() 方法来撤销。例如，某些操作可能是不可逆的，或者撤销操作可能会引发副作用。

• 解决方案：在设计命令对象时，确保每个命令都有明确的撤销逻辑。对于不可逆的操作，可以考虑记录操作的历史记录，或者提供其他方式来恢复系统状态。此外，可以在命令对象中添加一些检查机制，防止撤销操作引发意外的结果。

幽默小贴士：

命令模式不应该像《回到未来》中的时间旅行一样，陷入无限循环。确保每个命令都有明确的撤销逻辑，就像遵守交通规则一样，避免事故的发生！ ⏳

4. 处理命令的参数传递

• 问题：某些命令可能需要传递多个参数，或者参数的类型比较复杂。如果参数传递不当，可能会导致命令执行失败或产生意外的结果。

• 解决方案：在设计命令对象时，确保每个命令的参数传递是安全的。可以考虑使用构造函数或属性来传递参数，或者使用命令工厂模式来创建命令对象。此外，可以在命令对象中添加一些验证机制，确保传递的参数是有效的。

幽默小贴士：

命令模式不应该像《哈利·波特》中的魔法咒语一样，随意传递参数。确保每个命令的参数传递是安全的，就像遵守魔法咒语的规则一样，避免意外的发生！ 🪄

---

本章总结

在这章中，我们学习了 命令模式 的基本概念、应用场景、实现方法以及注意事项。命令模式允许你将请求封装成对象，从而实现请求的参数化、队列化和可撤销操作等功能。它在以下场景中有着重要的应用：

• 文本编辑器：如撤销和重做功能，用户可以随时撤销或重做任何操作。
• 智能家居控制系统：如控制灯光、空调、电视等设备，用户可以随时发送指令，控制家中的各种设备。
• 游戏开发：如玩家可以执行各种动作，如移动、攻击、使用道具等，用户可以随时撤销或重做任何操作。

关键点回顾：

• 命令模式：允许你将请求封装成对象，从而实现请求的参数化、队列化和可撤销操作等功能。客户端代码可以在运行时动态地设置和执行不同的命令，而不需要修改接收者或命令的具体实现。
• 分离关注点：通过命令模式，你可以将发起请求的对象与执行请求的对象解耦，使得系统更加灵活和可扩展。你可以轻松地添加新的命令，而不需要修改接收者的代码。
• 简化客户端代码：通过命令模式，客户端代码可以非常简洁地管理多个命令，而不需要手动调用每个命令的具体方法。
• 避免过多的命令对象：确保在不再需要命令对象时，及时将其释放，避免内存泄漏。
• 处理命令的依赖关系：确保每个命令对象都独立封装了完整的操作逻辑，尽量减少命令之间的依赖关系。
• 处理命令的撤销操作：确保每个命令都有明确的撤销逻辑，对于不可逆的操作，可以考虑记录操作的历史记录，或者提供其他方式来恢复系统状态。
• 处理命令的参数传递：确保每个命令的参数传递是安全的，避免传递无效或不安全的参数。

幽默小贴士：

命令模式就像是“魔法遥控器”，用户可以随时发送指令，控制家中的各种设备，就像《回到未来》中的时间机器一样，轻松控制未来的家居生活！ 📺

---

结束语

亲爱的学员们，恭喜你完成了 C# 设计模式 的第十六章！通过学习命令模式，你已经掌握了如何将请求封装成对象，从而实现请求的参数化、队列化和可撤销操作等功能。