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

网站建设哪家好，找创新互联！专注于网页设计、网站建设、微信开发、微信平台小程序开发、集团企业网站建设等服务项目。为回馈新老客户创新互联还提供了诸暨免费建站欢迎大家使用！

另外有需要云服务器可以了解下创新互联scvps.cn，海内外云服务器15元起步，三天无理由+7*72小时售后在线，公司持有idc许可证，提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案，具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势，专为企业上云打造定制，能够满足用户丰富、多元化的应用场景需求。

当前文章：设计模式-原型模式-创新互联
本文网址：http://pwwzsj.com/article/dehjsi.html