Difference between Boxing and Unboxing in C#

Last updated on July 13th, 2023 at 06:22 pm

Boxing is the process of converting a value type into a reference type, and unboxing is the process of converting a reference type back into a value type.

What is Boxing in C#?

Boxing in C# involves converting a value type, such as an integer or Boolean, into a reference type, like an object. When you perform boxing, you place the value inside a unique container known as an object. It allows you to treat the value type as an object.

Example of Boxing:

int myNumber = 42; // Declaring and initializing an integer value
object boxedNumber = myNumber; // Boxing the value into an object

// Print the boxed value
Console.WriteLine("Boxed Number: " + boxedNumber); // Output: 42

Code Explanation: 

In the code snippet above, we first declare and initialize an integer variable myNumber, with the value 42. 

Next, we box this value by assigning it to an object variable boxedNumber. This causes the value of myNumber to be wrapped in an object on the heap memory.

What is UnBoxing in C#?

Unboxing in C# is the process of converting a reference type (like an object) back to its original value type (such as an integer or boolean). 

When you unbox, you extract the value from the reference type and assign it to a value type variable. 

It’s like taking the value out of a special container and using it as its original type again.

Code Example of Unboxing:

object boxedNumber = 42; // Boxing an integer value
int unboxedNumber = (int)boxedNumber; // Unboxing the value

// Outputting the unboxed value
Console.WriteLine("Unboxed Number: " + unboxedNumber);

Understanding boxing and unboxing in C#

Let’s learn more about boxing and unboxing in C# programming with some sample code examples.

The concept of boxing and unboxing is the core of the type system in C# programming. It creates a bridge between value types and reference types by allowing any value of a value type to be converted to and from an object type.

The following figure demonstrates the boxing & Unboxing:

Example 2: Boxing in C#

A boxing conversion creates a copy of a value. Therefore, changing the value of one variable does not affect the other variables.

A C# program to demonstrate boxing is as follows:

using System;
public class BoxingExample
{
    public static void Main(string[] args)
    {
        int num = 100;  
        object obj = num;  // Boxing

        Console.WriteLine($"obj = {obj}"); // Output: obj = 100

        // Change the value of obj
        obj = 101;

        Console.WriteLine($"num ={num}, obj= {obj}");//Output: num =100, obj= 101
        Console.ReadLine();
    }
}

Example: UnBoxing

A C# program to demonstrate Unboxing is as follows:

using System;
public class UnBoxingExample
{
    public static void Main(string[] args)
    {
        int num = 100;  
        object obj = num;  // Boxing
       
        int x = (int)obj;  // Unboxing
        Console.WriteLine($"obj = {obj} , x = {x}"); //Output: obj = 100 , x = 100
        Console.ReadLine();
    }
}

Code Explanation:

In the above code snippet, we start by declaring a variable called “num” of type integer (which is a value type).

We assign the value 100 to this variable. In the next step, we box the “num” variable by assigning it to a variable named “obj” of type object (which is a reference type). This process converts the value type into a reference type.

Later on, the value stored in “obj” is unboxed and assigned to a new integer variable named “x”.
Unboxing retrieves the original value from the boxed object and assigns it to a variable of the corresponding value type.

Note: An InvaidCastException will be thrown if the value type does not match the boxed object, as shown in the following example.

In the above example, the obj points to a boxed object of type int, but we are trying to unbox it to type double rather than int. That’s why the compiler throws   InvalidCastException .

FAQs:

Conclusion:

This article has covered the “boxing and unboxing” of variables. We discussed examples of each and examined the results of each process.
It`s also important to note that boxing and unboxing variables require a lot of memory space. When a variable is boxed, a new memory block and object are created. It is advised against using these techniques frequently because continuously boxing and unboxing variables can significantly degrade performance.

References: MSDN-Boxing and Unboxing, “The C# Programming Language” by Anders Hejlsberg

I sincerely hope you enjoyed reading “Boxing and Unboxing“. If you would like to provide more details on the topic covered here. Please leave a comment below.

Articles to Check Out:

• C# Abstract class Vs Interface
• C# Array vs List: When should you use an array or a List?
• C# List Class With Examples
• SOLID Design Principles in C#: A Complete Example
• Understanding Class vs Struct vs Record in C# with examples
• Singleton Design Pattern in C#: A Beginner’s Guide with Examples
• C# Monitor class in multithreading
• C# Struct vs Class
• C# Dictionary with Examples
• Stream in C#: StreamReader and StreamWriter in C# with examples
• C# Hashtable vs Dictionary

• Author
• Recent Posts

Shekh Ali

Meet Sheikh Ali, a skilled Software engineer and passionate a blogger. He enjoys sharing his expertise in C#, Java, SQL, Design Patterns, and other related topics through his writing. When he's not coding, Sheikh Ali can often indulge in his passions for reading books and fitness training.

Latest posts by Shekh Ali (see all)

• Difference Between Array And ArrayList In C#: Choosing the Right Collection - May 28, 2024
• C# Program to Capitalize the First Character of Each Word in a String - February 21, 2024
• C# Program to Find the Longest Word in a String - February 19, 2024