C#中深拷贝和浅拷贝

一：概念

内存：用来存储程序信息的介质。

指针：指向一块内存区域，通过它可以访问该内存区域中储存的程序信息。（C#也是有指针的）

值类型：struct（整形、浮点型、decimal的内部实现都是struct）、enum、可空类型

引用类型：class、interface、delegate、数组、object、string。

二：深拷贝和浅拷贝的认识：

举个例子：

Myclass a=new Myclass();

Myclass b=a;

首先，深、浅拷贝与上面的语句并没有任何关系，要区分深、浅拷贝，关键要看“=”是如何重载的。

深拷贝：不管是值类型还是引用类型，都在内存中新建一块储存块，该储存块的内容（由b指向）与被拷贝的储存块（由a指向）的内容相同，并新建一个指针（b）指向该新建的储存块。所以对b的操作是不会影响a。

浅拷贝：对于值类型，拷贝一份值的副本；对于引用类型，拷贝一份指针的副本（该副本仍然指向原指针指向的内存块，即a、b指向同一块内存）。对b的值类型进行操作，不会影响a；对b的引用类型进行操作，会影响a。

对于浅拷贝，有一种奇怪的现象，即：若a中包含一个string类型的字段，对a进行浅拷贝，赋值给b，在b中改变这个string类型的字段，a中string类型字段不受影响。string类型明明是引用类型，按照上面的理解，修改b中的string字段，a中的string字段也该作出相应的改变，这是为什么呢？

我们不妨看看string的定义，会发现string被readonly关键字修饰了，即改变string的值时，就会重新分配内存空间。有兴趣的话可以了解一下“C#字符串不可变性”。

三：string

String是引用类型。究其原因，是因为string对象是不可变的，包括长度和其中任何字符都是不可以改变的。

关于不可变数据类型，请参考：https://www.cnblogs.com/mushroom/p/4373951.html

string 对象称为不可变的（只读），因为一旦创建了该对象，就不能修改该对象的值。有的时候看来似乎修改了，实际是string经过了特殊处理，每次改变值时都会建立一个新的string对象，变量会指向这个新的对象，而原来的还是指向原来的对象，所以不会改变。这也是string效率低下的原因。如果经常改变string的值则应该使用StringBuilder而不使用string。

在例子中str1=”ab”,这时在内存中就将“ab”存下来，如果再创建字符串对象，其值也等于“ab”，str2=”ab”,则并非再重新分配内存空间，而是将之前保存的“ab”的地址赋给str2的引用，这就能印证例子2中的结果。而当str1=”abc”其值发生改变时，这时检查内存，发现不存在此字符串，则重新分配内存空间，存储“abc”，并将其地址赋给str1，而str2依然指向“ab”的地址。可以印证例子中的结果。

String是引用类型，只是编译器对其做了特殊处理。

四：实例（原型模式）

1）浅拷贝：

声明一个将要被克隆的类 clsShallow 和它将要包含的引用类型成员clsRefSalary类，clsShallow包含 CompanyName(静态字符串)、Age(值类型)、EmployeeName(字符串)、EmpSalary(引用类型)四个成员。

public class clsShallow
    {
        public static string CompanyName = "My Company";
        public int Age;
        public string EmployeeName;
        public clsRefSalary EmpSalary;
 
        public clsShallow CreateShallowCopy(clsShallow inputcls)
        {
            return (clsShallow)inputcls.MemberwiseClone();
        }
    }
    public class clsRefSalary
    {
        public clsRefSalary(int _salary)
        {
            Salary = _salary;
        }
        public int Salary;
    }

再看如何调用：

 static void Main()
    {
        // Creates an instance of clsShallow and assign values to its fields.
        clsShallow objshallow = new clsShallow();
        objshallow.Age = 25;
        objshallow.EmployeeName = "Ahmed Eid";
        // add the ref value to the objshallow
        clsRefSalary clsref = new clsRefSalary(1000);
        objshallow.EmpSalary = clsref;
 
        // Performs a shallow copy of m1 and assign it to m2.
        clsShallow m2 = objshallow.CreateShallowCopy(objshallow);
        m2.Age = 20;
        m2.EmployeeName = "jay";
 
        // then modify the clsref salary value to be 2000
        clsref.Salary = 2000;
        // so the m1 object salary value become 2000
 
        Console.WriteLine(m2 == objshallow);
        Console.WriteLine(objshallow.EmpSalary.Salary);
        Console.WriteLine(m2.EmpSalary.Salary);
        Console.WriteLine(objshallow.Age);
        Console.WriteLine(m2.Age);
        Console.WriteLine(objshallow.EmployeeName);
        Console.WriteLine(m2.EmployeeName);
    }

最后看运行结果：

根据结果我们进行分析：

浅拷贝：

1、浅拷贝创建了类的一个新实例。（由对象的同一性得知：如果两个引用如m2 、 objshallow指向同一个对象的实例，则（m2 == objshallow）为true，而结果显示为  false，所以m2 和objshallow分别指向不同的实例，而objshallow引用所指向的实例是新创建的。

2、对于对象(clsShallow)中的引用类型成员(clsRefSalary)，引用被复制，但引用的实例没有被复制，即新创建实例中的引用成员(m2.EmpSalary)等于原实例的引用成员（objshallow.EmpSalary）。 因为改变 clsref.Salary 等于2000后，objshallow.EmpSalary 和m2.EmpSalary的Salary都改变了。其实可通过Console.WriteLine(objshallow.EmpSalary == m2.EmpSalary) 输出为true来解释。

3、值类型字段逐位复制到新实例。即改变m2.Age不影响objshallow.Age值。有人要问，string 为引用类型，为什么改变m2.EmployeeName = "jay"而objshallow.EmployeeName = "Ahmed Eid"没变呢？这是因为：字符串具有恒等性，一个字符串一旦被创建，我们就不能再将其变长、变短、或者改变其中的任何字符。

2） 深拷贝：

修改代码如下：

static void Main()
    {
        clsDeep objdeep = new clsDeep();
        objdeep.Age = 25;
        objdeep.EmployeeName = "Ahmed Eid";
 
        // add the ref value
        clsRefSalary clsref = new clsRefSalary(1000);
        objdeep.EmpSalary = clsref;
 
        // Performs a shallow copy of m1 and assign it to m2.
        clsDeep m2 = objdeep.CreateDeepCopy(objdeep);
 
        // then modify the clsref salary value to be 2000
        clsref.Salary = 2000;
 
        // so the m1 object salary value become 2000
        int EmpSalary = objdeep.EmpSalary.Salary;
        m2.Age = 20;
        m2.EmployeeName = "jay";
 
        // then modify the clsref salary value to be 2000
        clsref.Salary = 2000;
        // so the m1 object salary value become 2000
        Console.WriteLine(m2 == objdeep);
        Console.WriteLine(objdeep.EmpSalary.Salary);
        Console.WriteLine(m2.EmpSalary.Salary);
        Console.WriteLine(objdeep.EmpSalary == m2.EmpSalary);
        Console.WriteLine(objdeep.Age);
        Console.WriteLine(m2.Age);
        Console.WriteLine(objdeep.EmployeeName);
        Console.WriteLine(m2.EmployeeName);
    }
 
    [Serializable]
    // serialize the classes in case of deep copy
    public class clsDeep
    {
        public static string CompanyName = "My Company";
        public int Age;
        public string EmployeeName;
        public clsRefSalary EmpSalary;
        public clsDeep CreateDeepCopy(clsDeep inputcls)
        {
            MemoryStream m = new MemoryStream();
            BinaryFormatter b = new BinaryFormatter();
            b.Serialize(m, inputcls);
            m.Position = 0;
            return (clsDeep)b.Deserialize(m);
        }
    }
 
    [Serializable]
    public class clsRefSalary
    {
        public clsRefSalary(int _salary)
        {
            Salary = _salary;
        }
        public int Salary;
    }

记得加命名空间

using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

查看结果：

深拷贝：

1、深拷贝创建了类的一个新实例

2、对于实例中的引用类型成员，创建引用类型成员对象的新副本。 ( objshallow.EmpSalary != m2.EmpSalary)

3、值类型字段逐位复制到新实例。

其实，浅拷贝和深拷贝的本质区别是实例中的引用类型成员如何拷贝， 浅拷贝复制引用，深拷贝创建新实例。

注：无论浅、深拷贝，静态成员都不会复制，因为静态成员属于类成员。

3）深复制方法

/// <summary>
        /// Perform a deep Copy of the object.
        /// </summary>
        /// <typeparam name="T">The type of object being copied.</typeparam>
        /// <param name="source">The object instance to copy.</param>
        /// <returns>The copied object.</returns>
        public static T Clone<T>(this T source)
        {
            if (!typeof(T).IsSerializable)
            {
                throw new ArgumentException("The type must be serializable.", "source");
            }
 
            // Don't serialize a null object, simply return the default for that object
            if (Object.ReferenceEquals(source, null))
            {
                return default(T);
            }
 
            IFormatter formatter = new BinaryFormatter();
            Stream stream = new MemoryStream();
            using (stream)
            {
                formatter.Serialize(stream, source);
                stream.Seek(0, SeekOrigin.Begin);
                return (T)formatter.Deserialize(stream);
            }
        }