Analysis and examples of the difference between c# deep copy and shallow copy

Deep copy means that the source object and the copied object are independent of each other, and changes to any one of them will not affect the other object. For example, a person named Zhang San is later used to clone (assuming the law allows) another person named Li Si. Whether Zhang San is missing arms and legs or Li Si is missing arms and legs, it will not affect the other person. . The more typical ones are Value objects, such as predefined types Int32, Double, structures (struct), enumerations (Enum), etc.

Shallow copy means that the source object and the copy object share an entity, only the referenced variables are different (different names). Changes to any one object will affect the other object. For example, a person was named Zhang San at first, but later changed his name to Li Si, but it is still the same person. Whether Zhang San is missing arms and legs or Li Si is missing arms and legs, this person is unlucky.

There are two types of variables in C#, one is a value type variable and the other is a reference type variable. For the former, copy is a full copy; while for the latter, the general copy is only a shallow copy, which is equivalent to passing only a reference pointer. Therefore, it is also the most troublesome to make a real copy of the latter. Specifically, the Clone method provided in the ICloneable interface must be implemented for it.

Look at the definition:
Shallow copy (shadow clone): only copies the basic type of the object, the object type still belongs to the original reference.
Deep copy (deep clone): does not copy the object The basic class of the object also copies the object in the original object. That is to say, the new object is completely generated.

The difference between shallow copy and deep copy
Shallow copy refers to copying the numerical type fields in the object Copy to a new object, and the reference field in the object means copying one of its references to the target object. If the value of a reference field in the target object is changed, it will be reflected in the original object, which means that the corresponding fields in the original object will also change. The difference between deep copy and shallow copy is the processing of references. Deep copy will create a new field in the new object that is the same as the corresponding field in the original object (the same content), that is to say, this reference is the same as the original object. References are different. When we change this field in the new object, it will not affect the content of the corresponding field in the original object. Therefore, there are two different processing methods for the prototype mode: shallow copy and deep copy of the object.

The difference between shallow copy and deep copy can be clearly seen through the example below. The code is as follows:

using System;
 using System.Collections.Generic;
 using System.Text;

 namespace WindowsApplication1
 {
     class Program
     {
         public class Sex
         {
             private string _PSex;
             public string PSex
             {
                 set
                 {
                     _PSex = value;
                 }
                 get
                 {
                     return _PSex;
                 }
             }

         }

         public class Person : ICloneable
         {

             private Sex _pSex = new Sex();
             public int aa = 1213;

             public string pSex
             {
                 set
                 {
                     _pSex.PSex = value;
                 }
                 get
                 {
                     return _pSex.PSex;
                 }
             }
             private string _PName;
             public string PName
             {
                 set
                 {
                     this._PName = value;
                 }
                 get
                 {
                     return this._PName;
                 }
             }

             public void ShowPersonInfo()
             {
                 Console.WriteLine("-------------------------");
                 Console.WriteLine("Name:{0} Sex:{1}", _PName, this.pSex);
                 Console.WriteLine("-------------------------");
                 Console.WriteLine(this.aa);
             }
             //浅拷贝
             public object Clone()
             {
                 return this.MemberwiseClone();
             }
             //深拷贝
             public object DeepClone()
             {
                 Person newP = new Person();
                 newP.PName = this._PName;
                 newP.pSex = this.pSex;
                 return newP;
             }

         }

         static void Main(string[] args)
         {
             Console.WriteLine("原对象:");
             Person p = new Person();
             p.PName = "JackLee";
             p.pSex = "男";

             p.ShowPersonInfo();

 
             //浅拷贝        
             Person copy = (Person)p.Clone();
             //深拷贝
             Person dcopy = (Person)p.DeepClone();

 
             Console.WriteLine("修改后的原对象:");
             p.PName = "JackZhao";
             p.pSex = "女";
             p.aa = 1111;
             p.ShowPersonInfo();

 
             Console.WriteLine("修改后的浅拷贝对象：");
             copy.ShowPersonInfo();
             Console.WriteLine("修改后的深拷贝对象：");
             dcopy.ShowPersonInfo();

             Console.WriteLine("直接拷贝对象：");
             Person PP = p;
             PP.ShowPersonInfo();

             Console.ReadLine();

 
         }

     }
 }

Okay, that’s it for the deep copy and shallow copy. The project is not finished yet. Hurry up first. The code can be copied directly into the project and run.

For more c# analysis and examples of the difference between deep copy and shallow copy, please pay attention to the PHP Chinese website!