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

Each built-in type has a specific and unchanging size. Table 3-1 lists many of the built-in types offered by C#.

In addition to these primitive types, C# has two other value types: enum (which I’ll explain later in this chapter) and struct (discussed in Chapter 4).

float someFloat = 57f;
;

Create a variable of type short named x and initialize with the value 5
short x = 5;
// create an integer variable y and initialize with the value held in x
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, and one of the consequences of this requirement is that 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.

using System;


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#. 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.

using System;


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 an object whose value can’t be changed. Variables are a powerful tool, but there are times when you want to use 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;

You must initialize a constant when you declare it, 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.

using System;




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 = 212;


    }
  }
}

Example 3-4 creates two symbolic integer constants: FreezingPoint and BoilingPoint. As a matter of style, constant names are typically written in Pascal notation or all caps, but the language certainly does not require this (see the sidebar, "Camel and Pascal Notation“).

myCamelNotationIdentifier

MyPascalNotationIdentifier

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 to uncomment 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 can 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
};

We consider the optional attributes and modifiers later in this book. For now, just 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.

using System;


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 identifier (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 one.

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.

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 series of characters.

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

string myString;

You create a string literal 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";

We cover strings in much greater detail in Chapter 10.

An identifier is just the name the programmer chooses for the types, methods, variables, constants, objects, and so on in the program. An identifier must begin with a letter or an underscore, and remember that identifiers are case-sensitive, so C# treats someName and SomeName as two different identifiers.

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

You can create an unconditional branch 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.

using System;




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 also 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. I provide additional information about the first three jump statements later in this chapter. The return statement returns control to the calling method. I discuss the final statement, throw, in Chapter 11.

A conditional branch is created by a conditional statement, which is signaled by a keyword 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 = 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: 30 ValueTwo: 31

if (someCondition)
   someStatement;

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

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


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!");

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

if (temp == 32)

if (temp = 32)

if ( 32 == temp )

using System;
class SwitchStatement
{
    enum Party
    {
        Democrat,
        ConservativeRepublican,
        Republican,
        Libertarian,
        Liberal,
        Progressive,
    };
  static void Main(string[] args)
    {
        Party myChoice = Party.Libertarian;


        switch (myChoice)
        {
            case Party.Democrat:
                Console.WriteLine("You voted Democratic.
");
                break;
            case Party.ConservativeRepublican: // fall through
            //Console.WriteLine(
            //"Conservative Republicans are voting Republican
");
            case Party.Republican:
                Console.WriteLine("You voted Republican.
");
                break;
            case Party.Liberal:
                Console.WriteLine(" Liberal is now Progressive");
                goto case Party.Progressive;
            case Party.Progressive:
                Console.WriteLine("You voted Progressive.
");
                break;
            case Party.Libertarian:
                Console.WriteLine("Libertarians are voting Democratic");
                goto case Party.Democrat;
            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 (no statement for case 1)
case 2:

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

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

goto case Progressive;

Libertarians are voting Democrat now.
You voted Democrat.


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 int Main( string[] args )
    {
      int i = 11;
      do
      {
        Console.WriteLine( "i: {0}", i );
        i++;
      } while ( i < 10 );
      return 0;
    }
  }
}

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

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




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

The = 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. Statements that evaluate to a value are called expressions. You may be surprised how many statements do evaluate to a value. For example, an assignment such as:

myVariable = 57;

is an expression; it evaluates to the value assigned, which, in this case, is 57.

Note that the preceding statement assigns the value 57 to the variable myVariable. The assignment operator (=) doesn’t test equality; rather, it causes whatever is on the right side (57) to be assigned to whatever is on the left side (myVariable).

Because myVariable = 57 (read aloud as “assign the numeric value 57 to the variable whose name is myVariable”) is an expression that evaluates to 57, it can be used as part of another assignment operator, such as:

mySecondVariable = myVariable = 57;

In this statement, the literal value 57 is assigned to the variable myVariable. The value of that assignment (57) is then assigned to the second variable, mySecondVariable. Thus, the value 57 is assigned to both variables.

You can therefore initialize any number of variables to the same value with one statement:

a = b = c = d = e = 20;

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, whereas 2 > 5 returns the value false.

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

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# equals 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 expression:

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 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.

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.”)

The compiler must know the order in which to evaluate a series of operators. For example, if we 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.

if ( (x != null) && (x.IsBigAndScary ) )

If ( x ! = null )
{
   if (x.IsBigAndScary )
 {
     // do something
  }
}

if ( (x == null) ||  (x.IsBigAndScary) )

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#, listing the operators with the topmost layers being evaluated before the layers that come below.

In some complex equations, you might need to nest your parentheses to ensure the proper order of operations. Let’s assume we want to know how many seconds a fictional 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 our algorithm:

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

Although this works, it is hard to read and 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, to understand, and (most important) to 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 returns the value of 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, return the first; otherwise, return the second.” Example 3-18 illustrates.

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


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 though 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.

You 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 whether 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 whether 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 #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.