[No0000B9]C# 类型基础 值类型和引用类型 及其 对象复制 浅度复制vs深度复制 深入研究2

接上[No0000B5]C# 类型基础 值类型和引用类型 及其 对象判等 深入研究1

对象复制

有的时候，创建一个对象可能会非常耗时，比如对象需要从远程数据库中获取数据来填充，又或者创建对象需要读取硬盘文件。此时，如果已经有了一个对象，再创建新对象时，可能会采用复制现有对象的方法，而不是重新建一个新的对象。

本节就讨论如何进行对象的复制。

1.浅度复制

浅度复制和深度复制是以如何复制对象的成员(member)来划分的。

一个对象的成员有可能是值类型，有可能是引用类型。当我们对对象进行一个浅度复制的时候，对于值类型成员，会复制其本身(值类型变量本身包含了所有数据，复制时进行按位拷贝)；对于引用类型成员(注意它会引用另一个对象)，仅仅复制引用，而不创建其引用的对象。结果就是：新对象的引用成员和复制对象的引用成员指向了同一个对象。

继续我们上面的例子，如果我们想要进行复制的对象(RefLine)是这样定义的，(为了避免look up（向前翻），我在这里把代码再贴过来)：

    // 将要进行浅度复制的对象，注意为引用类型
    public class RefLine
    {
        public RefPoint RPoint;
        public ValPoint VPoint;

        public RefLine(RefPoint rPoint, ValPoint vPoint)
        {
            this.RPoint = rPoint;
            this.VPoint = vPoint;
        }
    }

    // 定义一个引用类型成员
    public class RefPoint
    {
        public int X;

        public RefPoint(int x)
        {
            X = x;
        }
    }

    // 定义一个值类型成员
    public struct ValPoint
    {
        public int X;

        public ValPoint(int x)
        {
            X = x;
        }
    }

    class Program
    {
        private static void Main()
        {
            RefPoint rPoint = new RefPoint(1);
            ValPoint vPoint = new ValPoint(1);
            RefLine line = new RefLine(rPoint, vPoint);
        }
    }

我们先创建一个想要复制的对象，它所产生的实际效果是(堆栈上仅考虑line部分)：

 

那么当我们对它复制时，就会像这样(newLine是指向新拷贝的对象的指针，在代码中体现为一个引用类型的变量)：

按照这个定义，再回忆上面我们讲到的内容，可以推出这样一个结论：当复制一个结构类型成员的时候，直接创建一个新的结构类型变量，然后对它赋值，就相当于进行了一个浅度复制，也可以认为结构类型隐式地实现了浅度复制。如果我们将上面的RefLine定义为一个结构(Struct)，结构类型叫ValLine，而不是一个类，那么对它进行浅度复制就可以这样：

ValLine newLine = line;

实际的效果图是这样：

现在你已经已经搞清楚了什么是浅度复制，知道了如何对结构浅度复制。那么如何对一个引用类型实现浅度复制呢？在.Net Framework中，有一个ICloneable接口，我们可以实现这个接口来进行浅度复制(也可以是深度复制，这里有争议，国外一些人认为ICloneable应该被标识为过时(Obsolete)的，并且提供IShallowCloneable和IDeepCloneble来替代)。这个接口只要求实现一个方法Clone()，它返回当前对象的副本。我们并不需要自己实现这个方法(当然完全可以)，在System.Object基类中，有一个保护的MemeberwiseClone()方法，它便用于进行浅度复制。所以，对于引用类型，如果想要实现浅度复制时，只需要调用这个方法就可以了：

        public object Clone()
        {
            return MemberwiseClone();
        }

 

现在我们来做一个测试：

using System;

// 将要进行浅度复制的对象，注意为引用类型
public class RefLine
{
    public RefPoint RPoint;
    public ValPoint VPoint;

    public RefLine(RefPoint rPoint, ValPoint vPoint)
    {
        RPoint = rPoint;
        VPoint = vPoint;
    }

    public object Clone()
    {
        return MemberwiseClone();
    }
}

// 定义一个引用类型成员
public class RefPoint
{
    public int X;

    public RefPoint(int x)
    {
        X = x;
    }
}

// 定义一个值类型成员
public struct ValPoint
{
    public int X;

    public ValPoint(int x)
    {
        X = x;
    }
}

internal class Program
{
    private static void Main(string[] args)
    {
        var rPoint = new RefPoint(1);
        var vPoint = new ValPoint(1);
        var line = new RefLine(rPoint, vPoint);

        var newLine = (RefLine) line.Clone();
        Console.WriteLine("Original: line.rPoint.x = {0}, line.vPoint.x = {1}", line.RPoint.X, line.VPoint.X); //Original: line.rPoint.x = 1, line.vPoint.x = 1
        Console.WriteLine("Cloned: newLine.rPoint.x = {0}, newLine.vPoint.x = {1}", newLine.RPoint.X, newLine.VPoint.X); //Cloned: newLine.rPoint.x = 1, newLine.vPoint.x = 1

        line.RPoint.X = 10; // 修改原先的line的引用类型成员 rPoint
        line.VPoint.X = 10; // 修改原先的line的值类型的成员 vPoint
        Console.WriteLine("Original: line.rPoint.x = {0}, line.vPoint.x = {1}", line.RPoint.X, line.VPoint.X); //Original: line.rPoint.x = 10, line.vPoint.x = 10
        Console.WriteLine("Cloned: newLine.rPoint.x = {0}, newLine.vPoint.x = {1}", newLine.RPoint.X, newLine.VPoint.X); //Cloned: newLine.rPoint.x = 10, newLine.vPoint.x = 1
    }
}

 

输出为：

Original: line.rPoint.x = 1, line.vPoint.x = 1
Cloned: newLine.rPoint.x = 1, newLine.vPoint.x = 1
Original: line.rPoint.x = 10, line.vPoint.x = 10
Cloned: newLine.rPoint.x = 10, newLine.vPoint.x = 1

可见，复制后的对象和原先对象成了连体婴，它们的引用成员字段依然引用堆上的同一个对象。

2.深度复制

其实到现在你可能已经想到什么时深度复制了，深度复制就是将引用成员指向的对象也进行复制。实际的过程是创建新的引用成员指向的对象，然后复制对象包含的数据。

深度复制可能会变得非常复杂，因为引用成员指向的对象可能包含另一个引用类型成员，最简单的例子就是一个线性链表。

如果一个对象的成员包含了对于线性链表结构的一个引用，浅度复制只复制了对头结点的引用，深度复制则会复制链表本身，并复制每个结点上的数据。

考虑我们之前的例子，如果我们期望进行一个深度复制，我们的Clone()方法应该如何实现呢？

    public object DeepClone()// 深度复制
    {       
        RefPoint rPoint = new RefPoint(this.RPoint.X);  // 对于引用类型，创建新对象,并复制当前引用类型成员的值到新对象
        ValPoint vPoint = this.VPoint;                  // 值类型，直接赋值
        RefLine newLine = new RefLine(rPoint, vPoint);
        return newLine;
    }

 

可以看到，如果每个对象都要这样去进行深度复制的话就太麻烦了，我们可以利用串行化/反串行化来对对象进行深度复制：先把对象串行化(Serialize)到内存中，然后再进行反串行化，通过这种方式来进行对象的深度复制：

    public object SerializeDeepClone()
    {
        BinaryFormatter binaryFormatter = new BinaryFormatter();
        MemoryStream serializationStream = new MemoryStream();
        binaryFormatter.Serialize(serializationStream, this);
        serializationStream.Position = 0;
        return (binaryFormatter.Deserialize(serializationStream)); ;
    }

 

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


// 将要进行浅度复制的对象，注意为引用类型
[Serializable]
public class RefLine
{
    public RefPoint RPoint;
    public ValPoint VPoint;

    public RefLine(RefPoint rPoint, ValPoint vPoint)
    {
        RPoint = rPoint;
        VPoint = vPoint;
    }

    public object Clone()
    {
        return MemberwiseClone();
    }

    public object DeepClone()// 深度复制
    {       
        RefPoint rPoint = new RefPoint(this.RPoint.X);  // 对于引用类型，创建新对象,并复制当前引用类型成员的值到新对象
        ValPoint vPoint = this.VPoint;                  // 值类型，直接赋值
        RefLine newLine = new RefLine(rPoint, vPoint);
        return newLine;
    }

    public object SerializeDeepClone()
    {
        BinaryFormatter binaryFormatter = new BinaryFormatter();
        MemoryStream serializationStream = new MemoryStream();
        binaryFormatter.Serialize(serializationStream, this);
        serializationStream.Position = 0;
        return (binaryFormatter.Deserialize(serializationStream)); ;
    }
}

// 定义一个引用类型成员
[Serializable]
public class RefPoint
{
    public int X;
    public RefPoint() {}

    public RefPoint(int x)
    {
        X = x;
    }
}

// 定义一个值类型成员
[Serializable]
public struct ValPoint
{
    public int X;

    public ValPoint(int x)
    {
        X = x;
    }
}

class Program
{
    static void Main(string[] args)
    {
        var rPoint = new RefPoint(1);
        var vPoint = new ValPoint(1);
        var line = new RefLine(rPoint, vPoint);

        var newLine = (RefLine)line.SerializeDeepClone();
        Console.WriteLine("Original: line.rPoint.x = {0}, line.vPoint.x = {1}", line.RPoint.X, line.VPoint.X); //Original: line.rPoint.x = 1, line.vPoint.x = 1
        Console.WriteLine("Cloned: newLine.rPoint.x = {0}, newLine.vPoint.x = {1}", newLine.RPoint.X, newLine.VPoint.X); //Cloned: newLine.rPoint.x = 1, newLine.vPoint.x = 1

        line.RPoint.X = 10; // 修改原先的line的引用类型成员 rPoint
        line.VPoint.X = 10; // 修改原先的line的值类型的成员 vPoint
        Console.WriteLine("Original: line.rPoint.x = {0}, line.vPoint.x = {1}", line.RPoint.X, line.VPoint.X); //Original: line.rPoint.x = 10, line.vPoint.x = 10
        Console.WriteLine("Cloned: newLine.rPoint.x = {0}, newLine.vPoint.x = {1}", newLine.RPoint.X, newLine.VPoint.X); //Cloned: newLine.rPoint.x = 1, newLine.vPoint.x = 1
    }
}

 

我们来做一个测试：

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


// 将要进行浅度复制的对象，注意为引用类型
[Serializable]
public class RefLine
{
    public RefPoint RPoint;
    public ValPoint VPoint;

    public RefLine(RefPoint rPoint, ValPoint vPoint)
    {
        RPoint = rPoint;
        VPoint = vPoint;
    }

    public object Clone()
    {
        return MemberwiseClone();
    }

    public object DeepClone()// 深度复制
    {       
        RefPoint rPoint = new RefPoint(this.RPoint.X);  // 对于引用类型，创建新对象,并复制当前引用类型成员的值到新对象
        ValPoint vPoint = this.VPoint;                  // 值类型，直接赋值
        RefLine newLine = new RefLine(rPoint, vPoint);
        return newLine;
    }

    public object SerializeDeepClone()
    {
        BinaryFormatter binaryFormatter = new BinaryFormatter();
        MemoryStream serializationStream = new MemoryStream();
        binaryFormatter.Serialize(serializationStream, this);
        serializationStream.Position = 0;
        return (binaryFormatter.Deserialize(serializationStream)); ;
    }
}

// 定义一个引用类型成员
[Serializable]
public class RefPoint
{
    public int X;
    public RefPoint() {}

    public RefPoint(int x)
    {
        X = x;
    }
}

// 定义一个值类型成员
[Serializable]
public struct ValPoint
{
    public int X;

    public ValPoint(int x)
    {
        X = x;
    }
}

class Program
{
    static void Main(string[] args)
    {
        RefPoint rPoint = new RefPoint(1);
        ValPoint vPoint = new ValPoint(2);

        RefLine line = new RefLine(rPoint, vPoint);
        RefLine newLine = (RefLine)line.SerializeDeepClone();

        Console.WriteLine("Original line.rPoint.x = {0}", line.RPoint.X);//Original line.rPoint.x = 1
        Console.WriteLine("Cloned newLine.rPoint.x = {0}", newLine.RPoint.X);//Cloned newLine.rPoint.x = 1

        line.RPoint.X = 10;   // 改变原对象引用成员的值
        Console.WriteLine("Original line.rPoint.x = {0}", line.RPoint.X);//Original line.rPoint.x = 10
        Console.WriteLine("Cloned newLine.rPoint.x = {0}", newLine.RPoint.X);//Cloned newLine.rPoint.x = 1
    }
}

输出为：

Original line.rPoint.x = 1
Cloned newLine.rPoint.x = 1
Original line.rPoint.x = 10
Cloned newLine.rPoint.x = 1

 

可见，两个对象的引用成员已经分离，改变原对象的引用对象的值，并不影响复制后的对象。

这里需要注意：如果想将对象进行序列化，那么对象本身，及其所有的自定义成员(类、结构)，都必须使用Serializable特性进行标记。所以，如果想让上面的代码运行，我们之前定义的类都需要进行这样的标记：

[Serializable()]
public class …… {……}

NOTE：关于特性(Attribute)，可以参考 .Net 中的反射(反射特性) 一文。

总结

从概念上看，值类型直接存储其值，而引用类型存储对其值的引用。
我们知道，C#中的每一种类型要么是值类型，要么是引用类型。所以每个对象要么是值类型的实例，要么是引用类型的实例。
值类型和引用类型的基类

1.引用类型和值类型都继承自System.Object类。不同的是，几乎所有的引用类型都直接从System.Object继承，而值类型则继承其子类，即直接继承System.ValueType。
2.作为所有类型的基类，System.Object提供了一组方法，这些方法在所有类型中都能找到，其中包含ToString方法、Equals反方法及MemberwiseClone（protected类型）等方法。
3.System.ValueType直接继承System.Object，即System.ValueType本身是一个类类型，而不是值类型；
4.System.ValueType没有添加任何成员，但覆盖了所继承的一些方法，使其更适合于值类型。例如，ValueType重写了Equals()方法，从而对值类型按照实例的值来比较，而不是引用地址来比较。

using System;
struct Program
{
    static void Main(string[] args)
    {
        Program testType = new Program();

        if (testType.GetType().IsValueType)
        {
            Console.WriteLine("{0} is value type.", testType);
        }
        Console.ReadLine();
    }
}

值类型
值类型的特性1.C#的所有值类型均隐式派生自System.ValueType。

各个值类型及其基类如下：

结构体：struct（直接派生于System.ValueType）；
整型及其数值类型：short（System.Int16），ushort（System.UInt16），int（System.Int32），uint（System.UInt32），long（System.Int64），ulong（System.UInt64），sbyte(System.SByte的别名），byte（System.Byte）；
字符型：char（System.Char）；
浮点型：float（System.Single），double（System.Double）；
用于财务计算的高精度decimal型：decimal（System.Decimal）；
bool型：bool（System.Boolean的别名）；
枚举：enum（派生于System.Enum）；
可空类型（派生于System.Nullable泛型结构体，语法 T? 是 System.Nullable<T> 的简写，此处的 T 为值类型。）

值类型的特性2.每种值类型均有一个隐式的默认构造函数来初始化该类型的默认值。
例如：

//一下均互相等价：使用new运算符时，将调用特定类型的默认构造函数并对变量赋以默认值。
int i = new int();
Int32 i = new Int32();
//在上例中，默认构造函数将值0赋给了i。
int i = 0;
Int32 i = 0;

值类型的特性3.所有的值类型都是密封（seal）的，所以无法派生出新的值类型。

值类型的特性4.值类型的实例通常是在线程栈上分配的（静态分配），但是在某些情形下可以存储在堆中。

引用类型

引用类型的特性1.C#的所有引用类型均隐式派生自System.object。

各个引用类型及其基类如下：

数组：（派生于System.Array）数组的元素，不管是引用类型还是值类型，都存储在托管堆上；
类：class（派生于System.Object）；
接口：interface（接口不是一个"东西"，所以不存在派生于何处的问题。）；
委托：delegate（派生于System.Delegate）；
object：（System.Object的别名）；
字符串：string（System.String的别名）。

引用类型的特性2.引用类型可以派生出新的类型。

引用类型的特性3.引用类型可以包含null值。

引用类型的特性4.引用类型变量的赋值只复制对对象的引用，而不复制对象本身。

引用类型的特性5.引用类型的对象总是在进程堆中分配（动态分配）。

值类型和引用类型的区别
1.所有继承System.Value的类型都是值类型，其他类型都是引用类型。
2.引用类型可以派生出新的类型，而值类型不能；
3.引用类型存储在堆中，而值类型既可以存储在堆中也可以存储在栈中。
4.引用类型可以包含null值，值类型不能（可空类型功能允许将 null 赋给值类型）；
5.引用类型变量的赋值只复制对对象的引用，而不复制对象本身。而将一个值类型变量赋给另一个值类型变量时，将复制包含的值。
6.当比较两个值类型时，进行的是内容比较；而比较两个引用类型时，进行的是引用比较。
7.值类型在内存管理方面具有更好的效率，并且不支持多态，适合用作存储数据的载体；引用类型支持多态，适合用于定义应用程序的行为。
8.Int[]是引用类型还是值类型？数组类型是一族类型，它们都继承System.Array，而System.Array继承自System.Object。所以所有的数组类型都是引用类型

本文简单地对C#中的类型作了一个回顾。

1.C#中的两种类型--值类型和引用类型

2.装箱/拆箱操作

3.C#中的对象判等

4.浅度复制和深度复制，并比较它们之间的不同。