读书笔记7：原型模式

今天刚看了原型模式，刚一开始还真没弄明白这个模式想干嘛，因为一直都在使用clone方法，我觉得到处深度clone和到处new一个对象的实例，那不是一样的吗？后来查了资料也发帖子问了，其实clone和new有区别的，很简单，clone后的对象的实例不仅和原对象的实例结构一致而且值也一致；而new出来的对象的实例只是结构一致，值是默认值。其实原型模式它的根本目的是创建对象的实例，而且是要创建和已经存在的那个实例一模一样，包括状态。这样的话clone就显示出优势了。那先看看什么是原型模式吧。

1、  概念

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

2、  模型

    它的模型是一个原型类实现一个接口或继承抽象类（这个接口和类一定要包含clone方法），并重写clone方法。

[csharp]  view plain copy print ?

1. //抽象父类，包含一个clone方法：  
2.  public abstract class AbstractProtoType  
3.  {  
4.       private string id;  
5.   
6.       public AbstractProtoType(string id)  
7.       {  
8.           this.id = id;  
9.       }  
10.       public string Id  
11.       {  
12.           get { return id; }  
13.       }  
14.       public abstract AbstractProtoType Clone();  
15.  }  
16.   
17.  //原型类，继承了抽象类，并实现了clone方法：  
18.    public class ProtoTypeClass : AbstractProtoType  
19.   {  
20.       public ProtoTypeClass(string id)  
21.   
22.           : base(id)  
23.       {  
24.   
25.       }  
26.      public override AbstractProtoType Clone()  
27.      {  
28.           return (AbstractProtoType)this.MemberwiseClone();  
29.   
30.      }  
31.  }  

调用:

[csharp]  view plain copy print ?

1. using System;  
2. using System.Collections.Generic;  
3. using System.Text;  
4.   
5. namespace PrototypePattern  
6. {  
7.     class Program  
8.     {  
9.         static void Main(string[] args)  
10.         {  
11.             ProtoTypeClass real = new ProtoTypeClass("2011");  
12.             Console.WriteLine("原型的id：{0}", real.Id);  
13.   
14.             ProtoTypeClass copy =(ProtoTypeClass)real.Clone();  
15.             Console.WriteLine("复制的id：{0}", copy.Id);  
16.             Console.ReadKey();  
17.         }  
18.     }  
19. }  

结果：

3、  c#.NET中的使用

（1）、浅度复制

在.NET中原型类实现Icloneable就可以了。

代码：

[csharp]  view plain copy print ?

1. public class ProtoTypeClass : ICloneable  
2. {  
3.     private string id;  
4.     public ProtoTypeClass(string id)  
5.     {  
6.         this.id = id;  
7.     }  
8.     public string Id  
9.     {  
10.         get { return id; }  
11.     }  
12.   
13.     public object Clone()  
14.     {  
15.         return (ProtoTypeClass)this.MemberwiseClone();  
16.     }  
17. }  

调用:

[csharp]  view plain copy print ?

1. static void Main(string[] args)  
2.  {  
3.      ProtoTypeClass real = new ProtoTypeClass("2011");  
4.      Console.WriteLine("原型的id：{0}", real.Id);  
5.   
6.      ProtoTypeClass copy = (ProtoTypeClass)real.Clone();  
7.      Console.WriteLine("复制的id：{0}", copy.Id);  
8.      Console.ReadKey();  
9.  }  

结果：

    如果原型类中对其他对象的引用的话，这种复制只能复制这个引用，因此复制后的实例中的该对象引用和原型中的对象指向同一个引用。这种复制成为浅度复制。

    （2）深度复制

  如果原型类中包含其它对象的引用，则深度复制情形如下：

[cpp]  view plain copy print ?

1. public class OtherClass:ICloneable  
2. {  
3.     private string id;  
4.     private string name;  
5.   
6.     public OtherClass(string idStr, string nameStr)  
7.     {  
8.         id = idStr;  
9.         name = nameStr;  
10.     }  
11.   
12.     public string Id  
13.   
14.     {  
15.         get { return id; }  
16.         set { id = value; }  
17.     }  
18.   
19.     public string Name  
20.     {  
21.         get { return name; }  
22.         set { name = value; }  
23.     }  
24.   
25.     public object Clone()  
26.     {  
27.         return (OtherClass)this.MemberwiseClone();  
28.     }  
29. }  
30.  public class ProtoTypeClass : ICloneable  
31.  {  
32.      private string id;  
33.      private OtherClass oclass;  
34.      public ProtoTypeClass(string id)  
35.      {  
36.          this.id = id;  
37.      }  
38.   
39.      public string Id  
40.      {  
41.          get { return id; }  
42.      }  
43.   
44.      public OtherClass Oclass  
45.      {  
46.          get { return oclass; }  
47.          set { oclass = value; }  
48.      }  
49.   
50.      public object Clone()  
51.      {  
52.          object obj = (ProtoTypeClass)this.MemberwiseClone();  
53.          if (oclass != null)  
54.              oclass = (OtherClass)oclass.Clone();  
55.          return obj;  
56.      }  
57.  }  

调用：

[csharp]  view plain copy print ?

1. static void Main(string[] args)  
2.   {  
3.       ProtoTypeClass real = new ProtoTypeClass("2011");  
4.       real.Oclass = new OtherClass("2012", "兰戈");  
5.       Console.WriteLine("原型的id：{0},原型引用类的id：{1}，原型引用类的name：{2}",  
6.           real.Id,real.Oclass.Id,real.Oclass.Name);  
7.   
8.        ProtoTypeClass copy = (ProtoTypeClass)real.Clone();  
9.       Console.WriteLine("复制的id：{0},复制引用类的id：{1}，复制引用类的name：{2}",  
10.           copy.Id, copy.Oclass.Id, copy.Oclass.Name);  
11.       Console.ReadKey();  
12.  }  

结果:

    深度复制将原型里包含的对象指向的类也复制过来。这样copy和real就是完全相同的对象，但是是独立的，销毁real，copy依然存在，并且值保持不变的。

    有一点要注意原型模式不是主要是clone，clone只是达到原型模式的一种方法。原型模式的意义是，原型的变化要使得使用原形的地方同时要变化，但不用修改代码。