设计模式之prototype（原型模型）

以我的理解原型模式的重点就几个字 用于克隆易变对象设计模式主要是为了解决new对象时的耦合问题，这是要克隆某个易变对象时只要直接传入要克隆的对象就可以实现克隆一下是我复制网上的一些代码 摘自《设计模式之美》  Dennis Gao

设计模式之美：Prototype（原型）

索引

• 别名
• 意图
• 结构
• 参与者
• 适用性
• 缺点
• 效果
• 相关模式
• 命名约定
• 实现
  • 实现方式（一）：使用一个原型管理器。
  • 实现方式（二）：使用浅拷贝实现克隆（Clone）操作。
  • 实现方式（三）：使用深拷贝实现克隆（Clone）操作。
  • 实现方式（四）：初始化克隆对象。

别名

• Clone

意图

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

Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.

结构

参与者

Prototype

• 声明一个克隆自身的接口。

ConcretePrototype

• 实现一个克隆自身的操作。

Client

• 让一个原型克隆自身从而创建一个新的对象。

适用性

在以下情况下可以使用 Prototype 模式：

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

缺点

• 每一个 Prototype 子类都必须实现 Clone 操作。当内部包括一些不支持拷贝或有循环引用的对象时，实现克隆可能也会很困难。

效果

• 它对客户隐藏了具体的产品类，因此减少了客户知道的名字的数目。
• 使客户无需改变即可使用与特定应用相关的类。
• 运行时刻增加和删除产品。
• 改变值以指定新对象。
• 改变结构以指定新对象。
• 减少子类的构造。
• 用类动态配置应用。

相关模式

• Abstract Factory 可以用 Prototype来实现。
• Composite和 Decorator模式的设计也可以从 Prototype 获益。

命名约定

使用命名约定是一个好习惯，例如，总是声明那些实现克隆的操作为 Clone()。

实现

实现方式（一）：使用一个原型管理器。

当一个系统中原型数目不固定时，可以保持一个可用原型的注册表，用以存储和检索原型。我们称这个注册表为原型管理器（Prototype Manager）。

客户在克隆一个原型前会先向注册表请求该原型。

 namespace PrototypePattern.Implementation1
 {
   public abstract class AbstractOrInterfaceOfPrototypeProduct
   {
     public int ValueProperty1 { get; set; }

     public abstract AbstractOrInterfaceOfPrototypeProduct Clone();
   }

   public class ConcretePrototypeProductA : AbstractOrInterfaceOfPrototypeProduct
   {
     public override AbstractOrInterfaceOfPrototypeProduct Clone()
     {
       return new ConcretePrototypeProductA()
       {
         ValueProperty1 = this.ValueProperty1,
       };
     }
   }

   public class ConcretePrototypeProductB : AbstractOrInterfaceOfPrototypeProduct
   {
     public override AbstractOrInterfaceOfPrototypeProduct Clone()
     {
       return new ConcretePrototypeProductB()
       {
         ValueProperty1 = this.ValueProperty1,
       };
     }
   }

   public class ProductPrototypeManager
   {
     private Dictionary<string, AbstractOrInterfaceOfPrototypeProduct> _registry
       = new Dictionary<string, AbstractOrInterfaceOfPrototypeProduct>();

     public void Register(string name,
       AbstractOrInterfaceOfPrototypeProduct prototypeProduct)
     {
       _registry[name] = prototypeProduct;
     }

     public void Unregister(string name)
     {
       _registry.Remove(name);
     }

     public AbstractOrInterfaceOfPrototypeProduct Retrieve(string name)
     {
       return _registry[name];
     }

     public bool IsRegisterd(string name)
     {
       return _registry.ContainsKey(name);
     }
   }

   public class Client
   {
     public void TestCase1()
     {
       AbstractOrInterfaceOfPrototypeProduct prototypeProduct1 = new ConcretePrototypeProductA();
       AbstractOrInterfaceOfPrototypeProduct prototypeProduct2 = new ConcretePrototypeProductB();

       ProductPrototypeManager manager = new ProductPrototypeManager();
       manager.Register("PrototypeProduct1", prototypeProduct1);
       manager.Register("PrototypeProduct2", prototypeProduct2);

       AbstractOrInterfaceOfPrototypeProduct clonedProduct1 = manager.Retrieve("PrototypeProduct1").Clone();

       if (manager.IsRegisterd("PrototypeProduct2"))
       {
         AbstractOrInterfaceOfPrototypeProduct clonedProduct2 = manager.Retrieve("PrototypeProduct2").Clone();
       }
     }
   }
 }

实现方式（二）：使用浅拷贝实现克隆（Clone）操作。

Prototype 模式最困难的部分在于正确的实现 Clone 操作。

浅拷贝（Shallow Copy）在拷贝时只复制对象所有字段的值。如果字段是值类型，则复制其值；如果字段是引用类型，则复制引用指针。

 namespace PrototypePattern.Implementation2
 {
   public class ReferencedClass
   {
     public int ReferencedClassProperty1 { get; set; }
   }

   public abstract class AbstractOrInterfaceOfPrototypeProduct
   {
     public int ValueProperty1 { get; set; }
     public ReferencedClass ReferenceProperty2 { get; set; }

     public abstract AbstractOrInterfaceOfPrototypeProduct Clone();
   }

   public class ConcreteShallowCopyPrototypeProductA
     : AbstractOrInterfaceOfPrototypeProduct
   {
     public ConcreteShallowCopyPrototypeProductA()
     {
       this.ReferenceProperty2 = new ReferencedClass()
       {
         ReferencedClassProperty1 =
       };
     }

     public override AbstractOrInterfaceOfPrototypeProduct Clone()
     {
       return new ConcreteShallowCopyPrototypeProductA()
       {
         ValueProperty1 = this.ValueProperty1,
         ReferenceProperty2 = this.ReferenceProperty2,
       };
     }
   }

   public class Client
   {
     public void TestCase2()
     {
       AbstractOrInterfaceOfPrototypeProduct prototypeProduct1 = new ConcreteShallowCopyPrototypeProductA();
       AbstractOrInterfaceOfPrototypeProduct clonedProduct1 = prototypeProduct1.Clone();
       bool areEqual1 = object.ReferenceEquals(
         prototypeProduct1.ReferenceProperty2,
         clonedProduct1.ReferenceProperty2);
     }
   }
 }

实现方式（三）：使用深拷贝实现克隆（Clone）操作。

深拷贝（Deep Copy）涉及对源对象整个结构的拷贝。

深拷贝在拷贝时复制对象的所有字段的值。如果字段是值类型，则复制其值；如果字段是引用类型，则会将这个引用指针指向的对象也克隆一份。

可以通过序列化和反序列化来实现深拷贝。

 namespace PrototypePattern.Implementation3
 {
   public class ReferencedClass
   {
     public int ReferencedClassProperty1 { get; set; }
   }

   public abstract class AbstractOrInterfaceOfPrototypeProduct
   {
     public int ValueProperty1 { get; set; }
     public ReferencedClass ReferenceProperty2 { get; set; }

     public abstract AbstractOrInterfaceOfPrototypeProduct Clone();
   }

   public class ConcreteShallowCopyPrototypeProductA
     : AbstractOrInterfaceOfPrototypeProduct
   {
     public ConcreteShallowCopyPrototypeProductA()
     {
       this.ReferenceProperty2 = new ReferencedClass()
       {
         ReferencedClassProperty1 =
       };
     }

     public override AbstractOrInterfaceOfPrototypeProduct Clone()
     {
       return new ConcreteShallowCopyPrototypeProductA()
       {
         ValueProperty1 = this.ValueProperty1,
         ReferenceProperty2 = this.ReferenceProperty2,
       };
     }
   }

   public class ConcreteDeepCopyPrototypeProductB
     : AbstractOrInterfaceOfPrototypeProduct
   {
     public ConcreteDeepCopyPrototypeProductB()
     {
       this.ReferenceProperty2 = new ReferencedClass()
       {
         ReferencedClassProperty1 =
       };
     }

     public override AbstractOrInterfaceOfPrototypeProduct Clone()
     {
       return new ConcreteDeepCopyPrototypeProductB()
       {
         ValueProperty1 = this.ValueProperty1,
         ReferenceProperty2 = new ReferencedClass()
         {
           ReferencedClassProperty1 =
             this.ReferenceProperty2.ReferencedClassProperty1
         },
       };
     }
   }

   public class Client
   {
     public void TestCase3()
     {
       AbstractOrInterfaceOfPrototypeProduct prototypeProduct1 = new ConcreteShallowCopyPrototypeProductA();
       AbstractOrInterfaceOfPrototypeProduct clonedProduct1 = prototypeProduct1.Clone();
       bool areEqual1 = object.ReferenceEquals(
         prototypeProduct1.ReferenceProperty2,
         clonedProduct1.ReferenceProperty2);

       AbstractOrInterfaceOfPrototypeProduct prototypeProduct2 = new ConcreteDeepCopyPrototypeProductB();
       AbstractOrInterfaceOfPrototypeProduct clonedProduct2 = prototypeProduct2.Clone();
       bool areEqual2 = object.ReferenceEquals(
         prototypeProduct2.ReferenceProperty2,
         clonedProduct2.ReferenceProperty2);

       Console.WriteLine("{0}, {1}", areEqual1, areEqual2);
     }
   }
 }

实现方式（四）：初始化克隆对象。

客户可能会希望使用一些值来初始化该对象的内部状态。

但在 Clone 操作中传递参数会破坏克隆接口的统一性。

原型的类可以在 Clone 操作之后，调用包含初始化参数的 Initialize 方法来设定对象内部状态。

 namespace PrototypePattern.Implementation4
 {
   public class ReferencedClass
   {
     public int ReferencedClassProperty1 { get; set; }
   }

   public abstract class AbstractOrInterfaceOfPrototypeProduct
   {
     public int ValueProperty1 { get; set; }
     public ReferencedClass ReferenceProperty2 { get; set; }

     public abstract AbstractOrInterfaceOfPrototypeProduct Clone();
   }

   public class ConcreteDeepCopyPrototypeProductB
     : AbstractOrInterfaceOfPrototypeProduct
   {
     public ConcreteDeepCopyPrototypeProductB()
     {
     }

     public void Initialize(int propertyValue)
     {
       this.ValueProperty1 = propertyValue;
       this.ReferenceProperty2.ReferencedClassProperty1 = propertyValue;
     }

     public override AbstractOrInterfaceOfPrototypeProduct Clone()
     {
       return new ConcreteDeepCopyPrototypeProductB()
       {
         ValueProperty1 = this.ValueProperty1,
         ReferenceProperty2 = new ReferencedClass()
         {
           ReferencedClassProperty1 =
             this.ReferenceProperty2.ReferencedClassProperty1
         },
       };
     }
   }

   public class Client
   {
     public void TestCase4()
     {
       AbstractOrInterfaceOfPrototypeProduct prototypeProduct2 = new ConcreteDeepCopyPrototypeProductB();
       ConcreteDeepCopyPrototypeProductB clonedProduct2 =
         (ConcreteDeepCopyPrototypeProductB)prototypeProduct2.Clone();

       clonedProduct2.Initialize();
     }
   }
 }

《设计模式之美》为 Dennis Gao 发布于博客园的系列文章

二.下面介绍另外一种方法主要介绍this.memberwiseclone()的使用