This chapter is from the book
This chapter is from the book
This chapter is from the book
Casting and Conversion
Put simply, a conversion allows an expression to be treated as being a specific type and is typically used to treat an expression of one type as being of a different type. Conversion can be either implicit or explicit, which determines if an explicit cast is required.
All of the predefined types support implicit conversions, shown in Table 3.13, that always succeed. These implicit conversions are allowed because when converting from the original numeric type to the new numeric type, no magnitude can be lost. An explicit conversion is required when there is the possibility of precision being lost as the result of the conversion operation and it requires you to specify the type to which you are converting the original value.
Table 3.13. Implicit Conversions on the Predefined Types
From |
To |
||||||||
short |
ushort |
int |
uint |
long |
ulong |
float |
double |
decimal |
|
sbyte |
|
|
|
|
|
|
|||
byte |
|
|
|
|
|
|
|
|
|
short |
|
|
|
|
|
||||
ushort |
|
|
|
|
|
|
|
||
int |
|
|
|
|
|||||
uint |
|
|
|
|
|
||||
long |
|
|
|
||||||
ulong |
|
|
|
||||||
char |
|
|
|
|
|
|
|
|
|
float |
|
For example, an int value can be implicitly converted to a long while the opposite, converting a long to an int, is explicit and requires an explicit cast. The form of an explicit cast is (T)e, where T is the destination (or result) type and e is the expression or variable being cast.
int i = 36; long j = i; // Implicit conversion from int to long. int j = (int)j; // Explicit conversion from long to int.
Boxing and Unboxing Conversions
What happens when you need a value type to act like a reference type? Earlier you learned that, as part of the unified type system, all value types are convertible to object. When a value type variable needs to be used as a reference type, an object “box” is automatically created and the value is copied into the box. When an object box is changed back to its original value type, the value is copied out of the box and into the variable. Once boxed, operations on the boxed variable do not affect the unboxed (original) variable and vice versa.
The following code shows an example of an implicit conversion where the integer variable i is implicitly boxed to an object variable named boxed. That object variable is then explicitly converted back into an integer variable named j.
int i = 36; object boxed = i; // Implicit boxing conversion from int to object. int j = (int)boxed; // Explicit unboxing conversion from object to int.
One of the problems with explicit conversion is that, if you are not careful, you can end up with code that compiles but fails at runtime. An explicit conversion effectively tells the compiler that you are certain the conversion will succeed, and if it doesn’t, a runtime error is acceptable.
To reduce the possibilities of an explicit conversion failing at runtime, C# provides the as operator, which looks like e as T, where e is an expression and T must be either a reference or nullable type. The as operator tells the compiler that there is sufficient reason to believe the conversion will succeed and attempt to convert the value to the specified type. If the conversion was successful, the converted value as T is returned; otherwise a null is returned.
To take advantage of the as operator, the previous code can be rewritten like this:
int? i = 36; object boxed = i; int? j = boxed as int?;
Try It Yourself: Conversions
By following these steps, you explore how to use conversions by converting a value type to a reference type. The application demonstrates how operations on value types, reference types, and boxed value types affect each other:
- Create a new console application.
- In the Main method, declare an integer variable named i and initialize it to 36. Then declare an object named boxed and initialize it to i.
- Enter two Console.WriteLine statements to display the value of i and the value of boxed.
- Increment the value of boxed by 2, making use of an explicit cast.
- Duplicate the two Console.WriteLine statements entered from step 3 to verify that the value of i has not changed while the value of boxed has.
- Now, increment the value of i by 1 and duplicate the two Console.WriteLine statements from step 3 to verify that the value of i has changed while the value of boxed has not.
- Set the value of i to the new value of boxed, again using an explicit cast.
- Finally, declare two nullable integers named h and j, initializing h to null and j to i and an object named jboxed initialized to j.
Enter the following code:
Console.WriteLine("h has a value? {0}", h.HasValue); h = jboxed as int?; Console.WriteLine("h now has the value {0}", h.Value);Run the application using Ctrl+F5 and observe that the output matches what is shown in Figure 3.5.
Figure 3.5. Output of boxing, unboxing, and casts.
- Press any key to close the console and return to Visual Studio.
)