C# 创建型设计模式----原型模式

1、值类型与引用类型、深拷贝与浅拷贝。

在了解原型模式前得先对这四个知识点有些了解。我先简单介绍一下这四个知识点。

1.1 值类型与引用类型(C#仅有这两种数据类型)

值类型:

常见的值类型：int、long、short、byte、float、double、bool、char、Struct（用户建立的结构体通常是值类型的）、Nullable Types(这是一个特殊的值类型，表示一个正常值或者空，比如int?)

所谓值类型就是其能直接用来表示一个值。不需要实例化等操作(new)，值类型变量声明后，不管是否已经赋值，编译器为其分配内存。

例如:

int a = 10;
int b = 20;

 值类型直接存储在内存（称之为栈（STACK），栈以LIFO访问，后进栈的数据先被访问，栈的大小是固定的，不是动态分配的，所以访问速度快）中，当把一个值赋值给另外一个变量时，其实是把变量的值复制给了新的变量，而不会改变原有值。

引用类型:

常见的引用类型包括类（class），接口（interface），数组（array），委托（delegate）等。

引用类型是存储数据的引用也就是内存地址，实际数据是存储在托管堆（Managed Heap）上，用new动态分配内存，由GC（垃圾回收器）释放。

例如:

MyClass my=new MyClass();

区别:

1. 存储位置‌：

   • ‌值类型‌：直接存储数据，例如整数、浮点数、结构体等。值类型变量在赋值或传递参数时会进行值的复制‌。
   • ‌引用类型‌：存储的是对象的引用，而对象的数据存储在堆上。引用类型变量在赋值或传递参数时，传递的是引用‌。

2. ‌内存管理‌：

   • ‌值类型‌：内存分配和释放由编译器自动处理，不需要手动管理内存‌。
   • ‌引用类型‌：需要手动进行内存管理，使用new关键字分配内存，并通过垃圾回收机制自动释放内存‌。

3. ‌传递方式‌：

   • ‌值类型‌：作为参数传递给方法时，是将变量的副本传递给方法‌。
   • ‌引用类型‌：作为参数传递给方法时，传递的是引用，方法中对引用类型的变量进行的任何修改都会影响到原始对象‌。

4. ‌可空性‌：

   • ‌值类型‌：可以是可空的，即可以赋予null值‌。
   • ‌引用类型‌：本身就是引用，可以直接赋予null值‌

1.2、深克隆与浅克隆

浅克隆（Shallow Clone）

浅克隆是指复制对象的所有值类型字段，而对于引用类型字段，只是复制其引用地址，而不是复制引用的对象本身。这意味着，如果对象中包含引用类型的字段，改变目标对象中引用类型字段的值将反映到原始对象中，因为它们指向的是同一个堆上的地址‌

这有两个类，我们对其进行一个浅拷贝

/// <summary>
/// 引用类型
/// </summary>
public class Other
{public int Id { get; set; }
}public class MyClass{/// <summary>/// 值类型/// </summary>public int age { get; set; }/// <summary>/// 引用类型/// </summary>public Other other { get; set; }/// <summary>/// 浅拷贝/// </summary>/// <returns></returns>public MyClass RetureCopy(){return (MyClass)this.MemberwiseClone();//C#提供的浅拷贝方法}}

上面这个MyClass里既有引用类型也有值类型，下面是拷贝 

 private void WTBtn_Click(object sender, EventArgs e){//实例化一个引用类型MyClass my = new MyClass();my.name = "张三";my.age = 12;var other = my;//直接赋值也是浅拷贝。var AA = my.RetureCopy();//浅拷贝。other.name = "李四";//因为是引用类型，所以给other赋值，my相应的值也会改变other.age = 15;}

 我们在赋值前打个断点看一下拷贝的AA对象的值发现完全等于my

 然后继续改变AA的值发现怎么my的age值没有改变，但是里面的引用类型other的Id值跟着变成51了。

由此可以看出浅拷贝下，对象中包含引用类型的字段，改变目标对象中引用类型字段的值将反映到原始对象中。这是因为浅拷贝的引用类型仅拷贝的是内存地址，虽然是两个对象中不同的other对象，但其根本是指向同一个值的。

这里需要说明一下直接赋值的情况:如: var AA = my;这种也类似浅拷贝。其根本就是将my的内存地址赋给AA。所以改变AA里的所有字段，my的字段值也会跟着改变。

深克隆（Deep Clone）

深克隆不仅复制对象的所有值类型字段，还会复制引用类型字段所指向的对象。这样，深拷贝后的对象与源对象完全独立，其中一个对象的改动不会影响到另一个对象。例如，如果有一个包含引用类型字段的对象，深克隆会复制这个引用类型字段所指向的对象，而不是仅仅复制引用地址‌。

还是以这两个类举例(改变一些东西，对照上面的看深拷贝与浅拷贝的区别): 

 /// <summary>/// 引用类型/// </summary>[Serializable]public class Other{public int Id { get; set; }}[Serializable]//表示此类可以序列化，深克隆必须声明该特性public class MyClass{/// <summary>/// 值类型/// </summary>public int age { get; set; }/// <summary>/// 引用类型/// </summary>public Other other { get; set; }/// <summary>/// 浅拷贝/// </summary>/// <returns></returns>public MyClass RetureCopy(){return (MyClass)this.MemberwiseClone();//C#提供的浅拷贝方法}/// <summary>/// 深克隆(该方法可写到其他地方)/// </summary>/// <typeparam name="T"></typeparam>/// <param name="obj"></param>/// <returns></returns>public  T DeepClone<T>(T obj){using (var memoryStream = new MemoryStream()){var formatter = new BinaryFormatter();formatter.Serialize(memoryStream, obj);memoryStream.Position = 0;return (T)formatter.Deserialize(memoryStream);}}}

进行深拷贝,可以看出对AA赋值再也影响不到my对象:

 private void WTBtn_Click(object sender, EventArgs e){//实例化一个引用类型MyClass my = new MyClass();my.other = new Other();my.other.Id = 21;my.age = 12;var AA = my.DeepClone<MyClass>(my);//深拷贝。//虽然other是引用类型，但深拷贝后无法影响原来的对象AA.age = 15;AA.other.Id = 51;}

通过对比发现，只有引用类型受深拷贝浅拷贝的影响，值类型都是深拷贝!!

到这大概对深克隆，浅克隆有个大概映像了吧，那我们说正题，原型模式。

2、原型模式

2.1 基本介绍

具体可分为2个角色：

  Prototype（原型类）：声明一个Clone(克隆)自身的接口；

  ConcretePrototype（具体原型类）：，实现一个Clone(克隆)自身的操作。

在原型模式中，Prototype通常提供一个包含Clone方法的接口，具体的原型ConcretePrototype使用Clone方法完成对象的创建。

本质：通过拷贝这些原型对象创建新的对象。

根据其本质可以理解，原型本身就是通过一个自身的Clone方法来进行自我复制，从而产生新的对象。

既然是自我拷贝，那也就分为深拷贝与浅拷贝(具体参考上面)。

浅拷贝：通过this.MemberWiseClone()，对实例的值类型进行拷贝（包含string类型），对引用类型只拷贝了引用。浅拷贝只对值类型成员进行复制，对于引用类型，只是复制了其引用，并不复制其对象。

深拷贝：需要通过反射和序列化来实现。

 2.2 应用场景

对象在创建（new）时，消耗资源过多或繁琐耗时。本质就是在对象的构造函数中有耗时长或者占用系统资源多的情况，使用原型模式进行复制对象时，可以省去这些耗时耗力的操作，直接获得对象的具体实例。

最常见的使用场景之一就是对象历史节点的保存，比如在对对象进行操作一次后，进行一次复制保存当前状态（恢复到某一历史状态），可实现撤销操作。

2.3 具体实例

原型类

    /// <summary>/// 原型类/// </summary>[Serializable]//表示此类可以序列化，深克隆必须声明该特性public abstract class MyClass{/// <summary>/// 值类型/// </summary>public int age { get; set; }/// <summary>/// 引用类型/// </summary>public Other other { get; set; }/// <summary>/// 拷贝方法/// </summary>/// <returns></returns>public abstract MyClass Clone();}

 具体原型类(浅拷贝)

    /// <summary>/// 创建具体原型/// </summary>public class My : MyClass{/// <summary>/// 浅克隆/// </summary>/// <returns></returns>public override MyClass Clone(){return (MyClass)base.MemberwiseClone();}}

使用

private void WTBtn_Click(object sender, EventArgs e)
{//实例化一个引用类型My my = new My();my.other = new Other();my.other.Id = 21;my.age = 12;Console.WriteLine($"拷贝前:other.Id:{my.other.Id}，age{my.age}");var AA = my.Clone();//深拷贝。AA.age = 15;AA.other.Id = 51;Console.WriteLine($"拷贝后:other.Id:{my.other.Id}，age{my.age}");
}

具体原型类(深拷贝) 

 [Serializable]public class My : MyClass{/// <summary>/// 深克隆/// </summary>/// <returns></returns>public override MyClass Clone(){using (var memoryStream = new MemoryStream()){var formatter = new BinaryFormatter();formatter.Serialize(memoryStream, this);memoryStream.Position = 0;return (MyClass)formatter.Deserialize(memoryStream);}}}

使用

private void WTBtn_Click(object sender, EventArgs e)
{//实例化一个引用类型My my = new My();my.other = new Other();my.other.Id = 21;my.age = 12;Console.WriteLine($"拷贝前:other.Id:{my.other.Id}，age{my.age}");var AA = my.Clone();//深拷贝。AA.age = 15;AA.other.Id = 51;Console.WriteLine($"拷贝后:other.Id:{my.other.Id}，age{my.age}");
}

结语:知道什么是深克隆什么是浅克隆后，原型模式理解起来就不会有太大的困难了。

END................................................................................................................................................................