原型模式(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(); 
        } 
    } 
 
原文地址:https://www.cnblogs.com/sujingnan/p/1741871.html