Boxing and Unboxing

srinivas

17y4.5kVisual Basic .NET

hi what is boxing and why it is used

4 Replies

Know the answer? Post it — somebody with the same question will find it here.

Kirtan Patel17y ago
Accepted answer
Friend,

Here is Explanation.

Boxing is the process of converting a value type to the type object or to any interface type implemented by this value type. When the CLR boxes a value type, it wraps the value inside a System.Object and stores it on the managed heap. Unboxing extracts the value type from the object. In the following example, the integer variable i is boxed and assigned to object o.
int i = 123;
object o = (object)i; // boxing

o = 123;
i = (int)o; // unboxing
theLizard17y ago
Kirtan, amazing, is it possible for you to come up with your own answers? I have seen you do this to a number of people who gave the right answer to a question. What poses-es you to take some one elses answer change it and claim it to be yours?
Purushottam Rathore17y ago
Boxing: The process of converting from a value type to a reference type is called boxing. Boxing is an implicit conversion.

Boxing example:

using System;
class ConversionSamp
{
    static void Main()
    {
        int a = 5;
        Object obj = a;
        Console.WriteLine(a.ToString());
        Console.WriteLine(obj.ToString());
    }
}

Unboxing: The process of converting from a reference type to a value type is called unboxing.

Unboxing example:

using System;
class ConversionSamp
{
    static void Main()
    {
        Object obj = 5;
        int a = (int)obj;
        Console.WriteLine(a.ToString());
        Console.WriteLine(obj.ToString());
    }
}
Lalit M17y ago
Boxing is what happens when a value-type object is assigned to a reference-type variable. Unboxing is what happens when a reference-type variable is assigned to a value-type variable.
- Value-type variables include the numeric types, System.Char, System.Boolean, System.DataTime, enumerations and structures.
- Reference-type variables include all arrays and classes.
In the following C# example, the variable PI is a double and this is allocated on the stack. However, when it is passed to the function foo, it must be "boxed" which involves making a copy of it on the heap. There is overhead in this. Within foo, even though o references the value 3.14159, it must be cast back (unboxed) to a double to be used. Again, there is overhead in this.
static void foo(object o)
{
double x = (double) o; // unboxing
Console.WriteLine( x );
}
static void main()
{
double PI = 3.14159;
foo( PI ); // PI is boxed when passed to o
}

Boxing and Unboxing with examples

more example
---------------
Boxing is converting a value type to reference type

Unboxing is an explicit operation.

Eg.

In C# :

int X 1;
Object Y;
int Z;

Y X; -------------> This is BOXING
Z (int)Y; ----------------> This is UNBOXING