設計模式-原型模式
阿新 • • 發佈：2018-05-10
設計模式 原型模式
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、原型模式用來優化工廠方法模式是非常好的，工廠方法模式每一個產品對象對應一個工廠，如果其中很多產品是相似的，那就會多出很多不必要的工廠，用原型模式復制一個產品，然後改變一下其中某些屬性，就成為了一個新的產品，這樣會特別省事省代碼還提高性能。
設計模式-原型模式