.NET的装箱与拆箱内幕

装箱与拆箱是.NET中非常重要的概念。

装箱是将值类型转换成引用类型，或者是实现了接口的值类型。装箱将数据存储的空间由Thread stack转存到了Managed Heap中。凡是在Managed Heap中开辟空间，都将触发GC（垃圾回收），在Thread statck将不会触发垃圾回收。

拆箱就是将数据从Managed Heap中提取出来，并拷贝到Thread stack中。所以拆箱会形成两份数据，一分在Managed Heap中，一份在Thread Statck中。

先来看一段装箱和拆箱的代码

        public static void BoxUnbox()
        {
            int i = 123;
            object o = i;//隐式装箱
            object p=(object)i;//显式装箱
            int j = (int)p;//拆箱
        }

IL的代码

堆栈图

可以看到i到o、i到p进行了装箱，而且o和p的数据存储到了Managed Heap中。而p到j是拆箱，数据复制了一份到Thread Stack中。

装箱可以是显式或者隐式的，但拆箱是显式的。乍一看，装箱和拆箱是互逆的操作，但从上图中可以看到，并非如此。装箱需要在Managed Heap中开辟空间，同时在空间中必须设置相应的指针(Type object ptr)和同步块索引(Sync bolck index)，之后才是将Thread Stack中的数据拷贝进去。而拆箱，只是从Managed Heap中将数据拷贝到Thread Stack中，并且紧接在相应的字段后面。所以装箱和拆箱并不是完全互逆的操作。而且从消耗上讲，拆箱的消耗会少于装箱的消耗。

我们来看一段测试代码

  internal struct Point
        {
            private Int32 _x, _y;
            public Point(Int32 x, Int32 y)
            {
                _x = x;
                _y = y;
            }
            public void Change(Int32 x, Int32 y)
            {
                _x = x; _y = y;
            }
            public override String ToString()
            {
                return String.Format("({0}, {1})", _x.ToString(), _y.ToString());
            }
        }

   public static void TypeTest()
        {
            Point p = new Point(1, 1);
            Console.WriteLine("p:"+p);
            p.Change(2, 2);
            Console.WriteLine("p:" + p);
            Object o = p;
            Console.WriteLine("o:"+o);
            ((Point)o).Change(3, 3);
            Console.WriteLine("o:" + o);
        }

输出结果

从结果中可以看到，p初始值为(1,1)，所以第一次输出时为(1,1)。经过Change函数后，第二次输出为(2,2)。将p转换成o后，输出o为(3,3)。这都是预料之中的。

但是经过(Point)o强转，又执行了Change（3，3）之后，输出的结果并不是所期望的(3,3)。这是为什么？

我们可以通过前面的Thread Stack和Managed Heap对比图知道，在将对象o拆箱为Point的时候，会将o的数据拷贝一份到Thread Statck中，这样一来，Change(3,3)的操作只是针对Thread Statck中的，而在输出时的数据是还在Managed Heap中的o。这样一想，结果就变的理所当然了。

那如果将Point继承自一个接口呢？结果又会如何？为了与Point区别，这里将Point变成Pointex。代码如下

 
 // Interface defining a Change method 
    internal interface IChangeBoxedPoint
    {
        void Change(Int32 x, Int32 y);
    }
    // Point is a value type. 
    internal struct Pointex : IChangeBoxedPoint
    {
        private Int32 _x, _y;
        public Pointex(Int32 x, Int32 y)
        {
            _x = x;
            _y = y;
        }
        public void Change(Int32 x, Int32 y)
        {
            _x = x; _y = y;
        }
        public override String ToString()
        {
            return String.Format("({0}, {1})", _x.ToString(), _y.ToString());
        }
    }

 public static void TypeTestPointex()
        {
            Pointex p = new Pointex(1, 1);
            Console.WriteLine(p);
            p.Change(2, 2);
            Console.WriteLine(p);
            Object o = p;
            Console.WriteLine(o);
            ((Pointex)o).Change(3, 3);
            Console.WriteLine(o);
            // Boxes p, changes the boxed object and discards it 
            ((IChangeBoxedPoint)p).Change(4, 4);
            Console.WriteLine(p);
            // Changes the boxed object and shows it 
            ((IChangeBoxedPoint)o).Change(5, 5);
            Console.WriteLine(o);
        }

结果如下图

从结果中可以看到，p初始值为(1,1)，所以第一次输出时为(1,1)。经过Change函数后，第二次输出为(2,2)。将o强转为Pointex并执行Change(3,3)，输出为(2,2)。这在上一例中已经作出了解译。那（IChangedBoxedPoint）强转p和o输出的结果为什么是(2,2)和(5,5)呢。

可以思考一下前面的Thread Statck和Managed Heap。p在经过IChangedBoxedPoint强制转换时，经过了装箱(box)，在Managed Heap会开辟一个空间来储存Point的x和y，在这里执行Change（4，4）操作，同时触发了GC，在执行完Changed返回时，GC自动将这一部分空间回收。p还是原来在Thread Stack中的p。所以输出的是(2,2)。

对于IChangedBoxedPoint强制转换o时，本来也是要有一个装箱操作的，不过这里的o是object，已经是装箱过的，所以不再装箱。所以Change(5,5)会改变这里的数据，同时由于IChangedBoxedPoint执行完Change后返回时，由于使用的是o空间的数据，而o还存在着，所以生命周期并没有结束，GC也就不会回收这部分数据。所以输出的是（5，5）。

据此，我们可以思考一下下面这段代码

 public static void TestWriteLine()
        {
            int i = 1;
            Console.WriteLine("{0},{1},{2}",i,i,i);
            object o = i;
            Console.WriteLine("{0},{1},{2}",o,o,o);
        }

两个Console.WriteLine输出的结果是一样的，但是内部却有差异。我们来查看一下IL代码