C#设计模式之 --备忘录模式

备忘录模式(Memento):

Memento（备忘录模式）:
再不破环封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象回复到原先保存的状态。

结构图：

Originator （发起人）：负责创建一个备忘录 Memento，用于记录当前时刻它的内部状态，并可以使用备忘录恢复状态。Originator 可以根据需求决定 Memento 存储 Originator 的那些内部状态。
Memento （备忘录）：负责存储 Originator 对象的内部状态。并可防止 Originator 以外的其他对象访问 Memento 。备忘录又两个接口，Caretaker 只能看到备忘录的窄接口，它只能给备忘录传递其他对象。Originator 能看到一个宽接口，允许它访问返回到先前状态所需要的所有数据。
Caretaker （管理者）：负责保存好备忘录 Memento，不能对备忘录的 内容 进行操作和检查。

代码演示：

Memento：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 备忘录模式
{
    /// <summary>
    /// 备忘录 类：负责存储 Originato(发起人)对象的内部状态，并可防止 Originato以外的对象访问备忘录
    ///  Memento 。备忘录有两个接口， Caretaker 只能看到备忘录的窄接口，它只能将备忘录传递给其它对象。
    ///  Originato 能看到一个宽接口，允许他访问返回到先前状态所需的所有数据。 
    /// </summary>
    class Memento
    {
        private string state;

        /// <summary>
        /// 构造函数，将相关数据导入
        /// </summary>
        /// <param name="s"></param>
        public Memento(string s)
        {
            this.state = s;
        }
        
        /// <summary>
        /// 需要保存的数据属性，可以是多个
        /// </summary>
        public string State { get => state; }
    }
}

Originator：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 备忘录模式
{
    /// <summary>
    /// 发起人：负责创建一个备忘录 Memento，用于记录当前时刻他的内部状态，并可以使用备忘录恢复状态。
    ///    Originator可以根据需要决定  Memento 存储 Originator 的那些内部状态。
    /// </summary>
    class Originator
    {
        /// <summary>
        /// 需要保存的属性，可能有多个
        /// </summary>
        public  string State { get; set; }

        /// <summary>
        /// 创建备忘录，将当前需要保存的信息导入并实例化出一个 Memento 对象。
        /// </summary>
        /// <returns></returns>
        public Memento CreateMemento()
        {
            return new Memento(State);
        }

        /// <summary>
        /// 恢复备忘录，将Memento相关的数据导入恢复数据
        /// </summary>
        /// <param name="memento"></param>
        public void SetMemento(Memento memento)
        {
            this.State = memento.State;
        }

        /// <summary>
        /// 显示数据
        /// </summary>
        public void Show()
        {
            Console.WriteLine($"State= {this.State}。");
        }
    }
}

Caretaker：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 备忘录模式
{
    /// <summary>
    /// 管理者类：负责保存好备忘录 Memento ,不能对备忘录的内容进行操作和检查。
    /// </summary>
    class Caretaker
    {
        public Memento Memento { get; set; }
    }
}

客户端调用：

 static void Main(string[] args)
        {
            Originator originator = new Originator();
            originator.State = "on";//初始状态为 on

            //保存状态：由于有了很好的封装，可以隐藏Originator的实现细节。
            Caretaker caretaker = new Caretaker();
            caretaker.Memento = originator.CreateMemento();

            //改变状态
            originator.State = "off";
            originator.Show();

            //恢复状态
            originator.SetMemento(caretaker.Memento);
            originator.Show();



            Console.ReadKey();

        }

说明：

1. 把要保存的细节封装在了 Memento 中，那一天需要更改保存细节也不影响客户端。
2. Memento 模式较适用于功能比较复杂的，但需要维护和记录历史属性的的类，或者需要保存的属性只是众多属性中的一小部分时，Originator 可以根据保存的 Memento 信息还原到前一状态。
3. 如果在某个系统中使用了命令模式时，需要实现命令的撤销功能，那么命令模式可以使用备忘录模式来存储可以撤销操作的状态。有时候，一些对象的内部信息必须保存在 对象意外的地方，但是必须要有对象自己读取，这时，使用备忘录模式可以把复杂的对象内部信息对其他对象屏蔽起来，从而，可以恰当的保持封装的 边界。
4. 最大作用时 ，当对象状态改变的时候，有可能这个 状态无效，这时候就可以使用暂时存储起来的备忘录将状态复原。