设计模式笔记（十三） —— 备忘录模式

备忘录模式(Memento):在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个对象。这样以后就可将该对象恢复到原先保存的状态。
    使用场合：备忘录模式比较适用于功能比较复杂的，但需要维护或记录属性历史的类，或者需要保存的属性只是众多属性的一小部分时，Originator可以根据保存的Memento信息还原到前一状态。 

1. using System;
3. /**
4.  * 备忘录模式(Memento):在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个对象。这样以后就可将该对象恢复到原先保存的状态。
5.  * 使用场合：备忘录模式比较适用于功能比较复杂的，但需要维护或记录属性历史的类，或者需要保存的属性只是众多属性的一小部分时，Originator可以根据保存的Memento信息还原到前一状态。
6.  */
7. namespace StuDesignMode.Memento
8. {
9.     #region 备忘录模式
11.     //发起人
12.     //class Originator
13.     //{
14.     //    public string State { get; set; }
16.     //    public Memento CreateMemento()
17.     //    {
18.     //        return new Memento(this.State);            
19.     //    }
21.     //    public void Show()
22.     //    {
23.     //        Console.WriteLine("当前状态：{0}",this.State);
24.     //    }
26.     //    public void SetMemento(Memento m)
27.     //    {
28.     //        this.State = m.State;
29.     //    }
30.     //}
32.     备忘录类
33.     //class Memento
34.     //{ 
35.     //    private string _state;
36.     //    public string State 
37.     //    {
38.     //        get { return this._state; }
39.     //    }
41.     //    public Memento(string state)
42.     //    {
43.     //        this._state = state;
44.     //    }
45.     //}
47.     管理者类
48.     //class Caretaker
49.     //{
50.     //    public Memento Memento { get; set; }    
51.     //}
53.     //class ClientTest
54.     //{
55.     //     static void Main(string[] args)
56.     //     {
57.     //        Originator o = new Originator();
59.     //         o.State = "ON";
60.     //         o.Show();
62.     //         Caretaker c = new Caretaker();
63.     //         c.Memento = o.CreateMemento();
65.     //         o.State = "OFF";
66.     //         o.Show();
68.     //         o.SetMemento(c.Memento);
69.     //         o.Show();
70.     //     }
71.     //}
72.     #endregion
74.     #region 示例代码
76.     ///<summary>游戏角色</summary>
77.     class GameRole
78.     {
79.         ///<summary>生命力</summary>
80.         public int Vitaliy { get; set; }
81.         ///<summary>攻击力</summary>
82.         public int Attack { get; set; }
83.         ///<summary>防御力</summary>
84.         public int Defense { get; set; }
86.         ///<summary>存档</summary>
87.         public RoleStateMemento SaveState()
88.         {
89.             return new RoleStateMemento(this.Vitaliy, this.Attack, this.Defense);
90.         }
92.         ///<summary>角色状态初始化</summary>
93.         public void RoleInitState()
94.         {
95.             this.Vitaliy = 1000;
96.             this.Attack = 500;
97.             this.Defense = 200;
98.         }
100.         ///<summary>战斗</summary>
101.         public void Fight()
102.         {
103.             this.Attack = 0;
104.             this.Defense = 0;
105.             this.Vitaliy = 0;
106.         }
108.         ///<summary>读档</summary>
109.         public void RecoveryState(RoleStateMemento roleState)
110.         {
111.             this.Attack = roleState.Attack;
112.             this.Defense = roleState.Defense;
113.             this.Vitaliy = roleState.Vitaliy;
114.         }
115.         public void Show()
116.         {
117.             Console.WriteLine("======角色状态=========");
118.             Console.WriteLine("生命力：{0}",this.Vitaliy);
119.             Console.WriteLine("攻击力：{0}", this.Attack);
120.             Console.WriteLine("防御力：{0}", this.Defense);
121.             Console.WriteLine("====================/n");
122.         }
123.     }
125.     ///<summary>角色状态存档</summary>
126.     class RoleStateMemento
127.     {
128.         ///<summary>生命力</summary>
129.         public int Vitaliy  { get; set; }
130.         ///<summary>攻击力</summary>
131.         public int Attack { get; set; }
132.         ///<summary>防御力</summary>
133.         public int Defense { get; set; }
135.         public RoleStateMemento(int vit, int ack, int def)
136.         {
137.             this.Vitaliy = vit;
138.             this.Attack = ack;
139.             this.Defense = def;
140.         }
141.     }
143.     /// <summary>
144.     /// 存档管理者
145.     /// </summary>
146.     class GameStateCaretaker
147.     {
148.         public RoleStateMemento RoleStateSaved { get; set; }
149.     }
151.     class ClientTest
152.     {
153.         static void Main(string[] args)
154.         {
155.             //初始状态
156.             GameRole lixiaoyao = new GameRole();
157.             lixiaoyao.RoleInitState();
158.             Console.WriteLine("李逍遥生死点时状态：");
159.             lixiaoyao.Show();
161.             //存档
162.             GameStateCaretaker gsc = new GameStateCaretaker();
163.             gsc.RoleStateSaved = lixiaoyao.SaveState();
165.             Console.WriteLine("李逍遥大战Boss后状态：");
166.             //大战Boss,死亡
167.             lixiaoyao.Fight();
168.             lixiaoyao.Show();
170.             Console.WriteLine("李逍遥读档后状态：");
171.             //读档重来
172.             lixiaoyao.RecoveryState(gsc.RoleStateSaved);
173.             lixiaoyao.Show();
175.         }
176.     }
178.     #endregion
179. }