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软件开发、手机移动建站、网页设计、网络整合营销。
