Writing do Statements | MicrosoftГ‚В® Visual C#Г‚В® 2005 Step by Step (Step By Step (Microsoft))

Writing do Statements

The while and for statements both test their Boolean expression at the start of the loop. This means that if the expression evaluates to false on the very first test, the body of the loop does not run, not even once. The do statement is different; its Boolean expression is evaluated after each iteration, and so the body always executes at least once.

The syntax of the do statement is as follows (don't forget the final semicolon):

do      statement  while (booleanExpression);

Use a statement block if the body of the loop comprises more than one statement. Here's a version of the previous example that writes the values 0 through 9 to the console, this time using a do statement:

int i = 0;  do  {      Console.WriteLine(i);      i++;  }  while (i != 10);

The break and continue Statements

In Chapter 4, you saw the break statement being used to jump out of a switch statement. You can also use a break statement to jump out of the body of an iteration statement. When you break out of a loop, the loop exits immediately and execution continues at the first statement after the loop. Neither the update nor the continuation condition of the loop is re-run.

In contrast, the continue statement causes the program to immediately perform the next iteration of the loop (after re-evaluating the Boolean expression). Here's a version of the previous example that writes the values 0 through 9 to the console, this time using break and continue statements:

int i = 0;  while (true)  {      Console.WriteLine("continue " + i);      i++;      if (i != 10)          continue;      else          break;  }

This code is absolutely ghastly. Many programming guidelines recommend using continue cautiously or not at all because it is often associated with hard-to-understand code. The behavior of continue is also quite subtle. For example, if you execute a continue statement from inside a for statement, the update part runs before performing the next iteration of the loop.

In the following exercise, you will write a do statement to convert a number to its string representation.

Write a do statement

Using Visual Studio 2005, open the DoStatement project, located in the \Microsoft Press\Visual CSharp Step by Step\Chapter 5\DoStatement folder in your My Documents folder.
On the Debug menu, click Start Without Debugging.

Visual Studio 2005 builds and runs the Windows application.

The application displays a form that has two text boxes and the Show Steps button. When you type a positive number (the algorithm used doesn't work with negative numbers) in the upper text box, and click the Show Steps button, the lower text box shows the steps used to create a string representation of this number.

NOTE
This is simply an example showing you how to convert a number to a string using a do loop. The .NET Framework provides the Convert.ToString method which does the same thing, and is the method you should really use to perform this task if you need it in your own applications.
As an example, type 2693 in the upper text box, and then click Show Steps.

The lower text box displays the steps used to create a string representation of 2693:
Close the window to return to the Visual Studio 2005 programming environment.
Display the code for Form1.cs in the Code and Text Editor window.
Locate the showSteps_Click method. This method runs when the user clicks the Show Steps button on the form.

This method contains the following statements:
```
int amount = System.Int32.Parse(number.Text);   steps.Text = "";  string current = "";  do  {      int digitCode = '0' + amount % 10;      char digit = Convert.ToChar(digitCode);      current = digit + current;      steps.Text += current + "\r\n";      amount /= 10;  }  while (amount != 0);
```
NOTE
\r indicates a carriage return. When writing text to a multiline TextBox control, you need to output a carriage return and a newline to proceed to the next line and return the cursor to the start of the line. Without it, the text will all appear on the same line.

The first statement converts the string value in the Text property of the number text box into an int using the Parse method of the System.Int32 class:
```
int amount = System.Int32.Parse(number.Text); 
```
The second statement clears the text displayed in the lower text box (called steps) by setting its Text property to the empty string:
```
steps.Text = "";
```
The third statement declares a string variable called current and initializes it to the empty string:
```
string current = "";
```
The real work in this method is performed by the do statement which begins at the fourth statement:
```
do  {      ...  }  while (amount != 0);
```
The algorithm repeatedly uses integer arithmetic and the modulus operator to divide the amount variable by 10; the remainder after each successive division constitutes the next digit in the string being built. Eventually amount is reduced to zero, and the loop finishes. Notice that the body must run at least once. This behavior is exactly what is required because even the number 0 has one digit.

The first statement inside the do loop is:
```
int digitCode = '0' + amount % 10;
```
This statement declares an int variable called digitCode and initializes it to the result of the following expression:
```
'0' + amount % 10
```
This expression requires a little explanation! The value of '0'is the zero character. In the character set used by Windows, this character equates to the integer value 48 (each character has its own unique character code which is an integer value). Similarly, the character code for '1' is 49, the character code for '2' is 50, and so on.

The value of amount % 10 is the remainder you get when you divide amount by 10. For example, if amount contains the value 2693, then 2693 % 10 is 3. (2693 divided by 10 is 269 with a remainder of 3.) Therefore, if amount equals 2693, then the expression '0' + amount % 10 is the same as '0' + 3, which is 51. This is the code for the character '3'. (The + operator performs an implicit cast, converting '0' to the integer value 48 to allow this expression to be evaluated.)

The second statement inside the do loop is:
```
char digit = Convert.ToChar(digitCode);
```
This statement declares a char variable called digit and initializes it to the result of the Convert.ToChar(digitCode) method call. This method call returns the char with the integer character code value of the argument. In other words, the value of Convert.ToChar('0' + 3) is the value of ‘3'.

The third statement inside the do loop is:
```
current = digit + current;
```
This statement prepends the char digit just calculated to the current string. Notice that this statement cannot be replaced by current += digit, because that would append the digit.

The fourth statement inside the do loop is:
```
steps.Text += current + "\r\n";
```
This statement appends another step to the Text property of the Steps text box.

The final statement inside the do loop is:
```
amount /= 10;
```
This statement is the same as amount = amount / 10;. If the value of amount is 2693, the value of amount after this statement runs is 269. Notice that each iteration through the do statement removes the last digit from amount and prepends that digit to the current string.

In the final exercise, you will use the Visual Studio 2005 debugger to step through the previous do statement to help you understand how it works.

Step through the do statement

In the Code and Text Editor window, find the showSteps_Click method.
Move the cursor to the first statement of the showSteps_Click method.

The first statement is as follows:
```
int amount = System.Int32.Parse(number.Text);
```
Right-click anywhere in the first statement and click Run To Cursor.

Visual Studio 2005 builds and runs the application.
When the form appears, type 2693 in the upper text box, and then click Show Steps.

The program stops and you are placed in Visual Studio 2005 in debug mode. A yellow arrow in the left margin of the Code and Text Editor window indicates the current statement.
Display the Debug toolbar if it is not visible (on the View menu, point to Toolbars and then select Debug). On the Debug toolbar, click the Windows drop-down arrow.

The following menu appears:
On the menu, click Locals.

The Locals window appears. This window displays the name, value, and type of the local variables in the current method, including the amount local variable. Notice that the value of amount is currently zero:
On the Debug toolbar, click the Step Into button.

The debugger runs the current statement:
```
int amount = System.Int32.Parse(number.Text);
```
The value of amount in the Locals window changes to 2693 and the yellow arrow moves to the next statement.
Click the Step Into button.

The debugger runs the statement:
```
steps.Text = "";
```
This statement does not affect the Locals window because steps is a field of the form and not a local variable. The yellow arrow moves to the next statement.
Click the Step Into button.

The debugger runs the statement:
```
string current = "";
```
The yellow arrow moves to the opening curly brace at the start of the do loop.
Click the Step Into button.

The yellow arrow moves to the first statement inside the do loop. The do loop contains two local variables of its own, digitCode and digit. Notice that these local variables have appeared in the Locals window and that the value of digitCode is zero.
Click the Step Into button.

The debugger runs the statement:
```
int digitCode = '0' + amount % 10;
```
The value of digitCode in the Locals window changes to 51. This is because the value of the expression amount % 10 is 3 (the value of amount is 2693), and the code for character '3' is 51 (48 + 3).
Click the Step Into button.

The debugger runs the statement:
```
char digit = Convert.ToChar(digitCode);
```
The value of digit changes to '3' in the Locals window. The Locals window shows char values using both the underlying numeric value (in this case, 51) and also the character representation ('3'). The yellow arrow moves to the next statement inside the do loop.

Note that in the Locals window, the value of the current variable is "".
Click the Step Into button.

The debugger runs the statement:
```
current = current + digit;
```
The value of current changes to "3" in the Locals window.
Click the Step Into button.

The debugger runs the statement:
```
steps.Text += current + "\r\n";
```
This statement displays the text "3" in the steps text box, followed by a carriage return and newline character, to cause subsequent output to be displayed on the next line in the text box.

In the Locals window, the value of amount is still 2693.
Click the Step Into button.

The debugger runs the statement:
```
amount /= 10;
```
The value of amount changes to 269 in the Locals window. The yellow arrow moves to the curly brace at the end of the do loop.
Click the Step Into button

The yellow arrow moves to the while statement.
Click the Step Into button.

The debugger runs the statement:
```
while (amount != 0);
```
The value of amount is 269, and the expression 269 != 0 evaluates to true, so the do loop should perform another iteration. The yellow arrow jumps back to open curly brace at the start of the do loop.
Click the Step Into button.

The yellow arrow moves to the first statement inside the do loop again.
Click the Step Into button 22 more times and watch the values of the local variables change in the Locals window.

In the Locals window, the value of amount is now zero and the value of current is “2693”. The yellow arrow is on the continuation condition of the do loop:
```
while (amount != 0);
```
The value of amount is now 0, so the expression amount != 0 evaluates to false, so the do loop should terminate.
Click the Step Into button.

The debugger runs the statement:
```
while (amount != 0);
```
As predicted the do loop terminates, and the yellow arrow moves to the closing brace at the end of the showSteps_Click method.
Click the Continue button.

The form appears, displaying the four steps used to create a string representation of 2693: “3”, “93”, “693”, and “2693”.
Close the form to return to the Visual Studio 2005 programming environment.

Congratulations! You have successfully written meaningful while and do statements and used the Visual Studio 2005 debugger to step through the do statement.

If you want to continue to the next chapter

Keep Visual Studio 2005 running and turn to Chapter 6, “Managing Errors and Exceptions.”
If you want to exit Visual Studio 2005 now

On the File menu, click Exit. If you see a Save dialog box, click Yes.