为什么 C# 中需要装箱和拆箱？

Question

为什么 C# 中需要装箱和拆箱？

我知道什么是装箱和拆箱，但我无法理解它的真正用途。为什么以及在哪里应该使用它？

short s = 25;

object objshort = s;  //Boxing

short anothershort = (short)objshort;  //Unboxing

Answer 1

当我们有一个需要对象作为参数的函数，但我们需要传递不同的值类型时，需要装箱，在这种情况下，我们需要首先将值类型转换为对象数据类型，然后再将其传递给函数。

我不认为这是真的，试试这个：

class Program
    {
        static void Main(string[] args)
        {
            int x = 4;
            test(x);
        }

        static void test(object o)
        {
            Console.WriteLine(o.ToString());
        }
    }

运行得很好，我没有使用装箱/拆箱。 （除非编译器在幕后执行此操作？）

Answer 2

在 .net 中，Object 的每个实例或从其派生的任何类型都包含一个数据结构，其中包含有关其类型的信息。 .net 中的“真实”值类型不包含任何此类信息。为了允许期望接收从对象派生的类型的例程操作值类型中的数据，系统自动为每个值类型定义具有相同成员和字段的相应类类型。装箱创建此类类型的新实例，并从值类型实例复制字段。拆箱将字段从类类型的实例复制到值类型的实例。所有从值类型创建的类类型都派生自具有讽刺意味的名称类 ValueType（尽管它的名称如此，但它实际上是一个引用类型）。

Answer 3

装箱是将值转换为引用类型，数据位于堆上对象的某个偏移处。

至于拳击实际上是做什么的。以下是一些示例

Mono C++

void* mono_object_unbox (MonoObject *obj)
 {    
MONO_EXTERNAL_ONLY_GC_UNSAFE (void*, mono_object_unbox_internal (obj));
 }

#define MONO_EXTERNAL_ONLY_GC_UNSAFE(t, expr) \
    t result;       \
    MONO_ENTER_GC_UNSAFE;   \
    result = expr;      \
    MONO_EXIT_GC_UNSAFE;    \
    return result;

static inline gpointer
mono_object_unbox_internal (MonoObject *obj)
{
    /* add assert for valuetypes? */
    g_assert (m_class_is_valuetype (mono_object_class (obj)));
    return mono_object_get_data (obj);
}

static inline gpointer
mono_object_get_data (MonoObject *o)
{
    return (guint8*)o + MONO_ABI_SIZEOF (MonoObject);
}

#define MONO_ABI_SIZEOF(type) (MONO_STRUCT_SIZE (type))
#define MONO_STRUCT_SIZE(struct) MONO_SIZEOF_ ## struct
#define MONO_SIZEOF_MonoObject (2 * MONO_SIZEOF_gpointer)

typedef struct {
    MonoVTable *vtable;
    MonoThreadsSync *synchronisation;
} MonoObject;

在 Mono 中拆箱对象是在对象中 2 个 gpointers 的偏移量（例如 16 个字节）处转换指针的过程。 gpointer 是一个void*。在查看 MonoObject 的定义时，这是有道理的，因为它显然只是数据的标头。

C++

要在 C++ 中对值进行装箱，您可以执行以下操作：

#include <iostream>
#define Object void*

template<class T> Object box(T j){
  return new T(j);
}

template<class T> T unbox(Object j){
  T temp = *(T*)j;
  delete j;
  return temp;
}

int main() {
  int j=2;
  Object o = box(j);
  int k = unbox<int>(o);
  std::cout << k;
}

Answer 4

当方法仅采用引用类型作为参数时（例如通过 new 约束将泛型方法限制为类），您将无法将引用类型传递给它并且必须装箱它。

对于任何采用 object 作为参数的方法也是如此 - 这将具有作为引用类型。

Answer 5

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

然而，在极少数情况下这是有用的。例如，如果您需要以 1.1 框架为目标，您将无法访问通用集合。在 .NET 1.1 中对集合的任何使用都需要将值类型视为 System.Object，这会导致装箱/拆箱。

在某些情况下，这在 .NET 2.0+ 中仍然有用。任何时候您想要利用所有类型（包括值类型）都可以直接视为对象的事实，您可能需要使用装箱/拆箱。这有时很方便，因为它允许您保存集合中的任何类型（通过在泛型集合中使用对象而不是 T），但一般来说，最好避免这种情况，因为您会失去类型安全性。然而，频繁发生装箱的一种情况是当您使用反射时 - 在处理值类型时，反射中的许多调用将需要装箱/拆箱，因为事先不知道该类型。

Answer 6

当值类型传递给对象类型的变量或参数时，就会发生装箱。由于它是自动发生的，所以问题不在于何时应该使用装箱，而在于何时应该使用 object 类型。

object 类型仅应在绝对必要时使用，因为它规避了类型安全性，而类型安全性是 C# 等静态类型语言的主要优点。但如果在编译时无法知道值的类型，则可能有必要这样做。

例如，通过 ADO.NET 框架读取数据库字段值时。返回的值可以是整数、字符串或其他值，因此类型必须是object，并且客户端代码必须执行适当的转换。为了避免此问题，Linq-to-SQL 或 EF Core 等 ORM 框架改用静态类型实体，因此避免使用 object。

在引入泛型之前，像 ArrayList 这样的集合的项目类型为 object。这意味着您可以在列表中存储任何内容，并且可以将字符串添加到数字列表中，而类型系统不会抱怨。泛型解决了这个问题，并且在使用值类型集合时使装箱变得不必要。

因此，很少需要将某些内容输入为 object，并且您希望避免这样做。在代码需要能够处理值类型和引用类型的情况下，泛型通常是更好的解决方案。

Answer 7

为什么

要拥有一个统一的类型系统，并允许值类型对其底层数据的表示方式与引用类型表示其底层数据的方式完全不同（例如，int 只是一桶 30-两位与引用类型完全不同）。

这样想吧。您有一个 object 类型的变量 o。现在您有一个 int 并且您想将其放入 o 中。 o 是对某个地方的引用，而 int 显然不是对某个地方的引用（毕竟，它只是一个数字）。因此，您要做的是：创建一个可以存储 int 的新对象，然后将该对象的引用分配给o 。我们称这个过程为“拳击”。

因此，如果您不关心是否有一个统一的类型系统（即，引用类型和值类型具有非常不同的表示形式，并且您不想要一种通用的方式来“表示”这两者），那么您就不需要装箱。如果您不关心让 int 代表其底层值（即，让 int 也成为引用类型并仅存储对其底层值的引用），那么您就不需要不需要拳击。

我应该在哪里使用它。

例如，旧的集合类型ArrayList只吃object。也就是说，它只存储对存在于某处的事物的引用。如果没有装箱，您就无法将 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);

在继续下一句话之前先想一想。

如果您说 True 和 False 那就太棒了！等等，什么？这是因为引用类型上的 == 使用引用相等来检查引用是否相等，而不是基础值是否相等。这是一个很容易犯的危险错误。也许更微妙的

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 是 struct，则输出为 1，但如果 Point 是 class > 那么输出是2！装箱转换会生成装箱值的副本，以解释行为的差异。

Answer 8

在.NET框架中，有两种类型——值类型和引用类型。这在 OO 语言中比较常见。

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

现在，回到过去（Microsoft.NET 1.0），并没有这种新奇的泛型喧嚣。您无法编写具有可以为值类型和引用类型提供服务的单个参数的方法。这是违反多态性的。因此，采用装箱作为将值类型强制转换为对象的方法。

如果这是不可能的，框架将充斥着方法和类，其唯一目的是接受其他类型的类型。不仅如此，由于值类型并不真正共享公共类型祖先，因此您必须为每个值类型（位、字节、int16、int32 等）提供不同的方法重载。

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

Answer 9

理解这一点的最佳方法是查看 C# 所基于的较低级编程语言。

在 C 等最低级语言中，所有变量都存放在一个地方：堆栈。每次声明一个变量时，它都会进入堆栈。它们只能是原始值，如 bool、byte、32 位 int、32 位 uint 等。堆栈既简单又快速。添加变量时，它们只是一个叠加另一个，因此您声明的第一个位于 RAM 中的 0x00，下一个位于 0x01，下一个位于 0x02，等等。此外，变量通常在编译时预先寻址。时间，因此在运行程序之前就知道它们的地址。

在下一个级别中，如 C++，引入了称为堆的第二个内存结构。您仍然主要居住在堆栈中，但是可以将称为指针的特殊整数添加到堆栈中，它们存储对象第一个字节的内存地址，并且该对象居住在堆中。堆有点混乱，而且维护起来有点昂贵，因为与堆栈变量不同，它们不会在程序执行时线性地向上然后向下堆积。它们可以没有特定的顺序来来去去，并且可以增长和收缩。

处理指针很困难。它们是内存泄漏、缓冲区溢出和失败的原因。 C# 来救援。

在更高的层次上，C#，您不需要考虑指针 - .Net 框架（用 C++ 编写）会为您考虑这些并将它们作为对象的引用呈现给您，并且为了性能，允许您存储更简单的值像 bool、bytes 和 ints 作为值类型。在底层，对象和实例化类的东西位于昂贵的内存管理堆中，而值类型位于与低级 C 中相同的堆栈中 - 速度超快。

从编码员的角度来看，为了保持这两个根本不同的内存概念（以及存储策略）之间的交互简单，可以随时对值类型进行装箱。 装箱会导致从堆栈中复制值，放入对象中，然后放置在堆 - 更昂贵，但是与参考世界的交互流畅。正如其他答案所指出的，当您说以下内容时，就会发生这种情况：

bool b = false; // Cheap, on Stack
object o = b; // Legal, easy to code, but complex - Boxing!
bool b2 = (bool)o; // Unboxing!

装箱优势的一个强有力的说明是对 null 的检查：

if (b == null) // Will not compile - bools can't be null
if (o == null) // Will compile and always return false

从技术上讲，我们的对象 o 是堆栈中的一个地址，它指向我们的 bool b 的副本，该地址已被复制到堆中。我们可以检查 o 是否为 null，因为布尔值已被装箱并放在那里。

一般来说，除非需要，否则应该避免装箱，例如将 int/bool/whatever 作为对象传递给参数。 .Net 中的一些基本结构仍然需要将值类型作为对象传递（因此需要装箱），但在大多数情况下，您永远不需要装箱。

需要装箱的历史 C# 结构的非详尽列表，您应该避免：

• 事件系统 天真的使用它时发现有一个竞争条件，并且它不支持异步。再加上拳击问题，也许应该可以避免。 （例如，您可以将其替换为使用泛型的异步事件系统。）

• 旧的 Threading 和 Timer 模型在其参数上强制使用 Box，但已被 async/await 取代，后者更干净、更高效。

• .Net 1.1 集合完全依赖于 Boxing，因为它们出现在泛型之前。这些仍然在 System.Collections 中存在。在任何新代码中，您应该使用 System.Collections.Generic 中的集合，其中 除了避免 Boxing 之外，还为您提供了更强的类型安全性。

您应该避免将值类型声明或传递为对象，除非您必须处理上述强制装箱的历史问题，并且您希望避免稍后当您知道它将被装箱时对其性能造成影响。

根据 Mikael 下面的建议：

这样做

using System.Collections.Generic;

var employeeCount = 5;
var list = new List<int>(10);

而不是这个

using System.Collections;

Int32 employeeCount = 5;
var list = new ArrayList(10);

更新

这个答案最初建议 Int32、Bool 等导致装箱，而实际上它们是值类型的简单别名。也就是说，.Net 具有 Bool、Int32、String 等类型，C# 将它们别名为 bool、int、string，没有任何功能差异。

Answer 10

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

现在使用通用集合，这个问题几乎消失了。如果您创建 List，则不会进行装箱 - List 可以直接保存整数。

Answer 11

装箱和拆箱专门用于将值类型对象视为引用类型；将它们的实际值移动到托管堆并通过引用访问它们的值。

如果没有装箱和拆箱，你永远无法通过引用传递值类型；这意味着您无法将值类型作为对象的实例传递。

Answer 12

我最后一次必须拆箱的地方是编写一些从数据库检索一些数据的代码时（我没有使用 LINQ 到 SQL，只是简单的旧 ADO.NET )：

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

基本上，如果您在泛型之前使用较旧的 API，您会遇到装箱问题。除此之外，这种情况并不常见。