設計模式-原型模式

public abstract class IYunSuan:ICloneable
    {
        public int result = 0;        

        public abstract void getResult(int num1, int num2);

        public abstract object Clone();
    }
    public class jia : IYunSuan
    {

        public override  void getResult(int num1, int num2)
        {
            result= num1 + num2;            
        }
        public override object Clone()
        {
            return (jia)this.MemberwiseClone();
        }

    }
    public class jian : IYunSuan, ICloneable
    {
        public override void getResult(int num1, int num2)
        {
            result = num1 - num2;
        }
        public override object Clone()
        {
            return (jian)this.MemberwiseClone();
        }
    }
    public class cheng : IYunSuan, ICloneable
    {
        public override void getResult(int num1, int num2)
        {
            result = num1 * num2;
        }
        public override object Clone()
        {
            return (cheng)this.MemberwiseClone();
        }
    }
    public class chu : IYunSuan, ICloneable
    {
        public override void getResult(int num1, int num2)
        {
            if (num2 == 0) result= 0;
            result= num1 / num2;
        }
        public override object Clone()
        {
            return (chu)this.MemberwiseClone();
        }
    }
    //原型里面帶引用對象,深度復制
    public class jia2 : IYunSuan
    {
        public tempObject temp;
        public jia2()
        {
            temp = new tempObject();
        }
        private jia2(tempObject _temp)
        {
            temp = (tempObject)_temp.Clone();
        }
        public override void getResult(int num1, int num2)
        {
            temp.num1 = num1;
            temp.num2 = num2;
            result = temp.num1 + temp.num2;
        }
        public void getTempResult(int num1, int num2)
        {
            temp.num1 = num1;
            temp.num2 = num2;            
        }
        public override object Clone()
        {
            jia2 j = new jia2(this.temp);            
            return j;
        }

    }
        //下面是原型工廠
        public interface IFactory
    {
        IYunSuan createYunSuanObj();
    }
    public class jiaFactory : IFactory
    {
        public IYunSuan createYunSuanObj()
        {
            return new jia();
        }
    }
    public class jianFactory : IFactory
    {
        public IYunSuan createYunSuanObj()
        {
            return new jian();
        }
    }
    public class chengFactory : IFactory
    {
        public IYunSuan createYunSuanObj()
        {
            return new cheng();
        }
    }
    public class chuFactory : IFactory
    {
        public IYunSuan createYunSuanObj()
        {
            return new chu();
        }
    }
    //深度復制
    public class jiaFactory2 : IFactory
    {
        public IYunSuan createYunSuanObj()
        {
            return new jia2();
        }
    }

        //前端
        static void Main(string[] args)
        {
            //IFactory factory = new jiaFactory();
            //var ajia = factory.createYunSuanObj();

            ///////第二個加法運算,和第一個加法并行存在，一般做法
            //var ajia2 = factory.createYunSuanObj();//重新new了下構造函數生成新的對象，

            ///////第二個加法運算,和第一個加法并行存在，使用原型模式,淺復制
            //var ajia2 = (jia)ajia.Clone();//省略了new,在內存里用流的方式復制生成新的對象.

            //ajia.getResult(1, 2);
            //ajia2.getResult(2, 3);
            //Console.WriteLine(ajia.result);            
            //Console.WriteLine(ajia2.result);
            //Console.ReadLine();

            ///////第二個加法運算,和第一個加法并行存在，使用原型模式，原型里面有引用對象，深復制
            IFactory factory2 = new jiaFactory2();
            var my = (jia2)factory2.createYunSuanObj();

            var my2 = (jia2)my.Clone();

            my.getTempResult(1, 2);
            my2.getTempResult(2, 3);
            Console.WriteLine(my.temp.num1.ToString()+"-"+my.temp.num2.ToString());
            Console.WriteLine(my2.temp.num1.ToString() + "-" + my2.temp.num2.ToString());
            Console.ReadLine();

        }

總結：用原型實例指定創建對象的種類，并且通過拷貝這些原型創建新的對象。
1、原型模式是以一個對象為原型，然后有復用的時候通過克隆的方式，重復出多個對象，一般情況下一個類如果需要被用到，就會new出對個對象，原型模式的話只需要new一個原型，省略了new的過程，實際是在內存中通過流的方式克隆了一塊相同的內存空間，性能提升了很多；
2、對象中如果引用了其他對象，那么這個引用對象不能被克隆，除非深度復制，深度復制是把每一層的淺復制結合起來，如果引用對象的層次太多，會很復雜。
3、原型模式用來優化工廠方法模式是非常好的，工廠方法模式每一個產品對象對應一個工廠，如果其中很多產品是相似的，那就會多出很多不必要的工廠，用原型模式復制一個產品，然后改變一下其中某些屬性，就成為了一個新的產品，這樣會特別省事省代碼還提高性能。