Search

Boxing in C#

Boxing is used to store value types in the garbage-collected heap. Boxing is an implicit conversion of a value type to the type object or to any interface type implemented by this value type. Boxing a value type allocates an object instance on the heap and copies the value into the new object.
Consider the following declaration of a value-type variable:
The following statement implicitly applies the boxing operation on the variable i: 
int i = 123;



// Boxing copies the value of i into object o. 
object o = i;

The result of this statement is creating an object reference o, on the stack, that references a value of the type int, on the heap. This value is a copy of the value-type value assigned to the variable i. The difference between the two variables, i and o, is illustrated in the following figure.
Boxing Conversion

BoxingConversion graphic
It also possible to perform the boxing explicitly as in the following example, but explicit boxing is never required: 
int i = 123;
object o = (object)i;  // explicit boxing
Example: 
class TestBoxing
{
static void Main()
{
int i = 123;

// Boxing copies the value of i into object o. 
object o = i;  

// Change the value of i.
i = 456;  

// The change in i does not effect the value stored in o.
System.Console.WriteLine("The value-type value = {0}", i);
System.Console.WriteLine("The object-type value = {0}", o);
}
}
/* Output:
The value-type value = 456
The object-type value = 123
*/
The following example demonstrates a case of invalid unboxing and the resulting InvalidCastException. Using try and catch, an error message is displayed when the error occurs. 
class TestUnboxing
{
static void Main()
{
int i = 123;
object o = i;  // implicit boxing 

try
{
int j = (short)o;  // attempt to unbox

System.Console.WriteLine("Unboxing OK.");
}
catch (System.InvalidCastException e)
{
System.Console.WriteLine("{0} Error: Incorrect unboxing.", e.Message);
}
}
}
This program outputs:
Specified cast is not valid. Error: Incorrect unboxing.
If you change the statement:
int j = (short) o;
to
int j = (int) o;
the conversion will be performed, and you will get the output:
Unboxing OK.

Boxing and Unboxing in C#

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. Boxing is implicit; unboxing is explicit. The concept of boxing and unboxing underlies the C# unified view of the type system, in which a value of any type can be treated as an object. In the following example, the integer variable i is boxed and assigned to object o. 



int i = 123;
// The following line boxes i. 
object o = i;






The object o can then be unboxed and assigned to integer variable i:


o = 123;
i = (int)o;  // unboxing






The following examples illustrate how boxing is used in C#.


// String.Concat example. 
// String.Concat has many versions. Rest the mouse pointer on  
// Concat in the following statement to verify that the version 
// that is used here takes three object arguments. Both 42 and 
// true must be boxed.
Console.WriteLine(String.Concat("Answer", 42, true));


// List example. 
// Create a list of objects to hold a heterogeneous collection  
// of elements.
List mixedList = new List();

// Add a string element to the list. 
mixedList.Add("First Group:");

// Add some integers to the list.  
for (int j = 1; j < 5; j++)
{
    // Rest the mouse pointer over j to verify that you are adding 
    // an int to a list of objects. Each element j is boxed when  
    // you add j to mixedList.
    mixedList.Add(j);
}

// Add another string and more integers.
mixedList.Add("Second Group:");
for (int j = 5; j < 10; j++)
{
    mixedList.Add(j);
}

// Display the elements in the list. Declare the loop variable by  
// using var, so that the compiler assigns its type. 
foreach (var item in mixedList)
{
    // Rest the mouse pointer over item to verify that the elements 
    // of mixedList are objects.
    Console.WriteLine(item);
}

// The following loop sums the squares of the first group of boxed 
// integers in mixedList. The list elements are objects, and cannot 
// be multiplied or added to the sum until they are unboxed. The 
// unboxing must be done explicitly. 
var sum = 0;
for (var j = 1; j < 5; j++)
{
    // The following statement causes a compiler error: Operator  
    // '*' cannot be applied to operands of type 'object' and 
    // 'object'.  
    //sum += mixedList[j] * mixedList[j]); 

    // After the list elements are unboxed, the computation does  
    // not cause a compiler error.
    sum += (int)mixedList[j] * (int)mixedList[j];
}

// The sum displayed is 30, the sum of 1 + 4 + 9 + 16.
Console.WriteLine("Sum: " + sum);






In relation to simple assignments, boxing and unboxing are computationally expensive processes. When a value type is boxed, a new object must be allocated and constructed. To a lesser degree, the cast required for unboxing is also expensive computationally.


  











































Casting in C#











Converting between data types can be done explicitly using a cast, but in some cases, implicit conversions are allowed. For example:  
static void TestCasting()
{
int i = 10;
float f = 0;
f = i;  // An implicit conversion, no data will be lost.
f = 0.5F;
i = (int)f;  // An explicit conversion. Information will be lost.
}









A cast explicitly invokes the conversion operator from one type to another. The cast will fail if no such conversion operator is defined. You can write custom conversion operators to convert between user-defined types. For more information about defining a conversion operator, see explicit (C# Reference) and implicit (C# Reference).


The following program casts a double to an int. The program will not compile without the cast.



class Test
{
static void Main()
{
double x = 1234.7;
int a;
a = (int)x;  // cast double to int
System.Console.WriteLine(a);
}
}







































                                      
                                    









Subscribe to:

Posts
                                      (
                                      Atom
                                      )