Boxing and Unboxing in C#

What is Boxing and Unboxing?

**Boxing and unboxing** are processes in C# that convert **value types** into **reference types** and vice versa. This allows value types (like int, double) to be stored in **reference type variables** (like object).

• Boxing: Converting a **value type** to an **object type** (stored in heap memory).
• Unboxing: Extracting the **original value** from an **object type** (back to stack memory).

Boxing in C#

**Boxing** is the process of converting a **value type** (e.g., int, char) into an **object type**. When boxing occurs, the **value is wrapped inside an object**, allowing it to be treated as a reference type.

Example of Boxing:

int num = 10;
object obj = num;  // Boxing: int is converted to object
Console.WriteLine(obj);
        

In this example, the **value type** num (stored in stack memory) is **boxed into an object** obj (stored in heap memory).

Unboxing in C#

**Unboxing** is the reverse process of boxing. It **extracts** the **original value type** from an **object** and assigns it back to a value-type variable.

Example of Unboxing:

object obj = 10;  // Boxing: int to object
int num = (int)obj;  // Unboxing: object to int
Console.WriteLine(num);
        

Here, **the object obj is unboxed back into the integer num**. If unboxing is performed incorrectly (e.g., casting to an incompatible type), it results in an **InvalidCastException**.

Performance Impact of Boxing and Unboxing

Since **boxing and unboxing involve heap memory allocation**, they **affect performance**.

Performance Considerations:

• Boxing: Requires **extra memory allocation** in the **heap**, which is slower than stack memory.
• Unboxing: Requires **type checking and casting**, which can lead to performance overhead.
• Excessive Boxing/Unboxing: Can cause **unnecessary memory usage**, leading to **Garbage Collection (GC) overhead**.

Performance Comparison:

int val = 100;
object obj = val;  // Boxing

int newVal = (int)obj;  // Unboxing

Console.WriteLine(newVal);
        

Avoid **unnecessary boxing and unboxing** in performance-critical applications.

Key Differences Between Boxing and Unboxing

Best Practices to Avoid Performance Overhead

• Use Generics: Instead of **storing value types in objects**, use **generic collections** like `List<T>` to avoid boxing.
• Use Value Types When Possible: Avoid unnecessary boxing by working with **value types** directly.
• Use `var` with Caution: `var` doesn’t prevent boxing but helps with **type inference**.
• Minimize Object Storage: If storing numbers in collections, use **generic data structures** instead of non-generic ones.