Deep copy vs Shallow copy (MemberwiseClone method Introduction)

The MemberwiseClone method, which belongs to the namespace system, exists in assembly mscorlib.dll. The return value is System.Object. This means: Create a shallow copy of the current object object.

The official explanation in MSDN is:

The MemberwiseClone method creates a shallow copy by creating a new object and then copying the non-static field of the current object to the new object. If the field is of value type, a bitwise copy of the field is performed. If the field is a reference type, the referenced object is copied and not copied, so the original object and its replica refer to the same object.

For example, consider an object called X that references objects A and B. object B refers to object C in turn. a shallow copy of X creates a new object, X2, that also references objects A and B. In contrast, a deep copy of X creates a new object, X2, that references new objects A2 and B2 (replicas of A and B, respectively). B2 also refers to the new object C2,C2 is a copy of C. This example illustrates the difference between shallow and deep copy operations.

There are many ways to implement a deep copy operation, provided that the shallow copy operation is performed by the MemberwiseClone method but does not meet your needs. These requirements include:

1. Call the class constructor of the object you want to copy to create a second object containing the value of the property raised from the first object. This assumes that the value of the object is entirely defined by the class constructor.

2. Call the MemberwiseClone method to create a shallow copy of the object, and then specify the new object whose value is the same, and the value of any property or field of the original object is a reference type. The Deepcopy method in the example illustrates this approach.

3. Serialize the object to be deeply copied, and then restore the serialized data to another object variable.

4. Deep copy operations performed using reflection with recursion.

I'm guessing you've been dizzy since you've seen this. Oh, this rookie is such a drop ... In their unremitting efforts, and from the example of the experiment to understand, the original so-called shallow copy and deep copy is so simple Ah!

In fact, it's easy to understand the relationship between the shortcuts and the source files we use in the Windows operating system! I believe that everyone from playing the computer may have encountered such an embarrassing situation, is to use the U disk copy of the computer files, and then happily go to print, and then a print shop Open the U disk copy to the file, "Nani!" I can't open it! It is the original copy of a shortcut, the amount of & ... "(haha ...) Speaking of which, it is estimated that some people are very sympathetic! Right? ）

Shortcut: In fact, the equivalent is the reference source file, the shortcut does not exist in the source file object, just the address of a source file, this address point to the source file, when you double-click, Windows will go to your computer based on this address to find the source file and open. Just copy a shortcut, which is equivalent to a shallow copy.

Copy the source file: Copy the file's data, which is called deep replication.

Still don't understand? Let's see an example! (Inspired by: The prototype model of the big talk design model--resume copy)

Look at the class diagram first:

Shallow copy:

The client code is as follows

[CSharp]View Plaincopy

2. Resume Rbill = New Resume ("Bill");
4. Rbill.setpersonalinfo ("man", "11");
6. Rbill.setworkexperience ("2015-1-2-2015-12-10", "IBM");
10. Resume Rcindy = (resume) rbill.clone ();
12. Rcindy.setworkexperience ("2015-1-2 to 2015-11-11", "Microsoft");
16. Resume Rll = (resume) rbill.clone ();
18. Rll.setpersonalinfo ("Rll", "99");
20. Rll.setworkexperience ("2015-1-2 to 2015-11-11", "Oracle");
24. Rbill.display ();
26. Rcindy.display ();
28. Rll.display ();
30. Console.read ();

The code for the class is as follows:

[CSharp]View Plaincopy

2. Public class Resume:icloneable
4. {
6. private string name;
8. private string age;
10. private string sex;
12. //private string workdate;
14. //private string company;
16. private workexperience work;
18. Public Resume (string strName)
20. {
22. this.name = strName;
24. Work = new Workexperience ();  //Instantiate a Workexperience object while initializing the resume.
26. }
30. //provides a private constructor for the Clone method call to clone the data.
32. Private Resume (workexperience work)
34. {
36. this.work = (workexperience) work.  Clone ();
38. }
40. public void Setpersonalinfo (string sex, string age)
42. {
44. this.sex = sex;
46. this.age = age;
48. }
52. public void Setworkexperience (string workdate, string company)
54. {
56. Work. Workdate = workdate;
58. Work.company = Company;
62. }
66. public void Display ()
68. {
70. Console.WriteLine ("{0},{1},{2}", Name, sex, age);
72. Console.WriteLine ("{0},{1}", work.   Workdate, Work.company);  //reference the work class's properties, fields.
76. }
80. Public Object Clone ()
82. {
84. Resume obj = new Resume (this.work); //Call the private constructor, complete the clone, and assign a value to the relevant field of the Resume object, returning a deep copy of the Resume object
86. Obj.name = name;
88. Obj.sex = sex;
90. //obj.workdate = workdate;
92. Obj.age = age;
94. return obj;
96. //return (object) this.  MemberwiseClone ();
102. }
104. }
106. class Workexperience:icloneable
108. {
110. private string workdate;
112. private String Company;
116. public string workdate
118. {
120. get { return workdate;}
122. set {workdate = value;}
124. }
126. public string Company
128. {
130. get { return company;}
132. set {company = value;}
134. }
138. Public Object Clone ()
140. {
142. return (object) this.  MemberwiseClone ();
144. }
146. }

See here, there is no enlightened bright it?

Ok,that ' s it! Thank for your attention!

Deep copy vs Shallow copy (MemberwiseClone method Introduction)