Boxing and Unboxing

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 the value type to the reference type is known as boxing, and converting the reference type back to the value type is known as unboxing.

Value type in C#

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 types are stored on the stack. All the value types are derived from System.ValueType. All structures and enumerated types are derived from System.ValueType is created on the 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.

Example

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.

Example

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 in C#

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.

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

Myobj obj1; // obj1 is ia reference type assuming Myobj is of class type.
obj1 = new myobj();

obj1 is a 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 in C#

convert ValueTypes to Reference Types, also known as boxing.

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

Unboxing in C#

UnBoxing an object type back to the value type.

Int32 x = 5;
object o = x; // Implicit Boxing
x = o; // Implicit UnBoxing
Int32 x = 5;
object o = x; // Implicit Boxing
x = (Int32)o; // Explicit UnBoxing