# Boxing and Unboxing in C#

In .NET, as with many other languages, we use Value types and Reference types. Value types are stored on the stack (if they are not contained inside a reference type), and Reference types are stored on the heap.

**Boxing** is taking a Value type and storing it in an Object (which is a reference type).

Here is an example:

```csharp
short age = 25;
Object ageRef = age;
```
As can be seen, we have saved age into a reference type and now it resides on the heap.

Boxing can occur when we call an Object method on a Value type too, such as:

```csharp
25.ToString();
```
In this case, the compiler creates an Object reference for us automatically.

In short, *Boxing occurs any time you assign a Value type to an Object*, and this includes passing Value types to a method that takes in an Object as the parameter type. For example:

```csharp
void BoxIt(Object o) {
  // do something
}

BoxIt(5); // Boxing the value type
```
Because boxing creates a new Object reference, you cannot compare references of the same Value type values. For example:

```csharp
Object.ReferenceEquals(5,5); // This will return false
```
We get false because 5 is a Value type and boxing causes the two parameters to have different references.

**Unboxing** is the opposite - think of it as opening up the Object and releasing the value out of it and storing it back to a Value type. This operation requires a cast.

 ```csharp
short age = 25;
Object ageRef = age;
short oldAge = (short) ageRef;  // casting to a short
```
We know that the int value type is larger than the short type. **Can we do the following**?

```csharp
short age = 25;
Object ageRef = age;
int bigAge = (int) ageRef;  // allowed?
```
The code above will throw a *System.InvalidCastException* exception. You **cannot** unbox and expect the casting rules to work.