23种设计模式之《备忘录模式（Memento）》在c#中的应用及理解

程序设计中的主要设计模式通常分为三大类，共23种：

1. 创建型模式（Creational Patterns）

单例模式（Singleton）：确保一个类只有一个实例，并提供全局访问点。
工厂方法模式（Factory Method）：定义创建对象的接口，由子类决定实例化哪个类。
抽象工厂模式（Abstract Factory）：提供一个创建一系列相关或依赖对象的接口，而无需指定具体类。
建造者模式（Builder）：将一个复杂对象的构建与其表示分离，使同样的构建过程可以创建不同的表示。
原型模式（Prototype）：通过复制现有对象来创建新对象。

2. 结构型模式（Structural Patterns）

适配器模式（Adapter）：将一个类的接口转换成客户希望的另一个接口。
桥接模式（Bridge）：将抽象部分与实现部分分离，使它们可以独立变化。
组合模式（Composite）：将对象组合成树形结构以表示"部分-整体"的层次结构。
装饰器模式（Decorator）：动态地给对象添加职责，相比生成子类更为灵活。
外观模式（Facade）：为子系统中的一组接口提供一个统一的接口。
享元模式（Flyweight）：通过共享技术有效地支持大量细粒度对象。
代理模式（Proxy）：为其他对象提供一种代理以控制对这个对象的访问。

3. 行为型模式（Behavioral Patterns）

责任链模式（Chain of Responsibility）：使多个对象都有机会处理请求，从而避免请求的发送者与接收者耦合。
命令模式（Command）：将请求封装为对象，使你可以用不同的请求对客户进行参数化。
解释器模式（Interpreter）：给定一个语言，定义其文法的一种表示，并定义一个解释器。
迭代器模式（Iterator）：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部表示。
中介者模式（Mediator）：定义一个中介对象来封装一系列对象之间的交互。
备忘录模式（Memento）：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
观察者模式（Observer）：定义对象间的一对多依赖关系，当一个对象改变状态时，所有依赖者都会收到通知并自动更新。
状态模式（State）：允许对象在其内部状态改变时改变其行为。
策略模式（Strategy）：定义一系列算法，将它们封装起来，并使它们可以互相替换。
模板方法模式（Template Method）：定义一个操作中的算法骨架，将一些步骤延迟到子类中。
访问者模式（Visitor）：表示一个作用于某对象结构中的各元素的操作，使你可以在不改变各元素类的前提下定义作用于这些元素的新操作。

4.备忘录模式（Memento）解释

备忘录模式（Memento Pattern）是一种行为设计模式，它允许在不破坏封装性的情况下，捕获并外部化一个对象的内部状态，以便以后可以将该对象恢复到之前的状态。备忘录模式通常用于实现撤销操作或保存对象的历史状态。

备忘录模式的核心思想是将对象的状态保存在一个独立的备忘录对象中，而不是直接暴露对象的内部状态。这样，对象可以在需要时恢复到之前的状态，而不需要暴露其内部实现细节。

备忘录模式通常涉及以下三个角色：

Originator（发起人）：负责创建备忘录对象，并使用备忘录对象恢复其内部状态。
Memento（备忘录）：存储发起人对象的内部状态。
Caretaker（管理者）：负责保存备忘录对象，并在需要时将备忘录对象返回给发起人以恢复状态。

5.C# 备忘录模式演示代码

复制代码

csharp

复制代码

using System;
using System.Collections.Generic;

// Memento类：存储Originator的内部状态
class Memento
{
    public string State { get; private set; }

    public Memento(string state)
    {
        State = state;
    }
}

// Originator类：负责创建备忘录对象，并使用备忘录对象恢复其内部状态
class Originator
{
    private string _state;

    public string State
    {
        get { return _state; }
        set
        {
            _state = value;
            Console.WriteLine("State set to: " + _state);
        }
    }

    // 创建备忘录对象
    public Memento CreateMemento()
    {
        return new Memento(_state);
    }

    // 使用备忘录对象恢复状态
    public void SetMemento(Memento memento)
    {
        State = memento.State;
    }
}

// Caretaker类：负责保存备忘录对象
class Caretaker
{
    private List<Memento> _mementos = new List<Memento>();

    public void AddMemento(Memento memento)
    {
        _mementos.Add(memento);
    }

    public Memento GetMemento(int index)
    {
        return _mementos[index];
    }
}

// 客户端代码
class Program
{
    static void Main(string[] args)
    {
        Originator originator = new Originator();
        Caretaker caretaker = new Caretaker();

        // 设置初始状态并保存
        originator.State = "State #1";
        caretaker.AddMemento(originator.CreateMemento());

        // 更改状态并保存
        originator.State = "State #2";
        caretaker.AddMemento(originator.CreateMemento());

        // 更改状态并保存
        originator.State = "State #3";
        caretaker.AddMemento(originator.CreateMemento());

        // 恢复到第一个保存的状态
        originator.SetMemento(caretaker.GetMemento(0));
        Console.WriteLine("Restored to: " + originator.State);

        // 恢复到第二个保存的状态
        originator.SetMemento(caretaker.GetMemento(1));
        Console.WriteLine("Restored to: " + originator.State);
    }
}

6.代码说明

Memento类 ：这是一个简单的类，用于存储Originator对象的内部状态。它只有一个属性State，表示Originator的状态。
Originator类 ：这是需要保存和恢复状态的对象。它有一个State属性，表示当前状态。CreateMemento方法用于创建一个Memento对象，保存当前状态。SetMemento方法用于从Memento对象中恢复状态。
Caretaker类 ：这是负责保存Memento对象的类。它有一个List<Memento>来存储多个状态。AddMemento方法用于添加Memento对象，GetMemento方法用于获取指定索引的Memento对象。
客户端代码 ：在Main方法中，我们创建了一个Originator对象和一个Caretaker对象。我们通过设置Originator的状态并保存到Caretaker中，然后通过Caretaker恢复到之前保存的状态。

7.运行结果

复制代码

State set to: State #1
State set to: State #2
State set to: State #3
Restored to: State #1
Restored to: State #2

8.总结

备忘录模式通过将对象的状态保存在独立的备忘录对象中，实现了对象状态的保存和恢复，而不需要暴露对象的内部实现细节。这种模式非常适合需要实现撤销操作或保存对象历史状态的场景。