C# 类型基础 值类型和引用类型

Posted 文 武

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C# 类型基础 值类型和引用类型相关的知识，希望对你有一定的参考价值。

引言

本文之初的目的是讲述设计模式中的 Prototype(原型)模式，但是如果想较清楚地弄明白这个模式，需要了解对象克隆(Object Clone)，Clone其实也就是对象复制。复制又分为了浅度复制(Shallow Copy)和深度复制(Deep Copy)，浅度复制和深度复制又是以如何复制引用类型成员来划分的。由此又引出了引用类型和值类型，以及相关的对象判等、装箱、拆箱等基础知识。索性从最基础的类型开始自底向上写起。

值类型和引用类型

先简单回顾一下C#中的类型系统。C# 中的类型一共分为两类，一类是值类型(Value Type)，一类是引用类型(Reference Type)。值类型和引用类型是以它们在计算机内存中是如何被分配的来划分的。值类型包括结构和枚举，引用类型包括类、接口、委托等。还有一种特殊的值类型，称为简单类型(Simple Type)，比如 byte，int等，这些简单类型实际上是FCL类库类型的别名，比如声明一个int类型，实际上是声明一个System.Int32结构类型。因此，在Int32类型中定义的操作，都可以应用在int类型上，比如 "123.Equals(2)"。

所有的值类型都隐式地继承自 System.ValueType类型(注意System.ValueType本身是一个类类型)，System.ValueType和所有的引用类型都继承自 System.Object基类。你不能显示地让结构继承一个类，因为C#不支持多重继承，而结构已经隐式继承自ValueType。

NOTE：堆栈(stack)是一种先进后出的数据结构，在内存中，变量会被分配在堆栈上来进行操作。托管堆(heap，不是堆. 堆是c语言中用的，托管堆是c#中用的.它有对托管堆中内存放置位置,指针等处理,这也关系到垃圾收集器的运行机制,垃圾收集器也是c#专有的.)是用于为类型实例(对象)分配空间的内存区域，在托管堆上创建一个对象，会将对象的地址传给堆栈上的变量(反过来叫变量指向此对象，或者变量引用此对象)。

1.值类型

当声明一个值类型的变量(Variable)的时候，变量本身包含了值类型的全部字段，该变量会被分配在线程堆栈(Thread Stack)上。

假如我们有这样一个值类型，它代表了直线上的一点：

    public struct ValPoint
    {
        public int X;

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

当我们在程序中写下这样的一条变量的声明语句时：

ValPoint vPoint1;

 实际产生的效果是声明了vPoint1变量，变量本身包含了值类型的所有字段(即你想要的所有数据)。

编译下面全部代码，用"C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v10.0A\\bin\\NETFX 4.6.1 Tools\\ildasm.exe"（最新）打开编译后的exe。

class Program
{
    private static void Main()
    {
        ValPoint vPoint1;
    }

    public struct ValPoint
    {
        public int X;

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

 

 NOTE：观察MSIL代码，会发现此时变量还没有被压到栈上，因为.maxstack(最高栈数) 为0。并且没有看到入栈的指令，这说明只有对变量进行操作，才会进行入栈。

因为变量已经包含了值类型的所有字段，所以，此时你已经可以对它进行操作了(对变量进行操作，实际上是一系列的入栈、出栈操作)。

using System;

class Program
{
    private static void Main()
    {
        ValPoint vPoint1;
        vPoint1.X = 10;
        Console.WriteLine(vPoint1.X); // 输出 10
    }

    public struct ValPoint
    {
        public int X;

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

 

NOTE：如果vPoint1是一个引用类型(比如class)，在运行时会抛出NullReferenceException异常。因为vPoint是一个值类型，不存在引用，所以永远也不会抛出NullReferenceException。

如果你不对vPoint1.x进行赋值，直接写Console.WriteLine(vPoint1.x)，则会出现编译错误：使用了未赋值的局部变量。产生这个错误是因为.Net的一个约束：所有的元素使用前都必须初始化。

比如这样的语句也会引发这个错误：

int i;
Console.WriteLine(i);

 解决这个问题我们可以通过这样一种方式：编译器隐式地会为结构类型创建了无参数构造函数。在这个构造函数中会对结构成员进行初始化，所有的值类型成员被赋予0或相当于0的值(针对Char类型)，所有的引用类型被赋予null值。(因此，Struct类型不可以自行声明无参数的构造函数)。所以，我们可以通过隐式声明的构造函数去创建一个ValPoint类型变量：

    private static void Main()
    {
        ValPoint vPoint1 = new ValPoint();
        Console.WriteLine(vPoint1.X); // 输出为0
    }

    public struct ValPoint
    {
        public int X;

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

我们将上面代码第一句的表达式由"="分隔拆成两部分来看：

  • 左边 ValPoint vPoint1，在堆栈上创建一个ValPoint类型的变量vPoint，结构的所有成员均未赋值。在进行new ValPoint()之前，将vPoint压到栈上。
  • 右边new ValPoint()，new 操作符不会分配内存，它仅仅调用ValPoint结构的默认构造函数，根据构造函数去初始化vPoint结构的所有字段。

注意上面这句，new 操作符不会分配内存，仅仅调用ValPoint结构的默认构造函数去初始化vPoint的所有字段。

那如果我这样做，又如何解释呢？

Console.WriteLine((new ValPoint()).X);     // 正常，输出为0 

在这种情况下，会创建一个临时变量，然后使用结构的默认构造函数对此临时变量进行初始化。我知道我这样很没有说服力，所以我们来看下MS IL代码，为了节省篇幅，我只节选了部分：

.locals init ([0] valuetype Prototype.ValPoint CS$0$0000) // 声明临时变量
IL_0000:  nop
IL_0001:  ldloca.s   CS$0$0000       // 将临时变量压栈
IL_0003:  initobj    Prototype.ValPoint     // 初始化此变量

而对于 ValPoint vPoint = new ValPoint(); 这种情况，其 MSIL代码是：

.locals init ([0] valuetype Prototype.ValPoint vPoint)       // 声明vPoint
IL_0000:  nop
IL_0001:  ldloca.s   vPoint          // 将vPoint压栈
IL_0003:  initobj    Prototype.ValPoint     // 使用initobj初始化此变量

那么当我们使用自定义的构造函数时，ValPoint vPoint = new ValPoint(10)，又会怎么样呢？通过下面的代码我们可以看出，实际上会使用call指令(instruction)调用我们自定义的构造函数，并传递10到参数列表中。

.locals init ([0] valuetype Prototype.ValPoint vPoint)
IL_0000:  nop
IL_0001:  ldloca.s   vPoint      // 将 vPoint 压栈
IL_0003:  ldc.i4.s   10          // 将 10 压栈
IL_0005:  call       instance void Prototype.ValPoint::.ctor(int32)   // 调用构造函数，传递参数

对于上面的MSIL代码不清楚不要紧，有的时候知道结果就已经够用了。

2.引用类型

当声明一个引用类型变量的时候，该引用类型的变量会被分配到堆栈上，这个变量将用于保存位于堆上的该引用类型的实例的内存地址，变量本身不包含对象的数据。此时，如果仅仅声明这样一个变量，由于在堆上还没有创建类型的实例，因此，变量值为null，意思是不指向任何类型实例(堆上的对象)。对于变量的类型声明，用于限制此变量可以保存的类型。

如果我们有一个这样的类，它依然代表直线上的一点：

    public class RefPoint
    {
        public int X;

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

        public RefPoint() {}
    }

当我们仅仅写下一条声明语句：

RefPoint rPoint1;

它的效果就向下图一样，仅仅在堆栈上创建一个不包含任何数据，也不指向任何对象(不包含创建再堆上的对象的地址)的变量。

而当我们使用new操作符时：

rPoint1 = new RefPoint(1);

会发生这样的事：

  1. 在应用程序堆(Heap)上创建一个引用类型(Type)的实例(Instance)或者叫对象(Object)，并为它分配内存地址。
  2. 自动传递该实例的引用给构造函数。(正因为如此，你才可以在构造函数中使用this来访问这个实例。)
  3. 调用该类型的构造函数。
  4. 返回该实例的引用(内存地址)，赋值给rPoint变量。   

3.关于简单类型

很多文章和书籍中在讲述这类问题的时候，总是喜欢用一个int类型作为值类型和一个Object类型作为引用类型来作说明。本文将采用自定义的一个结构和类分别作值类型和引用类型的说明。这是因为简单类型(比如int)有一些CLR实现了的行为，这些行为会让我们对一些操作产生误解。

举个例子，如果我们想比较两个int类型是否相等，我们会通常这样：

int i = 3;
int j = 3;
if (i == j) Console.WriteLine("i equals to j");

但是，对于自定义的值类型，比如结构，就不能用 "=="来判断它们是否相等，而需要在变量上使用Equals()方法来完成。

再举个例子，大家知道string是一个引用类型，而我们比较它们是否相等，通常会这样做：

string a = "123456";
string b = "123456";
if (a == b) Console.WriteLine("a Equals to b");

实际上，在后面我们就会看到，当使用"=="对引用类型变量进行比较的时候，比较的是它们是否指向的堆上同一个对象。而上面a、b指向的显然是不同的对象，只是对象包含的值相同，所以可见，对于string类型，CLR对它们的比较实际上比较的是值，而不是引用。

 string a = "abcdefg";
 string b = "abcdefg";
 if (a.Equals(b)) Console.WriteLine("a Equals() to b");

为了避免上面这些引起的混淆，在对象判等部分将采用自定义的结构和类来分别说明。

装箱 和 拆箱

简单来说，装箱就是将一个值类型转换成等值的引用类型。它的过程分为这样几步：

  1. 在堆上为新生成的对象(该对象包含数据，对象本身没有名称)分配内存。
  2. 将堆栈上值类型变量的值拷贝到堆上的对象中。
  3. 将堆上创建的对象的地址返回给引用类型变量(从程序员角度看，这个变量的名称就好像堆上对象的名称一样)。

当我们运行这样的代码时：

int i = 1;
Object boxed = i;
Console.WriteLine("Boxed Point: " + boxed);  //Boxed Point: 1

效果图是这样的：

MSIL代码是这样的：

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // 代码大小       19 (0x13)
  .maxstack  1                   // 最高栈数是1，装箱操作后i会出栈
  .locals init ([0] int32 i,     // 声明变量 i(第1个变量，索引为0)
           [1] object boxed)          // 声明变量 boxed (第2个变量，索引为1)
  IL_0000:  nop
  IL_0001:  ldc.i4.s   10         //#1 将10压栈
  IL_0003:  stloc.0                  //#2 10出栈，将值赋给 i
  IL_0004:  ldloc.0                  //#3 将i压栈
  IL_0005:  box   [mscorlib]System.Int32   //#4 i出栈，对i装箱(复制值到堆，返回地址)
  IL_000a:  stloc.1           //#5 将返回值赋给变量 boxed
  IL_000b:  ldloc.1           // 将 boxed 压栈
  IL_000c:  call       void [mscorlib]System.Console::WriteLine(object)   // 调用WriteLine()方法
  IL_0011:  nop
  IL_0012:  ret
} // end of method Program::Main

而拆箱则是将一个 已装箱的引用类型 转换为值类型：

 int i = 1;
 Object boxed = i;
 int j;
 j = (int)boxed;  // 显示声明拆箱后的类型
 Console.WriteLine("UnBoxed Point: " + j);

 

需要注意的是：UnBox 操作需要显示声明拆箱后转换的类型。它分为两步来完成：

  1. 获取已装箱的对象的地址。
  2. 将值从堆上的对象中拷贝到堆栈上的值变量中。

对象判等

因为我们要提到对象克隆(复制)，那么，我们应该有办法知道复制前后的两个对象是否相等。所以，在进行下面的章节前，我们有必要先了解如何进行对象判等。

NOTE：感谢微软的开源以及 VS2015 的FCL调试功能。关于如何调试 FCL 代码，请参考 Configuring Visual Studio to Debug .NET Framework Source Code。

我们先定义用作范例的两个类型，它们代表直线上的一点，唯一区别是一个是引用类型class，一个是值类型struct：

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

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

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

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

1.引用类型判等

我们先进行引用类型对象的判等，我们知道在System.Object基类型中，定义了实例方法Equals(object obj)，静态方法 Equals(object objA, object objB)，静态方法 ReferenceEquals(object objA, object objB) 来进行对象的判等。

我们先看看这三个方法，注意我在代码中用 #number 标识的地方，后文中我会直接引用：

    public static bool ReferenceEquals(Object objA, Object objB)
    {
        return objA == objB; // #1
    }

    public virtual bool Equals(Object obj)
    {
        return InternalEquals(this, obj); // #2
    }


    public static bool Equals(Object objA, Object objB)
    {
        if (objA == objB)  // #3
        {
            return true;
        }

        if (objA == null || objB == null)
        {
            return false;
        }

        return objA.Equals(objB); // #4
    }

 

参见：https://referencesource.microsoft.com/#mscorlib/system/object.cs。

我们先看ReferenceEquals(object objA, object objB)方法，它实际上简单地返回 objA == objB，所以，在后文中，除非必要，我们统一使用 objA == objB(省去了 ReferenceEquals 方法)。另外，为了范例简单，我们不考虑对象为null的情况。

我们来看第一段代码：

        bool result; // 复制对象引用
        RefPoint rPoint1 = new RefPoint(1);
        RefPoint rPoint2 = rPoint1;

        result = (rPoint1 == rPoint2); // #1返回 True;
        Console.WriteLine(result);

        result = rPoint1.Equals(rPoint2); // #2 返回 True;
        Console.WriteLine(result);

 

在阅读本文中，应该时刻在脑子里构思一个堆栈，一个堆，并思考着每条语句会在这两种结构上产生怎么样的效果。

在这段代码中，产生的效果是：

在堆上创建了一个新的RefPoint类型的实例(对象)，并将它的X字段初始化为1；

在堆栈上创建变量rPoint1，rPoint1保存堆上这个对象的地址；

将rPoint1 赋值给 rPoint2时，此时并没有在堆上创建一个新的对象，而是将之前创建的对象的地址复制到了rPoint2。

此时，rPoint1和rPoint2指向了堆上同一个对象。

从 ReferenceEquals()这个方法名就可以看出，它判断两个引用变量是不是指向了同一个变量，如果是，那么就返回true。这种相等叫做 引用相等(rPoint1 == rPoint2 等效于 ReferenceEquals)。因为它们指向的是同一个对象，所以对rPoint1的操作将会影响rPoint2：

bool result;
RefPoint rPoint1 = new RefPoint(1);
RefPoint rPoint2 = rPoint1; // 复制对象引用

result = (rPoint1 == rPoint2); // #1返回 True;
Console.WriteLine(result);

result = rPoint1.Equals(rPoint2); // #2 返回 True;
Console.WriteLine(result);

Console.WriteLine("rPoint1.X="+rPoint1.X+ "rPoint2.X="+rPoint2.X);
rPoint1.X = 10;
Console.WriteLine("rPoint1.X=" + rPoint1.X + "rPoint2.X=" + rPoint2.X);

 

注意System.Object静态的Equals(Object objA, Object objB)方法，在 #3 处，如果两个变量引用相等，那么将直接返回true。所以，可以预见我们上面的代码rPoint1.Equals(rPoint2); 在 #3 就会返回true。

但是我们没有调用静态Equals()，直接调用了实体方法，最后调用了#2 的 InternalEquals()，返回true。

我们再看引用类型的第二种情况：

        bool result; 
        RefPoint rPoint1 = new RefPoint(1);
        RefPoint rPoint2 = new RefPoint(1);//创建新引用类型的对象，其成员的值相等

        result = (rPoint1 == rPoint2);
        Console.WriteLine(result);      // #1 返回 false;

        result = rPoint1.Equals(rPoint2);
        Console.WriteLine(result);      // #2 返回 false

上面的代码在堆上创建了两个类型实例，并用同样的值初始化它们；然后将它们的地址分别赋值给堆上的变量 rPoint1和rPoint2。此时 #2 返回了false，可以看到，对于引用类型，即使类型的实例(对象)包含的值相等，如果变量指向的是不同的对象，那么也不相等。

2.简单值类型判等

注意本节的标题：简单值类型判等，这个简单是如何定义的呢？如果值类型的成员仅包含值类型，那么我们暂且管它叫简单值类型，如果值类型的成员包含引用类型，我们管它叫复杂值类型。(注意，这只是本文中为了说明,个人作的定义。)

应该还记得我们之前提过，值类型都会隐式地继承自 System.ValueType类型，而ValueType类型覆盖了基类System.Object类型

以上是关于C# 类型基础 值类型和引用类型的主要内容，如果未能解决你的问题，请参考以下文章

C#基础知识----值类型与引用类型

30天C#基础巩固-----值类型/引用类型，泛型，空合并操作符(??)，匿名方法

C#基础按值和按引用传递参数

C# 基础知识

C# 值类型和引用类型

NET基础：引用类型和值类型