知识点
- 值类型。
- 值类型是在栈中分配内存，在声明时初始化才能使用，不能为null。
- 值类型超出作用范围系统自动释放内存。
- 主要由两类组成：结构，枚举（enum），结构分为以下几类：
- 整型（Sbyte、Byte、Char、Short、Ushort、Int、Uint、Long、Ulong）
- 浮点型（Float、Double）
- decimal
- bool
- 用户定义的结构（struct）
- 引用类型。
- 引用类型在堆中分配内存，初始化时默认为null。
- 引用类型是通过垃圾回收机制进行回收。
- 包括类、接口、委托、数组以及内置引用类型object与string。
概念
由于C#中所有的数据类型都是由基类System.Object继承而来的，所以值类型和引用类型的值可以通过显式（或隐式）操作相互转换，而这转换过程也就是装箱（boxing）和拆箱（unboxing）过程。
- 装箱 是值类型到 object 类型或到此值类型所实现的任何接口类型的隐式转换（就算实现了某个接口，转为接口依旧要装箱）。对值类型装箱会在堆中分配一个对象实例，并将该值复制到新的对象中。
- 拆箱（取消装箱）是从 object 类型到值类型或从接口类型到实现该接口的值类型的显式转换。取消装箱操作包括：
-
检查对象实例，确保它是给定值类型的一个装箱值。（拆箱后没有转成原类型，编译时不会出错，但运行会出错，所以一定要确保这一点。用GetType().ToString()判断时一定要使用类型全称，如：System.String 而不要用String。）
-
将该值从实例复制到值类型变量中。
-
示例
首先写个简单的控制台程序：
- // Tutorial_boxing_unboxing.cs
- // 装箱与拆箱
- using System;
- class App
- {
- static void Main()
- {
- int i = 32;
- object o = i; //隐式装箱
- Console.WriteLine(”o = {0}”, o);
- Console.Read();
- }
- }
// Tutorial_boxing_unboxing.cs
// 装箱与拆箱
using System;
class App
{
static void Main()
{
int i = 32;
object o = i; //隐式装箱
Console.WriteLine("o = {0}", o);
Console.Read();
}
}
其中object o = i这里我们进行了装箱操作，然后我们用MSIL 反汇编程序查看下生成的.exe程序的内部机理。
- 1 .method private hidebysig static void Main() cil managed
- 2 {
- 3 .entrypoint
- 4 // 代码大小 30 (0x1e)
- 5 .maxstack 2
- 6 .locals init ([0] int32 i,
- 7 [1] object o)
- 8 IL_0000: nop
- 9 IL_0001: ldc.i4.s 32
- 10 IL_0003: stloc.0
- 11 IL_0004: ldloc.0
- 12 IL_0005: box [mscorlib]System.Int32
- 13 IL_000a: stloc.1
- 14 IL_000b: ldstr ”o = {0}”
- 15 IL_0010: ldloc.1
- 16 IL_0011: call void [mscorlib]System.Console::WriteLine(string,
- 17 object)
- 18 IL_0016: nop
- 19 IL_0017: call int32 [mscorlib]System.Console::Read()
- 20 IL_001c: pop
- 21 IL_001d: ret
- 22 } // end of method App::Main
1 .method private hidebysig static void Main() cil managed
2 {
3 .entrypoint
4 // 代码大小 30 (0x1e)
5 .maxstack 2
6 .locals init ([0] int32 i,
7 [1] object o)
8 IL_0000: nop
9 IL_0001: ldc.i4.s 32
10 IL_0003: stloc.0
11 IL_0004: ldloc.0
12 IL_0005: box [mscorlib]System.Int32
13 IL_000a: stloc.1
14 IL_000b: ldstr "o = {0}"
15 IL_0010: ldloc.1
16 IL_0011: call void [mscorlib]System.Console::WriteLine(string,
17 object)
18 IL_0016: nop
19 IL_0017: call int32 [mscorlib]System.Console::Read()
20 IL_001c: pop
21 IL_001d: ret
22 } // end of method App::Main
其中第12行是我们的装箱操作。（关于IL中出现的操作符代表的操作请查阅MSDN Library中的.NET开发/.NET Framework SDK/类库参考/System.Reflection.Emit/OpCodes 类/OpCodes 字段）
然后我们取消装箱操作：
- static void Main()
- {
- int i = 32;
- Console.WriteLine(”i = {0}”, i);
- Console.Read();
- }
static void Main()
{
int i = 32;
Console.WriteLine("i = {0}", i);
Console.Read();
}
再用MSIL工具查看生成的.exe，如下结果：
- .method private hidebysig static void Main() cil managed
- {
- .entrypoint
- // 代码大小 28 (0x1c)
- .maxstack 2
- .locals init ([0] int32 i)
- IL_0000: nop
- IL_0001: ldc.i4.s 32
- IL_0003: stloc.0
- IL_0004: ldstr ”i = {0}”
- IL_0009: ldloc.0
- IL_000a: box [mscorlib]System.Int32
- IL_000f: call void [mscorlib]System.Console::WriteLine(string,
- object)
- IL_0014: nop
- IL_0015: call int32 [mscorlib]System.Console::Read()
- IL_001a: pop
- IL_001b: ret
- } // end of method App::Main
.method private hidebysig static void Main() cil managed
{
.entrypoint
// 代码大小 28 (0x1c)
.maxstack 2
.locals init ([0] int32 i)
IL_0000: nop
IL_0001: ldc.i4.s 32
IL_0003: stloc.0
IL_0004: ldstr "i = {0}"
IL_0009: ldloc.0
IL_000a: box [mscorlib]System.Int32
IL_000f: call void [mscorlib]System.Console::WriteLine(string,
object)
IL_0014: nop
IL_0015: call int32 [mscorlib]System.Console::Read()
IL_001a: pop
IL_001b: ret
} // end of method App::Main
在IL_000a行，我们发现这里却也出现了一个box！不过这步是在call System.Console::WriteLine(string, object)时发生的。我们对比前面我们手动boxing的IL代码，发现在我们手动boxing后就没有这步box了。为什么呢？
当我们在调用一些方法的重载版本时，由于编译器找不到符合给定参数类型的重载方法，此时编译器便去寻找到的最接近的版本，然后使用找到的方法，而其参数却是我们传入的值类型的基类如System.Object或者其实现的接口类型，接着编译器为了求得与这个方法的原型一致，就必须对该值类型进行装箱操作(转换成引用类型)。
照这个说法当我们不手动boxing时，在调用了Console.WriteLine()方法输出一个Int32类型值时，系统就要自动进行boxing。也就是说如果我们要对该输出操作作5000次的循环，系统就要做5000次的boxing。这样对性能便会有一定的影响，而且要使循环次数是100,000,000次呢，或者跟多！
此时我们便要想如何消除这不应该的性能损失！正如第一个程序是展示的，我们可以在需要的地方先进行boxing，这个原理很简单，我们可以联想到类似的做法：
- //当我们如下时：
- for (int i = 0; i < arr.Length; i++)
- {
- //
- }
- //我们更因该这样：
- int L = arr.Length;
- for (int i = 0; i < L; i++)
- {
- //
- }
//当我们如下时：
for (int i = 0; i < arr.Length; i++)
{
//
}
//我们更因该这样：
int L = arr.Length;
for (int i = 0; i < L; i++)
{
//
}
这样，我们只要一次boxing，就可以避免让系统重复的做这个操作。
用途
像在调用Console.WriteLine()的过程中系统自动进行boxing一样，当我们在调用其它的一些方法的重载版本进行操所时，为了避免由于无谓的隐式装箱所造成的性能损失，在执行这些多类型重载方法之前，最好先对值进行装箱。一般是在处理大量数据需要对类型进行装箱操作。
——————-一下是另一篇文章———————————–
1、
装箱和拆箱是一个抽象的概念
2、
装箱是将值类型转换为引用类型 ；拆箱是将引用类型转换为值类型
利用装箱和拆箱功能，可通过允许值类型的任何值与Object 类型的值相互转换，将值类型与引用类型链接起来
例如：
int val = 100;
object obj = val;
Console.WriteLine (“对象的值 = {0}”, obj);
这是一个装箱的过程，是将值类型转换为引用类型的过程
int val = 100;
object obj = val;
int num = (int) obj;
Console.WriteLine (“num: {0}”, num);
这是一个拆箱的过程，是将值类型转换为引用类型，再由引用类型转换为值类型的过程
注：被装过箱的对象才能被拆箱
3、
.NET中，数据类型划分为值类型和引用(不等同于C++的指针)类型，与此对应，内存分配被分成了两种方式，一为栈，二为堆，注意：是托管堆。
值类型只会在栈中分配。
引用类型分配内存与托管堆。
托管堆对应于垃圾回收。
4：装箱/拆箱是什么？
装箱：用于在垃圾回收堆中存储值类型。装箱是值类型到 object 类型或到此值类型所实现的任何接口类型的隐式转换。
拆箱：从 object 类型到值类型或从接口类型到实现该接口的值类型的显式转换。
5：为何需要装箱？(为何要将值类型转为引用类型？)
一种最普通的场景是，调用一个含类型为Object的参数的方法，该Object可支持任意为型，以便通用。当你需要将一个值类型(如Int32)传入时，需要装箱。
另一种用法是，一个非泛型的容器，同样是为了保证通用，而将元素类型定义为Object。于是，要将值类型数据加入容器时，需要装箱。
6：装箱/拆箱的内部操作。
装箱：
对值类型在堆中分配一个对象实例，并将该值复制到新的对象中。按三步进行。
第一步：新分配托管堆内存(大小为值类型实例大小加上一个方法表指针和一个SyncBlockIndex)。
第二步：将值类型的实例字段拷贝到新分配的内存中。
第三步：返回托管堆中新分配对象的地址。这个地址就是一个指向对象的引用了。
有人这样理解：如果将Int32装箱，返回的地址，指向的就是一个Int32。我认为也不是不能这样理解，但这确实又有问题，一来它不全面，二来指向Int32并没说出它的实质(在托管堆中)。
拆箱：
检查对象实例，确保它是给定值类型的一个装箱值。将该值从实例复制到值类型变量中。
有书上讲，拆箱只是获取引用对象中指向值类型部分的指针，而内容拷贝则是赋值语句之触发。我觉得这并不要紧。最关键的是检查对象实例的本质，拆箱和装箱的类型必需匹配，这一点上，在IL层上，看不出原理何在，我的猜测，或许是调用了类似GetType之类的方法来取出类型进行匹配(因为需要严格匹配)。
7：装箱/拆箱对执行效率的影响
显然，从原理上可以看出，装箱时，生成的是全新的引用对象，这会有时间损耗，也就是造成效率降低。
那该如何做呢？
首先，应该尽量避免装箱。
比如上例2的两种情况，都可以避免，在第一种情况下，可以通过重载函数来避免。第二种情况，则可以通过泛型来避免。
当然，凡事并不能绝对，假设你想改造的代码为第三方程序集，你无法更改，那你只能是装箱了。
对于装箱/拆箱代码的优化，由于C#中对装箱和拆箱都是隐式的，所以，根本的方法是对代码进行分析，而分析最直接的方式是了解原理结何查看反编译的IL代码。比如：在循环体中可能存在多余的装箱，你可以简单采用提前装箱方式进行优化。
8：对装箱/拆箱更进一步的了解
装箱/拆箱并不如上面所讲那么简单明了，比如：装箱时，变为引用对象，会多出一个方法表指针，这会有何用处呢？
我们可以通过示例来进一步探讨。
举个例子。
- public abstract class ValueType
- {
- // Summary:
- // Initializes a new instance of the System.ValueType class.
- protected ValueType();
- public override bool Equals(object obj);
- public override int GetHashCode();
- public override string ToString();
- }
- struct A : ICloneable
- {
- public Int32 x;
- public object Alf(int d)
- {
- return this.MemberwiseClone();
- }
- //public override String ToString()
- //{
- // return String.Format(“{0}”, x);
- //}
- public object Clone()
- {
- return MemberwiseClone();
- }
- }
- class Program
- {
- static void Main(string[] args)
- {
- object o = 8;
- A a;
- a.x = 100;
- Console.WriteLine(a.ToString());//不装箱
- Console.WriteLine(a.Equals(o));//不装箱
- Console.WriteLine(a.GetHashCode());//不装箱
- Console.WriteLine(a.GetType());//装箱，因为System.ValueType没有重写这个方法
- A a2 = (A)a.Clone();
- ICloneable c = a2;
- object os = c.Clone();
- }
- }
public abstract class ValueType
{
// Summary:
// Initializes a new instance of the System.ValueType class.
protected ValueType();
public override bool Equals(object obj);
public override int GetHashCode();
public override string ToString();
}
struct A : ICloneable
{
public Int32 x;
public object Alf(int d)
{
return this.MemberwiseClone();
}
//public override String ToString()
//{
// return String.Format("{0}", x);
//}
public object Clone()
{
return MemberwiseClone();
}
}
class Program
{
static void Main(string[] args)
{
object o = 8;
A a;
a.x = 100;
Console.WriteLine(a.ToString());//不装箱
Console.WriteLine(a.Equals(o));//不装箱
Console.WriteLine(a.GetHashCode());//不装箱
Console.WriteLine(a.GetType());//装箱，因为System.ValueType没有重写这个方法
A a2 = (A)a.Clone();
ICloneable c = a2;
object os = c.Clone();
}
}
5.0：a.ToString()。编译器发现A重写了ToString方法，会直接调用ToString的指令。因为A是值类型，编译器不会出现多态行为。因此，直接调用，不装箱。(注：ToString是A的基类System.ValueType的方法)
5.1：a.GetType()，GetType是继承于System.Object的方法，要调用它，需要一个方法表指针，于是a将被装箱，从而生成方法表指针，调用基类的System.Object。(补一句，所有的值类型都是继承于System.Object的)。
5.2：a.Clone()，因为A实现了Clone方法，所以无需装箱。
5.3：ICloneable转型：当a2为转为接口类型时，必须装箱，因为接口是一种引用类型。
5.4：c.Clone()。无需装箱，在托管堆中对上一步已装箱的对象进行调用。
附：其实上面的基于一个根本的原理，因为未装箱的值类型没有方法表指针，所以，不能通过值类型来调用其上继承的虚方法。另外，接口类型是一个引用类型。对此，我的理解，该方法表指针类似C++的虚函数表指针，它是用来实现引用对象的多态机制的重要依据。
9：如何更改已装箱的对象
对于已装箱的对象，因为无法直接调用其指定方法，所以必须先拆箱，再调用方法，但再次拆箱，会生成新的栈实例，而无法修改装箱对象。有点晕吧，感觉在说绕口令。还是举个例子来说：(在上例中追加change方法)
public void Change(Int32 x) {
this.x = x;
}
调用：
A a = new A();
a.x = 100;
Object o = a; //装箱成o，下面，想改变o的值。
((A)o).Change(200); //改掉了吗？没改掉。
没改掉的原因是o在拆箱时，生成的是临时的栈实例A，所以，改动是基于临时A的，并未改到装箱对象。
(附：在托管C++中，允许直接取加拆箱时第一步得到的实例引用，而直接更改，但C#不行。)
那该如何是好？
嗯，通过接口方式，可以达到相同的效果。
实现如下：
interface IChange {
void Change(Int32 x);
}
struct A : IChange {
…
}
调用：
((IChange)o).Change(200);//改掉了吗？改掉了。
为啥现在可以改？
在将o转型为IChange时，这里不会进行再次装箱，当然更不会拆箱，因为o已经是引用类型，再因为它是IChange类型，所以可以直接调用Change，于是，更改的也就是已装箱对象中的字段了，达到期望的效果。
10、————————–
将值类型转换为引用类型，需要进行装箱操作(boxing)：
1、首先从托管堆中为新生成的引用对象分配内存。
2、然后将值类型的数据拷贝到刚刚分配的内存中。
3、返回托管堆中新分配对象的地址。
可以看出，进行一次装箱要进行分配内存和拷贝数据这两项比较影响性能的操作。
将引用内型转换为值内型，需要进行拆箱操作(unboxing)：
1、首先获取托管堆中属于值类型那部分字段的地址，这一步是严格意义上的拆箱。
2、将引用对象中的值拷贝到位于线程堆栈上的值类型实例中。
经过这2步，可以认为是同boxing是互反操作。严格意义上的拆箱，并不影响性能，但伴随这之后的拷贝数据的操作就会同boxing操作中一样影响性能。
11、————————-
NET的所有类型都是由基类System.Object继承过来的，包括最常用的基础类型：int, byte, short，bool等等，就是说所有的事物都是对象。如果申明这些类型得时候都在堆(HEAP)中分配内存，会造成极低的效率！(个中原因以及关于堆和栈得区别会在另一篇里单独得说说！)
.NET如何解决这个问题得了？正是通过将类型分成值型(value)和引用型(regerencetype)，C#中定义的值类型包括原类型（Sbyte、Byte、Short、Ushort、Int、Uint、Long、Ulong、Char、Float、Double、Bool、Decimal）、枚举(enum)、结构(struct)，引用类型包括：类、数组、接口、委托、字符串等。
值型就是在栈中分配内存，在申明的同时就初始化，以确保数据不为NULL；
引用型是在堆中分配内存，初始化为null，引用型是需要GARBAGE COLLECTION来回收内存的，值型不用，超出了作用范围，系统就会自动释放！
下面就来说装箱和拆箱的定义！
装箱就是隐式的将一个值型转换为引用型对象。比如：
int i=0;
Syste.Object obj=i;
这个过程就是装箱！就是将i装箱！
拆箱就是将一个引用型对象转换成任意值型！比如：
int i=0;
System.Object obj=i;
int j=(int)obj;
这个过程前2句是将i装箱，后一句是将obj拆箱！
1424
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
