In .net, every instance of Object, or any type derived therefrom, includes a data structure which contains information about its type. "Real" value types in .net do not contain any such information. To allow data in value types to be manipulated by routines that expect to receive types derived from object, the system automatically defines for each value type a corresponding class type with the same members and fields. Boxing creates a new instances of this class type, copying the fields from a value type instance. Unboxing copies the fields from an instance of the class type to an instance of the value type. All of the class types which are created from value types are derived from the ironically named class ValueType (which, despite its name, is actually a reference type).

装箱并不是你真正使用的东西——它是运行时使用的东西，这样你就可以在必要时以同样的方式处理引用和值类型。例如，如果您使用ArrayList来保存整数列表，则整数将被装箱以适应ArrayList中的对象类型插槽。

现在使用泛型集合，这种情况几乎消失了。如果你创建一个List<int>，没有装箱完成- List<int>可以直接保存整数。

最后一个我不得不开箱的地方是从数据库中检索数据的代码(我没有使用LINQ to SQL，只是简单的旧ADO.NET):

int myIntValue = (int)reader["MyIntValue"];

基本上，如果使用泛型之前的旧api，就会遇到装箱。除此之外，这种情况并不常见。

在. net框架中，有两种类型——值类型和引用类型。这在面向对象语言中比较常见。

面向对象语言的一个重要特性是以类型不可知的方式处理实例的能力。这被称为多态性。由于我们希望利用多态性，但我们有两种不同的类型，因此必须有某种方法将它们组合在一起，以便以相同的方式处理其中一个或另一个。

现在，回到过去(Microsoft.NET 1.0)，还没有这种新奇的泛型喧闹。您不能编写一个方法，它只有一个参数，可以服务于值类型和引用类型。这违反了多态性。因此，采用装箱作为一种将值类型强制转换为对象的方法。

如果这是不可能的，那么框架中就会充斥着方法和类，它们的唯一目的就是接受其他类型。不仅如此，由于值类型并没有真正共享一个共同的类型祖先，因此必须为每种值类型(比特、字节、int16、int32等等)设置不同的方法重载。

拳击阻止了这种情况的发生。这就是英国人庆祝节礼日的原因。

一般来说，您通常会希望避免对值类型进行装箱。

然而，在极少数情况下，这是有用的。例如，如果您需要以1.1框架为目标，那么您将无法访问泛型集合。在. net 1.1中使用任何集合都需要将您的值类型视为系统。对象，该对象导致装箱/解装箱。

There are still cases for this to be useful in .NET 2.0+. Any time you want to take advantage of the fact that all types, including value types, can be treated as an object directly, you may need to use boxing/unboxing. This can be handy at times, since it allows you to save any type in a collection (by using object instead of T in a generic collection), but in general, it is better to avoid this, as you're losing type safety. The one case where boxing frequently occurs, though, is when you're using Reflection - many of the calls in reflection will require boxing/unboxing when working with value types, since the type is not known in advance.

为什么

拥有统一的类型系统，并允许值类型以与引用类型完全不同的方式表示其基础数据(例如，int只是一个32位的桶，这与引用类型完全不同)。

这样想。你有一个object类型的变量o。现在你有一个int型，你想把它变成o。o是对某处某物的引用，而int型显然不是对某处某物的引用(毕竟，它只是一个数字)。所以，你要做的是:创建一个可以存储int的新对象，然后将该对象的引用赋值给o。我们称这个过程为“装箱”。

所以，如果你不关心是否有一个统一的类型系统(例如，引用类型和值类型有非常不同的表示，你不想用一种通用的方式来“表示”这两者)，那么你就不需要装箱。如果你不关心用int表示它们的底层值(也就是说，用int作为引用类型，只存储对它们底层值的引用)，那么你不需要装箱。

我应该在哪里使用它。

例如，旧的集合类型ArrayList只包含对象。也就是说，它只存储对某个地方的某个对象的引用。如果没有装箱，就不能在这样的集合中放入int型。但在拳击中，你可以。

现在，在泛型的时代，你并不真的需要这个，通常可以轻松地进行，而不需要考虑这个问题。但有一些注意事项需要注意:

这是正确的:

double e = 2.718281828459045;
int ee = (int)e;

这不是:

double e = 2.718281828459045;
object o = e; // box
int ee = (int)o; // runtime exception

相反，你必须这样做:

double e = 2.718281828459045;
object o = e; // box
int ee = (int)(double)o;

首先，我们必须显式地打开double ((double)o)，然后将其强制转换为int型。

下面的结果是什么:

double e = 2.718281828459045;
double d = e;
object o1 = d;
object o2 = e;
Console.WriteLine(d == e);
Console.WriteLine(o1 == o2);

下句话之前先想一下。

如果你说真假太棒了!等等,什么?这是因为引用类型上的==使用引用相等来检查引用是否相等，而不是检查底层值是否相等。这是一个很容易犯的危险错误。也许更微妙

double e = 2.718281828459045;
object o1 = e;
object o2 = e;
Console.WriteLine(o1 == o2);

也会打印False!

更好的说法是:

Console.WriteLine(o1.Equals(o2));

然后，谢天谢地，它会打印True。

最后一个微妙之处:

[struct|class] Point {
    public int x, y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

Point p = new Point(1, 1);
object o = p;
p.x = 2;
Console.WriteLine(((Point)o).x);

输出是什么?视情况而定!如果Point是一个结构体，则输出为1，但如果Point是一个类，则输出为2!装箱转换生成被装箱的值的副本，以解释行为上的差异。