C# do while Loop

The do...while loop in C# is a type of loop that ensures that a block of code is executed at least once before checking a condition. Unlike the while loop, where the condition is evaluated before entering the loop, the do...while loop evaluates the condition after the loop body has been executed. This makes it useful for scenarios where you need to execute code at least once, regardless of the condition.

In this tutorial, we will cover everything you need to know about the do...while loop, from its syntax to practical examples and common use cases.

What is a do...while Loop?

The do...while loop in C# is a post-test loop, which means that the condition is checked after the block of code has been executed. This guarantees that the loop will execute the code inside at least once, even if the condition is false from the start. This behavior makes it ideal when you want the code to run at least once before evaluating the loop condition.

Key Characteristics:

• The loop body executes at least once, even if the condition is initially false.
• The condition is evaluated after each iteration of the loop.

Syntax of the do...while Loop

The do...while loop has a simple structure, starting with the do keyword followed by a block of code inside curly braces {}. After the loop body, the while keyword follows with a condition inside parentheses ().

do
{
    // Code to be executed
} while (condition);

Key Elements:

• Loop Body: The block of code that will be executed at least once.
• Condition: A Boolean expression that determines whether the loop should continue. It is checked after the loop body is executed.

Example Syntax:

int counter = 0;

do
{
    Console.WriteLine($"Counter: {counter}");
    counter++;
} while (counter < 5);

In this example:

• The loop will print the value of counter starting from 0.
• After each execution, the condition counter < 5 is checked. If true, the loop continues; if false, the loop stops.

How the do...while Loop Works

The do...while loop works by:

1. Executing the loop body: The block of code inside the do section is executed first.
2. Evaluating the condition: After executing the loop body, the while condition is evaluated.
3. Repeating or stopping: If the condition is true, the loop repeats. If false, the loop terminates.

Example Flow:

1. Step 1: Execute the code inside the loop body.
2. Step 2: Check the condition.
3. Step 3: If the condition is true, repeat from step 1; otherwise, stop.

Examples of do...while Loop in C#

Example 1: Basic do...while Loop

int count = 1;

do
{
    Console.WriteLine($"Count: {count}");
    count++;
} while (count <= 5);

Explanation:

• The loop will print the values 1 through 5.
• Even if the initial value of count was greater than 5, the loop would execute at least once.

Example 2: User Input with Validation

int input;

do
{
    Console.WriteLine("Please enter a number between 1 and 10:");
    input = Convert.ToInt32(Console.ReadLine());
} while (input < 1 || input > 10);

Console.WriteLine($"You entered a valid number: {input}");

Explanation:

• The loop asks the user to input a number between 1 and 10.
• It continues to ask until the user provides a valid number.
• The do...while loop ensures that the user is prompted at least once.

Example 3: Performing an Action Until Condition is Met

int total = 0;
int number;

do
{
    Console.WriteLine("Enter a positive number to add to the total, or -1 to stop:");
    number = Convert.ToInt32(Console.ReadLine());
    
    if (number != -1)
    {
        total += number;
    }
} while (number != -1);

Console.WriteLine($"The total sum is: {total}");

Explanation:

• The loop prompts the user to enter numbers to sum.
• It continues until the user enters -1 to stop the loop.
• The loop ensures that at least one number is requested from the user.

Common Use Cases of do...while Loop

1. Input Validation: A common use of the do...while loop is ensuring valid input by repeatedly asking for user input until a correct value is entered. Since the prompt should appear at least once, the do...while loop is ideal for this scenario.

   string password;
   
   do
   {
       Console.WriteLine("Enter your password:");
       password = Console.ReadLine();
   } while (password != "secret123");
   
   Console.WriteLine("Access granted!");
   

2. Executing Code Before Condition is Checked: When you want to ensure that some code executes at least once before checking a condition. For example, a loop that interacts with hardware or external resources that may need to initialize first.

   bool isReady;
   
   do
   {
       // Simulate checking if a device is ready
       Console.WriteLine("Checking if device is ready...");
       isReady = CheckDeviceStatus();
   } while (!isReady);
   
   Console.WriteLine("Device is ready!");
   

3. Repeating a Task Until User Quits: You can use a do...while loop to repeat a task until the user decides to stop.

   string command;
   
   do
   {
       Console.WriteLine("Enter command (type 'exit' to quit):");
       command = Console.ReadLine();
       Console.WriteLine($"You entered: {command}");
   } while (command.ToLower() != "exit");
   

   This loop will continue running until the user types "exit".

Key Takeaways

• The do...while loop guarantees that the loop body will execute at least once, as the condition is checked after the execution.
• It's particularly useful for scenarios such as input validation, interactive loops, or tasks that must run once before checking a condition.
• Be cautious with do...while loops to ensure that you do not create an infinite loop by not providing a way for the condition to eventually become false.
• Syntax difference: The do...while loop is similar to the while loop but checks the condition after executing the loop body, while the while loop checks the condition before.

Conclusion

The do...while loop is a powerful and versatile looping construct in C#. It provides an easy way to ensure that a block of code is executed at least once, making it the perfect choice when you need to guarantee that some action happens before evaluating a condition. Whether you're validating user input, interacting with external systems, or performing repetitive tasks, the do...while loop can be an invaluable tool in your programming arsenal.

By understanding its structure and use cases, you'll be able to write clearer and more efficient code when a pre-loop condition check isn't suitable. Keep the do...while loop in mind whenever you encounter situations where code must be executed at least once!