备忘录模式

内容摘录自《大话设计模式》

 

游戏存进度

游戏角色类，用来存储角色的生命力、攻击力、防御力的数据

public class GameRole
{
    // 生命力
    private int vit;
    public int Vit {
        get { return vit; } set { vit = value; }
    }
    // 攻击力
    private int atk;
    public int Attack
    {
        get { return atk; }
        set { atk = value; }
    }
    // 防御力
    private int def;
    public int Defense
    {
        get { return def; }
        set { def = value; }
    }
    // 状态显示
    public void StateDisplay()
    {
        Debug.Log("角色当前状态：");
        Debug.Log(string.Format("体力：{0}", vit));
        Debug.Log(string.Format("攻击力：{0}", atk));
        Debug.Log(string.Format("防御力：{0}", def));
    }
    // 获得初始状态
    public void GetInitState()
    {
        vit = 100;
        atk = 100;
        def = 100;
    }
    // 战斗，与boss大战后的数据
    public void Fight()
    {
        vit = 0;
        atk = 0;
        def = 0;
    }
}

客户端调用

        // 大战Boss前
        GameRole role = new GameRole();
        role.GetInitState();
        role.StateDisplay();

        // 保存进度
        GameRole backupRole = new GameRole();
        backupRole.Vit = role.Vit;
        backupRole.Attack = role.Attack;
        backupRole.Defense = role.Defense;

        // 大战boss后，损耗严重
        role.Fight();
        role.StateDisplay();

        // 恢复之前的状态
        role.Vit = backupRole.Vit;
        role.Attack = backupRole.Attack;
        role.Defense = backupRole.Defense;
        role.StateDisplay();

结果显示

保存和恢复的代码把整个游戏角色的细节暴露给了客户端，客户端的职责就太大了，需要知道游戏角色的生命力、攻击力、防御力这些细节，还要对它进行备份。以后需要增加新的数据，例如增加‘魔法力’或修改现有的某个属性，这部分就一定要修改了。

显然，我们希望把这些‘游戏角色’的存取状态细节封装起来，而且最好是封装在外部的类当中。以体现职责分离。

 

备忘录模式

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

Originator（发起人）：负责创建一个备忘录Memento，用以记录当前时刻它的内部状态，并可使用备忘录恢复内部状态。Originator可以根据需要决定备忘录存储Originator的哪些内部状态。

Memento（备忘录）：负责存储Originator对象的内部状态，并可防止Originator以外的其它对象访问备忘录Memento。备忘录有两个接口，Caretaker只能看到备忘录的窄接口，它只能将备忘录传递给其他对象。Originator能够看到一个宽接口，允许它访问返回到先前状态所需的所有数据。

Caretaker（管理者）：负责保存好备忘录Memento，不能对备忘录的内容进行操作或检查。

就刚才的例子，‘游戏角色’类就是一个Originator，而你用了同样的‘游戏角色’实例‘备份’来做备忘录，这仔当需要保存全部信息时，是可以考虑的，而用clone的方式来实现Memento的状态保存可能是更好的办法，但是如果是这样的话，使得我们相当于对上层应用开发了Originator的全部（public）接口。

很多情况下，我们需要保存的并不是全部信息，那么久应该有一个独立的备忘录类Memento，它只拥有需要保存的信息的属性。

 

备忘录模式基本代码

发起人（Originator）类

class Originator
{
    private string state;   // 需要保存的属性，可能有多个
    public string State
    {
        get { return state; }
        set { state = value; }
    }
    public Memento CreateMemento()  // 创建备忘录，将当前需要保存的信息导入并实例化一个Memento对象
    {
        return (new Memento(state));
    }
    public void SetMemento(Memento memento) // 恢复备忘录，将Memento导入并将相关数据恢复
    {
        state = memento.State;
    }
    public void Show()
    {
        Debug.Log("State=" + state);
    }
}

备忘录（Memento）类

class Memento
{
    private string state;   // 需要保存的属性，可能有多个
    public string State
    {
        get { return state; }
        set { state = value; }
    }

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

管理者（Caretaker）类

class Caretaker
{
    private Memento memento;
    public Memento Memento
    {
        get { return memento; }
        set { memento = value; }
    }
}

客户端程序

        Originator o = new Originator();    // Originator初始状态，状态属性为“On”
        o.State = "On";
        o.Show();

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

        o.State = "Off";    // Originator改变了状态属性
        o.Show();

        o.SetMemento(c.Memento);    // 恢复原初始状态
        o.Show();

把要保存的细节封装在Memento中，这样即使要更改保存的细节也不用影响客户端了。

Memento模式比较适用于功能比较复杂的，但需要维护或记录历史属性的类，或者需要保存的属性只是众多属性中的一小部分时，Originator可以根据保存的Memento信息还原到前一状态。

当角色的状态改变的时候，有可能这个状态无效，这时候就可以使用暂时存储起来的备忘录将状态复原。

 

游戏进度备忘

游戏角色类

public class GameRole
{

    ..........

    // 保存角色状态，新增
    public RoleStateMemento SaveState()
    {
        return (new RoleStateMemento(vit, atk, def));
    }

    // 恢复角色状态，新增
    public void RecoveryState(RoleStateMemento memento)
    {
        vit = memento.Vit;
        atk = memento.Attack;
        def = memento.Defense;
    }
    ..........

}

角色状态存储箱

// 角色状态存储箱
public class RoleStateMemento
{
    // 生命力
    private int vit;
    public int Vit
    {
        get { return vit; }
        set { vit = value; }
    }
    // 攻击力
    private int atk;
    public int Attack
    {
        get { return atk; }
        set { atk = value; }
    }
    // 防御力
    private int def;
    public int Defense
    {
        get { return def; }
        set { def = value; }
    }

    public RoleStateMemento(int _vit, int _atk, int _def)   // 将生命力、攻击力、防御力存入状态存储箱对象中
    {
        vit = _vit;
        atk = _atk;
        def = _def;
    }
}

角色状态管理者类

// 角色状态管理者类
class RoleStateCaretaker
{
    private RoleStateMemento memento;
    public RoleStateMemento Memento
    {
        get { return memento; }
        set { memento = value; }
    }
}

客户端代码

        // 大战Boss前
        GameRole role = new GameRole();
        role.GetInitState();
        role.StateDisplay();

        // 保存进度
        RoleStateCaretaker caretaker = new RoleStateCaretaker();
        caretaker.Memento = role.SaveState();

        // 大战boss后，损耗严重,GameOver了
        role.Fight();
        role.StateDisplay();

        // 恢复之前的状态，重新来过
        role.RecoveryState(caretaker.Memento);
        role.StateDisplay();

备忘录模式缺点：角色状态需要完整存储到备忘录对象中，如果状态数据很大很多，备忘录对象会非常耗内存。