Boxing and Unboxing

Value type

Value types are primitive types that are mapped directly to the FCL. Like Int32 maps to System.Int32, double maps to System.double. All value typesare stored on stack . All the value types are derived from System.ValueType. All structures and enumerated types that are derived from System.ValueType are created on stack, hence known as ValueType.

An object of a value type stores its associated data directly within itself. Any changes to that data do not affect any other object. For example, the predefined arithmetic types, such as int and double, are value types.

When we write:

  1. double pi = 3.14159;  
the value 3.14159 is directly stored within pi.

When we initialize or assign one value type with another, the data contained in the one is copied to the second. The two objects remain independent.

For example, when we write

  1. double shortPi = pi;  
although both pi and shortPi now hold the same value, the values are distinct instances contained in independent objects. We call this a deep copy. If we change the value stored by shortPi, shortPi = 3.14; the value of pi remains unchanged.

Simple Types: Integral Types (sbyte, byte, short, ushort, int, uint, long, ulong), bool type, char type, Floating point types(float,double) and the decimal types. They are all aliases of the .NET System Types.

  1. System.Int32 a = 10; //It is a value type  
Struct Types, Enumeration Types.

it is not possible to create a reference to a value type. Unlike reference types, the value of a value type cannot be a null reference.

Reference type

Reference Types are different from value types in such a way that memory is allocated to them from the heap. All the classes are of reference type.C#  new operator returns the memory address of the object. Reference types are stored on the run-time heap; they may only be accessed through a reference to that storage. This allows the garbage collector to track outstanding references to a particular instance and free the instance when no references remain. A variable of reference type always contains a reference to a value of that type or a null reference. A null reference refers to nothing; it is invalid to do anything with a null reference except assign it. Assignment to a variable of a reference type creates a copy of the reference, not a copy of the value being referenced.
  1. The Object Type
  2. The class Type
  3. Interfaces
  4. Delegates
  5. The string type
  6. Arrays

  1. Myobj obj1; // obj1 is ia reference type assuming Myobj is of class type.  
  2. obj1 = new myobj();  
obj1 is reference type variable (assuming Myobj is a class type variable).compiler allocates memory for this object on the heap and its address is stored in obj1.


Boxing and Unboxing in C# .Net

C# provides us with Value types and Reference Types. Value Types are stored on the stack and Reference types are stored on the heap. The conversion of value type to reference type is known as boxing and converting reference type back to the value type is known as unboxing.


convert ValueTypes to Reference Types also known as boxing.

  1. Int32 x = 10;  
  2. object o = x;  // Implicit boxing  
  3. Console.WriteLine("The Object o = {0}", o); // prints out 10      
  5. Int32 x = 10;  
  6. object o = (object)x; // Explicit Boxing  
  7. Console.WriteLine("The object o = {0}", o); // prints out 10  

UnBoxing an object type back to value type. 

  1. Int32 x = 5;
  2. object o = x; // Implicit Boxing
  3. x = o; // Implicit UnBoxing
  5. Int32 x = 5;
  6. object o = x; // Implicit Boxing
  7. x = (Int32)o; // Explicit UnBoxing