The C# language offers the usual cornucopia of intrinsic (built-in) types one expects in a modern language, each of which maps to an underlying type supported by the .NET CLS. Mapping the C# primitive types to the underlying .NET type ensures that objects created in C# can be used interchangeably with objects created in any other language compliant with the .NET CLS, such as VB.NET.

Each type has a specific and unchanging size. Unlike with C++, a C# int is always 4 bytes because it maps to an Int32 in the .NET CLS. Table 3-1 lists the built-in value types offered by C#.

byte

1

Byte

char

2

Char

bool

1

Boolean

sbyte

1

SByte

short

2

Int16

ushort

2

UInt16

int

4

Int32

uint

4

UInt32

float

4

Single

double

8

Double

decimal

16

Decimal

long

8

Int64

ulong

8

UInt64

In addition to these primitive types, C# has two other value types: enum (considered later in this chapter) and struct (see Chapter 4). Chapter 4 also discusses other subtleties of value types, such as forcing value types to act as reference types through a process known as boxing, and that value types don’t “inherit.”

float someFloat = 57f;

'

"

\

a



f

v

(int)'A'

(char)65

short x = 5;
int y = x; // implicit conversion

short x;
int y = 500;
x = y;  // won't compile

short x;
int y = 500;
x = (short) y;  // OK

C# requires definite assignment: that is, variables must be initialized or assigned to before they are used. To test this rule, change the line that initializes myInt in Example 3-1 to:

int myInt;

and save the revised program shown in Example 3-2.

#region Using directives

using System;
using System.Collections.Generic;
using System.Text;

#endregion

namespace UninitializedVariable
{
   class UninitializedVariable
   {
      static void Main(string[] args)
      {
         int myInt;
         System.Console.WriteLine
         ("Uninitialized, myInt: {0}", myInt);
         myInt = 5;
         System.Console.WriteLine("Assigned, myInt: {0}", myInt);

      }
   }
}

When you try to compile this listing, the C# compiler will display an error message as shown in Figure 3-1.

Figure 3-1. Error message resulting from using an unassigned variable

Double-clicking the error message will bring you to the problem in the code.

It isn’t legal to use an uninitialized variable in C#. So, does this mean you must initialize every variable in a program? In fact, no. You don’t actually need to initialize a variable, but you must assign a value to it before you attempt to use it. Example 3-3 illustrates a correct program.

#region Using directives

using System;
using System.Collections.Generic;
using System.Text;

#endregion

namespace AssigningWithoutInitializing
{
   class AssigningWithoutInitializing
   {
      static void Main(string[] args)
      {
         int myInt;
         myInt = 7;
         System.Console.WriteLine("Assigned, myInt: {0}", myInt);
         myInt = 5;
         System.Console.WriteLine("Reassigned, myInt: {0}", myInt);

      }
   }
}

A constant is a variable whose value can’t be changed. Variables are a powerful tool, but there are times when you want to manipulate a defined value, one whose value you want to ensure remains constant. For example, you might need to work with the Fahrenheit freezing and boiling points of water in a program simulating a chemistry experiment. Your program will be clearer if you name the variables that store the values FreezingPoint and BoilingPoint, but you don’t want to permit their values to be reassigned. How do you prevent reassignment? The answer is to use a constant.

Constants come in three flavors: literals , symbolic constants, and enumerations. In this assignment:

x = 32;

the value 32 is a literal constant. The value of 32 is always 32. You can’t assign a new value to 32; you can’t make 32 represent the value 99 no matter how you might try.

Symbolic constants assign a name to a constant value. You declare a symbolic constant using the const keyword and the following syntax:

consttype 
                  identifier = value;

A constant must be initialized when it is declared, and once initialized it can’t be altered. For example:

const int FreezingPoint = 32;

In this declaration, 32 is a literal constant and FreezingPoint is a symbolic constant of type int. Example 3-4 illustrates the use of symbolic constants.

#region Using directives

using System;
using System.Collections.Generic;
using System.Text;

#endregion

namespace SymbolicConstants
{
   class SymbolicConstants
   {
      static void Main(string[] args)
      {
         const int FreezingPoint = 32;   // degrees Fahrenheit
         const int BoilingPoint = 212;

         System.Console.WriteLine("Freezing point of water: {0}",
              FreezingPoint);
         System.Console.WriteLine("Boiling point of water: {0}",
              BoilingPoint);//BoilingPoint = 21;

      }
   }
}

Example 3-4 creates two symbolic integer constants: FreezingPoint and BoilingPoint. As a matter of style, constant names are written in Pascal notation, but this is certainly not required by the language.

These constants serve the same purpose as always using the literal values 32 and 212 for the freezing and boiling points of water in expressions that require them, but because these constants have names, they convey far more meaning. Also, if you decide to switch this program to Celsius, you can reinitialize these constants at compile time, to 0 and 100, respectively; all the rest of the code ought to continue to work.

To prove to yourself that the constant can’t be reassigned, try uncommenting the last line of the program (shown in bold). When you recompile, you should receive the error shown in Figure 3-2.

Figure 3-2. Warning that occurs when you try to reassign a constant

Enumerations provide a powerful alternative to constants. An enumeration is a distinct value type, consisting of a set of named constants (called the enumerator list).

In Example 3-4, you created two related constants:

const int FreezingPoint = 32;  
const int BoilingPoint = 212;

You might wish to add a number of other useful constants to this list, such as:

const int LightJacketWeather = 60;
const int SwimmingWeather = 72;
const int WickedCold = 0;

This process is somewhat cumbersome, and there is no logical connection between these various constants. C# provides the enumeration to solve these problems:

enum Temperatures
{
   WickedCold = 0,
   FreezingPoint = 32,
   LightJacketWeather = 60,
   SwimmingWeather = 72,
   BoilingPoint = 212,
}

Every enumeration has an underlying type, which can be any integral type (integer, short, long, etc.) except for char. The technical definition of an enumeration is:

[attributes] [modifiers] enum 
                  identifier 
     [:base-type] {
                  enumerator-list
                  };

The optional attributes and modifiers are considered later in this book. For now, let’s focus on the rest of this declaration. An enumeration begins with the keyword enum , which is generally followed by an identifier, such as:

enum Temperatures

The base type is the underlying type for the enumeration. If you leave out this optional value (and often you will), it defaults to int, but you are free to use any of the integral types (e.g., ushort, long) except for char. For example, the following fragment declares an enumeration of unsigned integers (uint):

enum ServingSizes :uint
{
    Small = 1,
    Regular = 2,
    Large = 3
}

Notice that an enum declaration ends with the enumerator list. The enumerator list contains the constant assignments for the enumeration, each separated by a comma.

Example 3-5 rewrites Example 3-4 to use an enumeration.

#region Using directives

using System;
using System.Collections.Generic;
using System.Text;

#endregion

namespace EnumeratedConstants
{
   class EnumeratedConstants
   {

      enum Temperatures
      {
         WickedCold = 0,
         FreezingPoint = 32,
         LightJacketWeather = 60,
         SwimmingWeather = 72,
         BoilingPoint = 212,
      }

      static void Main(string[] args)
      {
         System.Console.WriteLine("Freezing point of water: {0}",
            (int)Temperatures.FreezingPoint);
         System.Console.WriteLine("Boiling point of water: {0}",
            (int)Temperatures.BoilingPoint);
      }
   }
}

As you can see, an enum must be qualified by its enumtype (e.g., Temperatures.WickedCold). By default, an enumeration value is displayed using its symbolic name (such as BoilingPoint or FreezingPoint). When you want to display the value of an enumerated constant, you must cast the constant to its underlying type (int). The integer value is passed to WriteLine, and that value is displayed.

Each constant in an enumeration corresponds to a numerical value—in this case, an integer. If you don’t specifically set it otherwise, the enumeration begins at 0 and each subsequent value counts up from the previous.

If you create the following enumeration:

enum SomeValues
{
   First,
   Second,
   Third = 20,
   Fourth
}

the value of First will be 0, Second will be 1, Third will be 20, and Fourth will be 21.

Enums are formal types; therefore an explicit conversion is required to convert between an enum type and an integral type.

It is nearly impossible to write a C# program without creating strings. A string object holds a string of characters.

You declare a string variable using the string keyword much as you would create an instance of any object:

string myString;

A string literal is created by placing double quotes around a string of letters:

"Hello World"

It is common to initialize a string variable with a string literal:

string myString = "Hello World";

Strings are covered in much greater detail in Chapter 10.

Identifiers are names programmers choose for their types, methods, variables, constants, objects, and so forth. An identifier must begin with a letter or an underscore.

The Microsoft naming conventions suggest using camel notation (initial lowercase such as someName) for variable names and Pascal notation (initial uppercase such as SomeOtherName) for method names and most other identifiers.

Identifiers are case-sensitive, so C# treats myVariable and MyVariable as two different variable names.

An unconditional branch is created in one of two ways. The first way is by invoking a method. When the compiler encounters the name of a method, it stops execution in the current method and branches to the newly “called” method. When that method returns a value, execution picks up in the original method on the line just below the method call. Example 3-6 illustrates.

#region Using directives

using System;
using System.Collections.Generic;
using System.Text;

#endregion

namespace CallingAMethod
{
   class CallingAMethod
   {
      static void Main( )
      {
         Console.WriteLine("In Main! Calling SomeMethod( )...");
         SomeMethod( );
         Console.WriteLine("Back in Main( ).");
      }
      static void SomeMethod( )
      {
         Console.WriteLine("Greetings from SomeMethod!");
      }
   }
}
Output:
In Main! Calling SomeMethod( )...
Greetings from SomeMethod!
Back in Main( ).

Program flow begins in Main( ) and proceeds until SomeMethod() is invoked (invoking a method is sometimes referred to as “calling” the method). At that point, program flow branches to the method. When the method completes, program flow resumes at the next line after the call to that method.

The second way to create an unconditional branch is with one of the unconditional branch keywords: goto, break, continue, return, or throw. Additional information about the first three jump statements is provided later in this chapter; the return statement returns control to the calling method; the final statement, throw, is discussed in Chapter 11.

A conditional branch is created by a conditional statement, which is signaled by keywords such as if, else, or switch. A conditional branch occurs only if the condition expression evaluates true.

if (expression)
   statement1
[else
   statement2]

using System;
class Values
{
   static void Main( )
   {
      int valueOne = 10;
      int valueTwo = 20;

      if ( valueOne > valueTwo )
      {
         Console.WriteLine(
           "ValueOne: {0} larger than ValueTwo: {1}", 
                valueOne, valueTwo);
      }
      else
      {
         Console.WriteLine(
          "ValueTwo: {0} larger than ValueOne: {1}",  
                valueTwo,valueOne);
      }

      valueOne = 30; // set valueOne higher

      if ( valueOne > valueTwo )
      {
         valueTwo = valueOne++;
         Console.WriteLine("
Setting valueTwo to valueOne value, ");
         Console.WriteLine("and incrementing ValueOne.
");
            Console.WriteLine("ValueOne: {0}  ValueTwo: {1}", 
                valueOne, valueTwo);
      }
      else
      {
         valueOne = valueTwo;
         Console.WriteLine("Setting them equal. ");
            Console.WriteLine("ValueOne: {0}  ValueTwo: {1}", 
                valueOne, valueTwo);
      }         
   }
}

ValueTwo: 20 is larger than ValueOne: 10

Setting valueTwo to valueOne value,
and incrementing ValueOne.

ValueOne: 31  ValueTwo: 30

if (someCondition)
    someStatement;

if(someCondition)
{
    statementOne;
    statementTwo;
    statementThree;
}

#region Using directives

using System;
using System.Collections.Generic;
using System.Text;

#endregion

namespace NestedIf
{
   class NestedIf
   {
      static void Main( )
      {
         int temp = 32;

         if ( temp <= 32 )
         {
            Console.WriteLine( "Warning! Ice on road!" );
            if ( temp == 32 )
            {
               Console.WriteLine(
                  "Temp exactly freezing, beware of water." );
            }
            else
            {
               Console.WriteLine( "Watch for black ice! Temp: {0}", temp );
            }      // end else
         }         // end if (temp <= 32)
      }            // end main
   }               // end class
}                  // end namespace

if (temp <= 32)
{
   Console.WriteLine("Warning! Ice on road!");

if (temp == 32)

if (temp = 32)

switch (expression)
{
   case 
                     constant-expression:
      statement
                     jump-statement
   [default: statement]
}

#region Using directives

using System;
using System.Collections.Generic;
using System.Text;

#endregion

namespace SwitchStatement
{
   class SwitchStatement
   {
      static void Main( string[] args )
      {
         const int Democrat = 0;
         const int LiberalRepublican = 1;
         const int Republican = 2;
         const int Libertarian = 3;
         const int NewLeft = 4;
         const int Progressive = 5;

         int myChoice = Libertarian;

         switch ( myChoice )
         {
            case Democrat:
               Console.WriteLine( "You voted Democratic.
" );
               break;
            case LiberalRepublican:  // fall through
            //Console.WriteLine(
            //"Liberal Republicans vote Republican
");
            case Republican:
               Console.WriteLine( "You voted Republican.
" );
               break;
            case NewLeft:
               Console.WriteLine( "NewLeft is now Progressive" );
               goto case Progressive;
            case Progressive:
               Console.WriteLine( "You voted Progressive.
" );
               break;
            case Libertarian:
               Console.WriteLine( "Libertarians are voting Republican" );
               goto case Republican;
            default:
               Console.WriteLine( "You did not pick a valid choice.
" );
               break;
         }

         Console.WriteLine( "Thank you for voting." );
      }
   }
}

Case Is > 100
Case 50 to 60

case 1: // fall through ok 
case 2:

case 1:
    TakeSomeAction();
        // fall through not OK 
case 2:

case 1:
    TakeSomeAction(); 
    goto case 2; // explicit fall through 
case 2:

goto case Progressive;

Libertarians are voting Republican
You voted Republican.

Thank you for voting.

default:
    Console.WriteLine(
     "You did not pick a valid choice.
");

case "Libertarian":

C# provides an extensive suite of iteration statements, including for, while and do...while loops, as well as foreach loops (new to the C family but familiar to VB programmers). In addition, C# supports the goto, break, continue, and return jump statements.

#region Using directives

using System;
using System.Collections.Generic;
using System.Text;

#endregion

namespace UsingGoTo
{
   class UsingGoTo
   {
      static void Main( string[] args )
      {
         int i = 0;
      repeat:            // the label
         Console.WriteLine( "i: {0}", i );
         i++;
         if ( i < 10 )
            goto repeat;  // the dastardly deed
         return;
      }
   }
}

while (expression) statement

#region Using directives

using System;
using System.Collections.Generic;
using System.Text;

#endregion

namespace WhileLoop
{
   class WhileLoop
   {
      static void Main( string[] args )
      {
         int i = 0;
         while ( i < 10 )
         {
            Console.WriteLine( "i: {0}", i );
            i++;
         }
         return;
      }
   }
}

do 
                     statement 
                     while 
                     expression

#region Using directives

using System;
using System.Collections.Generic;
using System.Text;

#endregion

namespace DoWhile
{
   class DoWhile
   {
      static void Main( string[] args )
      {
         int i = 11;
         do
         {
            Console.WriteLine( "i: {0}", i );
            i++;
         } while ( i < 10 );
         return 0;
      }
   }
}

for ([initializers]; [expression]; [iterators]) 
                     statement

#region Using directives

using System;
using System.Collections.Generic;
using System.Text;

#endregion

namespace ForLoop
{
   class ForLoop
   {
      static void Main( string[] args )
      {
         for ( int i = 0; i < 100; i++ )
         {
            Console.Write( "{0} ", i );

            if ( i % 10 == 0 )
            {
               Console.WriteLine( "	{0}", i );
            }
         }
         return ;
      }
   }
}

Output:
0       0
1 2 3 4 5 6 7 8 9 10    10
11 12 13 14 15 16 17 18 19 20   20
21 22 23 24 25 26 27 28 29 30   30
31 32 33 34 35 36 37 38 39 40   40
41 42 43 44 45 46 47 48 49 50   50
51 52 53 54 55 56 57 58 59 60   60
61 62 63 64 65 66 67 68 69 70   70
71 72 73 74 75 76 77 78 79 80   80
81 82 83 84 85 86 87 88 89 90   90
91 92 93 94 95 96 97 98 99

if ( i % 10   == 0)

#region Using directives

using System;
using System.Collections.Generic;
using System.Text;

#endregion

namespace ForLoopScope
{
   class ForLoopScope
   {
      static void Main( string[] args )
      {
         for ( int i = 0; i < 100; i++ )
         {
            Console.Write( "{0} ", i );

            if ( i % 10 == 0 )
            {
               Console.WriteLine( "	{0}", i );
            }
         }         Console.WriteLine( "
 Final value of i: {0}", i );
      }
   }
}

         for (int i=0;i<100;i++)
         {
            if (i%10 == 0)
            {
               Console.WriteLine("	{0}", i);
            }
         }

         for ( int i = 0; i < 100; i++ )
         {
            if ( i % 10 == 0 )
            {
               Console.WriteLine("	{0}", i);
            }
         }

#region Using directives

using System;
using System.Collections.Generic;
using System.Text;

#endregion

namespace ContinueBreak
{
   class ContinueBreak
   {
      static void Main( string[] args )
      {
         string signal = "0";      // initialize to neutral
         while ( signal != "X" )      // X indicates stop
         {
            Console.Write( "Enter a signal: " );
            signal = Console.ReadLine( );

            // do some work here, no matter what signal you 
            // receive 
            Console.WriteLine( "Received: {0}", signal );

            if ( signal == "A" )
            {
               // faulty - abort signal processing
               // Log the problem and abort.
               Console.WriteLine( "Fault! Abort
" );
               break;
            }

            if ( signal == "0" )
            {
               // normal traffic condition
               // log and continue on
               Console.WriteLine( "All is well.
" );
               continue;
            }

            // Problem. Take action and then log the problem
            // and then continue on
            Console.WriteLine( "{0} -- raise alarm!
",
               signal );
         }  // end while
      }     // end main
   }        // end class
}           // end namespace

Output:
Enter a signal: 0
Received: 0
All is well.

Enter a signal: B
Received: B
B -- raise alarm!

Enter a signal: A
Received: A
Fault! Abort

Press any key to continue

The section titled “Expressions,” earlier in this chapter, demonstrates the use of the assignment operator. This symbol causes the operand on the left side of the operator to have its value changed to whatever is on the right side of the operator.

C# uses five mathematical operators: four for standard calculations and a fifth to return the remainder in integer division. The following sections consider the use of these operators.

#region Using directives

using System;
using System.Collections.Generic;
using System.Text;

#endregion

namespace DivisionModulus
{
   class DivisionModulus
   {
      static void Main( string[] args )
      {
         int i1, i2;
         float f1, f2;
         double d1, d2;
         decimal dec1, dec2;

         i1 = 17;
         i2 = 4;
         f1 = 17f;
         f2 = 4f;
         d1 = 17;
         d2 = 4;
         dec1 = 17;
         dec2 = 4;
         Console.WriteLine( "Integer:	{0}
float:		{1}",
             i1 / i2, f1 / f2 );
         Console.WriteLine( "double:		{0}
decimal:	{1}",
             d1 / d2, dec1 / dec2 );
         Console.WriteLine( "
Modulus:	{0}", i1 % i2 );

      }
   }
}

Output:
Integer:        4
float:          4.25
double:         4.25
decimal:        4.25

Modulus:        1

Console.WriteLine("Integer:	{0}
float:		{1}
",
    i1/i2, f1/f2);

"Integer:	{0}

float:		{1}

Console.WriteLine("
Modulus:	{0}", i1%i2);

A common requirement is to add a value to a variable, subtract a value from a variable, or otherwise change the mathematical value, and then to assign that new value back to the same variable. You might even want to assign the result to another variable altogether. The following two sections discuss these cases respectively.

mySalary = mySalary + 5000;

mySalary = mySalary * 5000;
mySalary = mySalary - 5000;

mySalary += 5000;
mySalary *= 5000;
mySalary -= 5000;

myAge++;

firstValue = secondValue++;

firstValue = secondValue++;  // postfix

firstValue = ++secondValue;  // prefix

#region Using directives

using System;
using System.Collections.Generic;
using System.Text;

#endregion

namespace PrefixPostfix
{
   class PrefixPostfix
   {
      static void Main( string[] args )
      {
         int valueOne = 10;
         int valueTwo;
         valueTwo = valueOne++;
         Console.WriteLine( "After postfix: {0}, {1}", valueOne,
         valueTwo );
         valueOne = 20;
         valueTwo = ++valueOne;
         Console.WriteLine( "After prefix: {0}, {1}", valueOne,
         valueTwo );

      }
   }
}

Output:
After postfix: 11, 10
After prefix: 21, 21

Relational operators are used to compare two values, and then return a Boolean (true or false). The greater-than operator (>), for example, returns true if the value on the left of the operator is greater than the value on the right. Thus, 5 > 2 returns the value true, while 2 > 5 returns the value false.

The relational operators for C# are shown in Table 3-3. This table assumes two variables: bigValue and smallValue, in which bigValue has been assigned the value 100 and smallValue the value 50.

==

bigValue == 100
bigValue == 80

true 
false

!=

bigValue != 100
bigValue != 80

false
true

>

bigValue > smallValue

true

>=

bigValue >= smallValue
smallValue >= bigValue

true
false

<

bigValue < smallValue

false

<=

smallValue <= bigValue
bigValue <= smallValue

true
false

Each relational operator acts as you might expect. However, take note of the equals operator (==), which is created by typing two equals signs (=) in a row (i.e., without any space between them); the C# compiler treats the pair as a single operator.

The C# equality operator (==) tests for equality between the objects on either side of the operator. This operator evaluates to a Boolean value (true or false). Thus, the statement:

myX == 5;

evaluates to true if and only if myX is a variable whose value is 5.

If statements (discussed earlier in this chapter) test whether a condition is true. Often you will want to test whether two conditions are both true, or whether only one is true, or none is true. C# provides a set of logical operators for this, as shown in Table 3-4. This table assumes two variables, x and y, in which x has the value 5 and y the value 7.

and

&&

(x == 3) && (y == 7)

false

or

||

(x == 3) || (y == 7)

true

not

!

! (x == 3)

true

The and operator tests whether two statements are both true. The first line in Table 3-4 includes an example that illustrates the use of the and operator:

(x == 3) && (y == 7)

The entire expression evaluates false because one side (x == 3) is false.

With the or operator, either or both sides must be true; the expression is false only if both sides are false. So, in the case of the example in Table 3-4:

(x == 3) || (y == 7)

the entire expression evaluates true because one side (y==7) is true.

With a not operator, the statement is true if the expression is false, and vice versa. So, in the accompanying example:

! (x == 3)

the entire expression is true because the tested expression (x==3) is false. (The logic is “it is true that it is not true that x is equal to 3.”)

int x = 8;
if ((x == 8) || (y == 12))

int x = 8;
if ((x == 5) && (y == 12))

The compiler must know the order in which to evaluate a series of operators. For example, if I write:

myVariable = 5 + 7 * 3;

there are three operators for the compiler to evaluate (=, +, and *). It could, for example, operate left to right, which would assign the value 5 to myVariable, then add 7 to the 5 (12) and multiply by 3 (36)—but of course then it would throw that 36 away. This is clearly not what is intended.

The rules of precedence tell the compiler which operators to evaluate first. As is the case in algebra, multiplication has higher precedence than addition, so 5+7*3 is equal to 26 rather than 36. Both addition and multiplication have higher precedence than assignment, so the compiler will do the math, and then assign the result (26) to myVariable only after the math is completed.

In C#, parentheses are also used to change the order of precedence much as they are in algebra. Thus, you can change the result by writing:

myVariable = (5+7) * 3;

Grouping the elements of the assignment in this way causes the compiler to add 5+7, multiply the result by 3, and then assign that value (36) to myVariable. Table 3-5 summarizes operator precedence in C#.

(x) x.y x->y f(x) a[x] x++ x-- new typeof sizeof checked unchecked stackalloc

+ - ! ~ ++x -- x (T)x *x &x

* / %

+ -

<< >>

< > <= >= is as

== !=

&

^

|

&&

||

?:

= *= /= %= += -= <<= >>= &= ^= |=

In some complex equations you might need to nest your parentheses to ensure the proper order of operations. Let’s assume I want to know how many seconds my family wastes each morning. It turns out that the adults spend 20 minutes over coffee each morning and 10 minutes reading the newspaper. The children waste 30 minutes dawdling and 10 minutes arguing.

Here’s my algorithm:

(((minDrinkingCoffee  + minReadingNewspaper )* numAdults ) + 
((minDawdling + minArguing) * numChildren)) * secondsPerMinute.

Although this works, it is hard to read and hard to get right. It’s much easier to use interim variables:

wastedByEachAdult = minDrinkingCoffee  +  minReadingNewspaper;
wastedByAllAdults =  wastedByEachAdult * numAdults;
wastedByEachKid =  minDawdling  + minArguing;
wastedByAllKids =  wastedByEachKid * numChildren;
wastedByFamily = wastedByAllAdults + wastedByAllKids;
totalSeconds =  wastedByFamily * 60;

The latter example uses many more interim variables, but it is far easier to read, understand, and (most important) debug. As you step through this program in your debugger, you can see the interim values and make sure they are correct.

Although most operators require one term (e.g., myValue++) or two terms (e.g., a+b), there is one operator that has three: the ternary operator (?:):

conditional-expression 
                  ? 
                  expression1 : expression2

This operator evaluates a conditional expression (an expression that returns a value of type bool), and then invokes either expression1 if the value returned from the conditional expression is true, or expression2 if the value returned is false. The logic is “if this is true, do the first; otherwise do the second.” Example 3-18 illustrates.

#region Using directives

using System;
using System.Collections.Generic;
using System.Text;

#endregion

namespace TernaryOperator
{
   class TernaryOperator
   {
      static void Main( string[] args )
      {
         int valueOne = 10;
         int valueTwo = 20;

         int maxValue = valueOne > valueTwo ? valueOne : valueTwo;

         Console.WriteLine( "ValueOne: {0}, valueTwo: {1}, maxValue: {2}",
             valueOne, valueTwo, maxValue );

      }
   }
}

Output:
ValueOne: 10, valueTwo: 20, maxValue: 20

In Example 3-18, the ternary operator is being used to test whether valueOne is greater than valueTwo. If so, the value of valueOne is assigned to the integer variable maxValue; otherwise the value of valueTwo is assigned to maxValue.

#define DEBUG defines a preprocessor identifier, DEBUG. Although other preprocessor directives can come anywhere in your code, identifiers must be defined before any other code, including using statements.

You can test whether DEBUG has been defined with the #if statement. Thus, you can write:

#define DEBUG

//... some normal code - not affected by preprocessor

#if DEBUG
   // code to include if debugging
#else
  // code to include if not debugging
#endif

//... some normal code - not affected by preprocessor

When the preprocessor runs, it sees the #define statement and records the identifier DEBUG. The preprocessor skips over your normal C# code and then finds the #if - #else - #endif block.

The #if statement tests for the identifier DEBUG, which does exist, and so the code between #if and #else is compiled into your program—but the code between #else and #endif is not compiled. That code doesn’t appear in your assembly at all; it is as if it were left out of your source code.

Had the #if statement failed—that is, if you had tested for an identifier that did not exist—the code between #if and #else would not be compiled, but the code between #else and #endif would be compiled.

Undefine an identifier with #undef. The preprocessor works its way through the code from top to bottom, so the identifier is defined from the #define statement until the #undef statement, or until the program ends. Thus, if you write:

#define DEBUG

#if DEBUG
   // this code will be compiled
#endif

#undef DEBUG

#if DEBUG
   // this code will not be compiled
#endif

the first #if will succeed (DEBUG is defined), but the second will fail (DEBUG has been undefined).

There is no switch statement for the preprocessor, but the #elif and #else directives provide great flexibility. The #elif directive allows the else-if logic of “if DEBUG then action one, else if TEST then action two, else action three”:

#if DEBUG
   // compile this code if debug is defined
#elif TEST
   // compile this code if debug is not defined
   // but TEST is defined
#else
  // compile this code if neither DEBUG nor TEST
  // is defined
#endif

In this example, the preprocessor first tests to see if the identifier DEBUG is defined. If it is, the code between #if and #elif will be compiled, and the rest of the code until #endif will not be compiled.

If (and only if) DEBUG is not defined, the preprocessor next checks to see if TEST is defined. Note that the preprocessor will not check for TEST unless DEBUG is not defined. If TEST is defined, the code between the #elif and the #else directives will be compiled. If it turns out that neither DEBUG nor TEST is defined, the code between the #else and the #endif statements will be compiled.

The #region preprocessor directive marks an area of text with a comment. The principal use of this preprocessor directive is to allow tools such as Visual Studio .NET to mark off areas of code and collapse them in the editor with only the region’s comment showing.

For example, when you create a Windows application (covered in Chapter 13), Visual Studio creates a region for code generated by the designer. When the region is expanded, it looks like Figure 3-3. (Note: I’ve added the rectangle and highlighting to make it easier to find the region.)

Figure 3-3. Expanding the Visual Studio code region

You can see the region marked by the #region and #endregion preprocessor directives. When the region is collapsed, however, all you see is the region comment (Windows Form Designer generated code), as shown in Figure 3-4.

Figure 3-4. Code region is collapsed