Boxing/Unboxing

The purpose of boxing is to have a unified type system where both reference types and value types ultimately inherit from System.Object.

This enables you to write generic code that can apply to any type or any type which implements a particular interface.

As System.Object and all interface types are references types, variables of those types always contain an address of an object on the heap.

This means that in order to assign a value type instance to an Object or interface variable, a wrapper needs to be created on the heap and the value type copied into it.The address of this wrapper can then be assigned to the variable.

The process of creating such a wrapper is known as 'boxing'.

When you retrieve the value type and use it as such, it then needs to be copied back to the variable you're using. This process is known as 'unboxing' and is achieved in C# by casting to the value type concerned.

Here's a simple example of all this:

using System;

class Test

{

static void Main()

{

int i = 21;

object obj = i; // i is boxed on the heap

Print(obj);

string s = "Hello"; // string is a reference type

Print(s);

int j = (int)obj; // obj is unboxed to j by casting to int

Compare(i, j); // i and j are boxed when passed as IComparable parameters

string t = "Goodbye";

Compare(s, t); // now passing reference types so no need for boxing

Console.ReadKey();

}

static void Print(object obj)

{

Console.WriteLine(obj.ToString() + " has been passed to the Print method");

}

static void Compare(IComparable obj1, IComparable obj2)

{

if(obj1.CompareTo(obj2) == 0)

{

Console.WriteLine("{0} and {1} are equal", obj1, obj2);

}

else

{

Console.WriteLine("{0} and {1} are not equal", obj1, obj2);

}

1 Reply

Know the answer? Post it — somebody with the same question will find it here.

Vulpes14y ago
The purpose of boxing is to have a unified type system where both reference types and value types ultimately inherit from System.Object.

This enables you to write generic code that can apply to any type or any type which implements a particular interface.

As System.Object and all interface types are references types, variables of those types always contain an address of an object on the heap.

This means that in order to assign a value type instance to an Object or interface variable, a wrapper needs to be created on the heap and the value type copied into it.The address of this wrapper can then be assigned to the variable.

The process of creating such a wrapper is known as 'boxing'.

When you retrieve the value type and use it as such, it then needs to be copied back to the variable you're using. This process is known as 'unboxing' and is achieved in C# by casting to the value type concerned.

Here's a simple example of all this:

using System;

class Test
{
static void Main()
{
int i = 21;
object obj = i; // i is boxed on the heap
Print(obj);
string s = "Hello"; // string is a reference type
Print(s);
int j = (int)obj; // obj is unboxed to j by casting to int
Compare(i, j); // i and j are boxed when passed as IComparable parameters
string t = "Goodbye";
Compare(s, t); // now passing reference types so no need for boxing
Console.ReadKey();
}

static void Print(object obj)
{
Console.WriteLine(obj.ToString() + " has been passed to the Print method");
}

static void Compare(IComparable obj1, IComparable obj2)
{
if(obj1.CompareTo(obj2) == 0)
{
Console.WriteLine("{0} and {1} are equal", obj1, obj2);
}
else
{
Console.WriteLine("{0} and {1} are not equal", obj1, obj2);
}
}
}