设计模式学习之Prototype模式

    原型(Prototype)模式:用原型实例指定创建对象的种类，并通过复制这些原型创建新的对象。其实就是从一个对象再创建另外一个可定制的对象，而且可以不需要知道创建的细节。当一个对象生成不是通过New而是通过复制旧对象的时候，可以考虑使用原型模式。

    原型模式的UML如下：

    其中IPrototype定义了符合原型模式要求的类型特征，即至少有一个Clone()方法，客户端只依赖该接口。下面直接上例子吧，例子很简单，根据上面的类图敲出的代码：

    C#

     public interface IPrototype

     {

         string Name { get; set; }

         //PeopleEntity PeoPle { get; }

         IPrototype Clone();

     } 

     //public class PeopleEntity { }

 1     public class ConcretePrototype : IPrototype

 2     {

 3         public string Name { get; set; }

 4         //public PeopleEntity PeoPle { get { return this.people; } }

 5         //private  PeopleEntity people = new PeopleEntity();

 6 

 7         public IPrototype Clone()

 8         {

 9             return (IPrototype)this.MemberwiseClone();

         }

     }

    UnitTest

 1         [TestMethod()]

 2         public void PrototypeTest()

 3         {

 4             IPrototype sample = new ConcretePrototype();

 5             var clone = sample.Clone();

 6             Assert.IsNull(sample.Name);

 7             Assert.IsNull(clone.Name);

 8 

 9             sample.Name = "A";

             clone = sample.Clone();

             Assert.AreEqual<string>("A", clone.Name);

             Assert.IsInstanceOfType(clone, typeof(ConcretePrototype));

             clone.Name = "B";

             Assert.IsTrue(sample.Name != clone.Name);

             //Assert.AreEqual<int>(sample.PeoPle.GetHashCode(), clone.PeoPle.GetHashCode());

         }

 上面的例子可以得到以下的结论：

    1.克隆出的副本与原型具有一致的类型和状态（值）
    2.副本和原型之间相互独立，改变其中一个不会影响另一个

    但是这里用到的复制方法是MemberwiseClone()，一般翻译为浅复制、映像复制，它只会把栈中的数据逐位复制到一块新的空间。简单的说只会复制值类型，对于引用类型的只会复制引用而不复制对象，导致副本和原型的引用成员指向同一个对象（string是特殊的引用类型，只读，在这里表现为值类型）。把上面代码中注释去掉，即可验证这一点，会发现副本和原型引用成员PeoPle的HashCode是一致的，即同一个对象。

    为了解决这个问题就要引入深复制(Deep Copy)，它会将栈和堆中的数据全部都复制到另一块新开辟的内存中，这样副本和原型就完全独立了。浅复制最简单直接调用MemberwiseClone()方法就可以了，那深复制如何实现呢？首先想到的是手工逐层完成，遇到引用类型就要在新对象中重新new()一个独立实例，这太麻烦了，也很容易出错；另一个办法就是序列化：先将原型中的数据全部都序列化到string中，再反序列化，这样就得到了一个与原型完全一样，但却是在另一片内存中新对象即副本。这种解决办法很实用，只要为目标类型标记“Serializable” 或“NonSerialized”的标签(Attribute)即可，对于复杂的情况自己也可以定制ISerializable的序列化过程。下面上例子：

    Prototype Class

 1     [Serializable]

 2     public class UserInfo 

 3     {

 4         public string name;

 5         public readonly List<string> Education = new List<string>();

 6 

 7         public UserInfo GetShallowCopy()

 8         {

 9             return this.MemberwiseClone() as UserInfo;

         }

         public UserInfo GetDeepCopy()

         {

             return SerializationHelper.DeserializeStringToObject<UserInfo>(SerializationHelper.SerializeObjectToString(this));

         }

     }

    UnitTest

 1         [TestMethod]

 2         public void ShallCopyTest()

 3         {

 4             var user1 = new UserInfo();

 5             user1.name = "Hans";

 6             user1.Education.Add("A");

 7             var user2 = user1.GetShallowCopy();

 8 

 9             Assert.AreEqual<string>(user1.name, user2.name);

             Assert.AreEqual<string>(user1.Education[0], user2.Education[0]);

 

             user2.Education[0] = "B";

             Assert.AreNotEqual<string>("A", user1.Education[0]);

         }

 

         [TestMethod]

         public void DeepCopyTest()

         {

             var user1 = new UserInfo();

             user1.name = "Hans";

             user1.Education.Add("A");

             var user2 = user1.GetDeepCopy();

 

             Assert.AreEqual<string>(user1.name, user2.name);

             Assert.AreEqual<string>(user1.Education[0], user2.Education[0]);

 

             user2.Education[0] = "B";

             Assert.AreEqual<string>("A", user1.Education[0]);

         }

     对于原型类中不想或不需要被复制的成员可以为其标上“NonSerialized”的标签即可实现简单的定制复制过程。在注重性能的场合，应该尽量控制复制的范围，仅需要把最小集做进去，而不是图省事把实例整体复制，即只在需要复制的成员上标记“Serializable”。

    如果遇到更精细的复制需求呢，比如说上面的Education成员我们只需要前3条记录（如高中以后），这时就需要自己去实现ISerializable接口，定制符合需求的序列化过程，实现个性化复制。下面就直接上代码吧：

    CustomizedUserInfo

 1     [Serializable]

 2     public class CustomizedUserInfo : ISerializable

 3     {

 4         public string Name { get; set; }

 5         public int Age { get; set; }

 6         public string[] Education { get; set; }

 7 

 8         public CustomizedUserInfo() { }

 9 

         // Deserialization process

         public CustomizedUserInfo(SerializationInfo info, StreamingContext context)

         {

             Name = info.GetString("Name");

             Education = info.GetValue("Education", typeof(string[])) as string[];

         }

         // Customized serialization content process

         // Implement interface method.Will be automatically invoked when Serialization 

         public void GetObjectData(SerializationInfo info, StreamingContext context)

         {

             info.AddValue("Name", this.Name);

             // Only serialize the first 3 items according to the demand

             info.AddValue("Education", this.Education.Take(3).ToArray());

         }

         public CustomizedUserInfo GetCustomizedDeepCopy()

         {

             return SerializationHelper.DeserializeStringToObject<CustomizedUserInfo>(SerializationHelper.SerializeObjectToString(this));

         }

     }

    Unit Test

 1         [TestMethod]

 2         public void CustomizedCopyTest()

 3         {

 4             var user = new CustomizedUserInfo()

 5             {

 6                 Name = "Hans",

 7                 Age = 20,

 8                 Education = new string[] { "A", "B", "C", "D", "E" }

 9             };

             var clone = user.GetCustomizedDeepCopy();

 

             // Only serialize the first 3 items

             Assert.AreEqual<int>(3, clone.Education.Length);

             CollectionAssert.AreEqual(new string[] { "A", "B", "C" }, clone.Education);

             // Age is not serialized

             Assert.AreNotEqual<int>(user.Age, clone.Age);

             // Name serialized

             Assert.AreEqual<string>(user.Name, user.Name);

         }

 

    附上SerializationHelper工具类：

 1     public static class SerializationHelper

 2     {

 3         public static string SerializeObjectToString(object graph)

 4         {

 5             using (MemoryStream memoryStream = new MemoryStream())

 6             {

 7                 IRemotingFormatter formatter = new BinaryFormatter();

 8                 formatter.Serialize(memoryStream, graph);

 9                 Byte[] arrGraph = memoryStream.ToArray();

                 return Convert.ToBase64String(arrGraph);

             }

         }

 

         public static T DeserializeStringToObject<T>(string serializedGraph)

         {

             Byte[] arrGraph = Convert.FromBase64String(serializedGraph);

             using (MemoryStream memoryStream = new MemoryStream(arrGraph))

             {

                 IRemotingFormatter formatter = new BinaryFormatter();

                 return (T)formatter.Deserialize(memoryStream);

             }

         }

     }

   

    下面做个小结吧，原型模式是创建型模式中比较强调产品个体特征的模式，通过自我复制的过程实现新的实例创建，不同于工厂类。项目中，使用原型模式的关键不在于定于一个IPrototype接口，而是如何又好又快的按照需求完成复制过程。