Plus and Minus Unary Operators (+, -)

Sometimes you may want to change the sign of a numeric value. In these cases, the unary minus operator (-) comes in handy. For example, Listing 4.2 changes the total current U.S. debt to a negative value to indicate that it is an amount owed.

Listing 4.2: Specifying Negative Values¹

1. As of July 1, 2020, according to www.treasurydirect.gov.

Click here to view code image

// National debt to the penny
decimal debt = -26457079712930.80M;

Using the minus operator is equivalent to subtracting the operand from zero.

The unary plus operator (+) rarely² has any effect on a value. It is a superfluous addition to the C# language and was included for the sake of symmetry.

2. The unary + operator is defined to take operands of type int, uint, long, ulong, float, double, and decimal (and nullable versions of those types). Using it on other numeric types such as short will convert its operand to one of these types as appropriate.

Arithmetic Binary Operators (+, -, *, /, %)

Binary operators require two operands. C# uses infix notation for binary operators: The operator appears between the left and right operands. The result of every binary operator other than assignment must be used somehow—for example, by using it as an operand in another expression such as an assignment.

The subtraction example in Listing 4.3 illustrates the use of a binary operator—more specifically, an arithmetic binary operator. The operands appear on each side of the arithmetic operator, and then the calculated value is assigned. The other arithmetic binary operators are addition (+), division (/), multiplication (*), and remainder (% [sometimes called the mod operator]).

Listing 4.3: Using Binary Operators

Click here to view code image

class Division
{
  static void Main()
  {
      int numerator;
      int denominator;
      int quotient;
      int remainder;

      System.Console.Write("Enter the numerator: ");
      numerator = int.Parse(System.Console.ReadLine());

      System.Console.Write("Enter the denominator: ");
      denominator = int.Parse(System.Console.ReadLine());

      quotient = numerator / denominator;                                
      remainder = numerator % denominator;                               

      System.Console.WriteLine(
          $"{numerator} / {denominator} = {quotient} with remainder
{remainder}");
  }
}

Output 4.1 shows the results of Listing 4.3.

Output 4.1

Click here to view code image

Enter the numerator: 23
Enter the denominator: 3
23 / 3 = 7 with remainder 2

In the highlighted assignment statements, the division and remainder operations are executed before the assignments. The order in which operators are executed is determined by their precedence and associativity. The precedence for the operators used so far is as follows:

1. *, /, and % have the highest precedence.

2. + and - have lower precedence.

3. = has the lowest precedence of these six operators.

Therefore, you can assume that the statement behaves as expected, with the division and remainder operators executing before the assignment.

If you forget to assign the result of one of these binary operators, you will receive the compile error shown in Output 4.2.

Output 4.2

Click here to view code image

... error CS0201: Only assignment, call, increment, decrement,
and new object expressions can be used as a statement

class FortyTwo
{
  static void Main()
  {
      short windSpeed = 42;
      System.Console.WriteLine(
          "The original Tacoma Bridge in Washington
was "
          + "brought down by a "
          + windSpeed + " mile/hour wind.");
  }
}

The original Tacoma Bridge in Washington
was brought down by a 42 mile/hour wind.

int n = '3' + '4';
char c = (char)n;
System.Console.WriteLine(c);  // Writes out g

g

int distance = 'f' – 'c';
System.Console.WriteLine(distance);

3

float n=0f;
// Displays: NaN
System.Console.WriteLine(n / 0);

NaN

// Displays: -Infinity
System.Console.WriteLine(-1f / 0);
// Displays: Infinity
System.Console.WriteLine(3.402823E+38f * 2f);

-Infinity
Infinity

Compound Mathematical Assignment Operators (+=, -=, *=, /=, %=)

Chapter 1 discussed the simple assignment operator, which places the value of the right-hand side of the operator into the variable on the left-hand side. Compound mathematical assignment operators combine common binary operator calculations with the assignment operator. For example, consider Listing 4.10.

Listing 4.10: Common Increment Calculation

Click here to view code image

int x = 123;
x = x + 2;

In this assignment, first you calculate the value of x + 2, and then you assign the calculated value back to x. Since this type of operation is performed relatively frequently, an assignment operator exists to handle both the calculation and the assignment with one operator. The += operator increments the variable on the left-hand side of the operator with the value on the right-hand side of the operator, as shown in Listing 4.11.

Listing 4.11: Using the += Operator

Click here to view code image

int x = 123;
x += 2;

This code, therefore, is equivalent to Listing 4.10.

Numerous other compound assignment operators exist to provide similar functionality. You can also use the assignment operator with subtraction, multiplication, division, and remainder operators (as demonstrated in Listing 4.12).

Listing 4.12: Other Assignment Operator Examples

Click here to view code image

x -= 2;
x /= 2;
x *= 2;
x %= 2;

Increment and Decrement Operators (++, --)

C# includes special unary operators for incrementing and decrementing counters. The increment operator, ++, increments a variable by one each time it is used. In other words, all of the code lines shown in Listing 4.13 are equivalent.

Listing 4.13: Increment Operator

Click here to view code image

spaceCount = spaceCount + 1;
spaceCount += 1;
spaceCount++;

Similarly, you can decrement a variable by 1 using the decrement operator, --. Therefore, all of the code lines shown in Listing 4.14 are also equivalent.

Listing 4.14: Decrement Operator

Click here to view code image

lines = lines - 1;
lines -= 1;
lines--;

We saw that the assignment operator first computes the value to be assigned, and then performs the assignment. The result of the assignment operator is the value that was assigned. The increment and decrement operators are similar: They compute the value to be assigned, perform the assignment, and result in a value. It is therefore possible to use the assignment operator with the increment or decrement operator, though doing so carelessly can be extremely confusing. See Listing 4.16 and Output 4.10 for an example.

Listing 4.16: Using the Post-increment Operator

Click here to view code image

int count = 123;
int result;
result = count++;                                             
System.Console.WriteLine(
  $"result = {result} and count = {count}");

Output 4.10

result = 123 and count = 124

You might be surprised that result was assigned the value that was count before count was incremented. Where you place the increment or decrement operator determines whether the assigned value should be the value of the operand before or after the calculation. If you want the value of result to be the value assigned to count, you need to place the operator before the variable being incremented, as shown in Listing 4.17.

Listing 4.17: Using the Pre-increment Operator

Click here to view code image

   int count = 123;
   int result;
   result = ++count;                                          
   System.Console.WriteLine(
     $"result = {result} and count = {count}");

Output 4.11 shows the results of Listing 4.17.

Output 4.11

result = 124 and count = 124

In this example, the increment operator appears before the operand, so the result of the expression is the value assigned to the variable after the increment. If count is 123, ++count will assign 124 to count and produce the result 124. By contrast, the postfix increment operator count++ assigns 124 to count and produces the value that count held before the increment: 123. Regardless of whether the operator is postfix or prefix, the variable count will be incremented before the value is produced; the only difference is which value is produced. The difference between prefix and postfix behavior is illustrated in Listing 4.18. The resultant output is shown in Output 4.12.

Listing 4.18: Comparing the Prefix and Postfix Increment Operators

Click here to view code image

class IncrementExample
{
  static void Main()
  {
      int x = 123;
      // Displays 123, 124, 125
      System.Console.WriteLine($"{x++}, {x++}, {x}");
      // x now contains the value 125
      // Displays 126, 127, 127
      System.Console.WriteLine($"{++x}, {++x}, {x}");
      // x now contains the value 127
  }
}

Output 4.12

123, 124, 125
126, 127, 127

As Listing 4.18 demonstrates, where the increment and decrement operators appear relative to the operand can affect the result produced by the expression. The result of the prefix operators is the value that the variable had before it was incremented or decremented. The result of the postfix operators is the value that the variable had after it was incremented or decremented. Use caution when embedding these operators in the middle of a statement. When in doubt as to what will happen, use these operators independently, placing them within their own statements. This way, the code is also more readable and there is no mistaking the intention.

Constant Expressions and Constant Locals

Chapter 3 discussed literal values, or values embedded directly into the code. It is possible to combine multiple literal values in a constant expression using operators. By definition, a constant expression is one that the C# compiler can evaluate at compile time (instead of evaluating it when the program runs) because it is composed entirely of constant operands. Constant expressions can then be used to initialize constant locals, which allow you to give a name to a constant value (similar to the way local variables allow you to give a name to a storage location). For example, the computation of the number of seconds in a day can be a constant expression that is then used in other expressions by name.

The const keyword in Listing 4.19 declares a constant local. Since a constant local is, by definition, the opposite of a variable—constant means “not able to vary”—any attempt to modify the value later in the code would result in a compile-time error.

Listing 4.19: Declaring a Constant

Note that the expression assigned to secondsPerWeek in Listing 4.19 is a constant expression because all the operands in the expression are also constants.

if Statement

The if statement is one of the most common statements in C#. It evaluates a Boolean expression (an expression that results in either true or false) called the condition. If the condition is true, the consequence statement is executed. An if statement may optionally have an else clause that contains an alternative statement to be executed if the condition is false. The general form is as follows:

if (condition)
  consequence-statement
else
  alternative-statement

In Listing 4.20, if the user enters 1, the program displays Play against computer selected. Otherwise, it displays Play against another player.

Listing 4.20: if/else Statement Example

Click here to view code image

class TicTacToe      // Declares the TicTacToe class
{
  static void Main() // Declares the entry point of the program
  {
      string input;

      // Prompt the user to select a 1- or 2-player game
      System.Console.Write(
          "1 – Play against the computer
" +
          "2 – Play against another player.
" +
          "Choose:"
      );
      input = System.Console.ReadLine();

      if(input=="1")                                           
          // The user selected to play the computer            
          System.Console.WriteLine(                            
              "Play against computer selected.");              
      else                                                     
          // Default to 2 players (even if user didn't enter 2)
          System.Console.WriteLine(                            
              "Play against another player.");                 
  }
}

Nested if

Sometimes code requires multiple if statements. The code in Listing 4.21 first determines whether the user has chosen to exit by entering a number less than or equal to 0; if the user has not chosen to exit, it checks whether the user knows the maximum number of turns in tic-tac-toe.

Listing 4.21: Nested if Statements

Click here to view code image

1.   class TicTacToeTrivia
2.   {
3.     static void Main()
4.     {
5.         int input;    // Declare a variable to store the input
6.
7.         System.Console.Write(
8.             "What is the maximum number " +
9.             "of turns in tic-tac-toe?" +
10.            "(Enter 0 to exit.): ");
11.
12.        // int.Parse() converts the ReadLine()
13.        // return to an int data type
14.        input = int.Parse(System.Console.ReadLine());
15.
16.        if (input <= 0) // line 16
17.                // Input is less than or equal to 0
18.            System.Console.WriteLine("Exiting...");
19.        else
20.            if (input < 9)  // line 20
21.                // Input is less than 9
22.                System.Console.WriteLine(
23.                    $"Tic-tac-toe has more than {input}" +
24.                    " maximum turns.");
25.            else
26.                if(input > 9) // line 26
27.                    // Input is greater than 9
28.                    System.Console.WriteLine(
29.                        $"Tic-tac-toe has fewer than {input}" +
30.                        " maximum turns.");
31.                else
32.                    // Input equals 9
33.                    System.Console.WriteLine( // line 33
34.                        "Correct, tic-tac-toe " +
35.                        "has a maximum of 9 turns.");
36.    }
37.  }

Output 4.13 shows the results of Listing 4.21.

Output 4.13

Click here to view code image

What is the maximum number of turns in tic-tac-toe? (Enter 0 to exit.): 9
Correct, tic-tac-toe has a maximum of 9 turns.

Assume the user enters 9 when prompted at line 14. Here is the execution path:

1. Line 16: Check if input is less than 0. Since it is not, jump to line 20.

2. Line 20: Check if input is less than 9. Since it is not, jump to line 26.

3. Line 26: Check if input is greater than 9. Since it is not, jump to line 33.

4. Line 33: Display that the answer was correct.

Listing 4.21 contains nested if statements. To clarify the nesting, the lines are indented. However, as you learned in Chapter 1, whitespace does not affect the execution path. If this code was written without the indenting and without the newlines, the execution would be the same. The code that appears in the nested if statement in Listing 4.22 is equivalent to Listing 4.21.

Listing 4.22: if/else Formatted Sequentially

Click here to view code image

if (input < 0)
  System.Console.WriteLine("Exiting...");
else if (input < 9)
  System.Console.WriteLine(
      $"Tic-tac-toe has more than {input}" +
      " maximum turns.");
else if(input < 9)
  System.Console.WriteLine(
      $"Tic-tac-toe has less than {input}" +
      " maximum turns.");
else
  System.Console.WriteLine(
      "Correct, tic-tac-toe has a maximum " +
      " of 9 turns.");

Although the latter format is more common, in each situation you should use the format that results in the clearest code.

Both of the if statement listings omit the braces. However, as discussed next, this is not in accordance with the guidelines, which advocate the use of code blocks except, perhaps, in the simplest of single-line scenarios.

Relational and Equality Operators

Relational and equality operators determine whether a value is greater than, less than, or equal to another value. Table 4.2 lists all the relational and equality operators. All are binary operators.

The C# syntax for equality uses ==, just as many other programming languages do. For example, to determine whether input equals 9, you use input == 9. The equality operator uses two equal signs to distinguish it from the assignment operator, =. The exclamation point signifies NOT in C#, so to test for inequality you use the inequality operator, !=.

Relational and equality operators always produce a bool value, as shown in Listing 4.30.

Listing 4.30: Assigning the Result of a Relational Operator to a bool Variable

bool result = 70 > 7;

In the full tic-tac-toe program listing, you use the equality operator to determine whether a user has quit. The Boolean expression in Listing 4.31 includes an OR (||) logical operator, which the next section discusses in detail.

Listing 4.31: Using the Equality Operator in a Boolean Expression

Click here to view code image

if (input.Length == 0  || input == "quit")
{
  System.Console.WriteLine($"Player {currentPlayer} quit!!");
  break;
}

Logical Boolean Operators

The logical operators have Boolean operands and produce a Boolean result. Logical operators allow you to combine multiple Boolean expressions to form more complex Boolean expressions. The logical operators are |, ||, &, &&, and ^, corresponding to OR, AND, and exclusive OR. The | and & versions of OR and AND are rarely used for Boolean logic, for reasons which we discuss in this section.

if ((hourOfTheDay > 23) || (hourOfTheDay < 0))
  System.Console.WriteLine("The time you entered is invalid.");

if ((10 < hourOfTheDay) && (hourOfTheDay < 24))
  System.Console.WriteLine(
  "Hi-Ho, Hi-Ho, it's off to work we go.");

Logical Negation Operator (!)

The logical negation operator, or NOT operator, !, inverts a bool value. This operator is a unary operator, meaning it requires only one operand. Listing 4.34 demonstrates how it works, and Output 4.16 shows the result.

Listing 4.34: Using the Logical Negation Operator

Click here to view code image

bool valid = false;
bool result = !valid;                                         
// Displays "result = True"
System.Console.WriteLine($"result = { result }");

Output 4.16

result = True

At the beginning of Listing 4.34, valid is set to false. You then use the negation operator on valid and assign the value to result.

Conditional Operator (?:)

As an alternative to using an if-else statement to select one of two values, you can use the conditional operator. The conditional operator uses both a question mark and a colon; the general format is as follows:

Click here to view code image

condition ? consequence : alternative

The conditional operator is a ternary operator because it has three operands: condition, consequence, and alternative. (As it is the only ternary operator in C#, it is often called the ternary operator, but it is clearer to refer to it by its name than by the number of operands it takes.) Like the logical operators, the conditional operator uses a form of short-circuiting. If the condition evaluates to true, the conditional operator evaluates only consequence. If the conditional evaluates to false, it evaluates only alternative. The result of the operator is the evaluated expression.

Listing 4.35 illustrates the use of the conditional operator. The full listing of this program appears in Chapter04TicTacToe.cs of the source code.

Listing 4.35: Conditional Operator

Click here to view code image

class TicTacToe
{
  static void Main()
  {
      // Initially set the currentPlayer to Player 1
      int currentPlayer = 1;

      // ...

      for (int turn = 1; turn <= 10; turn++)
      {
         // ...

         // Switch players
         currentPlayer = (currentPlayer == 2) ? 1 : 2;         
      }
  }
}

The program swaps the current player. To do so, it checks whether the current value is 2. This is the conditional portion of the conditional expression. If the result of the condition is true, the conditional operator results in the consequence value, 1. Otherwise, it results in the alternative value, 2. Unlike in an if statement, the result of the conditional operator must be assigned (or passed as a parameter); it cannot appear as an entire statement on its own.

The C# language requires that the consequence and alternative expressions in a conditional operator be consistently typed and that the consistent type be determined without examination of the surrounding context of the expression. For example, f ? "abc" : 123 is not a legal conditional expression because the consequence and alternative are a string and a number, neither of which is convertible to the other. Even if you say object result = f ? "abc" : 123;, the C# compiler will flag this expression as illegal because the type that is consistent with both expressions (i.e., object) is found outside the conditional expression.

Checking for null and Not null

It turns out there are multiple ways to check for null, as shown in Table 4.4.

string? uri = null;
// ...

if(uri != null)
{
    System.Console.WriteLine(
        $"Uri is: { uri }");
}
else // (uri == null)
{
    System.Console.WriteLine(
        "Uri is null");
}

string? uri = null;
// ...

if(object.ReferenceEquals(
  uri, null))
{
    System.Console.WriteLine(
        "Uri is null");
}

if( uri is object )
{
    System.Console.WriteLine(
        $"Uri is: { uri }");
}
else // (uri is null)
{
    System.Console.WriteLine(
        "Uri is null");
}

if( uri is { } )
{
    System.Console.WriteLine(
        $"Uri is: { uri }");
}
else
{
    System.Console.WriteLine(
        "Uri is null");
}

Of course, having multiple ways to check whether a value is null raises the question as to which one to use. Obviously, if you are programming with C# 6.0 or earlier, the equality/inequality operators are the only option aside from using is object to check for not null. Similarly, given C# 7.0’s enhanced is operator, you can use the is null syntax to check for null. In fact, this approach is preferred because the is operator’s behavior can’t be changed, so there are no performance implications to consider. Lastly, property pattern matching (C# 8.0) with is { } will check for not null; however, but unlike using is object, it won’t report a warning when checking for not null on a non-nullable type.

In summary, use is object when checking for not null and use is null when checking for null in C# 7.0 or later. Prior to C# 7.0, use object.ReferenceEquals(<target>, null) to guarantee the expected behavior or == null if there is no overloading and optimizing readability.

Rows 2 and 3 of Table 4.4 introduce pattern matching, a concept covered in more detail in Chapter 7.

Null-Coalescing and Null-Coalescing Assignment Operators (??, ??=)

The null-coalescing operator is a concise way to express “If this value is null, then use this other value.” It has the following form:

expression1 ?? expression2

The null-coalescing operator also uses a form of short-circuiting. If expression1 is not null, its value is the result of the operation and the other expression is not evaluated. If expression1 does evaluate to null, the value of expression2 is the result of the operator. Unlike the conditional operator, the null-coalescing operator is a binary operator.

Listing 4.36 illustrates the use of the null-coalescing operator.

Listing 4.36: Null-Coalescing Operator

Click here to view code image

string? fullName = GetDefaultDirectory();
// ...

// Null-coalescing operator
string fileName = GetFileName() ?? "config.json";
string directory = GetConfigurationDirectory() ??
    GetApplicationDirectory() ??
    System.Environment.CurrentDirectory;
// Null-coalescing assignment operator
fullName ??= $"{ directory }/{ fileName }";

// ...

In this listing, we use the null-coalescing operator to set fileName to "default.txt" if GetFileName() is null. If GetFileName() is not null, fileName is simply assigned the value of GetFileName().

The null-coalescing operator “chains” nicely. For example, an expression of the form x ?? y ?? z results in x if x is not null; otherwise, it results in y if y is not null; otherwise, it results in z. That is, it goes from left to right and picks out the first non-null expression, or uses the last expression if all the previous expressions were null. The assignment of directory in Listing 4.36 provides an example.

C# 8.0 provides a combination of the null-coalescing operator and the assignment operator with the addition of the null-coalescing assignment operator. With this operator, you can evaluate if the left-hand side is null and assign the value on the righthand side if it is. Listing 4.36 uses this operator when assigning fullName.

Null-Conditional Operator (?., ?[])

In recognition of the frequency of the pattern of checking for null before invoking a member, C# 6.0 introduced the ?. operator, known as the null-conditional operator, as shown in Listing 4.37.

Listing 4.37: Null-Conditional Operator

Click here to view code image

string[]? segments = null;
// ...

int? length = segments?.Length;
if (length is object && length != 0){
    uri = string.Join('/', segments!);
}

// Null-conditional with array accessor
// assuming we know there is at least one element
// uri = segments?[0];

if (uri is null || length is 0){
    System.Console.WriteLine(
        "There were no segments to combine.");
}
else
{
    System.Console.WriteLine(
        $"Uri: { uri }");
}

The null-conditional operator checks whether the operand (the segments in Listing 4.37) is null prior to invoking the method or property (in this case, Length). The logically equivalent explicit code would be the following (although in the C# 6.0 syntax, the value of segments is evaluated only once):

Click here to view code image

int? length =
    (segments != null) ? (int?)segments.Length : null

An important thing to note about the null-conditional operator is that it always produces a nullable value. In this example, even though the string.Length member produces a non-nullable int, invoking Length with the null-conditional operator produces a nullable int (int?).

You can also use the null-conditional operator with the array accessor. For example, segments?[0] will produce the first element of the segments array if the segments array was not null. Using the array accessor version of the null-conditional operator is relatively rare, however, as it is only useful when you don’t know whether the operand is null, but you do know the number of elements, or at least whether a particular element exists.

What makes the null-conditional operator especially convenient is that it can be chained (with and without more null-coalescing operators). For example, in the following code, both ToLower() and StartWith() will be invoked only if both segments and segments[0] are not null:

Click here to view code image

segments?[0]?.ToLower().StartsWith("file:");

In this example, of course, we assume that the elements in segments could potentially be null, so the declaration (assuming C# 8.0) would more accurately have been

string?[]? segments;

The segments array is nullable, in other words, and each of its elements is a nullable string.

When null-conditional expressions are chained, if the first operand is null, the expression evaluation is short-circuited, and no further invocation within the expression call chain will occur. You can also chain a null-coalescing operator at the end of the expression so that if the operand is null, you can specify which default value to use:

Click here to view code image

string uri = segments?[0]?.ToLower().StartsWith(
    "file:")??"intellitect.com";

Notice that the data type resulting from the null-coalescing operator is not nullable (assuming the right-hand side of the operator ["intellitect.com" in this example] is not null—which would make little sense).

Be careful, however, that you don’t unintentionally neglect additional null values. Consider, for example, what would happen if ToLower() (hypothetically, in this case) returned null. In this scenario, a NullReferenceException would occur upon invocation of StartsWith(). This doesn’t mean you must use a chain of null-conditional operators, but rather that you should be intentional about the logic. In this example, because ToLower() can never be null, no additional null-conditional operator is necessary.

Although perhaps a little peculiar (in comparison to other operator behavior), the return of a nullable value type is produced only at the end of the call chain. Consequently, calling the dot (.) operator on Length allows invocation of only int (not int?) members. However, encapsulating segments?.Length in parentheses—thereby forcing the int? result via parentheses operator precedence—will invoke the int? return and make the Nullable<T> specific members (HasValue and Value) available.

Null-Forgiving Operator (!)

Notice that the Join() invocation of Listing 4.37 includes an exclamation point after segments:

Click here to view code image

uri = string.Join('/', segments!);

At this point in the code, segments.Length is assigned to the length variable, making it not null. Furthermore, the if statement verifies that it is not null because length is not null.

Click here to view code image

if (length is object && length != 0){ }

However, the compiler has the capability to make the same determination. And, since Join() requires a non-nullable string array, it issues a warning when passing an unmodified segments variable whose declaration was nullable. To avoid the warning, we can add the null-forgiving operator (!), starting in C# 8.0. It declares to the compiler that we, as the programmer, know better, and that the segments variable is not null. Then, at compile time, the compiler assumes we know better and dismisses the warning (although the runtime still checks that our assertion is not null).

Unfortunately, this example is naïve, if not dangerous, because the null-conditional operator gives a false sense of security, implying that if segments isn’t null, then the element must exist. Of course, this isn’t the case: The element may not exist even if segments isn’t null.

Shift Operators (<<, >>, <<=, >>=)

Sometimes you want to shift the binary value of a number to the right or left. In executing a left shift, all bits in a number’s binary representation are shifted to the left by the number of locations specified by the operand on the right of the shift operator. Zeroes are then used to backfill the locations on the right side of the binary number. A right-shift operator does almost the same thing in the opposite direction. However, if the number is a negative value of a signed type, the values used to backfill the left side of the binary number are 1s, rather than 0s. The shift operators are >> and <<, known as the right-shift and left-shift operators, respectively. In addition, there are combined shift and assignment operators, <<= and >>=.

Consider the following example. Suppose you had the int value -7, which would have a binary representation of 1111 1111 1111 1111 1111 1111 1111 1001. In Listing 4.39, you right-shift the binary representation of the number –7 by two locations.

Listing 4.39: Using the Right-Shift Operator

Click here to view code image

int x;
x = (-7 >> 2); // 11111111111111111111111111111001 becomes
               // 11111111111111111111111111111110
// Write out "x is -2."
System.Console.WriteLine($"x = { x }.");

Output 4.17 shows the results of Listing 4.39.

Output 4.17

x = -2.

Because of the right shift, the value of the bit in the rightmost location has “dropped off” the edge, and the negative bit indicator on the left shifts by two locations to be replaced with 1s. The result is -2.

Although legend has it that x << 2 is faster than x * 4, you should not use bit-shift operators for multiplication or division. This difference might have held true for certain C compilers in the 1970s, but modern compilers and modern microprocessors are perfectly capable of optimizing arithmetic. Using shifting for multiplication or division is confusing and frequently leads to errors when code maintainers forget that the shift operators are lower precedence than the arithmetic operators.

Bitwise Operators (&, |, ^)

In some instances, you might need to perform logical operations, such as AND, OR, and XOR, on a bit-by-bit basis for two operands. You do this via the &, |, and ^ operators, respectively.

Listing 4.40 demonstrates the use of these bitwise operators. The results of Listing 4.40 appear in Output 4.18.

Listing 4.40: Using Bitwise Operators

Click here to view code image

byte and, or, xor;
and = 12 & 7;   // and = 4
or = 12 | 7;    // or = 15
xor = 12 ^ 7;   // xor = 11
System.Console.WriteLine(
    $"and = { and } 
or = { or }
xor = { xor }");

Output 4.18

and = 4
or = 15
xor = 11

In Listing 4.40, the value 7 is the mask; it is used to expose or eliminate specific bits within the first operand using the particular operator expression. Note that, unlike the AND (&&) operator, the & operator always evaluates both sides even if the left portion is false. Similarly, the | version of the OR operator is not “short-circuiting”: It always evaluates both operands, even if the left operand is true. The bit versions of the AND and OR operators, therefore, are not short-circuiting.

To convert a number to its binary representation, you need to iterate across each bit in a number. Listing 4.41 is an example of a program that converts an integer to a string of its binary representation. The results of Listing 4.41 appear in Output 4.19.

Listing 4.41: Getting a String Representation of a Binary Display

Click here to view code image

class BinaryConverter
{
  static void Main()
  {
      const int size = 64;
      ulong value;
      char bit;

      System.Console.Write ("Enter an integer: ");
      // Use long.Parse() to support negative numbers
      // Assumes unchecked assignment to ulong
      value = (ulong)long.Parse(System.Console.ReadLine());

      // Set initial mask to 100...
      ulong mask = 1UL << size - 1;
      for (int count = 0; count < size; count++)
      {
          bit = ((mask & value) != 0) ? '1': '0';
          System.Console.Write(bit);
          // Shift mask one location over to the right
          mask >>= 1;
      }
      System.Console.WriteLine();
  }
}

Output 4.19

Click here to view code image

Enter an integer: 42
0000000000000000000000000000000000000000000000000000000000101010

Within each iteration of the for loop in Listing 4.41 (as discussed later in this chapter), we use the right-shift assignment operator to create a mask corresponding to each bit position in value. By using the & bit operator to mask a particular bit, we can determine whether the bit is set. If the mask test produces a nonzero result, we write 1 to the console; otherwise, we write 0. In this way, we create output describing the binary value of an unsigned long.

Note also that the parentheses in (mask & value) != 0 are necessary because inequality is higher precedence than the AND operator. Without the explicit parentheses, this expression would be equivalent to mask & (value != 0), which does not make any sense; the left side of the & is a ulong and the right side is a bool.

This particular example is provided for learning purposes only. There is actually a built-in CLR method, System.Convert.ToString(value, 2), that does such a conversion. In fact, the second argument specifies the base (e.g., 2 for binary, 10 for decimal, or 16 for hexadecimal), allowing for more than just conversion to binary.

Bitwise Compound Assignment Operators (&=, |=, ^=)

Not surprisingly, you can combine these bitwise operators with assignment operators as follows: &=, |=, and ^=. As a result, you could take a variable, OR it with a number, and assign the result back to the original variable, which Listing 4.42 demonstrates.

Listing 4.42: Using Logical Assignment Operators

Click here to view code image

byte and = 12, or = 12, xor = 12;
and &= 7;   // and = 4
or  |= 7;   // or = 15
xor ^= 7;   // xor = 11
System.Console.WriteLine(
    $"and = { and } 
or = { or }
xor = { xor }");

The results of Listing 4.42 appear in Output 4.20.

Output 4.20

and = 4
or = 15
xor = 11

Combining a bitmap with a mask using something like fields &= mask clears the bits in fields that are not set in the mask. The opposite, fields &= ~mask, clears the bits in fields that are set in mask.

Bitwise Complement Operator (~)

The bitwise complement operator takes the complement of each bit in the operand, where the operand can be an int, uint, long, or ulong. The expression ~1, therefore, returns the value with binary notation 1111 1111 1111 1111 1111 1111 1111 1110, and ~(1<<31) returns the number with binary notation 0111 1111 1111 1111 1111 1111 1111 1111.

The while and do/while Loops

Thus far you have learned how to write programs that do something only once. However, computers can easily perform similar operations multiple times. To do so, you need to create an instruction loop. The first instruction loop we discuss is the while loop, because it is the simplest conditional loop. The general form of the while statement is as follows:

while (condition)
  statement

The computer will repeatedly execute the statement that is the “body” of the loop as long as the condition (which must be a Boolean expression) evaluates to true. If the condition evaluates to false, code execution skips the body and executes the code following the loop statement. Note that statement will continue to execute even if it causes the condition to become false. The loop exits only when the condition is reevaluated “at the top of the loop.” The Fibonacci calculator shown in Listing 4.43 demonstrates the while loop.

Listing 4.43: while Loop Example

Click here to view code image

class FibonacciCalculator
{
  static void Main()
  {
      decimal current;
      decimal previous;
      decimal temp;
      decimal input;

      System.Console.Write("Enter a positive integer:");

      // decimal.Parse converts the ReadLine to a decimal
      input = decimal.Parse(System.Console.ReadLine());

      // Initialize current and previous to 1, the first
      // two numbers in the Fibonacci series
      current = previous = 1;

      // While the current Fibonacci number in the series is
      // less than the value input by the user
      while (current <= input)                                
      {                                                       
          temp = current;                                     
          current = previous + current;                       
          previous = temp; // Executes even if previous       
          // statement caused current to exceed input         
      }                                                       

      System.Console.WriteLine(
        $"The Fibonacci number following this is { current }");
  }
}

A Fibonacci number is a member of the Fibonacci series, which includes all numbers that are the sum of the previous two numbers in the series, beginning with 1 and 1. In Listing 4.43, you prompt the user for an integer. Then you use a while loop to find the first Fibonacci number that is greater than the number the user entered.

The do/while loop is very similar to the while loop except that a do/while loop is preferred when the number of repetitions is from 1 to n and n is not known when iterating begins. This pattern frequently occurs when prompting a user for input. Listing 4.44 is taken from the tic-tac-toe program.

Listing 4.44: do/while Loop Example

Click here to view code image

// Repeatedly request player to move until he
// enters a valid position on the board
bool valid;
do
{
  valid = false;

  // Request a move from the current player
  System.Console.Write(
      $"
Player {currentPlayer}: Enter move:");
  input = System.Console.ReadLine();

  // Check the current player's input
  // ...
} while (!valid);

In Listing 4.44, you initialize valid to false at the beginning of each iteration, or loop repetition. Next, you prompt and retrieve the number the user input. Although not shown here, you then check whether the input was correct, and if it was, you assign valid equal to true. Since the code uses a do/while statement rather than a while statement, the user will be prompted for input at least once.

The general form of the do/while loop is as follows:

do
  statement
while (condition);

As with all the control flow statements, a code block is generally used as the single statement to allow multiple statements to be executed as the loop body. However, any single statement except for a labeled statement or a local variable declaration can be used.

The for Loop

The for loop iterates a code block until a specified condition is reached. In that way, it is very similar to the while loop. The difference is that the for loop has built-in syntax for initializing, incrementing, and testing the value of a counter, known as the loop variable. Because there is a specific location in the loop syntax for an increment operation, the increment and decrement operators are frequently used as part of a for loop.

Listing 4.45 shows the for loop used to display an integer in binary form. The results of this listing appear in Output 4.21.

Listing 4.45: Using the for Loop

Click here to view code image

class BinaryConverter
{
  static void Main()
  {
      const int size = 64;
      ulong value;
      char bit;

      System.Console.Write("Enter an integer: ");
      // Use long.Parse()to support negative numbers
      // Assumes unchecked assignment to ulong
      value = (ulong)long.Parse(System.Console.ReadLine());

      // Set initial mask to 100...
      ulong mask = 1UL << size - 1;
      for (int count = 0; count < size; count++)
      {
          bit = ((mask & value) > 0) ? '1': '0';
          System.Console.Write(bit);
          // Shift mask one location over to the right
          mask >>= 1;
      }
  }
}

Output 4.21

Click here to view code image

Enter an integer: -42
1111111111111111111111111111111111111111111111111111111111010110

Listing 4.45 performs a bit mask 64 times—once for each bit in the number. The three parts of the for loop header first declare and initialize the variable count, then describe the condition that must be met for the loop body to be executed, and finally describe the operation that updates the loop variable. The general form of the for loop is as follows:

Click here to view code image

for (initial ; condition ; loop)
  statement

Here is a breakdown of the for loop:

• The initial section performs operations that precede the first iteration. In Listing 4.45, it declares and initializes the variable count. The initial expression does not have to be a declaration of a new variable (though it frequently is). It is possible, for example, to declare the variable beforehand and simply initialize it in the for loop, or to skip the initialization section entirely by leaving it blank. Variables declared here are in scope throughout the header and body of the for statement.

• The condition portion of the for loop specifies an end condition. The loop exits when this condition is false, exactly like the while loop does. The for loop will execute the body only as long as the condition evaluates to true. In Listing 4.45, the loop exits when count is greater than or equal to 64.

• The loop expression executes after each iteration. In Listing 4.45, count++ executes after the right shift of the mask (mask >>= 1) but before the condition is evaluated. During the 64th iteration, count is incremented to 64, causing the condition to become false and therefore terminating the loop.

• The statement portion of the for loop is the “loop body” code that executes while the conditional expression remains true.

If you wrote out each for loop execution step in pseudocode without using a for loop expression, it would look like this:

1. Declare and initialize count to 0.

2. If count is less than 64, continue to step 3; otherwise, go to step 7.

3. Calculate bit and display it.

4. Shift the mask.

5. Increment count by 1.

6. Jump back to line 2.

7. Continue the execution of the program after the loop.

The for statement doesn’t require any of the elements in its header. The expression for(;;){ ... } is perfectly valid, although there still needs to be a means to escape from the loop so that it will not continue to execute indefinitely. (If the condition is missing, it is assumed to be the constant true.)

The initial and loop expressions have an unusual syntax to support loops that require multiple loop variables, as shown in Listing 4.46.

Listing 4.46: for Loop Using Multiple Expressions

Click here to view code image

for (int x = 0, y = 5; ((x <= 5) && (y >=0 )); y--, x++)
{
  System.Console.Write(
      $"{ x }{ ((x > y) ? '>' : '<' )}{ y }	";
}

The results of Listing 4.46 appear in Output 4.22.

Output 4.22

Click here to view code image

0<5    1<4    2<3     3>2    4>1    5>

Here the initialization clause contains a complex declaration that declares and initializes two loop variables, but this is at least similar to a declaration statement that declares multiple local variables. The loop clause is quite unusual, as it can consist of a comma-separated list of expressions, not just a single expression.

The for loop is little more than a more convenient way to write a while loop; you can always rewrite a for loop like this:

{
  initial;
  while (condition)
  {
    statement;
    loop;
  }
}

The foreach Loop

The last loop statement in the C# language is foreach. The foreach loop iterates through a collection of items, setting a loop variable to represent each item in turn. In the body of the loop, operations may be performed on the item. A nice property of the foreach loop is that every item is iterated over exactly once; it is not possible to accidentally miscount and iterate past the end of the collection, as can happen with other loops.

The general form of the foreach statement is as follows:

Click here to view code image

foreach(type variable in collection)
  statement

Here is a breakdown of the foreach statement:

• type is used to declare the data type of the variable for each item within the collection. It may be var, in which case the compiler infers the type of the item from the type of the collection.

• variable is a read-only variable into which the foreach loop will automatically assign the next item within the collection. The scope of the variable is limited to the body of the loop.

• collection is an expression, such as an array, representing any number of items.

• statement is the loop body that executes for each iteration of the loop.

Consider the foreach loop in the context of the simple example shown in Listing 4.47.

Listing 4.47: Determining Remaining Moves Using the foreach Loop

Click here to view code image

class TicTacToe      // Declares the TicTacToe class
{
  static void Main() // Declares the entry point of the program
  {
      // Hardcode initial board as follows:
      // ---+---+---
      //  1 | 2 | 3
      // ---+---+---
      //  4 | 5 | 6
      // ---+---+---
      //  7 | 8 | 9
      // ---+---+---
      char[] cells = {
        '1', '2', '3', '4', '5', '6', '7', '8', '9'
      };

      System.Console.Write(
          "The available moves are as follows: ");

      // Write out the initial available moves
      foreach (char cell in cells)                            
      {                                                       
        if (cell != 'O' && cell != 'X')                       
        {                                                     
            System.Console.Write($"{ cell } ");               
        }                                                     
      }                                                       
  }
}

Output 4.23 shows the results of Listing 4.47.

Output 4.23

Click here to view code image

The available moves are as follows: 1 2 3 4 5 6 7 8 9

When the execution engine reaches the foreach statement, it assigns to the variable cell the first item in the cells array—in this case, the value '1'. It then executes the code within the block that makes up the foreach loop body. The if statement determines whether the value of cell is 'O' or 'X'. If it is neither, the value of cell is written out to the console. The next iteration then assigns the next array value to cell, and so on.

Note that the compiler prevents modification of the variable (cell) during the execution of a foreach loop. Also, the loop variable has a subtly different behavior starting in C# 5.0 than it did in previous versions; the difference is apparent only when the loop body contains a lambda expression or anonymous method that uses the loop variable. See Chapter 13 for details.

The Basic switch Statement

A basic switch statement is simpler to understand than a complex if statement when you have a value that must be compared against different constant values. The switch statement looks like this:

switch (expression)
{
    case constant:
      statements
    default:
      statements
}

Here is a breakdown of the switch statement:

• expression is the value that is being compared against the different constants. The type of this expression determines the “governing type” of the switch. Allowable governing data types are bool, sbyte, byte, short, ushort, int, uint, long, ulong, char, any enum type (covered in Chapter 9), the corresponding nullable types of each of those value types, and string.

• constant is any constant expression compatible with the governing type.

• A group of one or more case labels (or the default label) followed by a group of one or more statements is called a switch section. The pattern given previously has two switch sections; Listing 4.49 shows a switch statement with three switch sections.

• statements is one or more statements to be executed when the expression equals one of the constant values mentioned in a label in the switch section. The end point of the group of statements must not be reachable. Typically, the last statement is a jump statement such as a break, return, or goto statement.

A switch statement should have at least one switch section; switch(x){} is legal but will generate a warning. Also, the guideline provided earlier was to avoid omitting braces in general. One exception to this rule of thumb is to omit braces for case and break statements because they serve to indicate the beginning and end of a block.

Listing 4.49, with a switch statement, is semantically equivalent to the series of if statements in Listing 4.48.

Listing 4.49: Replacing the if Statement with a switch Statement

Click here to view code image

static bool ValidateAndMove(
  int[] playerPositions, int currentPlayer, string input)
{
  bool valid = false;

  // Check the current player's input
  switch (input)
  {
    case "1" :
    case "2" :
    case "3" :
    case "4" :
    case "5" :
    case "6" :
    case "7" :
    case "8" :
    case "9" :
      // Save/move as the player directed
      ...
      valid = true;
      break;

    case "" :
    case "quit" :
      valid = true;
      break;
    default :
      // If none of the other case statements
      // is encountered, then the text is invalid
      System.Console.WriteLine(
        "
ERROR:  Enter a value from 1-9. "
        + "Push ENTER to quit");
      break;
  }

  return valid;
}

In Listing 4.49, input is the test expression. Since input is a string, the governing type is string. If the value of input is one of the strings 1, 2, 3, 4, 5, 6, 7, 8, or 9, the move is valid and you change the appropriate cell to match that of the current user’s token (X or O). Once execution encounters a break statement, control leaves the switch statement.

The next switch section describes how to handle the empty string or the string quit; it sets valid to true if input equals either value. The default switch section is executed if no other switch section had a case label that matched the test expression.

There are several things to note about the switch statement:

• A switch statement with no switch sections will generate a compiler warning, but the statement will still compile.

• Switch sections can appear in any order; the default section does not have to appear last. In fact, the default switch section does not have to appear at all—it is optional.

• The C# language requires that every switch section, including the last section, ends with a jump statement (see the next section). This means that switch sections usually end with a break, return, throw, or goto.

C# 7.0 introduced an improvement to the switch statement that enables pattern matching so that any data type—not just the limited few identified earlier—can be used for the switch expression. Pattern matching enables the use of switch statements based on the type of the switch expression and the use of case labels that also declare variables. Lastly, pattern matching switch statements support conditional expressions so that not only the type but also a Boolean expression at the end of the case label can identify which case label should execute. For more information on pattern matching switch statements, see Chapter 7.

The break Statement

To escape out of a loop or a switch statement, C# uses a break statement. Whenever the break statement is encountered, control immediately leaves the loop or switch. Listing 4.50 examines the foreach loop from the tic-tac-toe program.

Listing 4.50: Using break to Escape Once a Winner Is Found

Click here to view code image

class TicTacToe      // Declares the TicTacToe class
{
  static void Main() // Declares the entry point of the program
  {
      int winner = 0;
      // Stores locations each player has moved
      int[] playerPositions = { 0, 0 };

      // Hardcoded board position:
      //  X | 2 | O
      // ---+---+---
      //  O | O | 6
      // ---+---+---
      //  X | X | X
      playerPositions[0] = 449;
      playerPositions[1] = 28;

      // Determine if there is a winner
      int[] winningMasks = {
            7, 56, 448, 73, 146, 292, 84, 273 };

      // Iterate through each winning mask to determine
      // if there is a winner
      foreach (int mask in winningMasks)                        
      {                                                         
          if ((mask & playerPositions[0]) == mask)
          {
              winner = 1;
              break;                                            
          }
          else if ((mask & playerPositions[1]) == mask)
          {
              winner = 2;
              break;                                            
          }
      }                                                         

      System.Console.WriteLine(
          $"Player { winner } was the winner");
  }
}

Output 4.24 shows the results of Listing 4.50.

Output 4.24

Player 1 was the winner

Listing 4.50 uses a break statement when a player holds a winning position. The break statement forces its enclosing loop (or a switch statement) to cease execution, and control moves to the next line outside the loop. For this listing, if the bit comparison returns true (if the board holds a winning position), the break statement causes control to jump and display the winner.

The continue Statement

You might have a block containing a series of statements within a loop. If you determine that some conditions warrant executing only a portion of these statements for some iterations, you can use the continue statement to jump to the end of the current iteration and begin the next iteration. The continue statement exits the current iteration (regardless of whether additional statements remain) and jumps to the loop condition. At that point, if the loop conditional is still true, the loop will continue execution.

Listing 4.52 uses the continue statement so that only the letters of the domain portion of an email are displayed. Output 4.25 shows the results of Listing 4.52.

Listing 4.52: Determining the Domain of an Email Address

Click here to view code image

class EmailDomain
{
  static void Main()
  {
      string email;
      bool insideDomain = false;
      System.Console.WriteLine("Enter an email address: ");
      email = System.Console.ReadLine();

      System.Console.Write("The email domain is: ");

      // Iterate through each letter in the email address
      foreach (char letter in email)
      {
          if (!insideDomain)
          {
              if (letter == '@')
              {
                  insideDomain = true;
              }
              continue;
          }

          System.Console.Write(letter);
      }
  }
}

Output 4.25

Click here to view code image

Enter an email address:
[email protected]
The email domain is: IntelliTect.com

In Listing 4.52, if you are not yet inside the domain portion of the email address, you can use a continue statement to move control to the end of the loop, and process the next character in the email address.

You can almost always use an if statement in place of a continue statement, and this format is usually more readable. The problem with the continue statement is that it provides multiple flows of control within a single iteration, which compromises readability. In Listing 4.53, the example in Listing 4.52 has been rewritten by replacing the continue statement with the if/else construct to demonstrate a more readable version that does not use the continue statement.

Listing 4.53: Replacing a continue Statement with an if Statement

Click here to view code image

foreach (char letter in email)
{
  if (insideDomain)
  {
      System.Console.Write(letter);
  }

  else
  {
      if (letter == '@')
      {
          insideDomain = true;
      }
  }
}

The goto Statement

Early programming languages lacked the relatively sophisticated “structured” control flows that modern languages such as C# have as a matter of course. Instead, they relied on simple conditional branching (if) and unconditional branching (goto) statements for most of their control flow needs. The resultant programs were often hard to understand. The continued existence of a goto statement within C# seems like an anachronism to many experienced programmers. However, C# supports goto, and it is the only method for supporting fall-through within a switch statement. In Listing 4.54, if the /out option is set, code execution jumps to the default case using the goto statement, and similarly for /f.

Listing 4.54: Demonstrating a switch with goto Statements

Click here to view code image

// ...
static void Main(string[] args)
{
  bool isOutputSet = false;
  bool isFiltered = false;

  foreach (string option in args)
  {
      switch (option)
      {
          case "/out":
              isOutputSet = true;
              isFiltered = false;
              goto default;                                    
          case "/f":
              isFiltered = true;
              isRecursive = false;
              goto default;                                    
          default:
              if (isRecursive)
              {
                  // Recurse down the hierarchy
                  // ...
              }
              else if (isFiltered)
              {
                  // Add option to list of filters
                  // ...
              }
              break;
      }
  }

  // ...

}

Output 4.26 shows how to execute the code shown in Listing 4.54.

Output 4.26

Click here to view code image

C:SAMPLES>Generate /out fizbottle.bin /f "*.xml" "*.wsdl"

To branch to a switch section label other than the default label, you can use the syntax goto case constant;, where constant is the constant associated with the case label you wish to branch to. To branch to a statement that is not associated with a switch section, precede the target statement with any identifier followed by a colon; you can then use that identifier with the goto statement. For example, you could have a labeled statement myLabel : Console.WriteLine();. The statement goto myLabel; would then branch to the labeled statement. Fortunately, C# prevents you from using goto to branch into a code block; instead, goto may be used only to branch within a code block or to an enclosing code block. By enforcing these restrictions, C# avoids most of the serious goto abuses possible in other languages.

In spite of the improvements, use of goto is generally considered to be inelegant, difficult to understand, and symptomatic of poorly structured code. If you need to execute a section of code multiple times or under different circumstances, either use a loop or extract code to a method of its own.

Excluding and Including Code (#if, #elif, #else, #endif)

Perhaps the most common use of preprocessor directives is in controlling when and how code is included. For example, to write code that could be compiled by both C# 2.0 and later compilers and the prior version 1.0 compilers, you would use a preprocessor directive to exclude C# 2.0–specific code when compiling with a version 1.0 compiler. You can see this in the tic-tac-toe example and in Listing 4.55.

Listing 4.55: Excluding C# 2.0 Code from a C# 1.x Compiler

Click here to view code image

#if CSHARP2PLUS
System.Console.Clear();
#endif

In this case, you call the System.Console.Clear() method. Using the #if and #endif preprocessor directives, this line of code will be compiled only if the preprocessor symbol CSHARP2PLUS is defined.

Another use of preprocessor directives would be to handle differences among platforms, such as surrounding Windows- and Linux-specific APIs with WINDOWS and LINUX #if directives. Developers often use these directives in place of multiline comments (/*...*/) because they are easier to remove by defining the appropriate symbol or via a search and replace.

A final common use of the directives is for debugging. If you surround code with an #if DEBUG, you will remove the code from a release build on most IDEs. The IDEs define the DEBUG symbol by default in a debug compile and RELEASE by default for release builds.

To handle an else-if condition, you can use the #elif directive within the #if directive instead of creating two entirely separate #if blocks, as shown in Listing 4.56.

Listing 4.56: Using #if, #elif, and #endif Directives

Click here to view code image

#if LINUX
...
#elif WINDOWS
...
#endif

Defining Preprocessor Symbols (#define, #undef)

You can define a preprocessor symbol in twov ways. The first is with the #define directive, as shown in Listing 4.57.

Listing 4.57: A #define Example

Click here to view code image

#define CSHARP2PLUS

The second method uses the define command line. Output 4.27 demonstrates this with Dotnet command-line interface.

Output 4.27

Click here to view code image

>dotnet.exe -define:CSHARP2PLUS TicTacToe.cs

To add multiple definitions, separate them with a semicolon. The advantage of the define compiler option is that no source code changes are required, so you may use the same source files to produce two different binaries.

To undefine a symbol, you use the #undef directive in the same way you use #define.

Emitting Errors and Warnings (#error, #warning)

Sometimes you may want to flag a potential problem with your code. You do this by inserting #error and #warning directives to emit an error or a warning, respectively. Listing 4.58 uses the tic-tac-toe example to warn that the code does not yet prevent players from entering the same move multiple times. The results of Listing 4.58 appear in Output 4.28.

Listing 4.58: Defining a Warning with #warning

Click here to view code image

#warning    "Same move allowed multiple times."

Output 4.28

Click here to view code image

Performing main compilation...
...	ictactoe.cs(471,16): warning CS1030: #warning: '"Same move allowed
multiple times."'

Build complete -- 0 errors, 1 warnings

By including the #warning directive, you ensure that the compiler will report a warning, as shown in Output 4.28. This particular warning is a way of flagging the fact that there is a potential enhancement or bug within the code. It could be a simple way of reminding the developer of a pending task.

Turning Off Warning Messages (#pragma)

Warnings are helpful because they point to code that could potentially be troublesome. However, sometimes it is preferred to turn off specific warnings explicitly because they can be ignored legitimately. C# provides the preprocessor #pragma directive for just this purpose (see Listing 4.59).⁵

5. Introduced in C# 2.0.

Listing 4.59: Using the Preprocessor #pragma Directive to Disable the #warning Directive

Click here to view code image

#pragma warning disable CS1030

Note that warning numbers are prefixed with the letters CS in the compiler output, a prefix that is optional in the #pragma directive. Such a number corresponds to the warning error number emitted by the compiler when there is no preprocessor command.

To reenable the warning, #pragma supports the restore option following the warning, as shown in Listing 4.60.

Listing 4.60: Using the Preprocessor #pragma Directive to Restore a Warning

Click here to view code image

#pragma warning restore  CS1030

In combination, these two directives can surround a particular block of code where the warning is explicitly determined to be irrelevant.

Perhaps one of the most common warnings to disable is CS1591. This warning appears when you elect to generate XML documentation using the /doc compiler option, but you neglect to document all of the public items within your program.

nowarn:<warn list> Option

In addition to the #pragma directive, C# compilers generally support the nowarn=<warn list> option. This achieves the same result as #pragma, except that instead of adding it to the source code, you can insert the command as a compiler option. The nowarn option affects the entire compilation, whereas the #pragma option affects only the file in which it appears. To turn off the CS0219 warning, for example, you would use the command line as shown in Output 4.29.

Output 4.29

Click here to view code image

> dotnet build /p:NoWarn="0219"

Specifying Line Numbers (#line)

The #line directive controls on which line number the C# compiler reports an error or warning. It is used predominantly by utilities and designers that emit C# code. In Listing 4.61, the actual line numbers within the file appear on the left.

Listing 4.61: The #line Preprocessor Directive

Click here to view code image

124        #line 113 "TicTacToe.cs"
125        #warning "Same move allowed multiple times."
126        #line default

Including the #line directive causes the compiler to report the warning found on line 125 as though it were on line 113, as shown in the compiler error message in Output 4.30.

Output 4.30

Click here to view code image

Performing main compilation...
...	ictactoe.cs(113,18): warning CS1030: #warning: '"Same move allowed
multiple times."'

Build complete -- 0 errors, 1 warnings

Following the #line directive with default reverses the effect of all prior #line directives and instructs the compiler to report true line numbers rather than the ones designated by previous uses of the #line directive.

Hints for Visual Editors (#region, #endregion)

C# contains two preprocessor directives, #region and #endregion, that are useful only within the context of visual code editors. Code editors, such as Microsoft Visual Studio, can search through source code and find these directives to provide editor features when writing code. C# allows you to declare a region of code using the #region directive. You must pair the #region directive with a matching #endregion directive, both of which may optionally include a descriptive string following the directive. In addition, you may nest regions within one another.

Listing 4.62 shows the tic-tac-toe program as an example.

Listing 4.62: #region and #endregion Preprocessor Directives

Click here to view code image

...
#region Display Tic-tac-toe Board

#if CSHARP2PLUS
  System.Console.Clear();
#endif

// Display the current board
border = 0;   //  set the first border (border[0] = "|")

// Display the top line of dashes
// ("
---+---+---
")
System.Console.Write(borders[2]);
foreach (char cell in cells)
{
  // Write out a cell value and the border that comes after it
  System.Console.Write($" { cell } { borders[border] }");

  // Increment to the next border
  border++;

  // Reset border to 0 if it is 3
  if (border == 3)
  {
      border = 0;
  }
}
#endregion Display Tic-tac-toe Board
...

These preprocessor directives are used, for example, with Microsoft Visual Studio. Visual Studio examines the code and provides a tree control to open and collapse the code (on the left-hand side of the code editor window) that matches the region demarcated by the #region directives (see Figure 4.5).

Activating Nullable Reference Types (#nullable)

As described in Chapter 3, the #nullable preprocessor directive activates (or deactivates) support for nullable reference types. #nullable enable turns on the nullable reference type feature, and #nullable disable turns it off. In addition, #nullable restore returns the nullable reference type feature back to the default value identified in the project file’s Nullable element.