Lesson 4: Control Statements

The C# Station Tutorial

by Joe Mayo, 9/7/00

Lesson 4: Control Statements - Loops

This lesson teaches you how to use C# Selection Control Statements. More specifically, the looping statements. It's goal is to meet the following objectives:

	Learn the "while" loop.
	Learn the "do" loop.
	Learn the "for" loop.
	Learn the foreach loop.
	Complete your knowledge of the "break" statement.
	Teach you how to use the "continue" statement.

In the last lesson, you learned how to create a simple loop by using the "goto" statement. I advised you that this is not the best way to perform loops in C#. The information in this lesson will teach you the proper way to execute iterative logic with the various C# looping statements.

Our first statement is the while loop.

Listing 4-1. The While Loop: WhileLoop.cs

using System;

class WhileLoop
{
    public static void Main()
    {
        int myInt = 0;

        while (myInt < 10)
        {
            Console.Write("{0} ", myInt);
            myInt++;
        }
        Console.WriteLine();
    }
}

Listing 4-1 shows a simple while loop. It begins with the keyword "while", followed by a boolean expression. All control statements use boolean expressions. This means that the expression must evaluate to either a true or false value. In this case we are checking the myInt variable to see if it is less than (<) 10. Since myInt was initialized to 0, the boolean expression will return true the first time it is evaluated. When the boolean expression evaluates to true, the block immediately following the boolean expression will be executed.

Within the while block we print the number and a space to the console. Then we increment (++) myInt to the next integer. Once the statements in the while block have executed, the boolean expression is evaluated again. This sequence will continue until the boolean expression evaluates to false. Once the boolean expression is evaluated as false, program control will jump to the first statement following the while block. In this case, we will write the numbers 0 through 9 to the console, exit the while block, and print a new line to the console.

Similar to "while" loop is the "do" loop.

Listing 4-2. The Do Loop: DoLoop.cs

using System;

class DoLoop
{
    public static void Main()
    {
        string myChoice;

        do
       {
            // Print A Menu
            Console.WriteLine("My Address Book\n");

            Console.WriteLine("A - Add New Address");
            Console.WriteLine("D - Delete Address");
            Console.WriteLine("M - Modify Address");
            Console.WriteLine("V - View Addresses");
            Console.WriteLine("Q - Quit\n");

            Console.WriteLine("Choice (A,D,M,V,or Q): ");

            // Retrieve the user's choice
            myChoice = Console.ReadLine();

            // Make a decision based on the user's choice
            switch(myChoice)
            {
                case "A":
                case "a":
                    Console.WriteLine("You wish to add an address.");
                    break;
                case "D":
                case "d":
                    Console.WriteLine("You wish to delete an address.");
                    break;
                case "M":
                case "m":
                    Console.WriteLine("You wish to modify an address.");
                    break;
                case "V":
                case "v":
                    Console.WriteLine("You wish to view the address list.");
                    break;
                case "Q":
                case "q":
                    Console.WriteLine("Bye.");
                    break;
                default:
                    Console.WriteLine("{0} is not a valid choice", myChoice);
                    break;
            }

            // Pause to allow the user to see the results
            Console.Write("Press any key to continue...");
            Console.ReadLine();
            Console.WriteLine();
        } while (myChoice != "Q" && myChoice != "q"); // Keep going until the user wants to quit
    }
}

Listing 4-2 shows a "do" loop in action. The syntax of the "do" loop is "do { <statements> } while (<boolean expression>);". The statements can be any valid C# programming statements you like. The boolean expression is the same as all other's we've encountered so far. It returns either true or false.

One reason you may want to use a "do" loop instead of a "while" loop is to present a message or menu such as the one in Listing 4-2 and then retrieve input from a user. Since the boolean expression is evaluated at the end of the loop, the "do" loop guarantees that the statement's inside the loop will execute at least 1 time. However, since a "while" loop evaluates it's boolean expression at the beginning, there is generally no guarantee that the statements inside the loop will be executed, unless you program it explicitly to do so.

We'll do a quick review of Listing 4-2. In the Main() method, we declare the variable "myChoice" of type string. Then we print a series of statement to the console. This is a menu of choices for the user. We must get input from the user, which is in the form of a Console.ReadLine() method which returns the user's value into the myChoice variable. We must take the user's input and process it. A very efficient way to do this is with a "switch" statement. Notice that we've placed matching upper and lower case letters together to obtain the same functionality. This is the only legal way to have automatic fall through between cases. If you were to place any statements between two cases, you would not be able to fall through. Another point is that we used the "default:" case - a very good habit to make.

Listing 4-3. The For Loop: ForLoop.cs

using System;

class ForLoop
{
    public static void Main()
    {
        for (int i=0; i < 20; i++)
        {
            if (i == 10)
                break;

            if (i % 2 == 0)
                continue;

            Console.Write("{0} ", i);
        }
        Console.WriteLine();
    }
}

Listing 4-3 shows the "for" loop. For loops are good for when you know exactly how many times you want to perform the statements within the loop. This listing produces the same results as the "while" loop in Listing 4-1. The contents within the "for" loop parenthesis holds three sections separated by semicolons "(<initializer list>; <boolean expression>; <post-loop action list>)".

The initializer list is a comma separated list of expressions. These expressions are evaluated only once during the lifetime of the "for" loop. This is in the beginning, before loop execution. As shown in Listing 4-3, this section is commonly used to initialize an integer to be used as a counter.

Once the initializer list has been evaluated, the "for" loop gives control to its second section, the boolean expression. There is only one boolean expression, but it can be as complicated as you like as long as the result is true or false. The boolean expression is commonly used to verify the status of a counter variable.

When the boolean expression evaluates to true, the statements within the curly braces of the "for" loop are executed. Normally, these statements execute from the opening curly brace to the closing curly brace without interruption. However, in Listing 4-3, we've made a couple exceptions. We have a couple "if" statements that disrupt the flow of control within the "for" block.

The first "if" statement checks to see if "i" is equal to 10. Now you see another use of the "break" statement. It's behavior is similar to the selection statements. It simply breaks out of the loop at that point and transfers control to the first statement following the end of the "for" block.

The second "if" statement uses the remainder operator to see if "i" is a multiple of 2. This will evaluate to true when "i" is divided by 2 with a remainder equal to zero, (0). When true, the "continue" statement is executed. Control will skip over the remaining statements in the loop and transfer back to the post-loop action list. By arranging the statements within a block properly, you can conditionally execute them based upon whatever condition you need.

When program control encounters either a continue statement or end of block, right curly brace, it transfers to the third section within the "for" loop parentheses, the post-loop action list. This is a comma separated list of actions you would like to see occur after the statements in the "for" block have been executed. Listing 4-3 is a typical action, incrementing the counter. Once this is complete, control transfers to the boolean expression for evaluation. The loop will continue as long as the boolean expression is true. When the boolean expression becomes false, control is transferred to the first statement following the "for" block.

Listing 4-4. The ForEach Loop: ForEachLoop.cs

using System;

class ForEachLoop
{
    public static void Main()
    {
        string[] names = {"Cheryl", "Joe", "Matt", "Robert"};

        foreach (string person in names)
        {
            Console.WriteLine("{0} ", person);
        }
    }
}

The "foreach" loop allows you to iterate through a collection. An array, as used in Listing 4-4, is one such collection (there are others in "System.Collections"). The first thing we've done inside the Main() method is declare and initialize the "names" array with 4 strings.

Within the "foreach" parentheses is an expression composed of two elements divided by the keyword "in". The right-hand side is the collection you want to use to access each element. The left-hand side holds a variable with a type identifier compatible with whatever type the collection returns.

Every time through this loop the collection is queried for a new value. As long as the collection can return a value, this value will be put into the read-only variable and the expression will return true, thus causing the statements in the "foreach" block to be executed. When the collection has been fully traversed, the expression will evaluate to false and control will transfer to the first executable statement following the end of the "foreach" block.

In the case of Listing 4-4, we've used a string variable named "person" to hold each element of the names array. As long as there are names in the array that have not been returned, we will use the Console.WriteLine() method to print each value of the person variable to the screen.

By now you know how to perform iterative logic with the "while", "do", "for", and "foreach" loops. You are aware of some common reasoning of when to use each of these. Finally, you know how to transfer control from the block of a loop based on the conditions you set.

I invite you to return for Lesson 5: Introduction to Methods.

Your feedback is very important and I appreciate any constructive contributions you have. Please feel free to contact me for any questions or comments you may have about this lesson.

Feedback