Performance implications of boxing in C Sharp (C#) - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of boxing with value types

What is the output of this C# code snippet involving boxing and unboxing?

C Sharp (C#)

int x = 10;
object o = x; // boxing
int y = (int)o; // unboxing
Console.WriteLine(y + 5);

A 10

B 15

C Runtime error

D Compilation error

💡 Hint

Remember that boxing copies the value type into an object and unboxing extracts it back.

Boxing copies the integer value 10 into an object. Unboxing extracts the integer back. Adding 5 results in 15.

❓ Predict Output

intermediate

Effect of boxing on performance counters

What will be printed by this code that counts boxing operations?

C Sharp (C#)

int count = 0;
object Box(int x) { count++; return x; }

int a = 5;
object o1 = Box(a);
object o2 = Box(a + 1);
Console.WriteLine(count);

A 2

B 1

C 0

D Compilation error

💡 Hint

Each time an int is assigned to object, boxing occurs.

Both calls to Box receive an int and return an object, so boxing happens twice, incrementing count twice.

🔧 Debug

advanced

Identify the performance issue caused by boxing

Which line in this code causes boxing and may degrade performance?

C Sharp (C#)

List<int> numbers = new List<int> {1, 2, 3};
foreach (object obj in numbers) {
    Console.WriteLine(obj);
}

A List<int> numbers = new List<int> {1, 2, 3};

B Console.WriteLine(obj)

C No boxing occurs

D foreach (object obj in numbers)

💡 Hint

Check the type used in the foreach loop variable.

The foreach uses object to iterate over a List. Each int is boxed to object causing performance overhead.

❓ Predict Output

advanced

Output when boxing affects method overload resolution

What is the output of this code involving method overloads and boxing?

C Sharp (C#)

void Print(int x) { Console.WriteLine("Int: " + x); }
void Print(object o) { Console.WriteLine("Object: " + o); }

int val = 7;
Print(val);

A Object: 7

B Runtime error

C Int: 7

D Compilation error

💡 Hint

Method overload resolution prefers exact type matches over boxing.

The Print(int) method is chosen because it matches the argument type exactly, avoiding boxing.

🧠 Conceptual

expert

Why does boxing impact performance negatively?

Which of the following best explains why boxing can degrade performance in C#?

A Boxing creates a new object on the heap and copies the value, causing extra memory and CPU overhead.

B Boxing allows direct modification of the original value type, improving speed.

C Boxing converts a value type to a reference type without copying, so it uses less memory.

D Boxing compiles the code to machine language, which slows down execution.

💡 Hint

Think about what happens when a value type is boxed.

Boxing copies the value type into a new object on the heap, which uses more memory and CPU time, slowing performance.

Practice

1. What is boxing in C#?

easy

A. Converting a value type to an object type

B. Converting an object type to a value type

C. Copying a reference type to another reference

D. Converting a string to a number

Solution

1. Step 1: Understand value and object types

   Value types hold data directly, object types hold references to data.

2. Step 2: Define boxing

   Boxing wraps a value type inside an object so it can be treated as an object.

3. Final Answer:

   Converting a value type to an object type -> Option A

4. Quick Check:

   Boxing = value type to object [OK]

Hint: Boxing wraps value types as objects to use object features [OK]

Common Mistakes:

• Confusing boxing with unboxing
• Thinking boxing converts reference types
• Assuming boxing changes the value itself

2. Which of the following code snippets causes boxing in C#?

easy

A. int x = 5; object o = x;

B. int x = 5; int y = x + 2;

C. string s = "hello"; object o = s;

D. int[] arr = new int[3];

Solution

1. Step 1: Identify boxing operation

   Boxing happens when a value type is assigned to an object type.

2. Step 2: Analyze each option

   int x = 5; object o = x; assigns int (value type) to object, causing boxing. Others do not.

3. Final Answer:

   int x = 5; object o = x; -> Option A

4. Quick Check:

   Value type to object assignment = boxing [OK]

Hint: Assigning value type to object causes boxing [OK]

Common Mistakes:

• Thinking string to object is boxing (string is reference type)
• Confusing array creation with boxing
• Assuming arithmetic operations cause boxing

3. What is the output of this C# code?

int i = 10;
object o = i;
int j = (int)o + 5;
Console.WriteLine(j);

medium

A. 10

B. Runtime error

C. 15

D. Compilation error

Solution

1. Step 1: Understand boxing and unboxing here

   int i is boxed into object o. Then unboxed back to int j with cast.

2. Step 2: Calculate the output

   j = (int)o + 5 = 10 + 5 = 15, printed by Console.WriteLine.

3. Final Answer:

   15 -> Option C

4. Quick Check:

   Unboxing and addition = 15 [OK]

Hint: Unbox with cast, then add normally [OK]

Common Mistakes:

• Forgetting to cast during unboxing causing runtime error
• Assuming boxing changes the value
• Expecting output to be 10 or error

4. Identify the error in this code related to boxing/unboxing:

object o = 42;
int x = o;

medium

A. Cannot assign int to object

B. Missing explicit cast during unboxing

C. Boxing not allowed for int

D. No error, code is correct

Solution

1. Step 1: Check assignment from object to int

   Unboxing requires explicit cast from object to value type.

2. Step 2: Identify missing cast

   Code assigns object to int without cast, causing compile error.

3. Final Answer:

   Missing explicit cast during unboxing -> Option B

4. Quick Check:

   Unboxing needs cast [OK]

Hint: Unboxing always needs explicit cast [OK]

Common Mistakes:

• Assuming implicit cast works for unboxing
• Confusing boxing with unboxing errors
• Thinking boxing is disallowed for int

5. You want to improve performance by avoiding boxing in this code:

List<object> list = new List<object>();
for (int i = 0; i < 5; i++) {
    list.Add(i);
}
int sum = 0;
foreach (int x in list) {
    sum += x;
}
Console.WriteLine(sum);

What is the best way to avoid boxing here?

hard

A. No change needed, boxing is minimal

B. Cast each element to int before adding

C. Use object array instead of List

D. Use List<int> instead of List<object>

Solution

1. Step 1: Identify boxing cause

   Adding int to List<object> boxes each int to object.

2. Step 2: Use generic List of int

   Using List<int> stores ints directly, no boxing occurs.

3. Final Answer:

   Use List<int> instead of List<object> -> Option D

4. Quick Check:

   Generic list of value type avoids boxing [OK]

Hint: Use generic collections with value types to avoid boxing [OK]

Common Mistakes:

• Casting before adding does not avoid boxing
• Using object array still boxes ints
• Ignoring boxing impact on performance