Analyse et exemples de la différence entre la copie profonde c# et la copie superficielle

La copie profonde signifie que l'objet source et l'objet copié sont indépendants l'un de l'autre et que les modifications apportées à l'un d'entre eux n'affecteront pas l'autre objet. Par exemple, une personne nommée Zhang San est ensuite utilisée pour cloner (en supposant que la loi le permet) une autre personne nommée Li Si. Que Zhang San n'ait pas de bras et de jambes ou que Li Si n'ait pas de bras et de jambes, cela n'affectera pas l'autre personne. . Les plus typiques sont les objets Value, tels que les types prédéfinis Int32, Double, les structures (struct), les énumérations (Enum), etc.

La copie superficielle signifie que l'objet source et l'objet copie partagent une entité, seules les variables référencées sont différentes (noms différents). Les modifications apportées à un objet affecteront l’autre objet. Par exemple, une personne s'appelait d'abord Zhang San, mais a ensuite changé son nom en Li Si, mais c'est toujours la même personne. Que Zhang San n'ait pas de bras et de jambes ou que Li Si n'ait pas de bras et de jambes, cette personne n'a pas de chance. .

Il existe deux types de variables en C#, l'une est une variable de type valeur et l'autre est une variable de type référence. Pour le premier, la copie est une copie complète ; tandis que pour le second, la copie générale n'est qu'une copie superficielle, ce qui équivaut à transmettre uniquement un pointeur de référence. C'est donc aussi le plus gênant de faire une copie réelle de ce dernier. Concrètement, la méthode Clone fournie dans l'interface ICloneable doit être implémentée pour cela.

Regardez la définition :
Copie superficielle (clone fantôme) : copie uniquement le type de base de l'objet, le type d'objet appartient toujours à la référence d'origine
Copie profonde (clone profond) : ne copie pas l'objet de près. La classe de base de l'objet copie également l'objet dans l'objet original, c'est-à-dire qu'il est entièrement généré en tant que nouvel objet.

La différence entre la copie superficielle et la copie profonde<.> La copie superficielle fait référence à la copie des champs de type numérique dans l'objet Copier vers un nouvel objet, et le champ de référence dans l'objet signifie copier l'une de ses références vers l'objet cible. Si la valeur d'un champ de référence dans l'objet cible est modifiée, elle sera reflétée dans l'objet d'origine, ce qui signifie que les champs correspondants dans l'objet d'origine changeront également. La différence entre la copie profonde et la copie superficielle réside dans le traitement des références. La copie profonde créera un nouveau champ dans le nouvel objet qui est le même que le champ correspondant dans l'objet d'origine (le même contenu), c'est-à-dire cette référence. est le même que l'objet d'origine. Les références sont différentes. Lorsque nous modifions ce champ dans le nouvel objet, cela n'affectera pas le contenu du champ correspondant dans l'objet d'origine. Par conséquent, il existe deux méthodes de traitement différentes pour le mode prototype : la copie superficielle et la copie approfondie de l'objet.

La différence entre la copie superficielle et la copie profonde est clairement visible à travers l'exemple ci-dessous. Le code est le suivant :

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

 
         }

     }
 }

D'accord, c'est tout pour la copie profonde et la copie superficielle. le projet n’est pas encore terminé. Allez, dépêche-toi d’abord. Le code peut être copié directement dans le projet et exécuté.

Pour plus d'articles sur l'analyse des différences et des exemples de copie profonde c# et de copie superficielle, veuillez faire attention au site Web PHP chinois !