首页 > 代码库 > .NET的装箱与拆箱内幕

.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代码


可以看到Console.WriteLine("{0},{1},{2}",i,i,i)进行三次的装箱操作,因为Console.WriteLine这时调用的是三个obj参数的方法,见下图。i是int类型,是值类型,要转换成object,所以需要装箱操作,因为是三个obj,所以有三次装箱(box)。


再看Console.WriteLine("{0},{1},{2}",o,o,o),只进行了次装箱操作,同时Console.WriteLine这时调用的是另一个方法,见下图。这里通过对象o将i进行了一次装箱,所以后面的Console.WriteLine调用时,就不再需要装箱。


由此,可以看到,虽然输出的结果一致,但因为内部的装箱操作次数不同,可以预见,两者在性能上必然是后者优于前者。

综上,我们可以得出以下结论:

1.装箱是将值类型转换成引用类型,或者是继承了接口的值类型。如果装箱后的值类型需要改变内部的字段,需要通过接口来实现。

2.装箱时,必然会在Managed Heap中开辟相应的空间,并触发GC。

3.拆箱时,会将数据从Managed Headp中拷贝一份到Thread Stack中。

4.装箱和拆箱并不完全互逆。

5.拆箱的消耗要小于装箱的消耗。

附MSDN的说明http://msdn.microsoft.com/en-us/library/yz2be5wk.aspx

转载请注明出处http://blog.csdn.net/xxdddail/article/details/36892781