原型模式

原型模式（Prototype Pattern）是用於創建重複的對象，同時又能保證性能。其實就是從一個對象再創建另外一個可定製的對象，而且不需知道任何創建的的細節。這種類型的設計模式屬於創建型模式，它提供了一種創建對象的最佳方式。

這種模式是實現了一個原型接口，該接口用於創建當前對象的克隆。當直接創建對象的代價比較大時，則採用這種模式。例如，一個對象需要在一個高代價的數據庫操作之後被創建。我們可以緩存該對象，在下一個請求時返回它的克隆，在需要的時候更新數據庫，以此來減少數據庫調用。

介紹

意圖：用原型實例指定創建對象的種類，並且通過拷貝這些原型創建新的對象。

主要解決：在運行期建立和刪除原型。

何時使用： 1、當一個系統應該獨立於它的產品創建，構成和表示時。 2、當要實例化的類是在運行時刻指定時，例如，通過動態裝載。 3、當一個類的實例只能有幾個不同狀態組合中的一種時。建立相應數目的原型並克隆它們可能比每次用合適的狀態手工實例化該類更方便一些。

如何解決：利用已有的一個原型對象，快速地生成和原型對象一樣的實例。

關鍵代碼： 1、實現克隆操作，在 JAVA 繼承 Cloneable，重寫 clone()，在 .NET 中可以使用 Object 類的 MemberwiseClone() 方法來實現對象的淺拷貝或通過序列化的方式來實現深拷貝。 2、原型模式同樣用於隔離類對象的使用者和具體類型（易變類）之間的耦合關係，它同樣要求這些"易變類"擁有穩定的接口。

應用實例： 1、細胞分裂。 2、簡歷複製

優點： 每new一次，都需要執行一次構造函數，如果構造函數的執行時間很長，那麼多次的執行這個初始化操作就太低效了。一般在初始化的信息不發生變化的情況下，克隆是最好的方法，這即隱藏了對象創建的細節，又對性能是大大的提高。即不用重新初始化對象，而是動態地獲得對象運行的狀態。即性能提高並且逃避構造函數的約束。

缺點： 1、配備克隆方法需要對類的功能進行通盤考慮，這對於全新的類不是很難，但對於已有的類不一定很容易，特別當一個類引用不支持串行化的間接對象，或者引用含有循環結構的時候。 2、必須實現 ICloneable 接口。 3、逃避構造函數的約束。

使用場景： 1、資源優化場景。 2、類初始化需要消化非常多的資源，這個資源包括數據、硬件資源等。 3、性能和安全要求的場景。 4、通過 new 產生一個對象需要非常繁瑣的數據準備或訪問權限，則可以使用原型模式。 5、一個對象多個修改者的場景。 6、一個對象需要提供給其他對象訪問，而且各個調用者可能都需要修改其值時，可以考慮使用原型模式拷貝多個對象供調用者使用。 7、在實際項目中，原型模式很少單獨出現，一般是和工廠方法模式一起出現，通過 clone 的方法創建一個對象，然後由工廠方法提供給調用者。

注意事項：與通過對一個類進行實例化來構造新對象不同的是，原型模式是通過拷貝一個現有對象生成新對象的。淺拷貝實現 Cloneable，重寫，深拷貝是通過實現 Serializable 讀取二進制流。

實現

我們將創建一個抽象類 Shape 和擴展了 Shape 類的實體類。下一步是定義類 ShapeCache，該類把 shape 對象存儲在一個Hashtable 中，並在請求的時候返回它們的克隆。

PrototypPatternDemo，我們的演示類使用 ShapeCache 類來獲取 Shape 對象。

步驟 1

創建一個實現了 IClonable 接口的抽象類。IClonable源碼其實就是：

namespace System
{
    // 摘要: 
    //     支持克隆，即用與現有實例相同的值創建類的新實例。
    [ComVisible(true)]
    public interface ICloneable
    {
        // 摘要: 
        //     創建作爲當前實例副本的新對象。
        //
        // 返回結果: 
        //     作爲此實例副本的新對象。
        object Clone();
    }
}

Shape.cs

using System;
namespace Prototype_Pattern
{
   public abstract class Shape : ICloneable 
   {
       private string id;
       protected string type;
   
       public abstract void draw();

       public string getType()
       {
          return type;
       }

       public string getId()
       {
          return id;
       }

       public void setId(string id)
       {
          this.id = id;
       }

       public object Clone()
       {
           object clone = null;
           clone = this.MemberwiseClone();
           return clone;
       }
   }
}

步驟 2

創建擴展了上面抽象類的實體類。

Rectangle.cs

using System;
namespace Prototype_Pattern
{
    class Rectangle : Shape 
    {
        public Rectangle()
        {
            type = "Rectangle";
        }
        public override void draw()
        {
            Console.WriteLine("Inside Rectangle::draw() method.");
        }
    }
}

Square.cs

using System;
namespace Prototype_Pattern
{
   class Square : Shape
   {
       public Square()
       {
         type = "Square";
       }
       public override void draw()
       {
           Console.WriteLine("Inside Square::draw() method.");
       }
   }
}

Circle.cs

using System;
namespace Prototype_Pattern
{
   class Circle : Shape 
   {
       public Circle()
       {
           type = "Circle";
       }
       public override void draw()
       {
           Console.WriteLine("Inside Circle::draw() method.");
       }
   }
}

步驟 3

創建一個類，從數據庫獲取實體類，並把它們存儲在一個 Hashtable 中。

ShapeCache.cs

using System;
using System.Collections;
namespace Prototype_Pattern
{
    public class ShapeCache
    {
        private static Hashtable shapeMap = new Hashtable();
        public static Shape getShape(string shapeId)
        {
            if (shapeMap.ContainsKey(shapeId))
            {
                Shape cachedShape = (Shape)shapeMap[shapeId];
                return (Shape)cachedShape.Clone();
            }
            return null;
        }

        // 對每種形狀都運行數據庫查詢，並創建該形狀
        // shapeMap.Add(shapeKey, shape);
        // 例如，我們要添加三種形狀
        public static void loadCache()
        {
            Circle circle = new Circle();
            circle.setId("1");
            shapeMap.Add(circle.getId(), circle);

            Square square = new Square();
            square.setId("2");
            shapeMap.Add(square.getId(), square);

            Rectangle rectangle = new Rectangle();
            rectangle.setId("3");
            shapeMap.Add(rectangle.getId(), rectangle);
        }
    }
}

步驟 4

PrototypePatternDemo 使用 ShapeCache 類來獲取存儲在 Hashtable 中的形狀的克隆。

PrototypePatternDemo.cs

using System;
namespace Prototype_Pattern
{
    class PrototypePatternDemo 
    {
        static void Main(string[] args)
        {
            ShapeCache.loadCache();

            Shape clonedShape = ShapeCache.getShape("1");
            Console.WriteLine("Shape : " + clonedShape.getType());        

            Shape clonedShape2 = ShapeCache.getShape("2");
            Console.WriteLine("Shape : " + clonedShape2.getType());        

            Shape clonedShape3 = ShapeCache.getShape("3");
            Console.WriteLine("Shape : " + clonedShape3.getType());

            Console.Read();
        }
    }
}

步驟 5

驗證輸出。

Shape : Circle
Shape : Square
Shape : Rectangle

深拷貝與淺拷貝

MemberwiseClone方法：如果字段是值類型的，則對該字段進行逐位複製，如果字段是引用類型，則複製引用但不復制引用的對象，因此，原始對象及其複本引用同一對象。我們先看個例子：

using System;
using System.Collections.Generic;
using System.Text;

namespace 原型模式
{
    class Program
    {
        static void Main(string[] args)
        {
            Resume a = new Resume("大鳥");
            a.SetPersonalInfo("男", "29");
            a.SetWorkExperience("1998-2000", "XX公司");

            Resume b = (Resume)a.Clone();
            b.SetWorkExperience("1998-2006", "YY企業");

            Resume c = (Resume)a.Clone();
            c.SetPersonalInfo("男", "24");
            c.SetWorkExperience("1998-2003", "ZZ企業");

            a.Display();
            b.Display();
            c.Display();

            Console.Read();
        }
    }

    //簡歷
    class Resume : ICloneable
    {
        private string name;
        private string sex;
        private string age;

        private WorkExperience work;

        public Resume(string name)
        {
            this.name = name;
            work = new WorkExperience();
        }

        //設置個人信息
        public void SetPersonalInfo(string sex, string age)
        {
            this.sex = sex;
            this.age = age;
        }
        //設置工作經歷
        public void SetWorkExperience(string workDate, string company)
        {
            work.WorkDate = workDate;
            work.Company = company;
        }

        //顯示
        public void Display()
        {
            Console.WriteLine("{0} {1} {2}", name, sex, age);
            Console.WriteLine("工作經歷：{0} {1}", work.WorkDate, work.Company);
        }

        public Object Clone()
        {
            return (Object)this.MemberwiseClone();
        }

    }

    //工作經歷
    class WorkExperience
    {
        private string workDate;
        public string WorkDate
        {
            get { return workDate; }
            set { workDate = value; }
        }
        private string company;
        public string Company
        {
            get { return company; }
            set { company = value; }
        }
    }

}

輸出結果：

大鳥 男 29
工作經歷 1998-2003 ZZ 企業
大鳥 男 29
工作經歷 1998-2003 ZZ 企業
大鳥 男 24
工作經歷 1998-2003 ZZ 企業

這就說明了MemberwiseClone對於值類型的的複製，沒什麼問題，對於引用類型，就只是複製了引用，對引用的對象還是指向了原來的對象。所以會出現輸出情況中三個引用都是最後的設置。

淺拷貝：被複制對象的所有變量都含有與原來對象相同的值，而所有的對其他對象的引用都仍然指向原來的對象。

深拷貝：把引用對象的變量指向複製過的新對象，而不是原來的被引用對象。

爲了實現深拷貝，我們將程序修改爲：

using System;

namespace 原型模式
{
    class Program
    {
        static void Main(string[] args)
        {
            Resume a = new Resume("大鳥");
            a.SetPersonalInfo("男", "29");
            a.SetWorkExperience("1998-2000", "XX公司");

            Resume b = (Resume)a.Clone();
            b.SetWorkExperience("1998-2006", "YY企業");

            Resume c = (Resume)a.Clone();
            c.SetWorkExperience("1998-2003", "ZZ企業");

            a.Display();
            b.Display();
            c.Display();

            Console.Read();

        }
    }

    //簡歷
    class Resume : ICloneable
    {
        private string name;
        private string sex;
        private string age;

        private WorkExperience work;

        public Resume(string name)
        {
            this.name = name;
            work = new WorkExperience();
        }

        private Resume(WorkExperience work)
        {
            this.work = (WorkExperience)work.Clone();
        }

        //設置個人信息
        public void SetPersonalInfo(string sex, string age)
        {
            this.sex = sex;
            this.age = age;
        }
        //設置工作經歷
        public void SetWorkExperience(string workDate, string company)
        {
            work.WorkDate = workDate;
            work.Company = company;
        }

        //顯示
        public void Display()
        {
            Console.WriteLine("{0} {1} {2}", name, sex, age);
            Console.WriteLine("工作經歷：{0} {1}", work.WorkDate, work.Company);
        }

        public Object Clone()
        {
            Resume obj = new Resume(this.work);

            obj.name = this.name;
            obj.sex = this.sex;
            obj.age = this.age;


            return obj;
        }

    }

    //工作經歷
    class WorkExperience : ICloneable
    {
        private string workDate;
        public string WorkDate
        {
            get { return workDate; }
            set { workDate = value; }
        }
        private string company;
        public string Company
        {
            get { return company; }
            set { company = value; }
        }

        public Object Clone()
        {
            return (Object)this.MemberwiseClone();
        }
    }

}

輸出結果爲：

大鳥 男 29
工作經歷 1998-2000 XX 公司
大鳥 男 29
工作經歷 1998-2006 YY 企業
大鳥 男 29
工作經歷 1998-2003 ZZ 企業

設計模式【原型模式Prototype Pattern】

原型模式

介紹

實現

步驟 1

步驟 2

步驟 3

步驟 4

步驟 5

深拷貝與淺拷貝

DAPPER 事務 TRANSACTION

設計模式【中介者模式Mediator Pattern】

設計模式【原型模式Prototype Pattern】

設計模式【迭代器模式Iterator Pattern】

設計模式【過濾器模式Filter Pattern】

設計模式【解釋器模式Interpreter Pattern】

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結