原型模式(Prototype Pattern)

• 原型模式概述

---

 定义：使用原型实例指定待创建对象的类型，并且通过复制这个原型来创建新的对象。简单的来说就是克隆(Clone),通过已经存在的，将其复制而产生新的。原型模式属于创建型模式，将一个原型对象传给要发动创建的对象(客户端对象)，该对象通过请求原型对象复制自己来实现创建过程。

既然是通过Clone创建的，那么就会存该拷贝是浅拷贝还是深拷贝的问题了。

浅拷贝(Shallow Clone):当原型对象被复制时，只复制它本身和其中包含的值类型的成员变量，而引用类型的成员变量并没没复制。如我想将A复制一份出来，命名为为B，那么我在浅拷贝后，确实可以得到A和B。而且A和B的值也相等，但是，我将B的值稍作修改，A的值也会变动，这往往不是我们想要的。因为我们想拷贝一个副本出来，二者也能独立，这样才算拷贝。但是，浅拷贝后A和B却是指向同一片地址空间，也就是二者共用一个值，改一个，两个都变。

深拷贝(Deep Clone):除了对象本身被复制外，对象所包含的所有成员变量也被复制，就是我们想要的那种拷贝，即有一个副本，与原者老死不想往来，互不影响

 原型模式的实现 :

---

结构:

1. Prototype(抽象原型类):声明克隆方法的接口，所有具体原型类的公共父类，抽象类、接口皆可，也可是具体类
2. ConcretePrototpye(具体原型类):实现在抽象原型类中声明的克隆方法，返回自己的克隆对象
3. Client(客户类):让一个原型对象克隆自身而创建一个新的对象，直接实例化或通过工厂方法创建一个原型对象，在调用克隆方法即可

• 原型模式应用实例

---

 问题描述：为某销售管理系统设计并实现一个客户类Customer，在客户类中包含一个名为客户地址的成员变量，客户地址的类型为Address，用浅克隆和深克隆分别实现Customer对象的复制，并比较这两种克隆方式的异同(异同前面简单说了，就不重复了)

结构 :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization.Formatters.Binary; //序列化
using System.IO;//文件
using System.Runtime.Serialization;//序列化异常处理

namespace Customer
{
    [Serializable]//将Customer类设置为可序列化
    public abstract class Customer : ICloneable
    {
        public abstract object Clone();
    }

    [Serializable]//将Address类设置为可序列化
    public class Address//地址类
    {
        private string province;
        private string city;

        public string City
        {
            get { return city; }
            set { city = value; }
        }

        public string Province
        {
            get { return province; }
            set { province = value; }
        }

        public  Address(string province,string city)
        {
            this.province = province;
            this.city = city;
        }

        public override string ToString()//打印地区
        {
            return "地址为：" + province + " 省，" + city + " 市。";
        }
    }

    [Serializable]//将CustomerA设置为可序列化
    public class CustomerA : Customer//顾客A类
    {
        private string name;
        private int age;
        private string call;
        private Address address;

        public Address Address
        {
            get { return address; }
            set { address = value; }
        }

        public string Name
        {
            get { return name; }
            set { name = value; }
        }
       
        public int Age
        {
            get { return age; }
            set { age = value; }
        }
        
        public string Call
        {
            get { return call; }
            set { call = value; }
        }

        public CustomerA(string name, int age, string call,Address address)
        {
            this.name = name;
            this.age = age;
            this.call = call;
            this.address = address;
        }

        public override string ToString()
        {
            return "客户A--姓名：" + this.name + " 年龄：" + this.age + " 联系方式：" + this.call + " "+ this.address.ToString();
        }

       #region 浅克隆+this.MemberwiseClone()
       public  object MemClone()
       {
           return this.MemberwiseClone();
       } 
       #endregion

       #region 深克隆+object Clone()
       public override object Clone()
       {
           Kits.FileSer(@"d:1.txt", this);//
           object obj = Kits.FileDSer(@"d:1.txt");
           return obj;
       }
       #endregion
    }

    [Serializable]//将CustomerB设置为可序列化
    public class CustomerB : Customer//顾客B类
    {
        private string name;
        private int age;
        private string call;
        private Address address;

        public Address Address
        {
            get { return address; }
            set { address = value; }
        }

        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        public int Age
        {
            get { return age; }
            set { age = value; }
        }

        public string Call
        {
            get { return call; }
            set { call = value; }
        }

        public CustomerB(string name, int age, string call, Address address)
        {
            this.name = name;
            this.age = age;
            this.call = call;
            this.address = address;
        }

        public override string ToString()
        {
            return "客户B--姓名：" + this.name + " 年龄：" + this.age + " 联系方式：" + this.call + " " + this.address.ToString();
        }

       #region 浅克隆+this.MemberwiseClone()
       public  object MemClone()
       {
           return this.MemberwiseClone();
       } 
       #endregion

       #region 深克隆+object Clone()
       public override object Clone()
       {
           Kits.FileSer(@"d:1.txt", this);//读
           object obj = Kits.FileDSer(@"d:1.txt");//写
           return obj;
       }
        #endregion
    }
    
   public class Kits//工具类
    {
       public static void FileSer(string path,object obj)//读出信息
       {
           FileStream fs = new FileStream(path, FileMode.OpenOrCreate);//通道 序列化
           BinaryFormatter bf = new BinaryFormatter();//搬运工
           try
           {
               bf.Serialize(fs, obj);//序列化
           }
           catch (SerializationException e)
           {
               Console.WriteLine("该文件进行序列化失败。原因 : " + e.Message);
               throw;

           }
           finally { fs.Close(); }
       }

       public static object  FileDSer(string path)//写入
       {
           FileStream fs = new FileStream(path, FileMode.Open);//通道、路径，权限
           BinaryFormatter bf = new BinaryFormatter();//搬运工
           object obj = null;
           try
           {
               obj=bf.Deserialize(fs);//反序列化
           }
           catch (SerializationException e)
           {
               Console.WriteLine("该文件进行反序列化失败。原因 : " + e.Message);
               throw;

           }
           finally 
           {                
               fs.Close();
           }
           return obj;
       }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("
--------------------------------Customer-------------------------------------");
            Address addr1 = new Address("中国江苏", "扬州");
            CustomerA c1 = new CustomerA("社会人c1", 20, "13288888888", addr1);
            Console.WriteLine(c1.ToString());//c1的作为原对象

            Console.WriteLine("
-----------------------------------Copy(c2 = c1)-------------------------------------");
            CustomerA c2 = c1;
            Console.WriteLine("社会人c2，更新信息.直接复制对象
");
            Console.WriteLine();
            Console.WriteLine(c2.ToString());

            Console.WriteLine("
-----------------------------ShallowCopy-------------------------------------");
            Console.WriteLine();
            Console.WriteLine("社会人c3，更新信息
");
            CustomerA c3 = (CustomerA)c1.MemClone();//浅克隆
            Console.WriteLine(c3.ToString());

            Console.WriteLine("此时 c2:");
            Console.WriteLine(c2.ToString());

            Console.WriteLine("
--------------------------------Customer-------------------------------------
");
            Console.WriteLine();
            Address addr2 = new Address("中国广东", "广州");
            CustomerB c4 = new CustomerB("小猪佩琪", 24, "16612345678", addr2);
            Console.WriteLine("c4 "+c4.ToString());
            Console.WriteLine("
--------------------------------DeepCopy(update c5.Age = 26)--------------------------
");

            CustomerB c5 = (CustomerB)c4.Clone();
            c5.Age = 26;
            Console.WriteLine("一年后，搬家
");
            c5.Address = new Address("中国天津", "河西区");
            Console.WriteLine(c5.ToString());

            Console.WriteLine("此时 c4:");
            Console.WriteLine(c4.ToString());
            ;
        }
    }
}

运行结果：

上述FileStream类和BinaryFormatter类是实现对象序列化和反序列化的操作的，就是用序列化把当前对象写入流中，流入文件，再用反序列化从文件中流出对象。文件相当于中介，当然，中介还可以是内存、网络。

• 原型管理器

---

 简单介绍：原型管理器(Prototype Manager)就是将多个原型对象存储在一个集合中供客户端使用，它是一个专门负责克隆对象的工厂，其中定义了一个集合用于存储原型对象，如果需要某个原型对象的一个克隆，可以通过复制集合中对应的原型对象获得。

using System.Collections;
class PrototypeManager
{
Hashtable ht = new Hashtable();  //使用Hashtable存储原型对象
    public PrototypeManager()
    {
        ht.Add("A", new ConcretePrototypeA());
        ht.Add("B", new ConcretePrototypeB());
    }
    public void Add(string key, Prototype prototype)
    {
        ht.Add(key,prototype);
    }
    public Prototype Get(string key)
    {
        Prototype clone = null;
        clone = ((Prototype)ht[key]).Clone();  //通过克隆方法创建新对象
        return clone;
    }
}

 

原型模式的优缺点和适用环境

---

• 原型模式的优点：

1. 简化对象的创建过程，通过复制一个已有对象实例可以提高新实例的创建效率
2. 扩展性好
3. 提供了简化的创建结构，原型模式中的产品的复制是通过封装在原型类中的克隆方法实现的，无需专门的工厂类来创建产品
4. 可以通过深克隆的方式保存对象的状态，使用原型模式将对象复制一份并其状态保存起来，以便在需要的时候使用，可辅助实现撤销操作

• 原型模式的缺点：

1. 需要为每一个类准备一个克隆方法，而且该克隆方法位于一个类的内部，当对已有类进行改造时，需要修改原代码，违背了开闭原则
2. 在实现深克隆时需要写较复杂的代码，而且当对象之间存在多重的嵌套引用时，为了实现深克隆，每一层对象对应的类必须支持深克隆，实现起来较烦较烦....

• 原型模式的适用环境：

1. 创建新对象成本较大，新对象可以通过复制已有对象来获得，如果是相似对象，则可以对其成员变量修改
2. 系统要保存对象的状态，而对象的状态变化很小
3. 需要避免使用分层次的工厂类来创建分层次的对象，并且类的实例对象只有一个或很少的几个组合状态，通过复制原型对象得到新实例可能比使用构造函数创建一个新实例更方便