Boxing and Unboxing in .NET framework

Paint QR in .NET framework Boxing and Unboxing

Even if performance is your primary concern, you shouldn t always opt for value types. Sometimes reference types are faster. For example, an assignment between value types involves the copy of every field in the object, whereas assigning a reference value to a variable requires only the copy of the object s address (4 bytes in 32-bit versions of Windows). When you pass a value type to a method that expects an Object argument, a different kind of performance hit occurs because the value must be boxed in this case. Boxing a value means that the compiler creates a copy of it in the managed heap and assigns the address of this copy to an Object variable or argument so that the type can then be used as a reference type. (See the section Value Types and Reference Types in 2.) A boxed value doesn t maintain a link to the original value, which means you can modify either one without affecting the other. If this boxed value is later assigned to a variable of the original (value) type, the object is said to be unboxed and data is copied from the managed heap into the memory allo cated to the variable (for example, on the stack if it s a local variable). Not surprisingly, boxing and unboxing takes CPU time and eventually requires some memory to be reclaimed during a garbage collection. The bottom line: if you carry out many assign ments or frequently perform operations that result in a boxing and unboxing sequence, implementing a reference type might be a wiser choice. Boxing occurs transparently in most cases, whereas you require an explicit CType or DirectCast operator to convert back from an Object to a value type if Option Strict is On. You can determine whether a call causes a boxing operation by looking at the method declaration in the object browser or in the class documentation. If the method

7:

takes an argument of the type you re passing, no boxing occurs; if it takes a generic Object argument, your argument will be boxed. When creating your own methods, you might consider including overloaded variations that take arguments of different types as well as a catchall procedure that takes an Object argument. In general, it doesn t make sense to compare the performance of a method that uses boxing with a similar method that doesn t. However, the companion code includes a simple benchmark named TestBoxing that gives you a broad idea of what kind of overhead boxing and unboxing is going to add to your applications. It shows that a tight loop that calls a function that requires boxing can be up to 30 times slower than a loop that doesn t use boxing. However, you must repeat the loop 10 million times to see a significative difference in absolute terms, so in practice you should worry about boxing only in time-critical code sections. You might be using boxing sometimes without knowing it. First, you implicitly box a Structure if you call one of the virtual methods that the Structure inherits from Sys tem.Object for example, ToString. Second, you implicitly box a Structure if you call a method of an interface the structure exposes. As I mentioned, boxing typically occurs transparently. In rare cases, however, you must explicitly tell Visual Basic that you want to box a value, by using the CObj function. This is necessary, for example, when you want to invoke the ToString method (or another method inherited from System.Object) on an interface variable, as in

Sub DisposeIt(ByVal idisp As IDisposable) Dispose the object and display a diagnostic message. idisp.Dispose() Explicitly box the reference to call ToString. Console.WriteLine( Disposing & CObj(idisp).ToString()) End Sub