A question cropped up at work today about how to convert an object into its specific type (an int), I said to cast it:
int i = (int)object;
a colleague said to use Convert.ToInt32().
int i = Convert.ToInt32(object)
What's the difference between Convert.ToInt32() and a direct object cast?
Not every object can be cast directly to int. For example, the following will not compile:
string s = "1";
int i = (int)s;
because string is not implicitly convertible to int.
However, this is legal:
string s = "1";
int i = Convert.ToInt32(s);
As a side note, both casting and Convert can throw exceptions if the input object cannot be converted. However, int.TryParse does not throw if it fails; rather, it returns false (but it only takes in a string, so you have to .ToString() your input object before using it):
object s = "1";
int i;
if(int.TryParse(s.ToString(), out i))
{
// i now has a value of 1
}
They are fundamentally different
Casting says that the object is an instance of the type being cast to, so cast it.
Convert says that there is a conversion between the types being converted.
So for example you can't cast a string to an int, but you can convert it. There is some grey area/overlap due to certain built in cast rules for primitive types, or explicit cast conversions you can add to your own types. But generally I wouldn't think of these two as the equivalent.
Given that there is no 'better' option, you should use the option that makes sense in the given context.
You can only cast when the original type has a cast defined for the new type. So casting from one numeric type to another (e.g. long to int) is normally possible but casting from non-numeric types to numeric types (e.g. string to int) normally is not possible. Convert provides many more methods to change these non-numeric types to numeric, so the reason to use it is you are less likely to get an error.
I tend to prefer Convert myself just because it provides a nice uniform interface to conversion. For example Convert.ToInt32("45") works but (int)"45", does not.
Convert will also report issues such as throwing an OverflowException. Casting can be dangerous as casting from say long to an int could yield a poor result and the runtime won't tell you.
I also like that Convert.ToX(object obj) exists, which lets you just fire things off to Convert and for the most part forget about it.
Convert.ToInt32 is basically the same as int.Parse With one difference: if you use int.Parse(null) an exception is thrown, while Convert.ToInt32 returns 0
Casting on the other hand is a more complex operation and will only work if the value really is a boxed int or anohter (boxed/unboxed) value type that can be implicitly converted.
(boxing is an object representation of a value type)
Convert is a class that contains a series of static methods and is suposed to be used to convert base types, the supported types are Boolean, Char, SByte, Byte, Int16, Int32, Int64, UInt16, UInt32, UInt64, Single, Double, Decimal, DateTime and String. The cast operator allows you to do the same thing but you can use it for other types as well, including the types you create. You also can define this operators in your classes, allowing you to convert from anything to anything. So thats the difference, one is a method and the other one is an operator, I have not checked the guts of the operaror when converting and int to a string, but it might have the same logic as the methods in Convert.
If you know that the boxed instance is an int, you can safely use the (int) cast operator to unbox it. However, if it's convertible to an int (e.g. a float), using the cast operator will fail at runtime.
Check out the Convert class documentation for more details on the specific conversions it allows and disallows.
The difference is Convert.ToInt32(object value) will try to use IConvertible to convert the value to int where as direct cast will simply throw an exception if such cast is not valid.
The other overloads also try converting and not casting.
