原型模式（Prototype）

本文参考:http://www.cnblogs.com/QinBaoBei/archive/2010/05/22/1741661.html

本文只做学习笔记

简单的浅

using System;
namespace XixaoNan.A
{
    /// <summary>
    /// 声明一个抽象类
    /// </summary>
    public abstract class AbstractPrototype
    {
        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        public abstract AbstractPrototype Clone();
    }

    public class CreateProtoTypeA : AbstractPrototype
    {
        public CreateProtoTypeA(string name)
        {
            this.Name = name;
        }

        public override AbstractPrototype Clone()
        {
            /* 摘自 MSDN: 
            MemberwiseClone 方法创建一个浅表副本 
            方法是创建一个新对象 
            然后将当前对象的非静态字段复制到该新对象 
            如果字段是值类型的 
            则对该字段执行逐位复制 
            如果字段是引用类型 
            则复制引用但不复制引用的对象 
            因此，原始对象及其复本引用同一对象。 
            例如，考虑一个名为 X 的对象， 
            该对象引用对象 A 和 B,对象 B 又引用对象 C 
            X 的浅表副本创建一个新对象 X2,该对象也引用对象 A 和 B 
            与此相对照,X 的深层副本创建一个新对象 X2, 
            该对象引用新对象 A2 和 B2，它们分别是 A 和 B 的副本 
            B2 又引用新对象 C2，C2 是 C 的副本 
            使用实现 ICloneable 接口的类执行对象的浅表或深层复制 
          */
            return (AbstractPrototype)this.MemberwiseClone();

        }
    }
  
    public class Client
    {
        static void Main()
        {
            AbstractPrototype absA = new CreateProtoTypeA("A的名字");
            AbstractPrototype absB = absA.Clone();
            Console.WriteLine("A的名字是："+absA.Name);
            Console.WriteLine("B的名字是："+absB.Name);
            absB.Name = "B 新换的名字";
            Console.WriteLine("B的名字是：" + absB.Name);
            Console.ReadLine();
        }
    }
}

 深克隆方法

using System; 

  
    public class ConcreteProtoTypeA : ICloneable 
    { 
        private string name; 
        private Test test; 

        public string Name 
        { 
            get { return name; } 
            set { name = value; } 
        } 

        public ConcreteProtoTypeA(string name, Test test) 
        { 
            this.Name = name; 
            this.test = test; 
        } 

        public Object Clone() 
        { 
            //先同过现有的 Test 对象来克隆一个新的 Test 对象 
            Test myTest = (Test)this.test.Clone(); 
            //然后通过这个新的 Test 对象来实例化一个新的 ConcreteProtoTypeA 对象 
            return new ConcreteProtoTypeA(this.name, myTest); 
        } 

        public void SetTest(string test) 
        { 
            this.test.TestName = test; 
        } 

        public void DisplayTest() 
        { 
            Console.WriteLine(this.test.TestName); 
        } 
    } 
 
 

 
    public class Test : ICloneable 
    { 
        private string testName; 

        public string TestName 
        { 
            get { return testName; } 
            set { testName = value; } 
        } 

        public Test(string name) 
        { 
            this.TestName = name; 
        } 

        /// <summary> 
        /// 实现一个克隆 
        /// </summary> 
        /// <returns></returns> 
        public Object Clone() 
        { 
            return (Object)this.MemberwiseClone(); 
        } 
    }

       
 

  
    class Program 
    { 
        static void Main(string[] args) 
        { 
            Test test = new Test("BaoBeiMe"); 
            //首先是要实例化一个原型对象 
            ConcreteProtoTypeA prototypeA = new ConcreteProtoTypeA("A", test); 
            //根据这个原型对象来克隆一个新的对象 
            ConcreteProtoTypeA prototypeB = (ConcreteProtoTypeA)prototypeA.Clone(); 

            prototypeA.DisplayTest(); 
            prototypeB.DisplayTest(); 

            //修改新对象指向的引用对象 Test 
            prototypeB.SetTest("BoyXiao"); 
            Console.WriteLine("\n修改值后的结果：\n"); 
            prototypeA.DisplayTest(); 
            prototypeB.DisplayTest(); 

            Console.ReadKey(); 
        } 
    }