Skip to content

Chapter 8: The Loop of Logic - 'while' and 'do-while' Iterations

Theoretical Foundations

The Core Problem: Repetition Without Fixed Boundaries

In previous chapters, you learned how to execute code statements sequentially—one after another—and how to make decisions using if statements to choose between two paths. However, real-world programming often requires repeating an action an unknown number of times.

Consider a simple scenario: You want a program to ask a user for their name, print a greeting, and then ask for another name. You cannot predict how many times the user will want to do this. Using if statements alone would be inefficient and unscalable; you would need to write the code for each potential iteration manually, which is impossible for an unknown number of repetitions.

This is where loops come in. Loops allow us to execute a block of code repeatedly based on a condition. In this chapter, we focus on the two fundamental conditional loops: while and do-while.

Entry-Controlled vs. Exit-Controlled Loops

To understand loops, we must understand the concept of control flow. Control flow dictates the order in which statements are executed. In loops, the critical question is: When do we check the condition?

  1. Entry-Controlled Loops: The condition is checked before the loop body executes. If the condition is false initially, the loop body never runs. This is like a security guard checking your ticket before you enter a concert venue. If you don't have a ticket, you never get inside.
  2. Exit-Controlled Loops: The condition is checked after the loop body executes. This guarantees that the loop body runs at least once, regardless of the initial condition. This is like a vending machine that dispenses a soda first and then checks if you have enough money to pay for the next one.

The while Loop: The Entry-Controlled Sentinel

The while loop is the primary entry-controlled iteration structure in C#. It is designed for scenarios where the action should only occur if a specific condition is true before the action starts.

Syntax and Mechanics

The syntax of a while loop is deceptively simple, but it contains three critical components that must work in harmony:

  1. Initialization: Setting up the variables that will determine the loop's state.
  2. Condition: A boolean expression (using concepts from Chapter 6: if, else, else if, Comparison and Chapter 7: Logical operators) that is evaluated before every iteration.
  3. Update: Modifying the variables within the loop body to eventually make the condition false (otherwise, you create an infinite loop).
using System;

class Program
{
    static void Main()
    {
        // 1. Initialization: We set a starting point.
        int counter = 1;

        // 2. Condition: Checked BEFORE the body runs.
        // If counter is 10, is 10 < 10? No. The loop is skipped entirely.
        while (counter <= 5)
        {
            // 3. Body: The code to repeat.
            Console.WriteLine($"Iteration {counter}");

            // 4. Update: Changing the state for the next check.
            // Without this, counter stays 1 forever (infinite loop).
            counter++; 
        }
    }
}

Output: 

Iteration 1
Iteration 2
Iteration 3
Iteration 4
Iteration 5

The "Do-Nothing" Scenario

A key characteristic of the while loop is its potential to execute zero times. If the condition is false at the very beginning, the code inside the curly braces {} is ignored completely.

int score = 100;

// The condition is false immediately (100 is not less than 50).
while (score < 50)
{
    // This code will NEVER run.
    Console.WriteLine("You passed!");
    score++;
}

Console.WriteLine("Loop finished.");

Output: 

Loop finished.

The do-while Loop: The Exit-Controlled Guarantee

The do-while loop is structurally similar to the while loop, but with one distinct difference: the condition is checked at the end of the loop body. The keyword do signals the start of the block, and while (followed by the condition and semicolon) marks the end.

Syntax and Mechanics

The do-while loop guarantees that the code block executes at least once. This is essential for scenarios where the action itself establishes the condition for repetition.

using System;

class Program
{
    static void Main()
    {
        int number;

        do
        {
            // This block runs immediately, before any check.
            Console.Write("Enter a positive number (or 0 to exit): ");

            // We read input and convert it (Chapter 5 concepts).
            string input = Console.ReadLine();
            number = int.Parse(input);

            // We print the number entered.
            Console.WriteLine($"You entered: {number}");

        } while (number > 0); // Condition checked AFTER the body.

        Console.WriteLine("Program ended.");
    }
}

Comparison of Behavior:

  • while loop: "Check the door lock. If unlocked, enter the room."
  • do-while loop: "Enter the room. Check the door lock. If unlocked, stay in the room."

Real-World Analogy: The Vending Machine vs. The Club

To visualize the structural difference, imagine two distinct real-world processes.

Analogy 1: The Club Entrance (while)

Imagine a club with a strict "Over 21 Only" policy. A bouncer stands at the door.

  • Condition Check: The bouncer checks your ID before you step inside.
  • Outcome: If you are under 21, you never enter the club. The "party" (loop body) never happens.
  • C# Equivalent: This is a while loop. The condition (age >= 21) is evaluated at the entry point.

Analogy 2: The Vending Machine (do-while)

Imagine a vending machine that dispenses a soda when you press a button.

  • Action: You press the button (the loop body executes).
  • Condition Check: The machine checks if you have inserted enough money after dispensing the soda.
  • Outcome: You always get the soda first (at least one execution). The machine then checks if you want to buy another one (the condition).
  • C# Equivalent: This is a do-while loop. The action (dispensing soda) happens first; the check (money remaining) happens second.

Critical Nuances and Edge Cases

1. The Infinite Loop

An infinite loop occurs when the loop's condition never becomes false. This happens if the update statement is missing or incorrect.

int i = 0;
while (i < 5)
{
    Console.WriteLine("This will print forever.");
    // i++;  <-- If this line is missing, i never changes.
    // The condition i < 5 remains true indefinitely.
}
Note: In a real application, you can usually stop an infinite loop by pressing Ctrl+C in the console.

2. Off-by-One Errors

A common logical error occurs when the loop runs one time too many or one time too few. This often involves the comparison operator (< vs <=).

  • while (i < 5): Runs for i = 0, 1, 2, 3, 4. (5 iterations)
  • while (i <= 5): Runs for i = 0, 1, 2, 3, 4, 5. (6 iterations)

3. State Mutation

Loops rely on state mutation—changing the value of variables over time. In C#, this involves using the increment operator (++) introduced in Chapter 4: Arithmetic.

  • counter++: Equivalent to counter = counter + 1.
  • counter--: Decreases the value by 1 (useful for counting down).

Visualization of Control Flow

The following diagram illustrates the decision-making process for both loop types using Graphviz DOT syntax.

The diagram visually explains the control flow of while and do-while loops, highlighting the decision-making process and the use of a counter-- operation to decrement values for counting down.
Hold "Ctrl" to enable pan & zoom

The diagram visually explains the control flow of `while` and `do-while` loops, highlighting the decision-making process and the use of a `counter--` operation to decrement values for counting down.

Application in AI Development: The Training Loop

While you are currently learning the basics, it is helpful to understand why these loops are foundational to AI and Machine Learning. In AI, specifically in training models, we use loops extensively.

The Concept: When training an AI model (like a neural network), we feed the model data in batches. The model makes a prediction, calculates the error, and updates its internal parameters (weights) to reduce that error. This process is repeated thousands or millions of times.

The while Loop in AI: We often use a while loop to train a model until a specific condition is met, such as "stop when the error rate drops below 1%" or "stop after 10,000 iterations."

Example Logic (Conceptual): 

// Conceptual AI Training Loop
double errorRate = 100.0; // Start with high error
int epoch = 0;

// We keep training as long as the error is high.
while (errorRate > 1.0) 
{
    // 1. Feed data to the model (Simulated)
    // double currentError = model.TrainOneBatch();

    // 2. Update the error variable (State Change)
    // errorRate = currentError; 

    // 3. Increment iteration counter
    epoch++;

    Console.WriteLine($"Epoch {epoch}: Current Error = {errorRate}%");
}

In this scenario, we do not know exactly how many epochs (iterations) it will take to reach 1% error. It could be 50, it could be 5000. The while loop handles this uncertainty dynamically, checking the condition (error rate) before every attempt to improve the model. This is the essence of conditional iteration: adapting the execution flow based on the current state of the system.

Basic Code Example

Problem: Counting Down for a Rocket Launch

Imagine you are a ground control engineer preparing for a rocket launch. You need a simple program that counts down from a specific number (like 10) to zero, announcing each number before the final "Liftoff!" message. This ensures a clear, timed sequence of events. A while loop is perfect for this because we know the starting point and the condition (count > 0), but the number of iterations is determined dynamically as the counter decreases.

Here is a C# program that performs this countdown:

using System;

class RocketLaunch
{
    static void Main()
    {
        // Initialize the countdown timer to 10 seconds
        int countdown = 10;

        // Loop as long as the countdown is greater than 0
        while (countdown > 0)
        {
            // Display the current countdown number using string interpolation
            Console.WriteLine($"T-minus {countdown} seconds...");

            // Decrement the countdown by 1 to move closer to 0
            countdown = countdown - 1; 
            // Note: You can also use the shorthand: countdown--;
        }

        // Once the loop finishes (countdown reaches 0), announce liftoff
        Console.WriteLine("Liftoff! We have ignition!");
    }
}

Code Breakdown

  1. Variable Initialization (int countdown = 10;):

    • We declare an integer variable named countdown and assign it the starting value of 10. This variable acts as our state tracker. It holds the current number we are counting down from. This concept is introduced in Chapter 2.

  2. The Loop Condition (while (countdown > 0)):

    • This is the gatekeeper of the loop. Before executing the code block inside the curly braces {}, the program checks if the condition countdown > 0 is true.
    • If countdown is 10, 9, ..., or 1, the condition is true, and the code inside runs.
    • If countdown becomes 0, the condition 0 > 0 is false, and the program skips the loop entirely. This is an entry-controlled loop because the condition is checked at the very beginning.

  3. The Loop Body:

    • Console.WriteLine($"T-minus {countdown} seconds...");: Using string interpolation (introduced in Chapter 3), we print the current value of the countdown variable to the console.
    • countdown = countdown - 1;: This is the most critical line for the loop's logic. It updates the state of the variable. Without this line, countdown would remain 10 forever, the condition 10 > 0 would always be true, and the program would enter an infinite loop. This arithmetic operation is based on Chapter 4.

  4. Post-Loop Execution:

    • Once countdown is decremented to 0, the condition 0 > 0 fails. The program exits the while loop and proceeds to the next line: Console.WriteLine("Liftoff! We have ignition!");. This ensures the final message is only displayed after the countdown is complete.

Visualizing the Flow

The logic of a while loop is linear and conditional. The program checks the condition, executes the body, updates the state, and checks the condition again.

Diagram: G
Hold "Ctrl" to enable pan & zoom

Common Pitfalls

Forgetting to Update the Loop Variable

The most frequent mistake beginners make with while loops is forgetting to modify the variable used in the condition. If you remove the line countdown = countdown - 1;, the variable countdown remains 10 forever. The condition 10 > 0 will never become false, and the program will print "T-minus 10 seconds..." infinitely. Always ensure that the logic inside your loop moves the state toward the condition becoming false.

Scenario: Validating User Input

Now, let's look at a different real-world scenario: ensuring a user enters a valid number. Sometimes, a user might accidentally type a letter or a number that is out of range. We can use a do-while loop to keep asking for input until the entry is valid. A do-while loop is exit-controlled, meaning it executes the code block at least once before checking the condition. This is ideal for user prompts.

Here is a program that asks the user for their age and won't stop asking until they enter a number between 1 and 120.

using System;

class AgeVerifier
{
    static void Main()
    {
        // Variable to store the user's age
        int age;

        // Variable to track if the input is valid
        bool isValid = false;

        // We use a do-while loop because we must ask for input at least once
        do
        {
            // Prompt the user
            Console.Write("Please enter your age (1-120): ");
            string input = Console.ReadLine();

            // Try to convert the string input to an integer
            // We use a logical OR (||) to check for two error conditions
            if (input == "" || (input != "" && !int.TryParse(input, out age)))
            {
                // If input is empty or cannot be parsed, show an error
                Console.WriteLine("Invalid input. Please enter a whole number.");
            }
            else
            {
                // If parsing succeeded, 'age' now holds the number.
                // Now check if the number is within the valid range.
                if (age >= 1 && age <= 120)
                {
                    isValid = true; // Set flag to true to exit the loop
                }
                else
                {
                    // Number was parsed but is out of range
                    Console.WriteLine("Age must be between 1 and 120.");
                }
            }

        } while (!isValid); // Continue looping as long as isValid is false

        // Final confirmation message
        Console.WriteLine($"Thank you. Age {age} recorded.");
    }
}

Code Breakdown

  1. Variable Setup:

    • int age;: We declare an integer variable to hold the parsed age. Note that it is not initialized yet because we will assign a value inside the loop.
    • bool isValid = false;: We use a boolean "flag". This is a common pattern in programming. The loop will continue running as long as this flag is false. We only set it to true when we have valid data.

  2. The do-while Structure:

    • do { ... } while (!isValid);: Notice the syntax difference from while. The do keyword starts the block, and the condition !isValid is checked at the end (after the semicolon).
    • Why use do-while? We always need to prompt the user at least once. If we used a standard while loop, we would have to duplicate the Console.Write line before the loop just to check the condition initially. do-while avoids this duplication.

  3. Input Handling and Parsing (Chapter 5 & 6):

    • string input = Console.ReadLine();: Captures the user's keystrokes as text.
    • int.TryParse(input, out age): This is a safe way to convert a string to an integer. Unlike int.Parse, TryParse returns true if the conversion works and false if it fails (e.g., if the user typed "abc"). It does not crash the program on bad input.
    • Logic Check: The if statement uses logical operators (&&, ||) to handle multiple scenarios:
      • Is the input empty (input == "")?
      • OR, is the input non-empty but fails to parse (!int.TryParse(...))?
    • If either is true, we print an error. If parsing succeeds, we proceed to check the range (1-120).

  4. Controlling the Loop:

    • If the input is valid (parsed successfully and within range), we set isValid = true;.
    • The loop condition while (!isValid); is checked. Since isValid is now true, !isValid is false, and the loop terminates.
    • If the input was invalid, isValid remains false, !isValid is true, and the loop repeats.

Visualizing the do-while Flow

The do-while loop guarantees the body executes at least once. This is distinct from the while loop, which might never execute if the initial condition is false.

Diagram: G
Hold "Ctrl" to enable pan & zoom

Common Pitfalls

Confusing while and do-while Conditions

A common logical error is forgetting that the do-while loop condition is checked after the code runs. If you write while (isValid); instead of while (!isValid);, the loop will continue running as long as the input is valid, which is the opposite of what you want. Always double-check your loop conditions to ensure they represent the logic for "continuing" the loop, not "stopping" it.

The chapter continues with advanced code, exercises and solutions with analysis, you can find them on the ebook on Leanpub.com or Amazon

Code License: All code examples are released under the MIT License. Github repo.

Content Copyright: Copyright © 2026 Edgar Milvus | Privacy & Cookie Policy. All rights reserved.

All textual explanations, original diagrams, and illustrations are the intellectual property of the author. To support the maintenance of this site via AdSense, please read this content exclusively online. Copying, redistribution, or reproduction is strictly prohibited.