Sorry Chryso,
I forgot to say this is an extract from the Microsoft C# specification.
That was from the introduction.
Here's a bit more detail:
4.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.
4.3.1 Boxing conversions
A boxing conversion permits a value-type to be implicitly converted to a reference-type. The following boxing conversions exist:
¡¤ From any value-type (including any enum-type) to the type object.
¡¤ From any value-type (including any enum-type) to the type System.ValueType.
¡¤ From any value-type to any interface-type implemented by the value-type.
¡¤ From any enum-type to the type System.Enum.
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. For any value-type T, the boxing class behaves as if it were declared as follows:
sealed class T_Box: System.ValueType
{
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);
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. 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.
4.3.2 Unboxing conversions
An unboxing conversion permits a reference-type to be explicitly converted to a value-type. The following unboxing conversions exist:
¡¤ From the type object to any value-type (including any enum-type).
¡¤ From the type System.ValueType to any value-type (including any enum-type).
¡¤ From any interface-type to any value-type that implements the interface-type.
¡¤ From the type System.Enum to any enum-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. 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;
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.
dave
;