Task

You will write a program that displays an overview of all the C# numeric data types. For each type, its range of possible values will be printed (see Figure 12-1).

Figure 12-1 Printing all numeric data types

Solution

Here is the code :

static void Main(string[] args)
{
    // Immediately outputs
    Console.WriteLine("Signed whole numbers");
    Console.WriteLine("--------------------");
    Console.WriteLine("sbyte:  " + sbyte.MinValue + " to " + sbyte.MaxValue);
    Console.WriteLine("short:  " + short.MinValue + " to " + short.MaxValue);
    Console.WriteLine("int:    " + int.MinValue + " to " + int.MaxValue);
    Console.WriteLine("long:   " + long.MinValue + " to " + long.MaxValue);
    Console.WriteLine();

    Console.WriteLine("Unsigned whole numbers");
    Console.WriteLine("----------------------");
    Console.WriteLine("byte:   " + byte.MinValue + " to " + byte.MaxValue);
    Console.WriteLine("ushort: " + ushort.MinValue + " to " + ushort.MaxValue);
    Console.WriteLine("unit:   " + uint.MinValue + " to " + uint.MaxValue);
    Console.WriteLine("ulong:  " + ulong.MinValue + " to " + ulong.MaxValue);
    Console.WriteLine();

    Console.WriteLine("Basic decimal numbers");
    Console.WriteLine("---------------------");
    Console.WriteLine("float:  " + float.MinValue + " to " + float.MaxValue);
    Console.WriteLine("double: " + double.MinValue + " to " + double.MaxValue);
    Console.WriteLine();

    Console.WriteLine("Exact decimal numbers");
    Console.WriteLine("---------------------");
    Console.WriteLine("decimal:  " + decimal.MinValue + " to " + decimal.MaxValue);

    // Waiting for Enter
    Console.ReadLine();
}

Discussion

The following sections discuss this program.

Task

In this section, you will write a program that tells you how many bytes of memory each type uses (see Figure 12-2).

Figure 12-2 Displaying the number of bytes each type uses

Solution

Here is the code:

static void Main(string[] args)
{
    // Outputs
    Console.WriteLine("Whole numbers");
    Console.WriteLine("-------------");
    Console.WriteLine("byte:   " + sizeof(byte));
    Console.WriteLine("sbyte:  " + sizeof(sbyte));
    Console.WriteLine();
    Console.WriteLine("short:  " + sizeof(short));
    Console.WriteLine("ushort: " + sizeof(ushort));
    Console.WriteLine();
    Console.WriteLine("int:    " + sizeof(int));
    Console.WriteLine("uint:   " + sizeof(uint));
    Console.WriteLine();
    Console.WriteLine("long:   " + sizeof(long));
    Console.WriteLine("ulong:  " + sizeof(ulong));
    Console.WriteLine();
    Console.WriteLine("Decimal numbers");
    Console.WriteLine("---------------");
    Console.WriteLine("float:    " + sizeof(float));
    Console.WriteLine("double:   " + sizeof(double));
    Console.WriteLine("decimal:  " + sizeof(decimal));
    Console.WriteLine();

    // Waiting for Enter
    Console.ReadLine();
}

Connections

It is possible to connect the results of the current and previous programs. For example, let’s discuss the important int type. It uses 4 bytes, or 32 bits of memory. This means 2 to the 32nd power of possible values, which is more than 4 billion. int is a signed type, so you have 2 billion for positive numbers and 2 billion for negative numbers. Its unsigned counterpart uint has all 4 billion values for positive numbers (and, of course, zero).

Discussion

You may feel confused about the variety of numeric data types. To help you understand them, here is a summary of when you should use each one:

• int: For regular work with values that are intrinsically integers (for example, counts of something).

• double: For regular work with values that may be decimal (for example, measured values) or values you do math with. Money amounts are also mostly OK.

• byte: For work with binary data.

• long: For big integer values such as file sizes, payment identifications (for example, ten digits may be required), or multiplication results of regular (whole) values.

• decimal: A common choice for money amounts.

The other types are not used that often.

Task

In this section, you will write a program that tries to calculate a million times a million.

Solution

Here is the code:

static void Main(string[] args)
{
    // Multiplying million by million
    int million = 1000000;
    int result = million * million;
    long resultInLong = million * million;

    // Outputs
    Console.WriteLine("Million times million: " + result);
    Console.WriteLine("also in long: " + resultInLong);

    // Waiting for Enter
    Console.ReadLine();
}

Discussion

What the program does is totally unexpected. You need to be aware of this kind of anomaly.

What is actually happening? The program multiplies a million by a million. The result is too big to fit into the positive or negative two-billion range of the 32-bit signed int type. So, the computer simply throws away the upper bits, resulting in complete nonsense.

Please note that you get the same nonsense even when you store the result in a long-typed variable. That nonsense, which throws away the bits greater than 32, arises during calculation. According to C# rules, int times int is simply int regardless of where you store the result.

Task

Here are two possibilities of how to handle overflow problems:

• If you do not expect a big value and it appears anyway, the program should at least crash or let you know about the problem. Displaying a nonsense value is the worst alternative. Users trust their computers and can make wrong decisions based upon believing incorrect results.

• If you have an idea that int might be insufficient, you can make the calculation correctly with the following solution.

Solution

The new project source code follows:

static void Main(string[] args)
{
    // 0. Preparation
    int million = 1000000;

    // 1. Crash at least, we do not
    //    definitely want a nonsense
    Console.WriteLine("1. calculation");
    try
    {
        long result = million * million;
        Console.WriteLine("Million times million:" + result);
    }
    catch (Exception)
    {
        Console.WriteLine("I cannot calculate this.");
    }

    // 2. Correct calculation of a big value
    Console.WriteLine("2. calculation");
    long millionInLong = million;
    long correctResult = millionInLong * millionInLong;
    Console.WriteLine("Million times million: " + correctResult.ToString("N0"));

    // 3. Alternative calculation of a big valule
    Console.WriteLine("3. calculation");
    long correctResultAlternatively = (long)million * (long)million;
    Console.WriteLine("Million times million: " + correctResultAlternatively.ToString("N0"));

    // Waiting for Enter
    Console.ReadLine();
}

Settings in Visual Studio

You need to set up your project in Visual Studio so that it reports overflow out of the program instead of sweeping it under the rug.

From the Visual Studio menu, choose Project and then <Project name> Properties (see Figure 12-4).

Figure 12-4 Opening the properties

Choose the Build tab next, scroll vertically (and maybe also horizontally) so that you can see the Advanced button (it is really hidden!), and then click that button (see Figure 12-5).

Figure 12-5 Build tab

In the dialog that appears, select the “Check for arithmetic overflow/underflow” check box and confirm by clicking the OK button (see Figure 12-6).

Figure 12-6 “Check for arithmetic overflow/underflow” check box

Your project is finally ready to run now .

Results

Now the program behaves according to expectations, as shown in Figure 12-7.

Figure 12-7 Multiplying a million by a million