.net 装箱/拆箱和类型转换有什么区别？

What is the difference between boxing/unboxing and type casting?

提问by

What is the difference between boxing/unboxing and type casting?

装箱/拆箱和类型转换有什么区别？

Often, the terms seem to be used interchangeably.

通常，这些术语似乎可以互换使用。

回答by jason

Boxing refers to a conversion of a non-nullable-value type into a reference type or the conversion of a value type to some interface that it implements (say intto IComparable<int>). Further, the conversion of an underlying value type to a nullable type is also a boxing conversion. (Caveat: Most discussions of this subject will ignore the latter two types of conversions.)

装箱是指将不可空值类型转换为引用类型或将值类型转换为它实现的某个接口（比如intto IComparable<int>）。此外，底层值类型到可为空类型的转换也是一种装箱转换。（警告：关于这个主题的大多数讨论都会忽略后两种类型的转换。）

For example,

例如，

int i = 5;
object o = i;

converts ito an instance of type object.

转换i为 type 的实例object。

Unboxing refers to an explicit conversion from an instance of objector ValueTypeto a non-nullable-value type, the conversion of an interface type to a non-nullable-value type (e.g., IComparable<int>to int). Further, the conversion of a nullable type to the underlying type is also an unboxing conversion. (Caveat: Most discussion of this subject will ignore the latter two types of conversions.)

拆箱是指从实例object或ValueType到非空值类型的实例的显式转换，接口类型到非空值类型（例如，IComparable<int>to int）的转换。此外，可空类型到基础类型的转换也是一种拆箱转换。（警告：关于这个主题的大多数讨论将忽略后两种类型的转换。）

For example,

例如，

object o = (int)5;
int i = (int)o;

converts the integer boxed in oto an instance of type int.

将装箱的整数转换o为 type 的实例int。

A type cast is an explicit conversion of an expression to a given type. Thus

类型转换是将表达式显式转换为给定类型。因此

(type) expression

explicitly converts expressionto an object of type type.

显式转换expression为类型的对象type。

回答by Mehrdad Afshari

Boxing and unboxing is a subset of type casts. Boxing is the act of treating a value type as reference type (which in practice, involves copying the contents of that value type (from stack) to the heap and returning a reference to that object). This allows a value type to be passed wherever a compatible reference type is expected. It also allows virtual method calls and other features of reference types to be performed on the value type. Unboxing is the reverse of this operation (getting back a value type out of a boxed object).

装箱和拆箱是类型转换的一个子集。装箱是将值类型视为引用类型的行为（实际上，这涉及将该值类型的内容（从堆栈）复制到堆并返回对该对象的引用）。这允许在需要兼容引用类型的任何地方传递值类型。它还允许对值类型执行虚方法调用和引用类型的其他功能。拆箱操作与此操作相反（从装箱对象中取回值类型）。

Type cast is the term used for anytype of conversion from a variable of specific type to another. It's a broader concept.

类型转换是用于从特定类型的变量到另一种类型的任何类型的转换的术语。这是一个更广泛的概念。

A few minutes ago I answered a related question that covers this difference. To summarize, I categorized different types of IL instructions generated by C# cast operator:

几分钟前，我回答了一个相关的问题，涵盖了这种差异。总而言之，我对 C# cast 运算符生成的不同类型的 IL 指令进行了分类：

1. Boxing (boxIL instruction) and unboxing (unboxIL instruction)
2. Casting through the inhertiance hierarchy (like dynamic_cast<Type>in C++, uses castclassIL instruction to verify)
3. Casting between primitive types (like static_cast<Type>in C++, there are plenty of IL instructions for different types of casts between primitive types)
4. Calling user defined conversion operators (at the IL level they are just method calls to the appropriate op_XXXmethod).

1. 装箱（boxIL指令）和拆箱（unboxIL指令）
2. 通过继承层次结构进行转换（如dynamic_cast<Type>在 C++ 中，使用castclassIL 指令进行验证）
3. 原始类型之间的转换（就像static_cast<Type>在 C++ 中，有很多 IL 指令用于原始类型之间的不同类型的转换）
4. 调用用户定义的转换运算符（在 IL 级别，它们只是对适当op_XXX方法的方法调用）。

回答by Judah Gabriel Himango

Boxing is the term for turning a value type (int, double, float, Guid, etc.) into a reference type (System.Object, System.String, etc.). Doing this boxing operation allocates memory on the heap (which the garbage collector will eventually need to reclaim). Unboxing is the reverse of this process, taking a reference type and turning it into a value type.

装箱是将值类型（int、double、float、Guid 等）转换为引用类型（System.Object、System.String 等）的术语。执行此装箱操作会在堆上分配内存（垃圾收集器最终需要回收）。拆箱是这个过程的逆过程，将引用类型转换为值类型。

Casting is taking a type (say, System.Object) and treating it as another type (say, System.String).

强制转换是采用一种类型（例如 System.Object）并将其视为另一种类型（例如 System.String）。

When you box something in C#, you are casting it to another type. The difference is that it allocates additional memory as a new reference type is created.

当您在 C# 中装箱时，您将其转换为另一种类型。不同之处在于它在创建新的引用类型时分配额外的内存。

Bottom line: boxing is a special kind of cast that converts a value type to a reference type, which requires the allocation of a new reference type.

底线：装箱是一种特殊的类型转换，它将值类型转换为引用类型，这需要分配一个新的引用类型。

回答by Guffa

Boxing/unboxing and type casting are two different operations, however they use the same syntax.

装箱/拆箱和类型转换是两种不同的操作，但它们使用相同的语法。

They are only used interchangeably when the person talking about it doesn't know what's really happening...

只有当谈论它的人不知道真正发生了什么时，它们才可以互换使用......

Boxing is storing a value type as an object on the heap, and unboxing is reading the value from the object. You can only unbox the value as it's exact type.

装箱是将值类型作为对象存储在堆上，拆箱是从对象中读取值。您只能取消装箱该值，因为它是确切类型。

Casting is when you convert a basic type to another basic type (like from an intto a long), or when you change the type of a reference (like from List<int>to IEnumerable<int>).

转换是指将基本类型转换为另一种基本类型（例如从 anint到 a long），或者更改引用的类型（例如 fromList<int>到IEnumerable<int>）。

回答by ajawad987

Boxing means converting a value type variable (i.e. an integer) to a reference type. Unboxing is the reverse of that, using type casting. In the .NET world, everything derives from the "object" type in a nutshell.

装箱意味着将值类型变量（即整数）转换为引用类型。拆箱是相反的，使用类型转换。在 .NET 世界中，简而言之，一切都源自“对象”类型。

For example (C# example):

例如（C# 示例）：

int myInt = 0;                 // original variable (unboxed to begin with)
object boxed = myInt;          // box it up
int myIntUnBoxed = (int)boxed; // and unbox it again using type casting

The take-away from this is the unification of the type system, allowing value-types to be treated as reference types. This articlehas a more indepth look at boxing/unboxing.

从中得出的结论是类型系统的统一，允许将值类型视为引用类型。这篇文章更深入地介绍了装箱/拆箱。