备忘录模式

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

 

游戏存进度

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

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();

结果显示

备忘录模式_第1张图片

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

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

 

备忘录模式

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

备忘录模式_第2张图片

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信息还原到前一状态

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

 

游戏进度备忘

备忘录模式_第3张图片

游戏角色类

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();

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

 

你可能感兴趣的:(设计模式)