设计模式学习总结4 - 创建型4 - Prototype原型模式

Prototype原型模式（创建型）

作用：

原型模式通过克隆已存在的原型类实例新对象。原型模式有两点优势：1、因为复制对象比构造新对象要快，而且这些要复制的对象已加载在内存中，可以快速复制这些大对象来创建新的对象；2、可以保留大对象的固定的部分来复制新对象，简化子类的实例过程。

Role
The  Prototype pattern  creates  new  objects by  cloning one of  a few stored  prototypes. The Prototype pattern has two advantages: it speeds up the instantiation of very large, dynamically loaded classes (when copying objects is faster), and it keeps a record of identifiable parts of a large data structure that can be copied without knowing the subclass from which they were created.

设计：

IPrototype，定义可以被克隆原型接口
Prototype，实现了原型接口，可以克隆出新对象
PrototypeManager，原型管理器，管理各种可克隆类型和他们的关键词
举例：
IPrototype：可复制的功能
Prototype：实现可复制功能的钢笔
PrototypeManager：管理各种具有克隆自己功能的钢笔
实现：

实例1

代码

using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;
using  PrototypePattern;

namespace  Prototype
{
    [Serializable()]
     //  Helper class used to create a second level data structure
     class  DeeperData 
    {
          public   string  Data { get ;  set ;}

          public  DeeperData( string  s) 
         {
           Data  =  s;
         }
          public   override   string  ToString () 
         {
            return  Data;
         }
    }
    


    [Serializable()]
     class   Prototype : IPrototype  < Prototype >   
    {
          //  Content members
          public   string  Country { get ;  set ;}
          public   string  Capital { get ;  set ;}
          public  DeeperData Language { get ;  set ;}

          public  Prototype ( string  country,  string  capital,  string  language) 
         {
           Country  =  country;
           Capital  =  capital;
           Language  =   new  DeeperData(language);
         }

          public   override   string  ToString() 
         {
            return  Country + " \t\t " + Capital + " \t\t-> " + Language;
         }
    }
     class  PrototypeManager 
    {
         public  Dictionary  < string , Prototype >  prototypes
             =   new  Dictionary  < string , Prototype >
            {
                { " Germany " ,
                 new  Prototype ( " Germany " ,  " Berlin " ,  " German " )},
                { " Italy " ,
                 new  Prototype ( " Italy " ,  " Rome " ,  " Italian " )},
                { " Australia " ,
                 new  Prototype ( " Australia " ,  " Canberra " ,  " English " )}
            };
    }
     // 引用类型
     class  RefTypeRectangle
    {
         public   int  Width;
         public   int  Height;
    }

     class  Program
    {
         static   void  Report ( string  s, Prototype a, Prototype b) {
             Console.WriteLine( " \n " + s);
             Console.WriteLine( " Prototype  " + a + " \nClone       " + b);
           }

         static   void  Main( string [] args)
        {
             #region  测试引用类型
             /*
            //有该程序可以看出，引用类型是相互影响的，因为他们是指向相同的内存空间实际的是操作同一个堆栈中的数据
            RefTypeRectangle refOne = new RefTypeRectangle();
            RefTypeRectangle refTwo = refOne;
            refOne.Width = 10;
            refOne.Height = 20;
            System.Console.WriteLine("引用类型测试：");
            System.Console.WriteLine("refTwo.Width:" + refTwo.Width);
            System.Console.WriteLine("refTwo.Height:" + refTwo.Height);
            System.Console.WriteLine("-----------------------------------");
            refTwo.Width = 15;
            refTwo.Height = 25;
            System.Console.WriteLine("refOne.Width:" + refOne.Width);
            System.Console.WriteLine("refOne.Height:" + refOne.Height);
            System.Console.WriteLine("-----------------------------------");



            string s1 = "s1";
            string s2 = s1;
            Console.WriteLine(s1);
            s2 = "s2";
            Console.WriteLine(s1);
            Console.ReadLine();
             */
             #endregion  
           PrototypeManager manager  =   new  PrototypeManager();
           Prototype  c2, c3;
  
            //  Make a copy of Australia's data
           c2   =   manager.prototypes[ " Australia " ].Clone();
           Report( " Shallow cloning Australia\n=============== " ,
               manager.prototypes[ " Australia " ], c2);
  
           //  Change the capital of Australia to Sydney
           c2.Capital  =   " Sydney " ;
           Report( " Altered Clone's shallow state, prototype unaffected " ,
               manager.prototypes[ " Australia " ], c2);
  
            //  Change the language of Australia (deep data)
           c2.Language.Data  =   " Chinese " ;
           Report( " Altering Clone deep state: prototype affected ***** " ,
                   manager.prototypes[ " Australia " ], c2);
  
            //  Make a copy of Germany's data
           c3   =   manager.prototypes[ " Germany " ].DeepCopy();
           Report( " Deep cloning Germany\n============ " ,
                   manager.prototypes[ " Germany " ], c3);
  
            //  Change the capital of Germany
           c3.Capital  =   " Munich " ;
           Report( " Altering Clone shallow state, prototype unaffected " ,
                   manager.prototypes[ " Germany " ], c3);
  
            //  Change the language of Germany (deep data)
           c3.Language.Data  =   " Turkish " ;
           Report( " Altering Clone deep state, prototype unaffected " ,
               manager.prototypes[ " Germany " ], c3);

           Console.ReadLine();
        }
    }
}

 

 

代码

using  System;
using  System.Collections.Generic;
using  System.Runtime.Serialization;
using  System.Runtime.Serialization.Formatters.Binary;
using  System.IO;

namespace  PrototypePattern 
{
     //  Prototype Pattern        Judith Bishop  Nov 2007
     //  Serialization is used for the deep copy option
     //  The type T must be marked with the attribute [Serializable()]

    [Serializable()]
     public   abstract   class  IPrototype  < T >  
    {

          //  Shallow copy
          public  T Clone() 
         {
               return  (T)  this .MemberwiseClone();
         }

          // Deep Copy
            public  T DeepCopy() 
           {
               MemoryStream stream  =   new  MemoryStream();
               BinaryFormatter formatter  =   new  BinaryFormatter();
               formatter.Serialize(stream,  this );
               stream.Seek( 0 , SeekOrigin.Begin);
               T copy  =  (T) formatter.Deserialize(stream);
               stream.Close();
                return  copy;
           }
    }
}

 

 

 使用场景：

1、隐藏具体的类，不让客户端知道
2、在运行时通过原型类添加或删除新类
3、在系统中保持最小数量的类
4、适用于在运行时改变数据的结构
5、在C#3.0中使用深度克隆是非常简单的
Use the Prototype pattern when…
You want to:
•  Hide concrete classes from the client.
•  Add and remove new classes (via prototypes) at runtime.
•  Keep the number of classes in the system to a minimum.
•  Adapt to changing structures of data at runtime.

总结：
Prototype原型模式是一种创建型模式，解决“结构复杂对象”的创建工作。《设计模式》：使用原型实例创建指定的对象类型，然后通过拷贝这些原型来创建新的对象。原型模式是通过拷贝一个已存在的实例来创建新的对象，这一点和其他创建型模式不相同。
Prototype原型模式的几个要点：
1、Prototype原型模式隔离对象的使用者和具体类型之间的耦合关系，它同样要求这些要使用的类拥有“稳定的接口”。
2、Prototype原型模式采用克隆原型的方法来创建对象，它使得我们可以非常灵活地动态创建“拥有某些稳定接口”的新对象——所需工作仅仅是注册一个新类的对象（即原型），然后在任何需要的地方不断地Clone克隆。
3、Prototype模式中的Clone方法可以利用Object类的浅拷贝MemberwiseClone（）或者序列化来实现深拷贝DeepCopy（）。
这里面我们再来说说浅拷贝和深拷贝。对于Prototype模式是很重要的。浅拷贝和深拷贝的关键区别是对于对象内引用类型数据的拷贝。
public class ClassB
{}
public class MainClass
{
    int a;
    ClassB b;
}

我们用浅拷贝实现了两个对象MainClass1和MainClass2，对于MainClass1.a和MainClass2.a，他们是值类型，在MainClass2.a是新分配的内存，他们所有的内存空间是不一样，值是相等的，但是MainClass1.b和MainClass2.b，由于它们是引用类型，在浅拷贝时只是拷贝了MainClass1.b的地址给MainClass2的b成员，实际上MainClass1.b和MainClass2.b指向同一块内存。
但如果我们用深拷贝，MainClass1.b和MainClass2.b指向的是不同的内存地址。一般利用序列化和反序列化来实现深拷贝来创建新的引用类型。

转载于:https://www.cnblogs.com/utopia/archive/2010/03/01/1675548.html