Wrox.com Code Downloads for this Chapter

You can find the wrox.com code downloads for this chapter at www.wrox.com/go/beginningvisualc#2015programming on the Download Code tab. The code is in the Chapter 4 download and individually named according to the names throughout the chapter.

All of the C# code you've seen so far has had one thing in common. In each case, program execution has proceeded from one line to the next in top-to-bottom order, missing nothing. If all applications worked like this, then you would be very limited in what you could do. This chapter describes two methods for controlling program flow — that is, the order of execution of lines of C# code: branching and looping. Branching executes code conditionally, depending on the outcome of an evaluation, such as “Execute this code only if the variable myVal is less than 10.” Looping repeatedly executes the same statements, either a certain number of times or until a test condition has been reached.

Both of these techniques involve the use of Boolean logic. In the last chapter, you saw the bool type, but didn't actually do much with it. In this chapter, you'll use it a lot, so the chapter begins by discussing what is meant by Boolean logic, and then goes on to cover how you can use it in flow control scenarios.

Boolean Logic

The bool type introduced in the previous chapter can hold one of only two values: true or false. This type is often used to record the result of some operation, so that you can act on this result. In particular, bool types are used to store the result of a comparison.

For instance, consider the situation (mentioned in the chapter introduction) in which you want to execute code based on whether a variable, myVal, is less than 10. To do this, you need some indication of whether the statement “myVal is less than 10” is true or false — that is, you need to know the Boolean result of a comparison.

Boolean comparisons require the use of Boolean comparison operators (also known as relational operators), which are shown in Table 4.1.

In all cases in Table 4.1, var1 is a bool type variable, whereas the types of var2 and var3 may vary.

You might use operators such as these on numeric values in code:

bool isLessThan10;
isLessThan10 = myVal < 10;

The preceding code results in isLessThan10 being assigned the value true if myVal stores a value less than 10, or false otherwise.

You can also use these comparison operators on other types, such as strings:

bool isBenjamin;
isBenjamin = myString == "Benjamin";

Here, isBenjamin is true only if myString stores the string "Benjamin".

You can also compare variables with Boolean values:

bool isTrue;
isTrue = myBool == true;

Here, however, you are limited to the use of the == and != operators.

The & and | operators also have two similar operators, known as conditional Boolean operators, shown in Table 4.2.

The result of these operators is exactly the same as & and |, but there is an important difference in the way this result is obtained, which can result in better performance. Both of these look at the value of their first operands (var2 in Table 4.2) and, based on the value of this operand, may not need to process the second operands (var3 in Table 4.2) at all.

If the value of the first operand of the && operator is false, then there is no need to consider the value of the second operand, because the result will be false regardless. Similarly, the || operator returns true if its first operand is true, regardless of the value of the second operand.

Operator Precedence Updated

Now that you have a few more operators to consider, Table 3-10: “Operator Precedence” from the previous chapter should be updated to include them. The new order is shown in Table 4.4.

Precedence	Operators
Highest	++, −− (used as prefixes); (), +, – (unary), !, ˜
	*, /, %
	+, –
	,
	<, >, <=, >=
	==, !=
	&
	^
	|
	&&
	||
	=, *=, /=, %=, +=, −=, =, =, &=, ^=, |=
Lowest	++, –– (used as suffixes)

This adds quite a few more levels but explicitly defines how expressions such as the following will be evaluated, where the && operator is processed after the <= and >= operators (in this code var2 is an int value):

var1 = var2 <= 4 && var2 >= 2;

It doesn't hurt to add parentheses to make expressions such as this one clearer. The compiler knows what order to process operators in, but we humans are prone to forget such things (and you might want to change the order). Writing the previous expression as

var1 = (var2 <= 4) && (var2 >= 2);

solves this problem by explicitly ordering the computation.

Branching

Branching is the act of controlling which line of code should be executed next. The line to jump to is controlled by some kind of conditional statement. This conditional statement is based on a comparison between a test value and one or more possible values using Boolean logic.

This section describes three branching techniques available in C#:

• The ternary operator
• The if statement
• The switch statement

<test> ? <resultIfTrue>: <resultIfFalse>

string resultString = (myInteger < 10) ? "Less than 10"
                                  : "Greater than or equal to 10";

if (<test>)
   <code executed if <test> is true>;

if (<test>)
   <code executed if <test> is true>;
else
   <code executed if <test> is false>;

if (<test>)
{
   <code executed if <test> is true>;
}
else
{
   <code executed if <test> is false>;
}

string resultString = (myInteger < 10) ? "Less than 10"
                                  : "Greater than or equal to 10";

string resultString;
if (myInteger < 10)
   resultString = "Less than 10";
else
   resultString = "Greater than or equal to 10";

if (var1 == 1)
{
   // Do something.
}
else
{
   if (var1 == 2)
   {
      // Do something else.
   }
   else
   {
      if (var1 == 3 || var1 == 4)
      {
         // Do something else.
      }
      else
      {
         // Do something else.
      }
   }
}

if (var1 == 1)
{
   // Do something.
}
else if (var1 == 2)
{
   // Do something else.
}
else if (var1 == 3 || var1 == 4)
{
   // Do something else.
}
else
{
   // Do something else.
}

switch (<testVar>)
{
   case <comparisonVal1>:
      <code to execute if <testVar> == <comparisonVal1> >
      break;
   case <comparisonVal2>:
      <code to execute if <testVar> == <comparisonVal2> >
      break;
   …
   case <comparisonValN>:
      <code to execute if <testVar> == <comparisonValN> >
      break;
   default:
      <code to execute if <testVar> != comparisonVals>
      break;
}

switch (<testVar>)
{
   case <comparisonVal1>:
      <code to execute if <testVar> == <comparisonVal1> >
      goto case <comparisonVal2>;
   case <comparisonVal2>:
      <code to execute if <testVar> == <comparisonVal2> >
      break;
   …

switch (<testVar>)
{
   case <comparisonVal1>:
   case <comparisonVal2>:
      <code to execute if <testVar> == <comparisonVal1> or
                          <testVar> == <comparisonVal2> >
      break;
   …

while Loops

while loops are very similar to do loops, but they have one important difference: The Boolean test in a while loop takes place at the start of the loop cycle, not at the end. If the test evaluates to false, then the loop cycle is never executed. Instead, program execution jumps straight to the code following the loop.

Here's how while loops are specified:

while (<Test>)
{
   <code to be looped>
}

They can be used in almost the same way as do loops:

int i = 1;
while (i <= 10)
{
   WriteLine($"{i++}");
}

This code has the same result as the do loop shown earlier; it outputs the numbers 1 to 10 in a column. The following Try It Out demonstrates how you can modify the last example to use a while loop.

for Loops

The last type of loop to look at in this chapter is the for loop. This type of loop executes a set number of times and maintains its own counter. To define a for loop you need the following information:

• A starting value to initialize the counter variable
• A condition for continuing the loop, involving the counter variable
• An operation to perform on the counter variable at the end of each loop cycle

For example, if you want a loop with a counter that increments from 1 to 10 in steps of one, then the starting value is 1; the condition is that the counter is less than or equal to 10; and the operation to perform at the end of each cycle is to add 1 to the counter.

This information must be placed into the structure of a for loop as follows:

for (<initialization>; <condition>; <operation>)
{
   <code to loop>
}

This works exactly the same way as the following while loop:

<initialization>
while (<condition>)
{
   <code to loop>
   <operation>
}

Earlier, you used do and while loops to write out the numbers from 1 to 10. The code that follows shows what is required to do this using a for loop:

int i;
for (i = 1; i <= 10; ++i)
{
   WriteLine($"{i}");
}

The counter variable, an integer called i, starts with a value of 1 and is incremented by 1 at the end of each cycle. During each cycle, the value of i is written to the console.

When the code resumes after the loop, i has a value of 11. That's because at the end of the cycle where i is equal to 10, i is incremented to 11. This happens before the condition i <= 10 is processed, at which point the loop ends. As with while loops, for loops execute only if the condition evaluates to true before the first cycle, so the code in the loop doesn't necessarily run at all.

As a final note, you can declare the counter variable as part of the for statement, rewriting the preceding code as follows:

for (int i = 1; i <= 10; ++i)
{
   WriteLine($"{i}");
}

If you do this, though, the variable i won't be accessible from code outside this loop (see the “Variable Scope” section in Chapter 6).

Interrupting Loops

Sometimes you want finer-grained control over the processing of looping code. C# provides commands to help you here:

• break — Causes the loop to end immediately
• continue — Causes the current loop cycle to end immediately (execution continues with the next loop cycle)
• return — Jumps out of the loop and its containing function (see Chapter 6)

The break command simply exits the loop, and execution continues at the first line of code after the loop, as shown in the following example:

int i = 1;
while (i <= 10)
{
   if (i == 6)
      break;
   WriteLine($"{i++}");
}

This code writes out the numbers from 1 to 5 because the break command causes the loop to exit when i reaches 6.

continue only stops the current cycle, not the whole loop, as shown here:

int i;
for (i = 1; i <= 10; i++)
{
   if ((i % 2) == 0)
      continue;
   WriteLine(i);
}

In the preceding example, whenever the remainder of i divided by 2 is zero, the continue statement stops the execution of the current cycle, so only the numbers 1, 3, 5, 7, and 9 are displayed.

Infinite Loops

It is possible, through both coding errors and design, to define loops that never end, so-called infinite loops. As a very simple example, consider the following:

while (true)
{
   // code in loop
}

This can be useful, and you can always exit such loops using code such as break statements or manually by using the Windows Task Manager. However, when this occurs by accident, it can be annoying. Consider the following loop, which is similar to the for loop in the previous section:

int i = 1;
while (i = 10)
{
   if ((i % 2) == 0)
      continue;
   WriteLine($"{i++}");
}

Here, i isn't incremented until the last line of code in the loop, which occurs after the continue statement. If this continue statement is reached (which it will be when i is 2), the next loop cycle will be using the same value of i, continuing the loop, testing the same value of i, continuing the loop, and so on. This will cause the application to freeze. Note that it's still possible to quit the frozen application in the normal way, so you won't have to reboot if this happens.