зеркало из https://github.com/mono/old-code.git
45 строки
3.0 KiB
XML
45 строки
3.0 KiB
XML
<?xml version="1.0"?>
|
|
<clause number="11.3.1" title="Boxing conversions">
|
|
<paragraph>A boxing conversion permits any <non_terminal where="11.1">value-type</non_terminal> to be implicitly converted to the type object or to any <non_terminal where="11.2">interface-type</non_terminal> implemented by the <non_terminal where="11.1">value-type</non_terminal>. Boxing a value of a <non_terminal where="11.1">value-type</non_terminal> consists of allocating an object instance and copying the <non_terminal where="11.1">value-type</non_terminal> value into that instance. </paragraph>
|
|
<paragraph>The actual process of boxing a value of a <non_terminal where="11.1">value-type</non_terminal> is best explained by imagining the existence of a boxing class for that type. <example>[Example: For any <non_terminal where="11.1">value-type</non_terminal> T, the boxing class behaves as if it were declared as follows: <code_example><![CDATA[
|
|
sealed class T_Box
|
|
{
|
|
T value;
|
|
public T_Box(T t) {
|
|
value = t;
|
|
}
|
|
}
|
|
]]></code_example></example></paragraph>
|
|
<paragraph>
|
|
<example>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 <code_example><![CDATA[
|
|
int i = 123;
|
|
object box = i;
|
|
]]></code_example>conceptually correspond to <code_example><![CDATA[
|
|
int i = 123;
|
|
object box = new int_Box(i);
|
|
]]></code_example>end example]</example>
|
|
</paragraph>
|
|
<paragraph>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>[Example: For example, <code_example><![CDATA[
|
|
int i = 123;
|
|
object box = i;
|
|
if (box is int) {
|
|
Console.Write("Box contains an int");
|
|
}
|
|
]]></code_example>will output the string "Box contains an int" on the console. end example]</example> </paragraph>
|
|
<paragraph>A boxing conversion implies making a copy of the value being boxed. This is different from a conversion of a <non_terminal where="11.2">reference-type</non_terminal> to type object, in which the value continues to reference the same instance and simply is regarded as the less derived type object. <example>[Example: For example, given the declaration <code_example><![CDATA[
|
|
struct Point
|
|
{
|
|
public int x, y;
|
|
public Point(int x, int y) {
|
|
this.x = x;
|
|
this.y = y;
|
|
}
|
|
}
|
|
]]></code_example>the following statements <code_example><![CDATA[
|
|
Point p = new Point(10, 10);
|
|
object box = p;
|
|
p.x = 20;
|
|
Console.Write(((Point)box).x);
|
|
]]></code_example>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]</example> </paragraph>
|
|
</clause>
|