In the previous lesson you learned how to make your program take decisions with if/else, but those decisions were only evaluated once. In BiblioTechConsole, though, almost no real task consists of looking at a single piece of data: you need to go through the entire book catalog to display it, count how many copies are available, or search for one by title until it's found (or confirm it doesn't exist). Repeating an action a fixed or an unknown number of times is the job of loops. In this lesson you'll learn the four loop forms C# offers — for, while, do-while, and foreach — and how to control them with break and continue.

1. The for loop
2. The while loop
3. The do-while loop
4. The foreach loop
5. Comparison: when to use each one
6. break and continue
7. Nested loops
8. Full application: listing, counting, and searching the catalog

The for loop is ideal when you know in advance (or can calculate) how many times an action must be repeated, typically because you're iterating over a collection by index.

The for header has three parts separated by ;:

Using bookTitles.Length in the condition, instead of a fixed number like 4, keeps the loop from breaking (or failing) if the array's size changes later on.

You can also iterate in reverse, which is useful when elements are going to be removed from a collection while iterating over it (a topic that will be expanded on with List<T> in Module 4):

while repeats a block while a condition is true, evaluating it before each iteration. It's the natural choice when you don't know in advance how many times the action needs to be repeated.

A typical while use case is waiting for valid user input, where you don't know how many attempts it will take:

Watch out: if a while condition never becomes false, the loop runs forever (an infinite loop). There must always be, inside the block, some statement that moves the condition toward its end (in the first example, index++).

do-while is almost identical to while, with one key difference: the condition is evaluated after the block runs, so the block always executes at least once, even if the condition was already false from the start.

Note the syntax: the while keyword and its condition go after the closing brace, and the line ends with ;. This pattern fits interactive menus well, where the menu must be displayed at least once before checking whether the user wants to exit.

foreach iterates over all the elements of a collection (an array, or any type that is "iterable", as you'll see in more detail in Module 4 with collections), without needing to manually manage an index or a stopping condition.

foreach is more readable than for when you don't need the index, but it has an important limitation: the iteration variable (title in the example) is read-only inside the loop; you cannot use foreach to modify the array's elements directly through it.

In practice, for and foreach cover the vast majority of traversals over arrays and collections in BiblioTechConsole; while and do-while are reserved for situations where the stopping condition depends on something other than "going through a full collection", such as validating user input or waiting for an external condition to be met.

Inside any loop, two keywords let you alter the normal iteration flow:

• break: ends the loop immediately, without evaluating any further iterations.
• continue: skips the rest of the loop body in the current iteration and moves straight to the next one.

break also works inside while, do-while, and foreach; so does continue.

A loop can contain another loop inside it. This is common when working with two-dimensional arrays (which you already saw in the arrays lesson), for example, to represent a map of shelves and shelf levels in BiblioTech:

The outer loop iterates over shelves; for each shelf, the inner loop iterates over its levels. In total, 2 × 3 = 6 iterations run. Keep in mind that break and continue only affect the innermost loop they're in; if you need to exit both loops at once, a simple technique is to use a boolean variable as a flag:

Let's combine everything above into three typical operations on the BiblioTechConsole catalog: listing the titles, counting how many are available, and searching for one by title.

This snippet already combines a for (when the index matters), a foreach (when only the value matters), and break (to stop a search as soon as the result is found): three deliberate decisions, not arbitrary ones.

• Infinite loops: forgetting to update the control variable in a while (for example, not incrementing the index) leaves the program hanging forever. Always double-check that the condition can eventually become false.
• Overflowing an array's index: in a for loop, using <= instead of < against array.Length causes access to a position that doesn't exist and throws an exception at runtime (you'll see this in detail in the last lesson of the module).
• Trying to modify the foreach variable: as shown, this doesn't compile. If you need to modify the elements, use for with an index.
• Using for when foreach is clearer (and vice versa): if you don't need the index, prefer foreach; it improves readability and reduces the risk of indexing mistakes.
• Confusing break with continue: break exits the entire loop; continue only skips to the next iteration. Using the wrong one often produces incomplete results or loops that end too early.
• Nesting loops unnecessarily: before nesting two loops, check whether the problem can be solved with a single pass; nesting multiplies the number of iterations (and the running time) and adds complexity.

1. Given the array int[] availableCopies = { 3, 0, 5, 2, 0 };, use a for loop to iterate over it and print to the console how many positions have 0 available copies (out-of-stock books).

2. Use a while loop to simulate validating an administrator password: start from string attempt = ""; and a simulated list of valid attempts string[] simulatedAttempts = { "1234", "abcd", "bibliotech" }; (walk this array with an increasing index on each pass of the while, as if they were successive user attempts). The loop must stop as soon as attempt equals "bibliotech", displaying how many attempts it took.

3. Given the array of titles string[] bookTitles = { "One Hundred Years of Solitude", "Hopscotch", "Ficciones", "The Aleph" };, iterate over the array with foreach and, using continue, print to the console only the titles that have more than 9 characters.

int[] availableCopies = { 3, 0, 5, 2, 0 };
int outOfStockBooks = 0;

for (int i = 0; i < availableCopies.Length; i++)
{
    if (availableCopies[i] == 0)
    {
        outOfStockBooks++;
    }
}

Console.WriteLine($"Out-of-stock books: {outOfStockBooks}");

The result is 2, corresponding to positions 1 and 4 (indices starting at 0).

string[] simulatedAttempts = { "1234", "abcd", "bibliotech" };
string attempt = "";
int index = 0;
int attemptCount = 0;

while (attempt != "bibliotech")
{
    attempt = simulatedAttempts[index];
    attemptCount++;
    index++;
}

Console.WriteLine($"Correct password found after {attemptCount} attempt(s).");

The result shows 3 attempts, because "bibliotech" occupies the third position in the simulated array (index 2). Notice that the while condition is evaluated before each pass, so the last check (attempt != "bibliotech", now false) is the one that stops the loop without running an extra pass.

string[] bookTitles = { "One Hundred Years of Solitude", "Hopscotch", "Ficciones", "The Aleph" };

foreach (string title in bookTitles)
{
    if (title.Length <= 9)
    {
        continue;
    }

    Console.WriteLine(title);
}

Only "One Hundred Years of Solitude" (29 characters) is printed, since it's the only title with more than 9 characters. "Hopscotch", "Ficciones", and "The Aleph" are all exactly 9 characters long, so the continue skips all three without printing anything for them. This is a good exercise to check with Console.WriteLine(title.Length) how the result changes if you use < instead of <=.

In this lesson you've learned to repeat actions with for, while, and do-while, to iterate over collections easily with foreach, to control a loop's flow with break and continue, and to combine nested loops when data has more than one dimension. With these tools, BiblioTechConsole can now list its full catalog, count available books, and search for specific titles without repeating code by hand.

So far, to classify something (like the status of a loan) you've used chains of if/else if/else. In the next lesson, Switch Statements, you'll learn a clearer alternative for when you need to compare the same variable against many possible values, for example, to classify a book by its category or genre within BiblioTech.