原型模式（Prototype Pattern）

一、什么是原型模式

原型模式（Prototype Pattern）也是一种创建型模式，它关注的是大量相似对象的创建问题。我们经常会遇到这样的情况：在系统中要创建大量的对象，这些对象之间具有几乎完全相同的功能，只是在细节上有一点儿差别。

意图

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

结构图

原型模式的基本实现

原型类：

public abstract class Prototype
{
    private int id;

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

    public int Id
    {
        get { return id; }
    }

    public abstract Prototype Clone();
}

具体的原型类：

public class ConcretePrototype : Prototype
{
    public ConcretePrototype(int id) : base(id) { }

    public override Prototype Clone()
    {
        return (Prototype)this.MemberwiseClone();
    }
}

客户端代码：

public class Client
{
    public static void Main(string[] args)
    {
        ConcretePrototype cp1 = new ConcretePrototype(1);
        ConcretePrototype cp2 = cp1.Clone() as ConcretePrototype;

        Console.WriteLine(cp1.Id);
        Console.WriteLine(cp2.Id);

        Console.Read();
    }
}

对于.NET而言,那个原型抽象类Prototype是用不着的，因为克隆实在是太常用了，所以.NET在System命名空间中提供了ICloneable接口，其中就是唯一的一个方法Clone()，这样你就只需要实现这个接口就可以完成原型模式了。

具体原型类就变成了以下代码：

public class ConcretePrototype : ICloneable
{
    private int id;

    public int Id
    {
        get { return id; }
    }

    public ConcretePrototype(int id)
    {
        this.id = id;
    }

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

 

二、原型模式的实例

需求：小沈今年刚大学毕业，正在找工作。星期天上午要去招聘会，现在正在准备招聘会上用的简历，简历内容包括姓名，年龄，性别的基本信息，还包括工作经验，联系方式等信息。往往招聘会去都要带上好几十份简历，我们总不能好几十份简历都手写吧？那怎么办呢？对了，只要写一份，然后复印上20来份就行了。这就是典型的原型模式。接下来，我们看看使用程序如何来实现。

1、定义一个简历类(Resume)，让其实现ICloneable接口，以实现原型模式

public class Resume : ICloneable
{
    public string Name { get; set; }

    public int Age { get; set; }

    public string Gender { get; set; }

    public string ContactPhone { get; set; }

    public string WorkTime { get; set; }

    public string Company { get; set; }

    public string Position { get; set; }

    public void Display()
    {
        Console.WriteLine("姓名：" + Name);
        Console.WriteLine("年龄：" + Age);
        Console.WriteLine("性别：" + Gender);
        Console.WriteLine("联系电话：" + ContactPhone);
        Console.WriteLine("工作经验：" + WorkTime + "\t" + Company + "\t" + Position);
    }

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

2、然后我们写客户端代码

public class Client
{
    public static void Main(string[] args)
    {
        Resume resume1 = new Resume
        {
            Name = "小沈",
            Age = 22,
            Gender = "男",
            ContactPhone = "13423233232",
            WorkTime = "2011.7~2012.1",
            Company = "XXX 公司",
            Position = "程序员"
        };

        Resume resume2 = (Resume)resume1.Clone();

        resume1.Display();
        resume2.Display();

        Console.Read();
    }
}

好，我们看看运行情况

在实际生活中，我们简历中的联系方式一般不单单是就一个联系电话，可能还包括你的住址、邮政编码等信息。因此我们可以把联系方式抽象出一个类来。

public class Contact
{
    public string Address { get; set; }

    public string Phone { get; set; }

    public string PostCode { get; set; }
}

我们也可以把工作经验抽象出一个类来。

public class WorkExperience
{
    public string WorkTime { get; set; }

    public string Company { get; set; }

    public string Position { get; set; }
}

此时我们的简历类就变成了

public class Resume : ICloneable
{
    public string Name { get; set; }

    public int Age { get; set; }

    public string Gender { get; set; }

    public Contact Contact { get; set; }

    public WorkExperience WorkExperience { get; set; }

    public void Display()
    {
        Console.WriteLine("姓名：" + Name);
        Console.WriteLine("年龄：" + Age);
        Console.WriteLine("性别：" + Gender);
        Console.WriteLine("联系电话：" + Contact.Phone);
        Console.WriteLine("联系地址：" + Contact.Address);
        Console.WriteLine("邮政编码：" + Contact.PostCode);
        Console.WriteLine("工作经验：" + WorkExperience.WorkTime + "\t" + WorkExperience.Company + "\t" + WorkExperience.Position);
    }

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

客户端代码修改为

public class Client
{
    public static void Main(string[] args)
    {
        Resume resume1 = new Resume
        {
            Name = "小沈",
            Age = 22,
            Gender = "男",
            Contact = new Contact{ Address = "仙霞路12号309室", Phone = "52066999", PostCode = "200120" },
            WorkExperience = new WorkExperience { WorkTime = "2011.7~2012.1", Company = "XXX公司", Position = "程序员" }
        };

        Resume resume2 = (Resume)resume1.Clone();
        resume2.Contact.Phone = "13312313232";

        resume1.Display();
        Console.WriteLine("====================================================");
        resume2.Display();

        Console.Read();
    }
}

最后的运行结果为

我们看了运行结果之后发现了问题，我们客户端代码中手动修改了resume2对象的联系电话的值，resume2.Contact.Phone = "13312313232";，没有修改过resume1对象的联系电话的值，为什么我修改了resume2对象的联系方式的值，resume1对象的联系方式的值也被修改成和resume2对象的联系电话的值一样的值了呢？这就是因为我们Resume类中的Clone()方法采用的是浅拷贝内存表。

 

 

三、浅拷贝和深拷贝

浅拷贝：被拷贝对象的所有变量都含有与原来的对象相同的值。而所有的其他对象的引用都仍然指向原来的对象。

深拷贝：把引用对象的变量指向复制过的新对象，而不是原有的被引用的对象。

 

弄明白了什么是浅拷贝，什么是深拷贝后，我们就可以改善我们实例中简历类，实现对象的深拷贝了，我们看以下代码，就是在.NET中实现对象的深拷贝。

修改后的简历程序的代码：

[Serializable]
public class Resume : ICloneable
{
    public string Name { get; set; }

    public int Age { get; set; }

    public string Gender { get; set; }

    public Contact Contact { get; set; }

    public WorkExperience WorkExperience { get; set; }

    public void Display()
    {
        Console.WriteLine("姓名：" + Name);
        Console.WriteLine("年龄：" + Age);
        Console.WriteLine("性别：" + Gender);
        Console.WriteLine("联系电话：" + Contact.Phone);
        Console.WriteLine("联系地址：" + Contact.Address);
        Console.WriteLine("邮政编码：" + Contact.PostCode);
        Console.WriteLine("工作经验：" + WorkExperience.WorkTime + "\t" + WorkExperience.Company + "\t" + WorkExperience.Position);
    }

    public object Clone()
    {
        MemoryStream memoryStream = new MemoryStream();
        BinaryFormatter formatter = new BinaryFormatter();
        formatter.Serialize(memoryStream, this);
        memoryStream.Position = 0;
        return (Resume)formatter.Deserialize(memoryStream);
    }
}

[Serializable]
public class Contact
{
    public string Address { get; set; }

    public string Phone { get; set; }

    public string PostCode { get; set; }
}

[Serializable]
public class WorkExperience
{
    public string WorkTime { get; set; }

    public string Company { get; set; }

    public string Position { get; set; }
}

public class Program3
{
    public static void Main(string[] args)
    {
        Resume resume1 = new Resume
        {
            Name = "小沈",
            Age = 22,
            Gender = "男",
            Contact = new Contact{ Address = "仙霞路12号309室", Phone = "52066999", PostCode = "200120" },
            WorkExperience = new WorkExperience { WorkTime = "2011.7~2012.1", Company = "XXX公司", Position = "程序员" }
        };

        Resume resume2 = (Resume)resume1.Clone();
        resume2.Contact.Phone = "13312313232";

        resume1.Display();
        Console.WriteLine("====================================================");
        resume2.Display();

        Console.Read();
    }
}

 

 四、原型模式另一种实现（登记式）

需求：我们考虑这样一个场景，假定我们要开发一个调色板，用户单击调色板上任一个方块，将会返回一个对应的颜色的实例，下面我们看看如何通过原型模式来达到系统动态加载具体产品的目的。

[Serializable]
public class ConcreteColor : ICloneable
{
    private int red, green, blue;

    public ConcreteColor(int red, int green, int blue)
    {
        this.red = red;
        this.blue = blue;
        this.green = green;
    }

    public object Clone()
    {
        MemoryStream memoryStream = new MemoryStream();
        BinaryFormatter formatter = new BinaryFormatter();
        formatter.Serialize(memoryStream, this);
        memoryStream.Position = 0;
        return (ConcreteColor)formatter.Deserialize(memoryStream);
    }

    public void Display(string colorName)
    {
        Console.WriteLine("{0}'s RGB Values are: {1},{2},{3}",colorName, red, green, blue);
    }
}

public class ColorManager
{
    public Hashtable colors = new Hashtable();

    public ConcreteColor this[string name]
    {
        get
        {
            return (ConcreteColor)colors[name];
        }

        set
        {
            colors.Add(name, value);
        }
    }
}

public class Client
{
    public static void Main(string[] args)
    {
        ColorManager colorManager = new ColorManager();
        colorManager["red"] = new ConcreteColor(255, 0, 0);
        colorManager["green"] = new ConcreteColor(0, 255, 0);
        colorManager["blue"] = new ConcreteColor(0, 0, 255);
        colorManager["angry"] = new ConcreteColor(255, 54, 0);
        colorManager["peace"] = new ConcreteColor(128, 211, 128);
        colorManager["flame"] = new ConcreteColor(211, 34, 20);

        string colorName = "red";
        ConcreteColor color = (ConcreteColor)colorManager[colorName].Clone();
        color.Display(colorName);

        string colorName2 = "green";
        ConcreteColor color1 = (ConcreteColor)colorManager[colorName2].Clone();
        color1.Display(colorName2);

        Console.Read();
    }
}

 

 

五、原型模式的总结

实现要点

1. 使用原型管理器，体现在一个系统中原型数目不固定时，可以动态的创建和销毁，如上面的举的调色板的例子。
2. 实现克隆操作，在.NET中可以使用Object类的MemberwiseClone()方法来实现对象的浅表拷贝或通过序列化的方式来实现深拷贝。
3. Prototype模式同样用于隔离类对象的使用者和具体类型（易变类）之间的耦合关系，它同样要求这些“易变类”拥有稳定的接口。 

效果

• 它对客户隐藏了具体的产品类，因此减少了客户知道的名字的数目。
• Prototype模式允许客户只通过注册原型实例就可以将一个具体产品类并入到系统中，客户可以在运行时刻建立和删除原型。
• 减少了子类构造，Prototype模式是克隆一个原型而不是请求工厂方法创建一个，所以它不需要一个与具体产品类平行的Creater类层次。
• Portotype模式具有给一个应用软件动态加载新功能的能力。由于Prototype的独立性较高，可以很容易动态加载新功能而不影响老系统。
• 产品类不需要非得有任何事先确定的等级结构，因为Prototype模式适用于任何的等级结构
• Prototype模式的最主要缺点就是每一个类必须配备一个克隆方法。而且这个克隆方法需要对类的功能进行通盘考虑，这对全新的类来说不是很难，但对已有的类进行改造时，不一定是件容易的事。

适用性

• 当一个系统应该独立于它的产品创建，构成和表示时；
• 当要实例化的类是在运行时刻指定时，例如，通过动态装载；
• 为了避免创建一个与产品类层次平行的工厂类层次时；
• 当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。