For the predefined types, C# will automatically convert from one data type to another—but only between those types for which there is no possibility of data loss between the source type and the target type. That is, the language does not provide automatic conversion between two types if there is any value of the source type that would lose data if it were converted to the target type. If you want to make a conversion of this type, you must use an explicit conversion, called a cast expression.

The following code shows an example of a cast expression. It converts the value of var1 to type sbyte. A cast expression consists of

When you use a cast expression, you are explicitly taking responsibility for performing the operation that might lose data. Essentially, you are saying, "In spite of the possibility of data loss, I know what I'm doing, so make this conversion anyway." (Make sure, however, that you do know what you're doing.)

For example, Figure 18-6 shows cast expressions converting two values of type ushort to type byte. In the first case, there is no loss of data. In the second case, the most significant bits are lost, giving a value of 85—which is clearly not equivalent to the source value, 1,365.

Figure 18-6. Casting a ushort to a byte

The output of the code in the figure is the following:

sb:  10 = 0×A
sb:  85 = 0×55

The implicit numeric conversions are shown in Figure 18-9.

The figure demonstrates that, as you would expect, there is an implicit conversion between numeric types that occupy fewer bits to those that occupy more bits.

Figure 18-9. The implicit numeric conversions

You've seen that explicit conversions have the possibility of losing data and not being able to represent the source value equivalently in the target type. For integral types, C# provides you with the ability to choose whether the runtime should check the result for overflow when making these types of conversions. It does this through the checked operator and the checked statement.

checked   ( Expression )
   unchecked ( Expression )

ushort sh = 2000;
byte   sb;

sb = unchecked ( (byte) sh );         // Most significant bits lost
Console.WriteLine("sb: {0}", sb);

sb =   checked ( (byte) sh );         // OverflowException raised
Console.WriteLine("sb: {0}", sb);

sb: 208

Unhandled Exception: System.OverflowException: Arithmetic operation resulted

   in an overflow. at Test1.Test.Main() in C:ProgramsTest1Program.cs:line 21

byte   sb;
   ushort sh = 2000;

   unchecked                                            // Set unchecked
   {
      sb = (byte) sh;
      Console.WriteLine("sb: {0}", sb);

      checked                                           // Set checked
      {
         sb = (byte) sh;
         Console.WriteLine("sb: {0}", sh);
      }
   }

You've seen that the implicit conversions automatically convert from the source expression to the target type because there is no possible loss of data. With the explicit conversions, however, there is the possibility of losing data—so it is important for you as the programmer to know how a conversion will handle that loss if it occurs.

In this section, you will look at each of the various types of explicit numeric conversions. Figure 18-10 shows the subset of explicit conversions shown in Figure 18-8.

Figure 18-10. The explicit numeric conversions

Integral to Integral

Figure 18-11 shows the behavior of the integral-to-integral explicit conversions. In the checked case, if the conversion loses data, the operation raises an OverflowException exception. In the unchecked case, any lost bits go unreported.

Figure 18-11. Integer type to integer type explicit conversions

float or double to Integral

When converting a floating point type to an integer type, the value is rounded toward 0 to the nearest integer. Figure 18-12 illustrates the conversion conditions. If the rounded value is not within the range of the target type, then

• The CLR raises an OverflowException exception if the overflow checking context is checked.

• C# does not define what its value should be if the context is unchecked.

Figure 18-12. Converting a float or a double to an integral type

decimal to Integral

When converting from decimal to the integer types, the CLR raises an OverflowException exception if the resulting value is not within the target type's range. Figure 18-13 illustrates the conversion conditions.

Figure 18-13. Converting a decimal to an integral

double to float

Values of type float occupy 32 bits, and values of type double occupy 64 bits. The double type value is rounded to the nearest float type value. Figure 18-14 illustrates the conversion conditions.

• If the value is too small to be represented by a float, the value is set to either positive or negative 0.

• If the value is too large to be represented by a float, the value is set to either positive or negative infinity.

Figure 18-14. Converting a double to a float

float or double to decimal

Figure 18-15 shows the conversion conditions for converting from floating point types to decimal.

• If the value is too small to be represented by the decimal type, the result is set to 0.

• If the value is too large, the CLR raises an OverflowException exception.

Figure 18-15. Converting a float or double to a decimal

decimal to float or double

Conversions from decimal to the floating point types always succeed. There might, however, be a loss of precision. Figure 18-16 shows the conversion conditions.

Figure 18-16. Converting a decimal to a float or double

Just as there are implicit numeric conversions that the language will automatically perform for you, there are also implicit reference conversions. These are illustrated in Figure 18-18.

Figure 18-18. Implicit conversions for classes and interfaces

A delegate can be implicitly converted to the .NET BCL classes and interfaces shown in Figure 18-19.

An array, ArrayS, with elements of type Ts, can be implicitly converted to

Figure 18-19. Implicit conversions for delegates and arrays

Explicit reference conversions are reference conversions from a general type to a more specialized type.

If this type of conversion were allowed without restriction, you could easily attempt to reference members of a class that are not actually in memory. The compiler, however, does allow these types of conversions. But when the system encounters them at run time, it raises an exception.

For example, the code in Figure 18-20 converts the reference of base class A to its derived class B, and assigns it to variable myVar2.

Figure 18-20. Invalid casts raise runtime exceptions.

There are three situations in which an explicit reference conversion will succeed at run time—that is, not raise an InvalidCastException exception.

The first case is where the explicit conversion is unnecessary—that is, where the language would have performed an implicit conversion for you anyway. For example, in the code that follows, the explicit conversion is unnecessary because there is always an implicit conversion from a derived class to one of its base classes.

class A { }
   class B: A { }
      ...
   B myVar1 = new B();
   A myVar2 = (A) myVar1;     // Cast is unnecessary; A is the base class of B.

The second case is where the source reference is null. For example, in the following code, even though it would normally be unsafe to convert a reference of a base class to that of a derived class, the conversion is allowed because the value of the source reference is null.

class A { }
   class B: A { }
      ...
   A myVar1 = null;
   B myVar2 = (B) myVar1;     // Allowed because myVar1 is null

The third case is where the actual data pointed to by the source reference could safely be converted implicitly. The following code shows an example, and Figure 18-21 illustrates the code.

B myVar1 = new B();
A myVar2 = myVar1;     // Implicitly cast myVar1 to type A.
B myVar3 = (B)myVar2;  // This cast is fine because the data is of type B.

Figure 18-21. Casting to a safe type

A common misunderstanding about boxing is that it somehow acts upon the item being boxed. It doesn't. It returns a reference type copy of the value. After the boxing procedure, there are two copies of the value—the value type original and the reference type copy—each of which can be manipulated separately.

For example, the following code shows the separate manipulation of each copy of the value. Figure 18-23 illustrates the code.

This code produces the following output:

i: 10, io: 10
i: 12, io: 15

Figure 18-23. Boxing creates a copy that can be manipulated separately.

The Boxing Conversions

Figure 18-24 shows the boxing conversions. Any value type ValueTypeS can be implicitly converted to any of types object, System.ValueType, or InterfaceT, if ValueTypeS implements InterfaceT.

Figure 18-24. Boxing is the implicit conversion of value types to reference types.

Figure 18-25 shows the unboxing conversions.

Figure 18-25. The unboxing conversions

There are some important constraints on user-defined conversions. The most important are the following:

The following code defines a class called Person that contains a person's name and age. The class also defines two implicit conversions. The first converts a Person object to an int value. The target int value is the age of the person. The second converts an int to a Person object.

This code produces the following output:

Person Info: bill, 25
Person Info: Nemo, 35

If you had defined the same conversion operators as explicit rather than implicit, then you would have needed to use cast expressions to perform the conversions, as shown here:

The user-defined conversions discussed so far have directly converted the source type to an object of the target type in a single step, as shown in Figure 18-26.

Figure 18-26. Single-step user-defined conversion

But user-defined conversions can have up to three steps in the full conversion. Figure 18-27 illustrates these stages, which include

There is never more than a single user-defined conversion in the chain.

Figure 18-27. Multi-step user-defined conversion

The following code declares class Employee, which is derived from class Person.

Figure 18-28. Conversion of Employee to float