// Implicitly cast myVar1 to type A. // This cast is fine because the data is of type B. in Visual C#

Maker DataMatrix in Visual C# // Implicitly cast myVar1 to type A. // This cast is fine because the data is of type B.

All C# types, including the value types, are derived from type object. Value types, however, are efficient, lightweight types that do not, by default, include their object component in the heap. When the object component is needed, however, you can use boxing, which is an implicit conversion that takes a value type value, creates from it a full reference type object in the heap, and returns a reference to the object. For example, Figure 18-22 shows three lines of code. The first two lines of code declare and initialize value type variable i and reference type variable oi. In the third line of code, you want to assign the value of variable i to oi. But oi is a reference type variable, and must be assigned a reference to an object in the heap. Variable i, however, is a value type, and does not have a reference to an object in the heap. The system therefore boxes the value of i by Creating an object of type int in the heap Copying the value of i to the int object Returning the reference of the int object to oi to store as its reference

A common misunderstanding about boxing is that it somehow acts upon the item being boxed. It doesn t. It returns a reference type copy of the value. After the boxing procedure, there are two copies of the value the value type original and the reference type copy each of which can be manipulated separately. For example, the following code shows the separate manipulation of each copy of the value. Figure 18-23 illustrates the code. The first line defines value type variable i and initializes its value to 10. The second line creates reference type variable oi and initializes it with the boxed copy of variable i. The last three lines of code show i and oi being manipulated separately. int i = 10; // Create and initialize value type Box i and assign its reference to oi. object oi = i; // Create and initialize reference type Console.WriteLine("i: {0}, io: {1}", i, oi); i = 12; oi = 15; Console.WriteLine("i: {0}, io: {1}", i, oi); This code produces the following output: i: 10, io: 10 i: 12, io: 15

Figure 18-24 shows the boxing conversions. Any value type ValueTypeS can be implicitly converted to any of types object, System.ValueType, or InterfaceT, if ValueTypeS implements InterfaceT.

Unboxing is the process of converting a boxed object back to its value type. Unboxing is an explicit conversion. The system performs the following steps when unboxing a value to ValueTypeT: It checks that the object being unboxed is actually a boxed value of type ValueTypeT. It copies the value of the object to the variable. For example, the following code shows an example of unboxing a value. Value type variable i is boxed and assigned to reference type variable oi. Variable oi is then unboxed, and its value assigned to value type variable j. static void Main() { int i = 10; Box i and assign its reference to oi. object oi = i; Unbox oi and assign its value to j. int j = (int) oi; Console.WriteLine("i: {0}, }

oi: {1},

j: {2}", i,

oi, j);

This code produces the following output:

i: 10,

oi: 10,

j: 10

Attempting to unbox a value to a type other than the original type raises an InvalidCastException exception.

Besides the standard conversions, you can also define both implicit and explicit conversions for your own classes and structs. The syntax for user-defined conversions is shown following. The syntax is the same for both implicit and explicit conversion declarations, except for the keywords implicit or explicit. The modifiers public and static are required. Required Operator Target Source public static implicit operator TargetType ( SourceType Identifier ) { Implicit or explicit ... return ObjectOfTargetType; } For example, the following shows an example of the syntax of a conversion method that converts an object of type Person to an int. public static implicit operator int(Person p) { return p.Age; }