11.3 Boxing and unboxing

11.3 Boxing and unboxing
The concept of boxing and unboxing is central to C#.s type system. It
provides a bridge between value-types
and reference-types by permitting any value of a value-type to be converted
to and from type object.
Boxing and unboxing enables a unified view of the type system wherein a
value of any type can ultimately
be treated as an object.
11.3.1 Boxing conversions
A boxing conversion permits any value-type to be implicitly converted to
the type object or to any
interface-type implemented by the value-type. Boxing a value of a
value-type consists of allocating an object
instance and copying the value-type value into that instance.
The actual process of boxing a value of a value-type is best explained by
imagining the existence of a boxing
class for that type. [Example: For any value-type T, the boxing class
behaves as if it were declared as
follows:
sealed class T_Box
{
T value;
public T_Box(T t) {
value = t;
}
}
Boxing of a value v of type T now consists of executing the expression new
T_Box(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 int_Box(i);
end example]
Chapter 11 Types
97
Boxing classes like T_Box and int_Box above don.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. [Example: 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. end example]
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. [Example: 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. end
example]
11.3.2 Unboxing conversions
An unboxing conversion permits an explicit conversion from type object to
any value-type or from any
interface-type to any value-type that implements the interface-type. An
unboxing operation consists of first
checking that the object instance is a boxed value of the given value-type,
and then copying the value out of
the instance.
Referring to the imaginary boxing class described in the previous section,
an unboxing conversion of an
object box to a value-type T consists of executing the expression
((T_Box)box).value. [Example: Thus,
the statements
object box = 123;
int i = (int)box;
conceptually correspond to
object box = new int_Box(123);
int i = ((int_Box)box).value;
end example]
For an unboxing conversion to a given value-type to succeed at run-time,
the value of the source operand
must be a reference to an object that was previously created by boxing a
value of that value-type. If the
source operand is null a System.NullReferenceException is thrown. If the
source operand is a
reference to an incompatible object, a System.InvalidCastException is
thrown.