设计模式:原型模式

原型模式:PrototypePattern

 

通过一个已经存在的对象,利用其现有的条件,克隆生成一个全新的对象,在此基础上修改部分内容,形成全新对象实体

其实际关键点就在于一个可克隆的对象(以及深,浅克隆),通过代码可快速理解:

namespace Core
{
    /// <summary>
    /// 通过一个已经存在的对象,利用其现有的条件,克隆生成一个全新的对象,在此基础上修改部分内容,形成全新对象实体
    /// 1.克隆对象时对象的构造方法不执行
    /// 2.潜复制和深复制:
    ///   浅复制:Object类的clone方法只是复制本对象的原始数据类型,如int,float,string等,对于数组和对象等的引用是不会复制.
    ///   深复制:对于对象和数组进行复制行为
    /// </summary>
    public class Daylife:ICloneable//可克隆接口ICloneable
    {
        private string name;

        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        public void Work()
        {
            Console.Write(this.name+"上班 ");
        }
        public void Gohome()
        {
            Console.Write(this.name+"下班 ");
         }

        
        //实现接口的克隆方法
        public object Clone()
        {
            //调用object父类的MemberwiseClone()
            return base.MemberwiseClone();
        }
    }
}

ICloneable接口下有一个Clone()方法,调用.Net FrameWork公共父类Object下的一个MemberwiseClone()完成子类的克隆;

定义一个工厂(行为规范):

namespace IFactory
{
    using Core;
    public interface IDaylife
    {
        Daylife GetInstance();
    }
}

实现这个接口:

namespace Factory
{
    using IFactory;
    using Core;
   public  class DaylifeFactory:IDaylife
    {
       //一个静态的实例对象
       public static Daylife dl = null;
        public Core.Daylife GetInstance()
        {
            if (dl == null)
            {
                Console.Write("new ");
                dl=new Daylife();
                return dl;
            }
            else
            {
                Console.Write("clone ");
                return (Daylife)dl.Clone();
            }
        }  
    }
}

Daylife类型对象必须是static,第一次获取对象时使用new创建,当第二次开始,使用原型模式的克隆.

IDaylife fac = new DaylifeFactory();
            //第一次:创建对象
            Daylife daylife=fac.GetInstance();
            daylife.Name = "Francis";
            daylife.Work();
            daylife.Gohome();
            //部分修改:克隆
            daylife = fac.GetInstance();
            daylife.Name = "Lyfeng";
            daylife.Gohome();
            daylife.Work();

在这里有必要继续提出一个浅,深复制的概念:

 浅复制:Object类的clone方法只是复制本对象的原始数据类型,如int,float,string等,对于数组和对象等的引用是不会复制.

 深复制:对于对象和数组进行复制行为

为了验证,新建一个Test类

 public class Test:ICloneable
    {
        public ArrayList list = new ArrayList();
        public void set(string s)
        {
            list.Add(s);
        }
        public string get(int i)
        {
            return list[i].ToString();
        }

        public object Clone()
        {
            //浅复制
           // return base.MemberwiseClone();
            //深克隆
            Test t = (Test)base.MemberwiseClone();
            t.list = (ArrayList)list.Clone();
            return t;
        }
    }

客户端中调用:  //验证浅复制和深复制的区别
            Test t = new Test();
            t.set("one");
            t.set("two");
            for (int i = 0; i < t.list.Count; i++)
            {
                Console.Write("t:" + t.list[i] + " ");
            }
            Test t1 = (Test)t.Clone();
            t1.set("four");
            Console.WriteLine();
            for (int i = 0; i < t1.list.Count; i++)
            {
                Console.Write("t1:" + t1.list[i] + " ");
            }
            Console.WriteLine();
            for (int i = 0; i < t.list.Count; i++)
            {
                Console.Write("t:" + t.list[i] + " ");
            }

浅克隆的方法,会改变原有的对象和数组,深克隆则不会;

使用场合:

1. 1.       产生对象过程比较复杂,初始化需要许多资源时
2. 2.       希望框架原型和产生对象分开时
3. 3.       同一个对象可能会供其他调用者同时调用访问时

 

原型模式一般式和工厂模式一起使用,工厂复杂提供克隆对象给应用程序的调用者.