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

最新推荐文章于 2024-05-10 13:54:18 发布
最新推荐文章于 2024-05-10 13:54:18 发布
阅读量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 1630
众所周知，C#复制有深度复制和浅度复制，这里本人添加了它们与赋值运算（=）进行复制的的比较。
C#对象间赋值
qq_44284055的博客
03-27 3441
C#中的类都属于引用类型，引用类型变量的赋值只复制对对象的引用，而不复制对象本身（浅度复制）。即使用 ‘=’，是将对象的地址赋值给新对象。
C#中的对象深拷贝和浅拷贝
最新发布
sdgfafg_25的博客
05-10 475
在C#中，对象拷贝是指将一个对象的副本创建到另一个对象中。对象拷贝通常用于数据传输或创建对象的新实例。C#中有两种主要的拷贝方式：浅拷贝和深拷贝浅拷贝通常用于数据传输，因为它是快速且有效的。但是，如果需要避免意外修改原始对象，则应使用深拷贝。以下是一些有关何时使用浅拷贝和深拷贝的准则：使用浅拷贝：当需要快速创建对象副本时当原始对象不可变时当原始对象和副本不会同时使用时使用深拷贝：当需要避免意外修改原始对象时当原始对象和副本需要同时使用时当原始对象包含引用类型成员时Aigu。
C sharp(C#) 属性赋值的方法 以及 步骤
qq_44858151的博客
11-12 2826
一. 先看属性类型，如果是C#中预定义的15种，则直接赋值 怎样看：鼠标挪到属性身上，在提示框中看第一个单词 1、15种属性类型：(类型查看Fn+F12) （1） 整数(8种) 位：代表整数的取值范围，2的位数次方，求出来-1就是最大值 符号：代表能否取负数 sbyte(8位有符号整数)（**有符号正负各取一半**） byte(8位无符号整数)（0~255）**无符号指只取正的，不取负的** ...
C# 的赋值操作
Cupido
05-20 2345
using System; namespace demo_01 { class Program { static void Main(string[] args) { //声明局部变量 并且赋值200 int num2 = 200; //输出局部变量num2 Console.WriteLine(num2);
C# 克隆(Clone)中的深拷贝和浅拷贝
阿斌(Ben)的博客
12-15 448
原文地址：https://blog.csdn.net/wdeng2011/article/details/79415801
C#中属性赋值的步骤以及语法详解
无糖加冰
04-10 7444
零基础C#学习(一) 首先我们要先知道什么是C#? C#是由微软（Microsoft）开发，其中还包括C（面向过程）,C++ C#是一个简单的，现代的，通用的，面向对象的编程语言 (面向对象)是一种解决问题的思想 那么什么是对象? 在程序员的眼中自己身边万物都可以理解为对象 对象是指通过计算机语言实现一个由属性行为构成的实物也可以说是载体，通俗的说就是属性+行为就是对象 知道了C#和对象以后,让我...
一文搞懂c# await,async执行流
08-19
主要介绍了c# await，async执行流的相关知识，文章讲解的非常细致，代码帮助理解和学习，感兴趣的朋友可以了解下
一文搞懂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# 引用对象赋值时 为什么需要深度克隆
BangBangZuo的专栏
08-18 736
有基础的开发者都应该很明白，对象是一个引用类型，例如: 1 2 objectb=newobject(); objecta=b; 那么a指向的是b的地址，这样在有些时候就会造成如果修改a的值，那么b的值也会跟随着改变（a和b是同一个引用内存地址）。 举一个简单的栗子 1 2 3 4 5 6 7 8 9 10 11 12 13 14...
C#学习——赋值
Abbey_qi的博客
03-19 1900
赋值，从开始学编程就知道的东西，并常常用到。但是我被坑到了。赋值也有大学问啊~ 值传递和引用传递 关于赋值，首先就要考虑到常见的两个概念“值”和“引用”。 一、值类型和引用类型 C# 中的类型一共分为两类，一类是值类型(Value Type)，一类是引用类型(Reference Type)。 值类型包括结构体(struct)和枚举(enum)。 引用类型包括类(class)、接口(int...
深拷贝和浅拷贝(copy和deepcopy)详解
qq_45812313的博客
04-12 6240
1.对于不可变对象，浅拷贝和深拷贝没有区别，因为不可变对象的数据是无法被修改的，因此不存在共享数据的问题； 2. 对于可变对象，浅拷贝会创建一个新对象，其中包含原始对象的引用，因此新对象与原始对象共享数据；而深拷贝会递归地创建新对象，并将原始对象的数据复制到新对象中，因此新对象与原始对象之间不存在数据共享。
C#中的浅拷贝和深拷贝
君子务本
02-12 1290
C#中的浅拷贝和深拷贝前言啥叫拷贝？浅拷贝深拷贝通过序列化实现深拷贝使用Json实现的深拷贝总结 前言 在之前的文章中，我们提及了C#中的值类型和引用类型，同时也简单提到了C#中的拷贝，今天让我们来深入看看这个话题。   啥叫拷贝？ 拷贝又名复制，在计算机里面，拷贝的意思就是按照字节一一复制出一个全新的、和现有对象一模一样的对象，在C#中，拷贝又有浅拷贝和深拷贝的区别。   浅...
C# 浅拷贝与深拷贝（复制）
weixin_34001430的博客
09-16 662
在有些时候，我们需要从数据库读取数据填充对象或从硬盘读取文件填充对象，但是这样做相对耗时。这时候我们就想到了对象的拷贝。本文即以实例形式解析了C#浅拷贝和深拷贝的用法。 C#中有两种类型变量，一种 是值类型变量，一种是引用类型变量。对于前者，copy是属于全盘复制；而对后者，一般的copy只是浅copy，相当于只传递一个引用指针一样。因此 对于后者进行真正co...
C# 中的浅拷贝和深拷贝
ananlele_的专栏
10-13 2065
C＃中的浅复制和深复制示例 在本文中，我将通过示例讨论C＃中的浅拷贝和深拷贝。这是我们上一篇文章的续篇。因此，在继续本文之前，请阅读我们以前的文章，其中我们使用示例讨论了C＃中的原型设计模式。 浅复制和深复制在复制原型设计模式中的对象中起着重要作用。因此，在本文中，我们将通过示例讨论什么是“浅复制”和“深复制”以及它们之间的区别。 了解C＃中的浅表复制： 如果是“浅复制”，它将从现有对象创建新对象，然后将当前对象的值类型字段复制到新对象。但是在引用类型的情况下，它将仅复制引用，而不复制被引用对象本身
C#深拷贝和浅拷贝的区别
Summer_Jack的博客
01-20 1004
先上代码，后解释： public class Person { public int Age; public DateTime BirthDate; public string Name; public IdInfo IdInfo; /// <summary> /// 浅拷贝（在当前对象中：只对值类型进行拷贝，并在堆中创建新的对象。） /// </summary&.
一文搞懂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、付费专栏及课程。

余额充值