具有引用类型变量的对象类型装箱

Boxing is when a value type is assigned to an object type. Is it the same when a reference type is assigned to an object?

拳击是指将值类型分配给对象类型。将引用类型分配给对象时是否相同?

When a type (which isn't object) is assigned, what happens? Is that boxing too?

如果分配了一个类型(不是对象),会发生什么?那个拳击呢?

    int num=5;
    object obj = num;  //boxing
    //////////////////////
    MyClass my = new MyClass();
    object obj = my; //what is name this convert  (whethere is boxing?)

5 个解决方案

#1

I assume you mean something like

我认为你的意思是

string s = "hello";
object x = s;        // no boxing, just implict conversion to base-type.

This works because System.String, like all other classes, derives from System.Object:

这是有效的,因为System.String与所有其他类一样,派生自System.Object:

public sealed class String : Object { ... }

#2

Boxing is when a value type is assigned to an object type.

拳击是指将值类型分配给对象类型。

Close. "Boxing" happens when a value of value type is converted to a reference type.

关。当值类型的值转换为引用类型时,会发生“Boxing”。

Is it the same when a value of reference type is assigned to a variable of type object?

将引用类型的值赋给对象类型的变量时是否相同?

No. Boxing happens when a value of value type is converted to a reference type. Converting a value of reference type to object is not a boxing conversion, it is a reference conversion.

不会。当值类型的值转换为引用类型时,就会发生Boxing。将引用类型的值转换为对象不是装箱转换,它是引用转换。

When a value of reference type (which isn't object) is assigned to a variable of type object, what happens?

当引用类型(不是对象)的值被赋给对象类型的变量时,会发生什么?

A value of reference type is a reference. When a reference is assigned to a variable of type object, a copy of the reference is made in the storage location associated with the variable.

引用类型的值是引用。将引用分配给object类型的变量时,将在与该变量关联的存储位置中创建引用的副本。

Is that boxing too?

那个拳击呢?

No. Boxing happens when a value of value type is converted to a reference type. Converting a value of reference type to object is not a boxing conversion, it is a reference conversion.

不会。当值类型的值转换为引用类型时,就会发生Boxing。将引用类型的值转换为对象不是装箱转换,它是引用转换。

#3

Boxing is creating an object reference, on the stack, that references a value of the type say for e.g. int, on the heap. But when a reference type (witch isn't object)assigned to object, it is not boxing.

Boxing正在堆栈上创建一个对象引用,它引用类型的值,例如: int,在堆上。但是当一个引用类型(女巫不是对象)分配给对象时,它不是拳击。

#4

Eric's answer corresponds to the CLI (Common Language Infrastructure) standard ECMA-335, partition I (Architecture), chapter 5 (Terms and definitions), which defines boxing as: "The conversion of a value having some value type, to a newly allocated instance of the reference type System.Object.", and unboxing as: "The conversion of a value having type System.Object, whose run-time type is a value type, to a value type instance."

Eric的答案对应于CLI(公共语言基础结构)标准ECMA-335,分区I(体系结构),第5章(术语和定义),它将装箱定义为:“将具有某种值类型的值转换为新分配的值”引用类型System.Object的实例。“,并取消装箱为:”将类型为System.Object的值(其运行时类型为值类型)转换为值类型实例。“

The box and unbox instructions of the CIL (Common Intermediate Language) behave like this, and this is also the meaning usually implied when speaking of boxing/unboxing in the context of C# or VB.NET.

CIL(通用中间语言)的box和unbox指令的行为与此类似,这也是在C#或VB.NET上下文中提到装箱/拆箱时通常隐含的含义。

However, the terms boxing and unboxing are sometimes used in a wider/pragmatic sense. For instance, the F# box and unbox operators can do conversions of value types and reference types to and from System.Object:

然而,术语装箱和拆箱有时用于更广泛/实用的意义上。例如,F#box和unbox运算符可以对System.Object进行值类型和引用类型的转换:

> let o = box "Hello World";;
val o : obj = "Hello World"
> let s:string = unbox o;;
val s : string = "Hello World"

#5

Compiling the provided code into a working executable and disassembling it reveals an explicit box instruction for the first assignment (obj) that is not present for the second (obj2):

将提供的代码编译成工作的可执行文件并反汇编它会显示第一个赋值(obj)的显式框指令,该指令不存在于第二个(obj2):

Source

namespace BoxingAndTypeConversion
{
    class Program
    {
        public class MyClass { }

        static void Main(string[] args)
        {
            int num = 5;
            object obj = num;  //boxing
            //////////////////////
            MyClass my = new MyClass();
            object obj2 = my; //what is name this convert  (whethere is boxing?)
        }
    }
}

CIL

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       19 (0x13)
  .maxstack  1
  .locals init ([0] int32 num,
           [1] object obj,
           [2] class BoxingAndTypeConversion.Program/MyClass my,
           [3] object obj2)
  IL_0000:  nop
  IL_0001:  ldc.i4.5
  IL_0002:  stloc.0
  IL_0003:  ldloc.0
  IL_0004:  box        [mscorlib]System.Int32
  IL_0009:  stloc.1
  IL_000a:  newobj     instance void BoxingAndTypeConversion.Program/MyClass::.ctor()
  IL_000f:  stloc.2
  IL_0010:  ldloc.2
  IL_0011:  stloc.3
  IL_0012:  ret
} // end of method Program::Main