Boxing conversions. A boxing conversion permits a value-type to be implicitly converted to a reference-type

A boxing conversion permits a value-type to be implicitly converted to a reference-type. The following boxing conversions exist:

· From any value-type to the type object.

· From any value-type to the type System.ValueType.

· From any non-nullable-value-type to any interface-type implemented by the value-type.

· From any nullable-type to any interface-type implemented by the underlying type of the nullable-type.

· From any enum-type to the type System.Enum.

· From any nullable-type with an underlying enum-type to the type System.Enum.

Note that an implicit conversion from a type parameter will be executed as a boxing conversion if at run-time it ends up converting from a value type to a reference type (§6.1.10).

Boxing a value of a non-nullable-value-type consists of allocating an object instance and copying the non-nullable-value-type value into that instance.

Boxing a value of a nullable-type produces a null reference if it is the null value (HasValue is false), or the result of unwrapping and boxing the underlying value otherwise.

The actual process of boxing a value of a non-nullable-value-type is best explained by imagining the existence of a generic boxing class, which behaves as if it were declared as follows:

sealed class Box<T>: System.ValueType
{
T value;

public Box(T t) {
value = t;
}
}

Boxing of a value v of type T now consists of executing the expression new Box<T>(v), and returning the resulting instance as a value of type object. Thus, the statements

int i = 123;
object box = i;

conceptually correspond to

int i = 123;
object box = new Box<int>(i);

A boxing class like Box<T> above doesn’t actually exist and the dynamic type of a boxed value isn’t actually a class type. Instead, a boxed value of type T has the dynamic type T, and a dynamic type check using the is operator can simply reference type T. For example,

int i = 123;
object box = i;
if (box is int) {
Console.Write("Box contains an int");
}

will output the string “Box contains an int” on the console.

A boxing conversion implies making a copy of the value being boxed. This is different from a conversion of a reference-type to type object, in which the value continues to reference the same instance and simply is regarded as the less derived type object. For example, given the declaration

struct Point
{
public int x, y;

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

the following statements

Point p = new Point(10, 10);
object box = p;
p.x = 20;
Console.Write(((Point)box).x);

will output the value 10 on the console because the implicit boxing operation that occurs in the assignment of p to box causes the value of p to be copied. Had Point been declared a class instead, the value 20 would be output because p and box would reference the same instance.