C# 4 and .NET 4

174 ❘ ChaPTer 7 OperAtOrs And cAsts
}
public override string ToString()
{
return string.Format( “ ${0}.{1, - 2:00} ” , Dollars,Cents);
}
code snippet SimpleCurrency/Program.cs
The use of unsigned data types for the Dollar and Cents fi elds ensures that a Currency instance can hold
only positive values. It is restricted this way to illustrate some points about explicit casts later on. You might
want to use a class like this to hold, for example, salary information for employees of a company (people ’ s
salaries tend not to be negative!). To keep the class simple, the fi elds are public, but usually you would make
them private and defi ne corresponding properties for the dollars and cents.
Start by assuming that you want to be able to convert Currency instances to float values, where the
integer part of the float represents the dollars. In other words, you would like to be able to write code
like this:
Currency balance = new Currency(10,50);
float f = balance; // We want f to be set to 10.5
To be able to do this, you need to defi ne a cast. Hence, you add the following to your Currency definition:
public static implicit operator float (Currency value)
{
return value.Dollars + (value.Cents/100.0f);
}
The preceding cast is implicit. It is a sensible choice in this case because, as should be clear from the
defi nition of Currency , any value that can be stored in the currency can also be stored in a float . There is
no way that anything should ever go wrong in this cast.
There is a slight cheat here — in fact, when converting a uint to a float, there can be
a loss in precision, but Microsoft has deemed this error suffi ciently marginal to count
the uint-to-float cast as implicit.
However, if you have a float that you would like to be converted to a Currency , the conversion is not
guaranteed to work. A float can store negative values, which Currency instances can ’ t, and a float
can store numbers of a far higher magnitude than can be stored in the ( uint ) Dollar fi eld of Currency .
Therefore, if a float contains an inappropriate value, converting it to a Currency could give unpredictable
results. Because of this risk, the conversion from float to Currency should be defi ned as explicit. Here is
the fi rst attempt, which will not give quite the correct results, but it is instructive to examine why:
public static explicit operator Currency (float value)
{
uint dollars = (uint)value;
ushort cents = (ushort)((value - dollars) * 100);
return new Currency(dollars, cents);
}
The following code will now successfully compile:
float amount = 45.63f;
Currency amount2 = (Currency)amount;
However, the following code, if you tried it, would generate a compilation error, because it attempts to use
an explicit cast implicitly:
float amount = 45.63f;
Currency amount2 = amount; // wrong
www.it-ebooks.info