《CLR Via C#》学习笔记(二)【装箱和拆箱】

╰+哭是因爲堅強的太久メ 2021-06-26 16:06 329阅读 0赞

装箱和拆箱是已经被嚼烂的两个概念了，并且在一些面试中也经常考到。

1.  装箱：将值类型转换为引用类型。
2.  拆箱：将引用类型转换为值类型。

值类型是一种相对轻型的类型，不像对象那样在托管堆中分配，也不会被`GC`，不通过指针来引用，不过在有些时候需要获取对值类型的引用，例如在使用net1.0的集合类`ArrayList`的时候。

class Program
    { 
        static void Main(string[] args)
        { 
            ArrayList list = new ArrayList();
            Point p;                        //因Point为值类型，分配在堆栈中
            for (int i = 0; i < 100; i++)
            { 
                p.x = p.y = i;              //初始化Point中的成员
                list.Add(p);                //对p进行装箱后，将引用添加到list中
            }
        }
    }
    struct Point
    { 
        public Int32 x;
        public Int32 y;
    }

ArrayList的Add方法是接受一个Object参数，如下

public virtual int Add(object value);

所以在执行`Add`方法时会将`Point`值类型转换为一个堆得托管对象，并获取到这个对象的引用，将引用地址存储在`ArrayList`中。

在一个值类型装箱的时候内部发生的事情：

1.  在托管堆分配好内存。分配的内存是值类型的各个字段所需内存量加上托管堆上的两个额外成员（类型对象指针和同步索引块）所需的内存量。
2.  值类型中的字段值复制到新分配的堆内存中。
3.  返回对象的引用地址。

拆箱就是执行和装箱相反的操作，将引用类型转化为值类型。接上面的代码，获取`ArrayList`中的元素值用如下代码：

for (int j = 0; j < 10; j++)
    { 
        Point point =(Point)list[j];
        Console.WriteLine("X:" + point.x + " Y:" + point.y);
    }

上面的代码中通过索引取到`ArrayList`中存储的各个`Point`的引用地址，通过`Point`类型转换将其对应的值从堆中复制到`Point`的实例`point`中，这个转换的过程就是拆箱的过程。

在拆箱的过程中要注意以下两点：

1.  如果对已装箱的值类型的引用的变量为`null`，会引发`NullRefreenceException`异常
2.  如果一个引用指向的对象在拆箱时不是用的装箱时所使用的类型，将会引发`InvalidCastException`异常。代码如下：

static void Main(string[] args)
    { 
        Int32 x = 5;
        Object o = x;
        Int16 y = (Int16)o;    //引发InvalidCastException异常
    }

正确的做法是，现将其用`Int32`类型来拆箱，然后再强制转换为`Int16`

static void Main(string[] args)
    { 
        Int32 x = 5;
        Object o = x;
        Int16 y = (Int16)(Int32)o;
    }

下面来看两段程序来深入理解下装箱和拆箱

代码一：

static void Main(string[] args)
    { 
        Int32 x = 5;
        Object o = x;
        x = 123;
        Console.WriteLine(x + ", " + (Int32)o);
    }

上面的代码中有多少次装箱呢？乍一看好像就一次（`Object o=x；`），其实一共有三次装箱，看看`IL`代码就一目了然了。  
![在这里插入图片描述][20201201133712501.png]  
程序的执行步骤：

1 创建一个Int32的未装箱的值类型实例x，并初始化为5.

2 创建Object类型的变量o，并指向x。由于引用类型的变量必须要执行堆中的对象，所以要对x进行装箱（第一次装箱），并将x在堆中的引用地址存储在o中。

3 将值123赋给未装箱的值类型实例x中。

4 调用`WriteLine`方法，`WriteLine`方法的参数值类型为`String`，现在`WriteLine`方法存在三个数据项，值类型x、string类型“，”和一个已装箱的Int32类型实例的引用o，这三个数据项必须要合并成一个string对象才能被调用。

5 调用`String`对象的静态方法`Concat`，`Concat`方法有9个重载，根据那三个数据项会选择下面方法执行。  
![在这里插入图片描述][20201201133741734.png]  
6 第一个参数`arg0`传入的是x ，参数类型为`object`，所以要对x进行装箱（第二次装箱），将引用地址传给`arg0，arg1`传入的是字符串“，”，字符串就是引用类型，直接传引用地址，arg2传入的是将o拆箱然后再装箱（第三次装箱）的引用地址传入。

上面代码中的`WriteLine`方法如果直接写成`Console.WriteLine(x + “, ” + o);`将会有跟高的相率，因为`o`本身就是`Object`类型，在`Concat`的时候不用进行装箱拆箱。

代码二：看看这段程序发生了几次装箱

static void Main(string[] args)
    { 
        Int32 x = 5;
        Object o=x;
        x=123;
        Console.WriteLine(x);
        x = (Int32)o;
        Console.WriteLine(x);
        Console.WriteLine(o);
    }

上面的代码只发生了一次装箱，因为`WriteLine`方法的重载版本中参数类型可以为`Object`或是`Int32`，在调用WriteLine方法是并没有装箱，唯一的一次装箱是Object o=x;。

代码三：

static void Main(string[] args)
    { 
        Int32 x = 5;
        CheckRef(x, x);  //输出不同引用
    }
    static void CheckRef(object obj1, object obj2)
    { 
        if (obj1 == obj2)
        Console.WriteLine("相同引用");
        else
        Console.WriteLine("不同引用");
    }

执行上面代码将发生两次装箱，因为CheckRef方法的两个参数都是Object类型，传入的都是值类型的实例，可以讲代

码改进下，先将x转换成Object类型再传入方法，如下:

static void Main(string[] args)
    { 
        Int32 x = 5;
        Object o = x;
        CheckRef(o,o);  //输出相同引用
    }
    static void CheckRef(object obj1, object obj2)
    { 
        if (obj1 == obj2)
        Console.WriteLine("相同引用");
        else
        Console.WriteLine("不同引用");
    }

改进后只进行一次装箱操作了，效率提高了，但是会发现运行的结果也发生了变化，所以这种做法在有些时候是很危险的。

装箱拆箱操作极大的破环程序的性能，不过在Net2.0中提供了泛型集合类，所以完全可以用`List<T>` 和`Dictionary<Tkey,Tvalue>` 来代替 原来1.0中的`ArrayList`和`HashTable`，即使是`List<Object>`也会比`ArrayList`的性能要好。

[20201201133712501.png]: /images/20210626/0445a60177b94d5f80d73a9f2cd6743b.png
[20201201133741734.png]: /images/20210626/34ca60917b534030ba570f0496f9310d.png