大话设计模式-原型模式（学习笔记）

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

原型模式其实就是从一个对象再创建另外一个可定制的对象，而且不需要知道任何创建的细节。

原型模式结构图：

基本原型代码：

原型类

    abstract class Prototype
    {
        private string id;


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


        public string Id {
            get { return id; }
        }


        public abstract Prototype Clone();
    }

具体原型类：

    class ConcretePrototype1 : Prototype {
        public ConcretePrototype1(string id) : base(id) { 
            
        }
        public override Prototype Clone()
        {

            //创建当前对像的浅表副本，方法是创建一个新对象，然后将前面对象昂的非静态字段复制到该新对象。如果字段是值类型的，则对该字段执行诸位复制。如果字段是引用类型，则复制引用但不复制引用对象；因此，原始对象以及其副本引用同一对象。

            return (Prototype)this.MemberwiseClone();
        }

    }

客户端代码：

            ConcretePrototype1 p1 = new ConcretePrototype1("I");
            ConcretePrototype1 c1 = (ConcretePrototype1)p1.Clone();//克隆类，得到当前对象。
            Console.WriteLine("Coloned:{0}", p1.Id);
            Console.WriteLine("Coloned:{0}",c1.Id);

            Console.Read()

具体实例（深复制与浅复制）

浅复制结构图：

深复制结构图

代码：

   

 //定义了一个Clone方法，对自身进行克隆

    //浅复制没有继承ICloneable接口，也没有 Clone方法的实现

    class WorkExperence：ICloneable {
        private string workDate;
        private string company;
        public string WorkDate {
            set { workDate = value;}
            get {return workDate;}
        }
        public string Company {
            set { company = value; }
            get { return company; }
        }
        public Object Clone() {
            return (Object)this.MemberwiseClone();
        }


    }

    //继承距ICloneable接口（system命名空间中）
    class Resume:ICloneable
    {
        private string name;
        private string age;
        private string sex;


        private WorkExperence work;


        public Resume(string name) {
            this.name = name;
            work = new WorkExperence();

        }

        //实现对资源对象进行深复制的构造函数

        public Resume(WorkExperence work) {
            this.work = (WorkExperence)work.Clone();
        }


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


        }


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


        public void Display() {
            Console.WriteLine("{0} {1} {1}",name,sex,age);
            Console.WriteLine("工作经历：{0} {1}",work.WorkDate,work.Company);
        }
        //浅复制
        public Object Clone() {
            return (Object)this.MemberwiseClone();
        }
        //深复制

        public Object CloneH() {

            //调用私有构造方法，让“工作经历”克隆完成，然后在给“简历”对象的相关字段赋值，最终返回一个深复制对象

            Resume obj =  new Resume(this.work);  
            obj.name = this.name;
            obj.sex = this.sex;
            obj.age = this.age;
            return obj;
        }

    }

    

 前台代码：

         static void Main(string[] args)
        {
            Resume r1 = new Resume("人物A");


            r1.SetPersonalInfo("男", "25");
            r1.SetWorkExperence("5", "marchsoft");


            Resume r2 =(Resume) r1.Clone();


            r2.SetPersonalInfo("女","22");
            r2.SetWorkExperence("2", "sun");


            Resume r3 = (Resume)r2.CloneH();
            r3.SetWorkExperence("10", "IBM");
            r3.SetPersonalInfo("男","35");


            r1.Display();
            r2.Display();
            r3.Display();
            


            Console.Read();


        }
    

结果如图：

小结：

浅复制，被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用动仍然指向原来的对象。

深复制，把引用对象的变量只想复制过的新对象，而不是原有的被引用的对象。

优点：一般在初始化的信息不发生变化的情况下，克隆是最好的办法。这即隐藏了对象创建的细节，有对性能是大大的提高。它等于不用重新初始化对象，而是动态的或侧对象运行时的状态。

​