C#学习笔记-原型模式

题目：编写基本的简历。

实现：

创建基本的Resume类，然后主函数通过实例化Resume来写简历即可。

Resume类：

 class Resume
         {
             private string name;
             private string sex;
             private string age;
             private string timeArea;
             private string company;

             public Resume(string name)
             {
                 this.name = name;
             }

             //设置个人信息
             public void  SetPersonalInfo(string sex,string age)
             {
                 this.age = age;
                 this.sex = sex;
             }

             public void SetWorkExperience(string timeArea,string company)
             {
                 this.timeArea = timeArea;
                 this.company = company;
             }

             public void Show()
             {
                 Console.WriteLine("{0}  {1}  {2} ", name, sex, age);
                 Console.WriteLine("工作经历：{0}  {1} ", timeArea, company);
             }
         }

主函数：

 static void Main(string[] args)
         {
             //每写一份简历就实例化一次Resume,写一百分相同的简历也要实例化一百次
             //且如果写错了一个词就得修改同样次数的简历
             Resume a = new Resume("Taylor");
             a.SetPersonalInfo("女", "");
             a.SetWorkExperience("1999-2008", "QWE");
             a.Show();

             Resume b = new Resume("Selena");
             b.SetPersonalInfo("女", "");
             b.SetWorkExperience("1999-2008", "MNB");
             b.Show();

             //Console.Read();

             //这是传引用，而不是传值，这样如同在c1和b1的纸张上写着：简历在a1处，并没有实际的内容
             Resume a1 = new Resume("Taylor");
             a1.SetPersonalInfo("女", "");
             a1.SetWorkExperience("1999-2008", "QWE");
             a1.Show();

             Resume b1 = a1;
             Resume c1 = a1;

             b1.Show();
             c1.Show();

             Console.Read();
         }

题目延伸1：如果我们现在批量打印简历，如果用上面的方法就得每写一份简历都得实例化一次，且如果简历的某种信息输入错误，那么我们就得修改同样次数的简历，这就使工作量变得巨大了。

解析：

这时我们就需要引进原型模式（Prototype）

原型模式（Prototype）,用原型实例指定创建对象的种类，并且 通过拷贝这些原型创建新的对象。

原型模式的范例：（这个例子是书上看来的，敲完了，看完了，还是理解的不是特别清楚，我的理解还是比较适合实例一点，这个真的看得无力......）

 class Program
     {
         static void Main(string[] args)
         {
             ConcretePrototypel p1 = new ConcretePrototypel("I");
             ConcretePrototypel c1 = (ConcretePrototypel)p1.Clone();
             Console.WriteLine("Cloned: {0}", c1.Id);

             ConcretePrototypel2 p2 = new ConcretePrototypel2("II");
             ConcretePrototypel2 c2 = (ConcretePrototypel2)p2.Clone();
             Console.WriteLine("Cloned: {0}", c2.Id);

             // Wait for user
             Console.Read();

         }
     }

     //原型模式其实就是从一个对象再创建另外一个可定制的对象，而且不需要知道任何创建的细节。
     abstract class Prototype
     {
         private string id;

         public Prototype(string id)
         {
             this.id = id;
         }

         public string Id
         {
             get
             {
                 return id;
             }
         }

         public abstract Prototype Clone();
     }

     class ConcretePrototypel:Prototype
     {
         public ConcretePrototypel(string id):base(id)
         {
         }

         public override Prototype Clone()
         {
             //创建当前对象的浅表副本。方法是创建一个新对象，然后将当前对象的
             //非静态字段复制到该新对象。如果字段是值类型的，则对该字段执行逐位复制。
             //如果字段是引用类型，则复制引用但不复制引用的对象。
             //因此，原始对象及副本引用同一对象。
             return (Prototype)this.MemberwiseClone();
         }
     }

     class ConcretePrototypel2 : Prototype
     {
         public ConcretePrototypel2(string id) : base(id)
         {
         }

         public override Prototype Clone()
         {
             //
             // 摘要:
             //     创建当前 System.Object 的浅表副本。
             //
             // 返回结果:
             //     当前 System.Object 的浅表副本。
             return (Prototype)this.MemberwiseClone();
         }
     }

实现：

Resume类：

class Resume
        {
            private string name;
            private string sex;
            private string age;
            private string timeArea;
            private string company;

            public  Resume(string name)
            {
                this.name = name;
            }

            public void SetPersonalInfo(string sex,string age)
            {
                this.sex = sex;
                this.age = age;
            }

            public void SetWorkExperience(string timeArea,string company)
            {
                this.timeArea = timeArea;
                this.company = company;
            }

            public void Display()
            {
                Console.WriteLine("{0}  {1}   {2}", name, sex, age);
                Console.WriteLine("工作经历:{0}   {1}", timeArea, company);
            }

            public object Clone()
            {
                /**
                 * MemberwiseClone()方法：
                 * 如果字段是值类型，则对该字段执行逐位复制，
                 * 如果字段是引用类型，则复制引用但不复制引用的对象
                 * 因此，原始对象及其复本引用同一对象
                 *
                 * 换句话就是，
                 * 如果Resume中有对象引用，那么引用的对象数据是不会被克隆过来的
                 */
                return (object)this.MemberwiseClone();
            }
        }

主函数：

 static void Main(string[] args)
         {
             /**一般在初始化的信息不发生变化的情况下，
              * 克隆是最好的办法
              * 这既隐藏了对象创建的细节，又对性能是大大的提高
              *
              * 不用重新初始化对象，而是动态地获取对象运行时的状态
              */
             Resume a = new Resume("taylor");
             a.SetPersonalInfo("女", "");
             a.SetWorkExperience("1999-2008", "YUT");

             Resume b = (Resume)a.Clone();
             b.SetWorkExperience("1998-2006", "RTE");

             Resume c = (Resume)a.Clone();
             c.SetPersonalInfo("男", "");

             a.Display();
             b.Display();
             c.Display();

             Console.Read();
         }

题目延伸2：如果在简历中设置一个“工作经历”类，其中包括“时间区间”和“公司名称”等属性，简历直接调用这个对象即可。

解析：

如果按照正常的方式书写就会发现，中途如果修改了工作经历的信息，那么所有的简历工作经历都变成了最后一次修改的信息。

对于工作经历里的参数而言，他们属于静态的参数值，故此他们的最后显示会根据最后的输入值。

 static void Main(string[] args)
         {
             Resume a = new Resume("Taylor");
             a.SetPersonalInfo("", "女");
             a.SetWorkExperience("1999-2008", "UIO");

             Resume b = (Resume)a.Clone();
             b.SetWorkExperience("1990-2000", "QWE");
             b.SetPersonalInfo("", "男");

             Resume c = (Resume)a.Clone();
             c.SetPersonalInfo("", "男");
             c.SetWorkExperience("1000-2000", "QWE");
             //最后c的将work.WorkDate设置为了"1000-2000"，work.Company设置为了"QWE"
             //故此b的工作经历显示也如同c一般了，a也同理
             //==>“浅复制”

             a.Display();
             b.Display();
             c.Display();

             Console.Read();
         }

         class Resume:ICloneable
         {
             private string name;
             private string sex;
             private string age;

             private WorkExperience work;

             public Resume(string name)
             {
                 this.name = name;
                 work = new WorkExperience();//实例化
             }

             public void SetPersonalInfo(string age,string sex)
             {
                 this.age = age;
                 this.sex = sex;
             }

             public void SetWorkExperience(string timeArea,string company)
             {
                 work.WorkDate = timeArea;
                 work.Company = company;

             }

             public void Display()
             {
                 Console.WriteLine("{0} {1} {2}", name, sex, age);
                 Console.WriteLine("工作经历：{0} {1}", work.WorkDate, work.Company);
             }

             public object Clone()
             {
                 return (object)this.MemberwiseClone();
             }
         }

         class WorkExperience
         {
             private string workDate;

             public string WorkDate
             {
                 get
                 {
                     return workDate;
                 }

                 set
                 {
                     workDate = value;
                 }
             }

             private string company;

             public string Company
             {
                 get
                 {
                     return company;
                 }

                 set
                 {
                     company = value;
                 }
             }
         }

所以这就涉及到了MemberwiseClone()方法，“浅复制”和“深复制”问题了。

MemberwiseClone()：如果字段是值类型，则对该字段执行逐位复制，如果字段是引用类型，则复制引用但不复制引用的对象；因此，原始对象及其副本引用同意对象。

=>换句话就是，简历中所包含的对象引用，其引用的对象数据是不会被克隆过来的。

MemberwiseClone()就是“浅复制”:被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用都仍然指向原来的对象。

“深复制”:把引用对象的变量指向复制过的新对象，而不是原来的被引用的对象。

实现：

 class Resume:ICloneable
         {
             private string name;
             private string age;
             private string sex;

             private WorkExperience work;
             public Resume(string name)
             {
                 this.name = name;
                 work = new WorkExperience();
             }

             /// <summary>
             /// 私有函数
             /// 将工作经历克隆过来
             /// </summary>
             /// <param name="work"></param>
             private Resume(WorkExperience work)
             {
                 this.work = (WorkExperience)work.Clone();
             }

             public void SetPersonalInfo(string age,string sex)
             {
                 this.age = age;
                 this.sex = sex;
             }

             public void SetWorkExperience(string workDate,string company)
             {
                 work.Company = company;
                 work.WorkDate = workDate;
             }

             public void Display()
             {
                 Console.WriteLine("{0} {1} {2}", name, sex, age);
                 Console.WriteLine("工作经历：{0} {1}", work.WorkDate, work.Company);
             }

             public object Clone()
             {
                 //调用私有的构造方法，让“工作经历”克隆完成
                 //然后再给这个“简历”对象的相关字段赋值
                 //最终返回一个深复制的简历对象
                 Resume obj = new Resume(this.work);
                 obj.name = this.name;
                 obj.sex = this.sex;
                 obj.age = this.age;

                 return obj;
             }
         }

         class WorkExperience : ICloneable
         {
             private string workDate;
             private string company;

             public string WorkDate
             {
                 get
                 {
                     return workDate;
                 }

                 set
                 {
                     workDate = value;
                 }
             }

             public string Company
             {
                 get
                 {
                     return company;
                 }

                 set
                 {
                     company = value;
                 }
             }

             public object Clone()
             {
                 return (object)this.MemberwiseClone();
             }
         }

注：文中所有代码及知识点均来自于《大话设计模式》,本人属于边学边看边敲代码边总结的阶段。