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、原型模式用来优化工厂方法模式是非常好的，工厂方法模式每一个产品对象对应一个工厂，如果其中很多产品是相似的，那就会多出很多不必要的工厂，用原型模式复制一个产品，然后改变一下其中某些属性，就成为了一个新的产品，这样会特别省事省代码还提高性能。

创新互联建站一直在为企业提供服务，多年的磨炼，使我们在创意设计，营销型网站到技术研发拥有了开发经验。我们擅长倾听企业需求，挖掘用户对产品需求服务价值，为企业制作有用的创意设计体验。核心团队拥有超过10多年以上行业经验，涵盖创意，策化，开发等专业领域，公司涉及领域有基础互联网服务雅安机房托管、成都app软件开发、手机移动建站、网页设计、网络整合营销。

标题名称：设计模式-原型模式
路径分享：http://myzitong.com/article/gpsije.html