Explain the concepts of boxing and unboxing with performance implications.

Boxing:

• Converting a value type to a reference type (object)
• The value is wrapped in an object and stored on the heap
• Implicit operation

Unboxing:

• Converting a reference type back to a value type
• Explicit operation (requires casting)
• Can throw InvalidCastException if types don't match

Example:

// BOXING - value type to reference type
int num = 123;
object obj = num;  // Boxing occurs - int copied to heap

// UNBOXING - reference type to value type
int num2 = (int)obj;  // Unboxing occurs - must cast explicitly

Performance Implications:

1. Memory Allocation: Boxing allocates memory on the heap (slower than stack)
2. Garbage Collection: Boxed objects need to be garbage collected
3. Type Safety: Unboxing requires explicit casting and runtime type checking
4. CPU Overhead: Both operations require CPU cycles

Common scenarios where boxing occurs:

// Adding value type to non-generic collection
ArrayList list = new ArrayList();
list.Add(1);  // Boxing occurs!

// String formatting
int age = 30;
string message = string.Format("Age: {0}", age);  // Boxing occurs!

// Using value types as object parameters
void PrintObject(object obj) { }
PrintObject(42);  // Boxing occurs!

How to avoid boxing:

// Use generic collections
List<int> numbers = new List<int>();
numbers.Add(1);  // No boxing!

// Use string interpolation or generic methods
string message = $"Age: {age}";  // No boxing in most cases

// Use generic constraints
void Print<T>(T value) { }
Print(42);  // No boxing!

Performance Impact:

• Boxing/unboxing in tight loops can significantly degrade performance
• Can cause increased garbage collection pressure
• Benchmark shows boxing can be 10-100x slower than working with value types directly