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

16 阅读 0 评论 0 点赞

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();

区别:

存储位置‌：
- ‌值类型‌：直接存储数据，例如整数、浮点数、结构体等。值类型变量在赋值或传递参数时会进行值的复制‌。
- ‌引用类型‌：存储的是对象的引用，而对象的数据存储在堆上。引用类型变量在赋值或传递参数时，传递的是引用‌。
‌内存管理‌：
- ‌值类型‌：内存分配和释放由编译器自动处理，不需要手动管理内存‌。
- ‌引用类型‌：需要手动进行内存管理，使用new关键字分配内存，并通过垃圾回收机制自动释放内存‌。
‌传递方式‌：
- ‌值类型‌：作为参数传递给方法时，是将变量的副本传递给方法‌。
- ‌引用类型‌：作为参数传递给方法时，传递的是引用，方法中对引用类型的变量进行的任何修改都会影响到原始对象‌。
‌可空性‌：
- ‌值类型‌：可以是可空的，即可以赋予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................................................................................................................................................................

本站资源均来自互联网，仅供研究学习，禁止违法使用和商用，产生法律纠纷本站概不负责！如果侵犯了您的权益请与我们联系！

转载请注明出处：免费源码网-免费的源码资源网站 » C# 创建型设计模式----原型模式

点赞(0) 打赏

本文分类：文章资讯
本文标签：C# 创建型设计模式----原型模式
浏览次数：16 次浏览
本文链接：https://freeymw.com/article/35016.html

上一篇 > 设计模式——装饰器模式
下一篇 > uniapp app.onshow 和 onMounted一样用吗

评论列表共有 0 条评论

暂无评论