值类型的装箱和拆箱

在CLR中为了将一个值类型转换成一个引用类型，要使用一个名为装箱的机制。

　　下面总结了对值类型的一个实例进行装箱操作时内部发生的事:

　　1）在托管堆中分配好内存。分配的内存量是值类型的各个字段需要的内存量加上托管堆上的所有对象都有的两个额外成员(类型对象指针和同步块索引)需要的内存量。

　　2）值类型的字段复制到新的分配的堆内存。

　　3）返回对象的地址。现在，这个地址是对一个对象的引用，值类型现在是一个引用类型。

　　拆箱不是直接将装箱过程倒过来。拆箱的代价比装箱低得多。拆箱其实就是一个获取一个指针的过程，该指针指向包含在一个对象中的原始值类型(数据字段)。事实上，指针指向的是已装箱实例中的未装箱部分。所以，和装箱不同，拆箱不要求在内存中复制字节。还有一个重点就是，拆箱之后，往往会紧接着发生一次字段的复制操作。

　　一个已装箱的值类型实例在拆箱时，内部会发生下面这些事情。

　　1.如果包含了"对已装箱值类型实例的引用"的变量为null，就抛出一个NullReferenceException异常。

　　2.如果引用指向的对象不是所期待的值类型的一个已装箱实例，就抛出一个InvalidCastException异常。

　　上面第二条意味着一下代码不会如你预期的那样工作：

public static void Main(){
    Int32 x = 5;
    Object o = x;
    Int16 y = (Int16) o;//抛出异常
}

　　在对一个对象进行拆箱的时候，只能将其转型为原始未装箱时的值类型——Int32，下面是正确的写法:

public static void Main(){
    Int32 x = 5;
    Object o = x;　　　　　        //对x进行装箱，o引用已装箱的对象　
    Int16 y = (Int16) (Int32) o; //先拆箱为正确的类型，在进行装箱
}

　　前面说过，在进行一次拆箱后，经常会紧接着一次字段的复制。以下演示了拆箱和复制操作：

public static void Main() {  
    Point p = new Point(); //栈变量
    p.x = p.y = 1;    
    object o = p;          //对p进行装箱，o引用已装箱的实例
    p = (Point) o;         //对o进行拆装，将字段从已装箱的实例复制到栈变量
}

　　在最后一行，C#编译器会生成一条IL指令对o进行拆箱，并生成另一条IL指令将这些字段从堆复制到基于栈的变量p中。

 

　　在看个演示装箱和拆箱的例子：　　

private static void Main(string[] args)
{
     Int32 v = 5;            // 创建一个值类型变量
     Object o = v;           // o引用一个已装箱的、包含值5的Int32
     v = 123;                // 将未装箱的值修改成为123
     Console.WriteLine(v + "," + (Int32)o);  //显示"123,5"
}

　　你可以看出上述代码进行了几次装箱操作？如果说是3次，你会不会意味呢？我们来看下生成的IL代码。　　

.method private hidebysig static void Main(string[] args) cil managed
{
    .entrypoint
    //代码大小
    .maxstack 3
    .locals init (
        [0] int32 num,
        [1] object obj2)
    L_0000: nop 

    // 将5加载到v中
    L_0001: ldc.i4.5 
    L_0002: stloc.0 

    // 对v进行装箱，将引用指针存储到o中
    L_0003: ldloc.0 
    L_0004: box int32
    L_0009: stloc.1 

    // 将123加载到v中
    L_000a: ldc.i4.s 0x7b
    L_000c: stloc.0 

    // 对v进行装箱，并将指针保留在栈上以进行Concat(连接)操作
    L_000d: ldloc.0 
    L_000e: box int32

    // 将字符串加载到栈上以执行Concat操作
    L_0013: ldstr ","

    // 对o进行拆箱：获取一个指针，它指向栈上的Int32的字段
    L_0018: ldloc.1 
    L_0019: unbox.any int32
    
    // 对Int32进行装箱，并将指针保留在栈上以进行Concat(连接)操作
    L_001e: box int32

    // 调用Concat
    L_0023: call string [mscorlib]System.String::Concat(object, object, object)
    // 将从Concat放回的字符串传给WriteLine
    L_0028: call void 
[mscorlib]System.Console::WriteLine(string)
    L_002d: nop 
    
    // 从Main返回
    L_002e: ret 
}

　　提示：主要原因是在Console.WriteLine方法上。

　　Console.WriteLine方法要求获取一个String对象，为了创建一个String对象，C#编译器生成的代码来调用String对象的静态方法Concate。该方法有几个重载的版本，唯一区别就是参数数量，在本例中需要连接三个数据项来创建一个字符串，所以编译器会选择以下Concat方法来调用:

public static String Concat(Objetc arg0, Object arg1, Onject arg2);

　　所以，如果像下面写对WriteLine的调用，生成的IL代码将具有更高的执行效率：

Console.WriteLine(v + "," + o);  //显示"123,5"

　　这只是移除了变量o之前的(Int32)强制转换。就避免了一次拆箱和一次装箱。

　　我们还可以这样调用WriteLine，进一步提升上述代码的性能：

Console.WriteLine(v.ToString() + "," + o);  //显示"123,5"

　　现在，会为未装箱的值类型实例v调用ToString方法，它返回一个String。String类型已经是引用类型，所以能直接传给Concat方法，不需要任何装箱操作。

　　下面在演示一个装箱和拆箱操作：　　

private static void Main(string[] args)
{
     Int32 v = 5;                  // 创建一个值类型变量
     Object o = v;                // o引用一个已装箱的、包含值5的Int32
     v = 123;                       // 将未装箱的值修改成为123
     Console.WriteLine(v)   //显示"123"
     v = (Int32) o;               //拆箱并将o复制到v
     Console.WriteLine(v);  //显示"5"
}

　　上述代码发生了多少次装箱呢？答案是一次。因为System.Console类定义了获取一个Int32作为参数的WriteLine方法的重载版本:　　

public static String Concat(Int32 value);

　　在WriteLine方法内部也许会发生装箱操作，但这已经不是我们能控制的。我们已经尽可能地从自己的代码中消除了装箱操作。