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................................................................................................................................................................ 

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论

微信公众账号

微信扫一扫加关注

发表
评论
返回
顶部