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

Question

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

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

short s = 25;

object objshort = s;  //Boxing

short anothershort = (short)objshort;  //Unboxing

Answer 1

为什么

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

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

因此，如果您不关心具有统一的类型系统（即，引用类型和值类型具有非常不同的表示形式，并且您不想要一种通用的方式来“表示”两者），那么您就不需要装箱。 如果您不关心让int表示它们的基础值（即，也让int成为引用类型，并且只存储对其基础值的引用），那么您就不需要装箱。

我应该在哪里使用它。

例如，旧的集合类型ArrayList只吃object s。 也就是说，它只存储对某处某物的引用。 如果没有装箱，您就不能将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 2

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

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

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

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

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

Answer 3

理解这一点的最佳方法是查看 C# 构建的低级编程语言。

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

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

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

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

为了从编码人员的角度保持这两个根本不同的内存概念（和存储策略）之间的交互简单，值类型可以随时装箱。 装箱会导致值从堆栈中复制，放入一个对象中，然后放置在堆上- 更昂贵，但与引用世界的交互流畅。 正如其他答案所指出的那样，例如，当您说：

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

Boxing 优势的一个有力例证是检查 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，因为 bool 已被装箱并放在那里。

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

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

• 事实证明，事件系统在幼稚的使用中存在竞争条件，并且它不支持异步。 添加拳击问题，它可能应该避免。 （例如，您可以将其替换为使用泛型的异步事件系统。）

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

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

您应该避免将您的值类型声明或传递为对象，除非您必须处理上述强制使用 Boxing 的历史问题，并且您想避免稍后在您知道它无论如何都会被 Boxed 时对其进行 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 4

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

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

Answer 5

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

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

Answer 6

我不得不拆箱的最后一个地方是在编写一些从数据库中检索一些数据的代码时（我没有使用LINQ to SQL ，只是简单的旧ADO.NET ）：

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

基本上，如果您在泛型之前使用较旧的 API，您会遇到拳击。 除此之外，它并不常见。

Answer 7

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

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

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

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

运行得很好，我没有使用装箱/拆箱。 （除非编译器在幕后这样做？）

Answer 8

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

Answer 9

通常，您通常希望避免装箱您的值类型。

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

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

Answer 10

当一个方法只接受一个引用类型作为参数时（比如一个通过new约束被约束为类的泛型方法），你将无法将引用类型传递给它，而必须将它装箱。

对于任何将object作为参数的方法也是如此——这必须是引用类型。

Answer 11

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

至于拳击实际上是做什么的。 这里有些例子

单声道 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的定义时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 12

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

仅在绝对必要时才应使用类型object ，因为它绕过了类型安全性，否则类型安全性是 C# 等静态类型语言的主要优点。 但是在编译时无法知道值的类型的情况下可能有必要。

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

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

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