C# tutorials > Core C# Fundamentals > Basics and Syntax > What is boxing and unboxing?

What is boxing and unboxing?

Boxing and unboxing are fundamental concepts in C# related to the interaction between value types (like int, bool, struct) and reference types (like object). They enable value types to be treated as objects and vice versa, which is crucial for the C# type system and certain operations, especially when dealing with collections or methods expecting objects.

Boxing: Converting Value Types to Object Types

Boxing is the process of converting a value type instance into an object reference. In essence, it involves allocating memory on the heap for a new object and copying the value type's data into that object. The object variable then holds a reference to this newly created boxed value. In the example, the integer variable i, which is a value type, is boxed into an object referred to by obj. The original value type remains unchanged.

int i = 123;
object obj = i; // Boxing

Console.WriteLine(obj); // Output: 123

Unboxing: Converting Object Types to Value Types

Unboxing is the reverse process of boxing. It involves extracting the value type from a previously boxed object. It requires an explicit type cast to the target value type. In the example, the object obj, which contains a boxed integer, is unboxed back into an integer variable i. An InvalidCastException will be thrown if the object does not contain a value type that can be converted to the specified type.

object obj = 123; // Boxing
int i = (int)obj; // Unboxing

Console.WriteLine(i); // Output: 123

Concepts Behind the Snippet

Boxing and unboxing are essential to C#'s support for treating value types as objects. Value types reside on the stack for performance reasons (faster allocation and deallocation), while objects reside on the heap. When a value type needs to be used where an object is expected (e.g., in a collection of objects), boxing allows it to be treated as an object. Unboxing retrieves the original value from the boxed object when needed.

Real-Life Use Case Section

A common use case is with non-generic collections like ArrayList. ArrayList stores elements as objects. Therefore, when adding value types (like int, bool) to an ArrayList, they are implicitly boxed. When retrieving them, they need to be explicitly unboxed. However, the use of non-generic collections is generally discouraged in modern C# due to type safety issues and performance overhead associated with boxing and unboxing. Generic collections (e.g., List) provide better type safety and avoid boxing/unboxing when dealing with value types.

using System.Collections;

ArrayList list = new ArrayList();
list.Add(10);
list.Add("Hello");
list.Add(true);

int number = (int)list[0]; // Unboxing
string message = (string)list[1]; //Unboxing
bool flag = (bool)list[2]; //Unboxing

Console.WriteLine($"Number: {number}, Message: {message}, Flag: {flag}");

Best Practices

  • Avoid Boxing/Unboxing When Possible: Boxing and unboxing operations incur a performance penalty due to memory allocation and type checking. Use generic collections (e.g., List instead of ArrayList) to avoid boxing when working with value types.
  • Use Type Safety: Always ensure that the type you are unboxing to is the actual type of the boxed object. Use is or as operators to perform type checking before unboxing.
  • Consider Alternatives: If boxing/unboxing is unavoidable, explore alternatives like interfaces or abstract classes that can handle value types without boxing.

Interview Tip

Be prepared to explain the differences between value types and reference types. Clearly articulate the process of boxing and unboxing, including the memory allocation involved. Also, be ready to discuss the performance implications of boxing and unboxing and how to avoid them using generics. Give examples of scenarios where boxing and unboxing might be encountered.

When to Use Them

While generally discouraged due to performance, boxing/unboxing is sometimes unavoidable:
  • Interacting with older APIs: Legacy code or libraries might rely on non-generic collections or methods that accept object parameters.
  • Reflection: When using reflection, you might need to box value types to pass them as arguments to methods.
  • Dynamic Type Scenarios: In dynamic programming scenarios, you might encounter situations where boxing and unboxing are necessary.
In modern C#, however, prefer generics to avoid boxing and unboxing wherever possible.

Memory Footprint

Boxing increases memory consumption. When a value type is boxed, a new object is created on the heap to hold the value. This object has additional overhead beyond the value type's data itself (e.g., type information, synchronization block index). Frequent boxing and unboxing can lead to increased memory pressure and garbage collection activity.

Alternatives

The primary alternative to boxing and unboxing is using Generics. Generics allow you to create type-safe collections and methods that operate on specific value types without requiring boxing. For example, use List instead of ArrayList for a list of integers.

Pros

  • Type Compatibility: Allows value types to be treated as objects, enabling them to be used in situations where objects are expected.
  • Flexibility: Facilitates the use of value types in non-generic collections and methods designed for objects.

Cons

  • Performance Overhead: Boxing and unboxing involve memory allocation and type checking, leading to performance degradation.
  • Type Safety Issues: Unboxing requires explicit type casting, which can result in InvalidCastException if the types are incompatible.
  • Increased Memory Consumption: Boxing creates new objects on the heap, increasing memory usage and garbage collection pressure.

← What is an exception in C#? What is encapsulation, and why is it important in C#? →

FAQ

  • What happens if I try to unbox an object to the wrong type?

    If you attempt to unbox an object to a type that it doesn't actually contain, a System.InvalidCastException will be thrown at runtime. For example, if you try to unbox an object containing a boxed int to a string, an exception will occur.
  • Does boxing modify the original value type variable?

    No, boxing creates a new object on the heap. The original value type variable remains unchanged. Boxing copies the value of the value type into the new object.
  • Why are generics preferred over boxing/unboxing in modern C#?

    Generics provide type safety at compile time, avoiding the runtime exceptions that can occur with unboxing. They also eliminate the performance overhead associated with boxing and unboxing because they operate directly on the specific value type without requiring conversion to and from objects.