一文搞懂C#中的赋值、深复制、浅复制

最新推荐文章于 2024-04-09 09:17:14 发布
最新推荐文章于 2024-04-09 09:17:14 发布
阅读量1w 收藏 22
点赞数 5
分类专栏： C# 白话C#高级编程 文章标签： C# ICloneabl Me berWiseClone 深度复
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27825451/article/details/81274668
版权

一、文字含义

先引入一个观念，赋值和深复制、浅复制并不是一样的，含义是不一样的。

本文所说的主要是针对“ 引用类型 ”本文以 “类 ”为例加以说明。一般的系统定义的值类型（int、double、float等等）此处不做考虑。

1、赋值。指的是 “ 等号= ”。它相当于是给引用对象起一个别名。

2、浅度复制和深度复制。指的是类实现 ICloneable接口，重写该接口的唯一方法。注意：不管是深度复制还是浅度复制，都是通过ICloneable接口去实现的。

二、实例代码

1、赋值

此处定义了一个父亲类Parent，他有三个属性 年龄Age，身高Height，孩子信息child，但是孩子信息又包含三个信息，即姓名Name,年龄Age，体重Weight。对于父类Parent而言，Age、Height是“ 值类型 ”，而成员child是“ 引用类型 ”。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 赋值_深度复制_浅度复制
{
    class Program
    {
        static void Main(string[] args)
        {
            Parent parent_01 = new Parent();
            parent_01.Age = 48;
            parent_01.Height = 173;
            parent_01.child = new Children("菲菲", 25, 55.55);
            Console.WriteLine("年龄：{0} 身高：{1} 孩子的信息为：{2} {3} {4}", parent_01.Age, parent_01.Height, parent_01.child.Name, parent_01.child.Age, parent_01.child.Weight);
            Parent parent_02 = parent_01;
            Console.WriteLine("年龄：{0} 身高：{1} 孩子的信息为：{2} {3} {4}", parent_02.Age, parent_02.Height, parent_02.child.Name, parent_02.child.Age, parent_02.child.Weight);
            Console.WriteLine("===========================================");
            parent_02.Age = 60;
            parent_02.Height = 189;
            parent_02.child.Age = 35;
            parent_02.child.Name = "宝宝";
            Console.WriteLine("年龄：{0} 身高：{1} 孩子的信息为：{2} {3} {4}", parent_01.Age, parent_01.Height, parent_01.child.Name, parent_01.child.Age, parent_01.child.Weight);
            Console.WriteLine("年龄：{0} 身高：{1} 孩子的信息为：{2} {3} {4}", parent_02.Age, parent_02.Height, parent_02.child.Name, parent_02.child.Age, parent_02.child.Weight);
        }
    }
    class Parent
    {
        private int age;
        private double height;
        public Children child;

        public Parent()
        {

        }

        public int Age { get => age; set => age = value; }
        public double Height { get => height; set => height = value; }
    }
    class Children
    {
        private string name;
        private int age;
        private double weight;
        public Children(string name,int age,double weight)
        {
            this.name = name;
            this.age = age;
            this.weight = weight;
        }

        public string Name { get => name; set => name = value; }
        public int Age { get => age; set => age = value; }
        public double Weight { get => weight; set => weight = value; }
    }
}

运行结果如下：

年龄：48 身高：173 孩子的信息为：菲菲 25 55.55
年龄：48 身高：173 孩子的信息为：菲菲 25 55.55
===========================================
年龄：60 身高：189 孩子的信息为：宝宝 35 55.55
年龄：60 身高：189 孩子的信息为：宝宝 35 55.55
请按任意键继续. . .

===================================================================

总结：parent_01和parent_02完全是共用的，不管是引用类型成员，还是值类型成员，都是共用的，parent_02任何成员改变，parent_01都会跟着改变。

2、浅复制

给父类Parent实现ICloneable接口，重写Clone方法，注意，默认的MemberWiseClone()就是系统实现的“ 浅度复制 ”。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 浅复制
{
    class Program
    {
        static void Main(string[] args)
        {
            Parent parent_01 = new Parent();
            parent_01.Age = 48;
            parent_01.Height = 173;
            parent_01.child = new Children("菲菲", 25, 55.55);
            Console.WriteLine("年龄：{0} 身高：{1} 孩子的信息为：{2} {3} {4}", parent_01.Age, parent_01.Height, parent_01.child.Name, parent_01.child.Age, parent_01.child.Weight);
            Parent parent_02 = parent_01.Clone() as Parent;
            Console.WriteLine("年龄：{0} 身高：{1} 孩子的信息为：{2} {3} {4}", parent_02.Age, parent_02.Height, parent_02.child.Name, parent_02.child.Age, parent_02.child.Weight);
            Console.WriteLine("===========================================");
            parent_02.Age = 60;
            parent_02.Height = 189;
            parent_02.child.Age = 35;
            parent_02.child.Name = "宝宝";
            Console.WriteLine("年龄：{0} 身高：{1} 孩子的信息为：{2} {3} {4}", parent_01.Age, parent_01.Height, parent_01.child.Name, parent_01.child.Age, parent_01.child.Weight);
            Console.WriteLine("年龄：{0} 身高：{1} 孩子的信息为：{2} {3} {4}", parent_02.Age, parent_02.Height, parent_02.child.Name, parent_02.child.Age, parent_02.child.Weight);
        }
    }
    class Parent:ICloneable
    {
        private int age;
        private double height;
        public Children child;

        public Parent()
        {

        }

        public int Age { get => age; set => age = value; }
        public double Height { get => height; set => height = value; }
        public object Clone()
        {
            return this.MemberwiseClone();  //浅复制
        }
    }
    class Children
    {
        private string name;
        private int age;
        private double weight;
        public Children(string name, int age, double weight)
        {
            this.name = name;
            this.age = age;
            this.weight = weight;
        }

        public string Name { get => name; set => name = value; }
        public int Age { get => age; set => age = value; }
        public double Weight { get => weight; set => weight = value; }
    }
}

运行结果为：

年龄：48 身高：173 孩子的信息为：菲菲 25 55.55
年龄：48 身高：173 孩子的信息为：菲菲 25 55.55
===========================================
年龄：48 身高：173 孩子的信息为：宝宝 35 55.55
年龄：60 身高：189 孩子的信息为：宝宝 35 55.55
请按任意键继续. . .

总结：从上可以看出，对于父亲类Parent的值类型成员，parent_01和parent_02是不共用的，parent_02改变，parent_01独立的，并不会改变；但是对于引用类型成员child，parent_01和parent_02是共用的，parent_02改变，parent_01也会跟着改变。

3、深度复制

深度复制的实现和浅度复制类似，只不过是重载的Clone方法实现不一样，具体可参见代码。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 深复制
{
    class Program
    {
        static void Main(string[] args)
        {
            Parent parent_01 = new Parent();
            parent_01.Age = 48;
            parent_01.Height = 173;
            parent_01.child = new Children("菲菲", 25, 55.55);
            Console.WriteLine("年龄：{0} 身高：{1} 孩子的信息为：{2} {3} {4}", parent_01.Age, parent_01.Height, parent_01.child.Name, parent_01.child.Age, parent_01.child.Weight);
            Parent parent_02 = parent_01.Clone() as Parent;
            Console.WriteLine("年龄：{0} 身高：{1} 孩子的信息为：{2} {3} {4}", parent_02.Age, parent_02.Height, parent_02.child.Name, parent_02.child.Age, parent_02.child.Weight);
            Console.WriteLine("===========================================");
            parent_02.Age = 60;
            parent_02.Height = 189;
            parent_02.child.Age = 35;
            parent_02.child.Name = "宝宝";
            Console.WriteLine("年龄：{0} 身高：{1} 孩子的信息为：{2} {3} {4}", parent_01.Age, parent_01.Height, parent_01.child.Name, parent_01.child.Age, parent_01.child.Weight);
            Console.WriteLine("年龄：{0} 身高：{1} 孩子的信息为：{2} {3} {4}", parent_02.Age, parent_02.Height, parent_02.child.Name, parent_02.child.Age, parent_02.child.Weight);
        }
    }
    class Parent : ICloneable
    {
        private int age;
        private double height;
        public Children child;

        public Parent()
        {

        }

        public int Age { get => age; set => age = value; }
        public double Height { get => height; set => height = value; }
        public object Clone()
        {
            Parent newparent = new Parent();
            newparent.Age = 48;newparent.Height = 173;
            newparent.child = new Children("菲菲", 25, 55.55);
            Object newParent = newparent;
            return newParent;  //深复制
        }
    }
    class Children
    {
        private string name;
        private int age;
        private double weight;
        public Children(string name, int age, double weight)
        {
            this.name = name;
            this.age = age;
            this.weight = weight;
        }

        public string Name { get => name; set => name = value; }
        public int Age { get => age; set => age = value; }
        public double Weight { get => weight; set => weight = value; }
    }
}

运行结果为：

年龄：48 身高：173 孩子的信息为：菲菲 25 55.55
年龄：48 身高：173 孩子的信息为：菲菲 25 55.55
===========================================
年龄：48 身高：173 孩子的信息为：菲菲 25 55.55
年龄：60 身高：189 孩子的信息为：宝宝 35 55.55
请按任意键继续. . .

总结：从上可以看出，对于父亲类Parent的所有成员，parent_01和parent_02是完全不共用的，parent_02改变，不管是改变父亲类Parent的值类型成员，还是应用类型成员，parent_01都是独立的，并不会改变。

三、总结

1、赋值。赋值和深度复制，浅度复制完全是不同的概念，并没有什么关系，很多文章说赋值对于值类型是深度复制，对于引用类型是浅度复制，这种说法是不正确的，它的本质是在线程栈上产生一样的副本。

2、浅度复制。值类型成员独立，但是引用类型成员共享。

3、深度复制。值类型成员和引用类型成员都是独立的，即完完全全的一个全新的副本，称之为深度复制。

有兴趣的可以参考python的深度复制和浅度复制，有类似的地方。

LoveMIss-Y
关注
  • 5
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
C#值类型、引用类型复制之比较
山阴夜雪满孤舟
07-25 1628
众所周知，C#复制有深度复制和浅度复制，这里本人添加了它们与赋值运算（=）进行复制的的比较。
一文搞懂c# await,async执行流
08-19
主要介绍了c# await，async执行流的相关知识，文章讲解的非常细致，代码帮助理解和学习，感兴趣的朋友可以了解下
C# 深入理解记录-浅拷贝和深拷贝
hisxiwu的博客
04-20 337
C# 深入理解记录-浅拷贝和深拷贝
C#引用类型的赋值 类的赋值
12-29
C#中除了基本类型以外的类型都是引用类型。引用类型的特点是，在堆栈中存储的是该引 用类型指向的堆中的“地址”。所以，当引用类型之间相互赋值的时候，只是将堆栈中的值 （可以理解为所指向的“堆”地址）相互赋值，这样一来他们指向的其实是一个地址。见下 面的例子:
C#类的成员变量赋值
最新发布
zhourongxiang1的博客
04-09 224
在outclass类中，给inClassd类的Code属性赋值
如果通过 C# 实现对象的深复制 ?
biyusr的专栏
07-11 296
NakedBrunch我想实现 之间的深复制，也就是在新的对象上修改不会影响到老的对象，我用了 C# 提供的 方法。 但貌似这样行不通，请问该如何正确实现？craastad如果你的是 json 友好的，那你完全可以借助第三方工具将其转为 ，比如 ，参考如下的 扩展方法。 然后像下面这样使用。 Stacked如果你要快速实现，建议使用对象映射化工具 , 它是一个高效并且轻量级的将一个对象转为另一个对象，它的底层使用的是 表达式树，参考如下代码： 上面的就是深copy后的对象，
C# 的赋值操作
Cupido
05-20 2340
using System; namespace demo_01 { class Program { static void Main(string[] args) { //声明局部变量 并且赋值200 int num2 = 200; //输出局部变量num2 Console.WriteLine(num2);
C#学习——赋值
Abbey_qi的博客
03-19 1895
赋值，从开始学编程就知道的东西，并常常用到。但是我被坑到了。赋值也有大学问啊~ 值传递和引用传递 关于赋值，首先就要考虑到常见的两个概念“值”和“引用”。 一、值类型和引用类型 C# 中的类型一共分为两类，一类是值类型(Value Type)，一类是引用类型(Reference Type)。 值类型包括结构体(struct)和枚举(enum)。 引用类型包括类(class)、接口(int...
一文搞懂C# 数据类型
08-18
值类型在内存中直接存储其值，当它们被赋值或传递时，会复制其存储的值。这意味着修改一个值类型变量不会影响到其他变量，因为每个变量都有自己的副本。例如，`int a = 10; int b = a;` 在这种情况下，`b` 和 `a` ...
一文搞懂C语言回调函数
01-27
我们先来看看百度百科是如何定义回调函数的：回调函数...下面我通过一幅图来说明什么是回调：假设我们要使用一个排序函数来对数组进行排序，那么在主程序(Mainprogram)中，我们先通过库，选择一个库排序函数(Library
一文看懂C#中List的扩容机制
08-19
C# 中 List 的扩容机制 本篇文章主要介绍了 C# 中 List 的扩容机制，以及其实现原理和应用场景。 一、背景 在前一篇文章中，我们讨论了 Dictionary 的扩容机制，而今天我们将深入探讨 List 的扩容机制。在实际开发...
C#中字段、属性、只读、构造函数赋值、反射赋值的问题
08-27
主要介绍了C#中字段、属性、只读、构造函数赋值、反射赋值的问题 ,非常不错，具有一定的参考借鉴借鉴价值，需要的朋友可以参考下
C#进阶之路（六）：表达式进行类的赋值
weixin_34112208的博客
09-07 566
　　好久没更新这个系列了，最近看.NET CORE源码的时候，发现他的依赖注入模块的很多地方用了表达式拼接实现的。比如如下代码 private Expression<Func<ServiceProviderEngineScope, object>> BuildExpression(IServiceCallSite callSite) { var conte...
C# 反射创建实例并赋值
一只不知疲倦的学习猿
01-08 614
C#反射创建实例
c# 两个具有相同属性的类赋值
xiongliuyun的博客
01-04 696
两个具有相同属性的类赋值 public static D Mapper<D, S>(S s) { D d = Activator.CreateInstance<D>(); try { var sType = s.GetType(); var dType = typeof(D); foreach (PropertyInfo sP in sType.GetPr
c#基础 函数传值
weixin_30323961的博客
07-31 76
随便新建个控制台程序做个演示！ 1、最基础，最普通的传值方式： static void Main(string[] args) { int x = test(10); Console.WriteLine("x:"+x); } public stati...
浅谈C#常用集合类的实现以及基本操作复杂度
anfeng4628的博客
02-11 158
List 集合类是顺序线性表，Add操作是O(1)或是O(n)的，由于List的容量是动态扩容的，在未扩容之前，其Add操作是O(1)，而在需要扩容的时候，会拷贝已存在的那些元素同时添加新的元素，此时的Add操作是O(n)的。而对于Contains方法，其是按照线性检索的，其复杂度是O(n)。而BinarySearch方法，其是按二分查找的，其复杂度是O(lg n)。 SortedLi...
通用编程训练-C#延迟赋值函数的实现
踏入神的领域
07-06 1259
public IEnumerator DelayAssignt(T v1, T v2, float time) { yield return new WaitForSeconds(time);  v1 = v2; } 问题：这个是错的，怎么改对？
C#值类型赋值和引用类型赋值
yulongguiziyao的专栏
02-11 1252
值类型保存的是实际数据，赋值的时候是把数据复制一份赋给另一个变量。 引用类型中保存的是“实际数据的指针”，赋值的时候是把指针复制一份，赋值给另一个引用变量，这两个指针指向相同的内存地址，有一个改变另一个同样改变。
一文搞懂CAN总线协议帧格式
06-07
CAN（Controller Area Network，控制器局域网）总线协议是一种广泛应用于工业自动化、汽车电子等领域的串行通讯协议。其帧格式如下： <img src="https://img-blog.csdnimg.cn/20200925125252655.png" width="400"> CAN总线协议的帧分为标准帧和扩展帧两种，其中标准帧包含11位标识符，扩展帧包含29位标识符。在CAN总线上，所有节点都可以同时发送和接收数据，因此需要在帧中包含发送方和接收方的信息。 帧格式的具体解释如下： 1. 帧起始符（SOF）：一个固定的位模式，表示帧的起始。 2. 报文控制（CTRL）：包含几个控制位，如IDE、RTR等。其中IDE表示标识符的类型，0表示标准帧，1表示扩展帧；RTR表示远程请求帧，0表示数据帧，1表示远程请求帧。 3. 标识符（ID）：11位或29位的标识符，用于区分不同的CAN消息。 4. 控制域（CTL）：包含几个控制位，如DLC、EDL等。其中DLC表示数据长度，即数据域的字节数；EDL表示数据长度是否扩展，0表示标准数据帧，1表示扩展数据帧。 5. 数据域（DATA）：0~8字节的数据。 6. CRC：用于校验数据是否正确。 7. 确认位（ACK）：由接收方发送的确认信息，表示数据是否正确接收。 8. 结束符（EOF）：一个固定的位模式，表示帧的结束。 以上就是CAN总线协议的帧格式。在实际应用中，节点之间通过CAN总线进行数据交换，通过解析帧中的各个字段，可以判断消息的发送方、接收方、数据内容等信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值