Unboxing in .NET

Drawing PDF417 in .NET Unboxing

Because a variable of type object can refer to a boxed copy of a value, it s only reasonable to allow you to get at that boxed value through the variable. You might expect to be able to access the boxed int value that a variable o refers to by using a simple assignment statement such as this:

int i = o;

However, if you try this syntax, you ll get a compile-time error. If you think about it, it s pretty sensible that you can t use the int i = o; syntax. After all, o could be referencing absolutely anything and not just an int. Consider what would happen in the following code if this statement were allowed:

Circle c = new Circle(); int i = 42; object o; o = c; i = o; // o refers to a circle // what is stored in i

To obtain the value of the boxed copy, you must use what is known as a cast, an operation that checks whether it is safe to convert one type to another and then does the conversion. You pre x the object variable with the name of the type in parentheses, as in this example:

The effect of this cast is subtle. The compiler notices that you ve speci ed the type int in the cast. Next, the compiler generates code to check what o actually refers to at run time. It could be absolutely anything. Just because your cast says o refers to an int, that doesn t mean it actually does. If o really does refer to a boxed int and everything matches, the cast succeeds and the compiler-generated code extracts the value from the boxed int. (In this example, the boxed value is then stored in i.) This is called unboxing. The following diagram shows what is happening:

However, if o does not refer to a boxed int, there is a type mismatch, causing the cast to fail. The compiler-generated code throws an InvalidCastException at run time. Here s an example of an unboxing cast that fails:

Circle c = new Circle(42); object o = c; // doesn t box because Circle is a reference variable int i = (int)o; // compiles okay but throws an exception at run time

8

You will use boxing and unboxing in later exercises. Keep in mind that boxing and unboxing are expensive operations because of the amount of checking required and the need to allocate additional heap memory. Boxing has its uses, but injudicious use can severely impair the performance of a program. You will see an alternative to boxing in 18, Introducing Generics.

By using a cast, you can specify that, in your opinion, the data referenced by an object has a speci c type and that it is safe to reference the object by using that type. The key phrase here is in your opinion. The C# compiler will trust you when it builds your application, but the runtime is more suspicious and will actually check that this is the case when your application runs. If the type of object in memory does not match the cast, the runtime will throw an InvalidCastException, as described in the preceding section. You should be prepared to catch this exception and handle it appropriately if it occurs. However, catching an exception and attempting to recover in the event that the type of an object is not what you expected it to be is a rather cumbersome approach. C# provides two more very useful operators that can help you perform casting in a much more elegant manner, the is and as operators.