C# - Issues with boxing / unboxing / typecasting ints. I don't understand

advantages and disadvantages of boxing and unboxing in c#
c# boxing performance
boxing and unboxing in c# stackoverflow
c# boxing vs casting
difference between boxing and unboxing in c#
boxing and unboxing in java
boxing and unboxing in c# interview questions
type casting in c#

I'm having a hard time understanding this. Consider the following example:

protected void Page_Load(object sender, EventArgs e)
{
    // No surprise that this works
    Int16 firstTest = Convert.ToInt16(0);
    int firstTest2 = (int)firstTest;

    // This also works
    object secondTest = 0;
    int secondTest2 = (int)secondTest;

    // But this fails!
    object thirdTest = Convert.ToInt16(0);
    int thirdtest2 = (int)thirdTest;  // It blows up on this line.
}

The specific error that I get at runtime is Specified cast is not valid. If I QuickWatch (int)thirdTest in Visual Studio, I get a value of Cannot unbox 'thirdTest' as a 'int'.

What the heck is going on here?

Boxing and Unboxing, Boxing is the process of converting a value type to the type object or to any interface type int i = 123; // The following line boxes i. object o = i;. 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;

What's going on is exactly what it says.

In the first case, you have a short, unboxed, that you are then explicitly typecasting to an int. This is a valid conversion that the compiler knows how to do, so it works.

In the second case, you have an int, boxed, that are are assigning back to an int. This is a simple unboxing of an integer, which also valid, so it works.

In the third case, you have a short, boxed, that are you trying to unbox into a variable that is not a short. This isn't a valid operation: you can't do this in one step. This is not an uncommon problem, either: if you are using, for example, a SqlDataReader that contains a SMALLINT column, you cannot do:

    int x = (int)rdr["SmallIntColumn"];

Either of the following should work in your third example:

    object thirdTest = Convert.ToInt16(0);
    int thirdTest2 = Convert.ToInt32(thirdTest);
    int thirdTest3 = (int)(short)thirdTest;

Pro C# 5.0 and the .NET 4.5 Framework, all of the previous issues, including boxing/unboxing penalties and a lack of type cars, and integers, you can use a generic collection class and specify the type of namespace) to contain various types of data in a strongly typed manner (don't Therefore, you do not need to perform a cast when plucking the items from  Boxing and unboxing are the most important concepts you always get asked in your interviews. Actually, it's really easy to understand, and simply refers to the allocation of a value type (e.g. int, char, etc.) on the heap rather than the stack.

Int16 is a fancy way to write short; there is no boxing/unboxing going on there, just the plain CLR conversion between 16-bit and 32-bit integers.

The second case boxes and unboxes to the same type, which is allowed: value type int gets wrapped in an object, and then gets unwrapped.

The third case tries to unbox to a different type (int instead of short) which is not allowed.

.NET 2.0 for Delphi Programmers, C# 2.0 uses the new, generic CIL to supporta generic syntax that looks like C++ templates. However, such a universal collection suffers from a couple of problems. involved in all the casting, and especially in any boxing and unboxing. You don't need to write type-safe wrappers; adding a value type doesn't boxit; you  Boxing and unboxing enables a unified view of the type system wherein a value of any type can ultimately be treated as an object. Converting a value type to reference type is called Boxing. Unboxing is the opposite operation and is an explicit operation.

Beginning C# 2008: From Novice to Professional, Problem. of. Value. Types. Another issue with pre-C# 2.0 collections is that Then, in the foreach statement, the integers are iterated. Don't think of the fix as a hack, but as a way of solving a problem that all NET environment uses the terms boxing and unboxing to denote converting a value type into a reference type  Casting and type conversions (C# Programming Guide) 07/20/2015; 5 minutes to read +8; In this article. Because C# is statically-typed at compile time, after a variable is declared, it cannot be declared again or assigned a value of another type unless that type is implicitly convertible to the variable's type.

Autoboxing and Unboxing (The Java™ Tutorials > Learning the , Examples and practices described in this page don't take advantage of For example, converting an int to an Integer, a double to a Double, and so on. objects, not a list of int values, you may wonder why the Java compiler does not issue a  I have a question related to Boxing/Unboxing: What is the difference between Boxing/Unboxing & Type Casting. Does Boxing/Unboxing mean that we can convert the integer type to object and then back to object .

Boxing And Unboxing In C#, Boxing and unboxing in C# allows conversion from value types to reference An int value can be converted into object and back again into int. above don't actually exist and the dynamic type of a boxed value isn't actually  A few days ago, a post alerted me on C# Corner discussion forums about collection and performance issues during boxing and unboxing. A collection such as an ArrayList stores data as 'generic objects' and boxing and unboxing operations may be used to store and retrieve data from a collection.

Comments
  • Int16 is actually a short. So I think you can replace 'Int16 firstTest = Convert.ToInt16(0);' with 'Int16 firstTest = 0s;'
  • Or unbox it with the correct type, then cast to your desired type. int thirdtest2 = (int)(short)thirdTest;