A For loop uses a variable to control the number of times it executes a series of statements. The For loop's syntax is as follows:

For variable[As datatype] = start To stop [Step amount]
    statements...
Next [variable]

Where:

For example, the following code displays the numbers 0 through 9, followed by their squares, in the Output window:

For i As Integer = 0 To 9
    Console.WriteLine(i & ": " & i * i)
Next i

This code is relatively straightforward. It uses the looping variable i declared as part of the loop. The value i starts at 0 and increases by 1 each time through the loop until it reaches 9. After the final pass through the loop with i = 9, the loop ends.

Here's a slightly more complicated example that calculates factorials. The program converts the value selected in the NumericUpDown control named nudNumber into a long integer and saves it in variable n. It initializes the variable factorial to 1 and then uses a loop to multiply factorial by each of the numbers between 2 and n. The result is 1 * 2 * 3 * ... * n, which is n!.

' Get the input value n.
Dim n As Long = CLng(nudNumber.Value)

' Calculate n!.
Dim factorial As Long = 1
For i As Long = 2 To n
    factorial *= i
Next i

' Display the result.
txtResult.Text = factorial.ToString()

You may recall that Lesson 16 used code to calculate Fibonacci numbers, and in that lesson's Exercise 1 you calculated factorials. Those programs used 20 lines of code to calculate and store 20 values that the program then used as a kind of lookup table.

The factorial calculation code shown here is more efficient. It doesn't require a large array to hold values. It also doesn't require that you know ahead of time how many values you might need to calculate (20 for the earlier programs), although the factorial function grows so quickly that this program can only calculate values up to 20! before the result won't fit in a long integer.

A For Each loop executes a block of code once for each item in an array or list. The syntax of the For Each loop is as follows:

For Each variable [As datatype] In items
    statements...
Next [variable]

Where:

For example, the following code calculates the average of the test scores stored in the ListBox named lstScores.

' Make sure the list isn't empty.
If (lstScores.Items.Count = 0) Then
    MessageBox.Show("There are no items to average.")
Else
    ' Add up the values.
    Dim total As Integer = 0
    For Each value As Integer In lstScores.Items
        total += value
    Next value

    ' Calculate the average.
    Dim average As Double = total / lstScores.Items.Count

' Display the result.
    MessageBox.Show("Average: " & average.ToString("0.00"))
End If

After confirming that the ListBox isn't empty, the code creates a variable named total and sets it equal to 0. It then loops through the items in the ListBox, adding each value to total.

The code finishes by dividing total by the number of items in the ListBox.

A While loop executes as long as some condition is true. The syntax for a While loop is as follows:

While condition
    statements...
End While

Where:

For example, the following code calculates a number's prime factors:

' Get the input number.
Dim number As Long = Long.Parse(txtNumber.Text)

' Find the factors.
Dim result As String = "1"

' Consider factors between 2 and the number.
For factor As Long = 2 To CLng(Math.Sqrt(number))
    ' Pull out as many copies of this factor as possible.
    While (number Mod factor = 0)
        result &= " * " & factor
        number = factor
    End While
Next factor

' Add whatever is left.
If number <> 1 Then result &= " * " & number

' Display the result.
txtResult.Text = result

The code starts by getting the user's input number. It builds a result string and initializes it to "1."

Next, the code users a For loop to consider the numbers between 2 and the square root of the user's number as possible factors.

For each of the possible factors, it uses a While loop to remove that factor from the number. As long as the factor divides evenly into the remaining number, the program adds the factor to the result and divides the user's number by the factor.

The code finishes by adding any remaining value and displaying its result.

Visual Basic provides two forms of Do loops. The first is similar to a While loop but with different syntax. The second is also similar to a While loop except it checks its stopping condition at the end of the loop instead of the beginning (so it executes its code at least once).

The syntax of the first kind of Do loop is as follows:

Do While condition
    statements...
Loop

The syntax of the second kind of Do loop is as follows:

Do
    statements...
Loop While condition

In both versions:

The following code uses a Do loop to calculate the greatest common divisor (GCD) of two numbers, the largest number that divides them both evenly:

' Get the input values.
Dim a As Long = Long.Parse(txtA.Text)
Dim b As Long = Long.Parse(txtB.Text)

' Calculate the GCD.
Dim remainder As Long
Do
    remainder = a Mod b
    If (remainder <> 0) Then
        a = b
        b = remainder
    End If
Loop While (remainder > 0)

txtResult.Text = b.ToString()

It's important that any loop eventually ends, and in this code it's not completely obvious why that happens. It turns out that each time through the loop (with the possible exception of the first time), a and b get smaller. If you run through a few examples, you'll be able to convince yourself.

If the loop runs long enough, b eventually reaches 1. At that point b must evenly divide a no matter what a is so the loop ends. If b does reach 1, then 1 is the greatest common divisor of the user's original numbers and those numbers are called relatively prime.

The Exit and Continue statements change the way a loop works.

The Exit statement makes the code exit a loop immediately without executing any more statements inside the loop. A second keyword after Exit determines the kind of loop that exits. That second keyword can be For, Do, or While to exit the corresponding kind of loop.

For example, the following code searches the selected items in a ListBox for the value Carter. If it finds that value, it sets the Boolean variable carterSelected to true and breaks out of the loop. If the ListBox has many selected items, breaking out of the loop early may enable the program to skip many loop iterations and save some time.

' See if Carter is one of the selected names.
Dim carterSelected As Boolean = False
For Each name As String In lstNames.SelectedItems
    If (name = "Carter") Then
        carterSelected = True
        Exit For
    End If
Next name

MessageBox.Show(carterSelected.ToString())

The Continue statement makes a loop jump to its looping statement early, skipping any remaining statements inside the loop after the Continue statement. Like the Exit statement, the Continue statement takes a second keyword that indicates what kind of loop should continue.

For example, the following code uses a For Each loop to display the square roots of the numbers in an array. The Math.Sqrt function cannot calculate the square root of a negative number, so to avoid trouble the code checks each value. If it finds a value less than zero, it uses the Continue statement to skip the rest of that trip through the loop so it doesn't try to take the number's square root. It then continues with the next number in the array.

' Display square roots.
Dim values() As Single = {4, 16, −1, 60, 100}
For Each value As Single In values
    If (value < 0) Then Continue For
    Console.WriteLine(String.Format(
        "The square root of {0} is {1:0.00}",
        value, Math.Sqrt(value)))
Next value

The following shows this program's results:

The square root of 4 is 2.00
The square root of 16 is 4.00
The square root of 60 is 7.75
The square root of 100 is 10.00

' Display square roots.
Dim values() As Single = {4, 16, −1, 60, 100}
For Each value As Single In values
    If (value >= 0) Then
        Console.WriteLine(String.Format(
            "The square root of {0} is {1:0.00}",
            value, Math.Sqrt(value)))
    End If
Next value

In this Try It, you make the simple login form shown in Figure 19-1. When the program's startup form loads, it enters a loop that makes it display this form until the user enters the correct username and password or clicks the Cancel button.

Figure 19.1. FIGURE 19-1