C# 4 and .NET 4

160 ❘ ChaPTer 7 OperAtOrs And cAsts
In this case, you will not get an error, but you also will not get the result you expect. If you run this code
and output the value stored in i, this is what you get:
-1294967296
It is good practice to assume that an explicit cast will not give the results you expect. As you saw earlier, C#
provides a checked operator that you can use to test whether an operation causes an arithmetic overflow.
You can use the checked operator to check that a cast is safe and to force the runtime to throw an overflow
exception if it is not:
long val = 3000000000;
int i = checked((int)val);
Bearing in mind that all explicit casts are potentially unsafe, you should take care to include code in your
application to deal with possible failures of the casts. Chapter 15, “Errors and Exceptions,” introduces
structured exception handling using the try and catch statements.
Using casts, you can convert most primitive data types from one type to another; for example, in this code,
the value 0.5 is added to price, and the total is cast to an int:
double price = 25.30;
int approximatePrice = (int)(price + 0.5);
This gives the price rounded to the nearest dollar. However, in this conversion, data is lost — namely,
everything after the decimal point. Therefore, such a conversion should never be used if you want to go
on to do more calculations using this modified price value. However, it is useful if you want to output the
approximate value of a completed or partially completed calculation — if you do not want to bother the
user with lots of figures after the decimal point.
This example shows what happens if you convert an unsigned integer into a char:
ushort c = 43;
char symbol = (char)c;
Console.WriteLine(symbol);
The output is the character that has an ASCII number of 43, the + sign. You can try any kind of conversion
you want between the numeric types (including char), and it will work, such as converting a decimal into a
char, or vice versa.
Converting between value types is not restricted to isolated variables, as you have seen. You can convert an
array element of type double to a struct member variable of type int:
struct ItemDetails
{
public string Description;
public int ApproxPrice;
}
//..
double[] Prices = { 25.30, 26.20, 27.40, 30.00 };
ItemDetails id;
id.Description = “Hello there.”;
id.ApproxPrice = (int)(Prices[0] + 0.5);
To convert a nullable type to a non-nullable type or another nullable type where data loss may occur,
you must use an explicit cast. This is true even when converting between elements with the same basic
underlying type, for example, int to int or float to float. This is because the nullable type may
have the value null, which cannot be represented by the non-nullable type. As long as an explicit cast
between two equivalent non-nullable types is possible, so is the explicit cast between nullable types.
However, when casting from a nullable to non-nullable type and the variable has the value null, an
InvalidOperationException is thrown. For example:
www.it-ebooks.info