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

Listing 1

int a = new int (5);

Or in a friendlier format:

Listing 2

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:

Listing 3

System.Int32 a = new System.Int32 (5) 
System.Int32 a = 5

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.

1.      The type should be a primitive type.

2.      The type does not need to be inherited from any other types available.

3.      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.

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.

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 application developed.

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.

Listing 4

class Test
{
  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
  }
}

Explanation

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.

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.

Figure 1

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 Unboxing time.

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 the screen.