Boxing and Unboxing in .NET
Views (Total / Last 10 Days):
This article deals with the boxing and unboxing in Microsoft
.NET. It is a fact that in our daily coding standards we usually forget to
keep track of these things, but each developer should know what it means and that
the proper use of this will definitely lead to a powerful application.
Before going into Boxing and Unboxing, it is really very important
to understand what a primitive data type is. All the supported datatypes by
the compiler of a language are known as primitive data types. These data types
map directly to the library of the corresponding language. For example, in C#
we are declaring an integer variable as
Or in a friendlier format:
int a = 5
Both listing 1 and 2 are same.
The int data type is a primitive data type of C# and for
that reason it maps directly to System.Int32 type. So the above two lines can
be re-written as:
System.Int32 a = new System.Int32 (5)
System.Int32 a = 5
|Reference and Value types|
Now let us get an idea regarding reference type and value
type objects. We all know that a new operator returns the memory address of an
object that is allocated from the managed memory (a pool of memory). We
usually store this address in a variable for our convenience. These types of
variables are known as reference variables. However, the value type variables
are not supposed to have the references; they always used to have the object itself
and not the reference to it.
Now if we consider the statement written above in Listing 3,
the C# compiler will detect System.Int32 as a value type and the object is not
allocated from the memory heap, assuming this as an unmanaged one.
In a general way we should declare a type as a value type if
the following are true.
The type should be a primitive type.
The type does not need to be inherited from any other types available.
No other types should also be derived from it.
A few other criteria are also there for this, but are beyond
the scope of this article.
|Few differences between value and reference|
Value type objects have two representations: an unboxed form
and a boxed form. Reference types are always in a boxed form.
Value types are implicitly derived from System.ValueType. This
type offers the same methods as defined by System.Object.
Reference type variables contain the memory address of
objects in the memory heap. By default, when a reference type variable is
created it is initialized to null, indicating that the reference type variable
does not currently point anywhere. So whenever we try to access a null
referenced variable, we get NullReferenceException exception. Whereas a value
type variable always has a value. By default, all members of the value type
are initialized to zero. It is not possible to generate a
NullReferenceException exception when accessing a value type.
While copying a value type to another value type, the value
only gets copied. However, assigning a reference type variable to another
reference type variable causes only the copy of the memory address.
Because of the previous point, it may be possible that two
or more reference type variables can refer to the same object in the managed
heap (pool of memory). This means an operation on one variable may hamper the
object referenced by another variable. On the other hand, value type variables
each have their own copy of the object's data and it is not possible for
operations on one value type variable to affect another.
|What is Boxing and UnBoxing?|
Boxing and Unboxing are two important portions of .NET
technology. Many of the developers are not really aware of it, but it is
really needed if somebody is interested in enhancing the performance of the
In a very brief way, one can say that Boxing is nothing but
converting a value type object to a reference type object. Unboxing is
completely explicit. The idea will be clearer after discussing the example
given below. This example shows how an integer type is converted to a reference
type using the boxing and then unboxed from the object type to the integer type.
static void Main()
int i = 1; // i is an integer. It is a value type variable.
object o = i;
// boxing is happening. The integer type is parsed to //object type
int j = (int)o;
// unboxing is happening. The object type is unboxed to //the value type
In the above example, it is shown how an int value can be
converted to an object and back again to an int. This example shows both
boxing and unboxing. When a variable of a value type needs to be converted to
a reference type, an object box is allocated to hold the value and the value is
copied into the box.
Unboxing is just the opposite. When an object box is cast
back to its original value type, the value is copied out of the box and into
the appropriate storage location.
|Make it inside out|
As we already discussed, the converting of a value type to a
reference type is known as Boxing. Now let us see what actually happens behind
the screen during Boxing.
The memory is allocated from the managed memory (can be
termed as heap also). The amount of memory allocated = the size of Value type
+ some overhead memory. This overhead memory is required as it includes
pointer to virtual method table and pointer to sync table.
Now once the memory is allocated, the inside value of the
value type variable gets copied to the newly allotted location.
Then the reference to the memory block is returned.
Type Info Block (TIB)
This block is typically an array of pointers to all the
objects of a class. It also holds much of the other information for a class.
Virtual method table (VMT)
This table holds the address of instruction that had asked
for the value. Now let us have a look at what actually happens during the
Here, the .NET CLR first ensures that the reference type
variable is not Null and is in a valid boxed format.
If the types do match, then a pointer to the value type
contained inside the object is returned. The value type that this pointer
refers to does not include the usual overhead associated with a true object
(i.e. a pointer to a virtual method table and a sync block).
In a nutshell we can say that Boxing always creates the new
object and copies the unboxed value to it while unboxing gives a pointer. This
pointer is nothing but points to the data in the boxed object.
Both boxing and unboxing are wanted devils. While the boxing
process occurs, there is an additional memory loss occurrence. This memory is actually
needed for pointer to virtual method and pointer to sync table which is not
there in the case of value type objects.
During the unboxing process, however, memory relaxation
occurs, but at the same time some unwanted checking (like whether the reference
type variable is not Null or it is a valid boxed value or not) takes place.
If we compare Reference type and Value type Objects, then we
certainly prefer Value Type objects. This is because as Reference types are
coming from the managed heap/memory, they used to affect the Garbage Collection
and memory management. On other hand, since Value types run on thread’s stack
there is no need to be worried for a garbage collection to occur for them.
So, for these reasons we should avoid unnecessary
boxing/unboxing processes and only add them when the application demands it.
However, the fact remains that most of the developers are not aware of the
underlying complications and they repeat these unnecessary processes
unknowingly, which can lead to the degradation of the performance.
The above topic is an important issue that should be known
to each .NET developer. One must understand what a reference type and value
type variable are and what impact they have on the application developed. The
C# and Visual Basic compiler automatically generate boxing and unboxing code. This
makes programming easier and at the same time leaves the user free from the
performance issue. But unlike these languages, there are few other languages
that force explicit Boxing/Unboxing. So, it is a good practice to go behind