之前在网上看过许多关于拆箱和装箱的说法，看多了更糊涂了。今天看了《CLR VIA C#》第三版，突然感觉豁然开朗。
这篇博客之所以起名为新解，只是我看到的关于装箱拆箱操作的嘴让人透彻明白的解释。
废话就不说了，我们还是来看看吧！先来看例子：
下面是一段代码的三中不同写法，还有他们的反编译后的il，请问每种方法中装箱的次数？？？
-----------------------------------程序一------------------------------------ static void Main(string[] args) { Int32 v = 5; object o = v; v = 123; Console.WriteLine(v.ToString()+","+(int32)o); Console.ReadKey(); } .method private hidebysig static void Main(string[] args) cil managed { .entrypoint // 代码大小 53 (0x35) .maxstack 3 .locals init ([0] int32 v, [1] object o) IL_0000: nop IL_0001: ldc.i4.5 IL_0002: stloc.0 IL_0003: ldloc.0 IL_0004: box [mscorlib]System.Int32 IL_0009: stloc.1 IL_000a: ldc.i4.s 123 IL_000c: stloc.0 IL_000d: ldloc.0 IL_000e: box [mscorlib]System.Int32 IL_0013: ldstr "," IL_0018: ldloc.1 IL_0019: unbox.any [mscorlib]System.Int32 IL_001e: box [mscorlib]System.Int32 IL_0023: call string [mscorlib]System.String::Concat(object, object, object) IL_0028: call void [mscorlib]System.Console::WriteLine(string) IL_002d: nop IL_002e: call valuetype [mscorlib]System.ConsoleKeyInfo [mscorlib]System.Console::ReadKey() IL_0033: pop IL_0034: ret } // end of method Program::Main -----------------------------------------程序二-------------------------------- static void Main(string[] args) { Int32 v = 5; object o = v; v = 123; Console.WriteLine(v+","+o); Console.ReadKey(); } .method private hidebysig static void Main(string[] args) cil managed { .entrypoint // 代码大小 43 (0x2b) .maxstack 3 .locals init ([0] int32 v, [1] object o) IL_0000: nop IL_0001: ldc.i4.5 IL_0002: stloc.0 IL_0003: ldloc.0 IL_0004: box [mscorlib]System.Int32 IL_0009: stloc.1 IL_000a: ldc.i4.s 123 IL_000c: stloc.0 IL_000d: ldloc.0 IL_000e: box [mscorlib]System.Int32 IL_0013: ldstr "," IL_0018: ldloc.1 IL_0019: call string [mscorlib]System.String::Concat(object, object, object) IL_001e: call void [mscorlib]System.Console::WriteLine(string) IL_0023: nop IL_0024: call valuetype [mscorlib]System.ConsoleKeyInfo [mscorlib]System.Console::ReadKey() IL_0029: pop IL_002a: ret } // end of method Program::Main ---------------------------程序三------------------------------------------- static void Main(string[] args) { Int32 v = 5; object o = v; v = 123; Console.WriteLine(v.ToString()+","+o); Console.ReadKey(); } .method private hidebysig static void Main(string[] args) cil managed { .entrypoint // 代码大小 44 (0x2c) .maxstack 3 .locals init ([0] int32 v, [1] object o) IL_0000: nop IL_0001: ldc.i4.5 IL_0002: stloc.0 IL_0003: ldloc.0 IL_0004: box [mscorlib]System.Int32 IL_0009: stloc.1 IL_000a: ldc.i4.s 123 IL_000c: stloc.0 IL_000d: ldloca.s v IL_000f: call instance string [mscorlib]System.Int32::ToString() IL_0014: ldstr "," IL_0019: ldloc.1 IL_001a: call string [mscorlib]System.String::Concat(object, object, object) IL_001f: call void [mscorlib]System.Console::WriteLine(string) IL_0024: nop IL_0025: call valuetype [mscorlib]System.ConsoleKeyInfo [mscorlib]System.Console::ReadKey() IL_002a: pop IL_002b: ret } // end of method Program::Main
程序1中：3次 程序2：2次 程序3:1次
why??当然我们可以根据il代码中box出现的次数就可以判断出为什么是3,2，1，但是当我们没有il代码，或者在决断我们改怎样编写代码避免不比较的装箱拆箱操作呢？？
《CLR Via C#》给了我们很详尽的解答：
我们先来认识一下装箱和拆箱的背景：
一.值类型和引用类型
CLR 支持两种类型，值类型和引用类型。
1.引用类型总是从托管堆上非配，C#的new关键词或放回对象的内存地址--也就是指向对象数据的内存地址；
2.引用类型对象是存放在栈上，而对象的引用实在堆上。
3.值类型一般就是在堆栈上非配的
4.值类型的复制是在堆栈中再开辟一个空间，将字节一个一个的复制过来，前后两个变量没有任何的联系
5.引用的类型复制，是在堆栈中声明一个对象，有别于待复制的对象，但其指向的引用都是堆中相同的一块地址。所以该变一个对象，另一个对象也会改变（如下图）
对应程序：
static void Main(string[] args) {
pointStrcut a1=new pointStrcut (); a1.x = "a1"; pointStrcut a2=a1; a2.x = "a2"; Console.WriteLine("a1 is " + a1.x + " a2 is "+a2.x); pointClass o1= new pointClass(); o1.x ="nihao"; pointClass o2= o1; o2.x = "buhao"; Console.WriteLine("a1.x is "+o1.x+" a2.x is "+o2.x)
}
internal class pointClass { public string x; public string y; } internal struct pointStrcut { public string x; public string y; }
结果：
strcutBox1 is strcutBox1 strcutBox2 is st
pclass1.x is buhao pclass2.x is buhao
在上例子中，class pointClass是引用类型，而struct PointStruct 是值类型
对已值类型，只在栈中开辟内存，复制是是整个copy。所以a1和a2 是完全没有联系的只是值相同的两个变量。a2的变化不会导致a1的变化
对引用类型，栈中保存对象，堆中保存对象的引用。copy是，栈中的对象不一样，但是所对应的引用地址是一样的，所以，o2的改变实际上市堆中内存块发生了改变，所以o1也随着改变。
那么值类型和引用类型有哪些?
值类型：直接派生于System.Valuetype 包括结构，枚举。枚举继承自system.enum,但是system.enum也继承自system.valueType 。
引用类型：类
一.何为装箱，拆箱
简单点装箱就是将值类型转化为引用类型，拆箱反之；
我们再看一段代码
class Program
{
static void Main(string[] args)
{
Point p = new Point(1, 1);
Console.WriteLine(p);
p.Change(2, 2);
Console.WriteLine(p); //1,1
object o = p;
Console.WriteLine(o); //2,2
((Point)o).Change(3, 3);
Console.WriteLine(o); //只改变了栈中的临时Point值(下式中显示写出临时变量o2) 2,2
Point o2 = (Point)o;
o2.Change(3, 3);
Console.WriteLine(o2); //2,2
Console.ReadKey();
}
}
internal struct Point
{
private Int32 x, y;
public Point(Int32 x, Int32 y)
{
this.x = x;
this.y = y;
}
public void Change(Int32 x, Int32 y)
{
this.x = x; this.y = y;
}
public override string ToString()
{
return "(" + x + "," + y + ")";
}
}
internal class pointClass
{
public string x;
public string y;
}
Console.WriteLine(o);的执行结果为什么是（2,2）？？
仔细研究一下这一句:((Point)o).Change(3, 3);
o是一个object类型，时刻记住引用类型：栈上面保存对象，堆上面保存对象的引用。
那上面一句话干了什么？
将一个引用类型转化为值类型（拆箱），再调用change方法。 注意拆箱过程：拆箱会在栈上新建一个临时变量，并将堆中的所有数据全部复制到这个临时变量中！
也就是说o还是o，没有变化！我们用下面的方法显示拆箱过程
Point o2 = (Point)o;
o2.Change(3, 3);
Console.WriteLine(o2); //2,2
那如果我们要改变引用类型的变量改怎么办？看下面代码：（代码中有注释，一看便知）
class Program
{
static void Main(string[] args)
{
Point p = new Point(1, 1);
Console.WriteLine(p);
p.Change(2, 2);
Console.WriteLine(p); //1,1
object o = p;
Console.WriteLine(o); //2,2
((Point)o).Change(3, 3);
Console.WriteLine(o); //只改变了栈中的临时Point值(下式中显示写出临时变量o2) 2,2
Point o2 = (Point)o;
o2.Change(3, 3);
Console.WriteLine(o2); //2,2
((IChangeBoxedPoint)p).Change(4, 4); //同样 p先装箱生成临时变量，在堆中改变值，
Console.WriteLine(p); //依旧显示的是栈中的值 2,2
// IChangeBoxedPoint ipoint = (IChangeBoxedPoint)p;
// ipoint.Change(4,4);
// Console.WriteLine(ipoint);
((IChangeBoxedPoint)o).Change(5, 5); //o已经是引用类型，无需装箱
Console.WriteLine(o); //显示的是堆中的数据 5,5
Console.ReadKey();
}
}
internal interface IChangeBoxedPoint {
void Change(Int32 x,Int32 y);
}
internal struct Point : IChangeBoxedPoint
{
private Int32 x, y;
public Point(Int32 x, Int32 y)
{
this.x = x;
this.y = y;
}
public void Change(Int32 x, Int32 y)
{
this.x = x; this.y = y;
}
public override string ToString()
{
return "(" + x + "," + y + ")";
}
}
internal class pointClass
{
public string x;
public string y;
}
}
总结：在装箱和拆箱的过程中，无时无刻记住
1.装箱是值类型转化为引用类型
2.转化都有新的变量生成，装箱生成在栈中的对象和堆中的引用，拆箱生成栈中的数据变量