DEV Community: Jos

8 Common Causes of Infinite C# Loops

Jos — Mon, 16 Dec 2019 17:56:39 +0000

This article appeared earlier on my website.

An infinite loop makes our C# program stuck, and can even cause an application crash. Luckily, infinite loops are often easy to solve. This article shows 8 common causes and how to fix them.

Fix infinite loops: 8 causes

An infinite loop is a loop that keeps running 'forever'. These loops don't exit like regular C# loops do, but instead use up computer resources and freeze our application.

Most infinite loops are caused by either a coding or logic mistake. Some faults are pretty easy to spot, while others are more subtle.

Here are several reasons why your C# code ran into an infinite loop:

Exit condition that can never be met.
Condition that makes the loop to start over again and again.
Loop variable that's reset to a new value inside the loop.
Loop without an exit condition.
Loop that doesn't change the loop variable (like a missing increment or decrement statement).
Mistakingly use the increment (++) rather than decrement (--) operator (or vice versa).
Incorrect logical comparison in the loop's condition (for instance, < rather than >).
The continue statement in the wrong place so that it jumps over code that changes the loop variable.

If you run into an infinite loop, chances are your code has one of the above problem. Let's take a closer look at each and see what the fix is.

An exit condition that's never reached

One thing that causes an infinite loop is when our code has an exit condition, but that condition can't be reached. This is a bit tricky, because our loop does have all the required components. Yet when it runs, it doesn't stop.

Here's an example:

byte i = 0;

while (true)
{
    // ...

    Console.WriteLine($"i = {i}");
    i++;

    if (i > 275)
    {
        break;
    }
}

This intentional infinite while loop prints the value of the i variable during each loop cycle. Then it increases that variable with one (i++). When that variable is above 275, the break statement ends the loop.

Or, at least, that's the idea. In practice this loop remains stuck. The cause for this is the byte loop variable. A byte variable can hold the values 0 through 255. When its value reaches that upper level, the variable's value wraps around and starts again from zero. That makes it impossible for i to become greater than 275.

The solution is to use a loop variable of a different type, like a regular integer (int) variable:

// Fixed: loop variable now an integer
int i = 0;

while (true)
{
    // ...

    Console.WriteLine($"i = {i}");
    i++;

    if (i > 275)
    {
        break;
    }
}

A similar issue can happen when our loop variable is a floating-point value. Since float values cannot be represented exactly, a loop test like while (i != 1.1) fails when floating-point imprecision gives our loop variable a value like 1.100000000000001.

A condition that makes the loop start over and over again

An infinite loop also happens when our loop condition doesn't terminate the loop, but rather make it start over again. This can be difficult to spot: usually the code compiles fine and there's no obvious thing missing. Yet one misspelled or missing character can cause this issue.

Here's an example of that mistake:

int i = 0;

// Loop 1,000 times at most
while ((i = 1) < 1000)
{
    Console.WriteLine($"i = {i}.");

    // ...

    if (i > 125)
    {
        break;
    }
}

This while loop continues as long as the i variable is under 1000. The loop has an if statement that checks if that variable is above 125. When it is, the break statement ends the loop early.

That's the idea at least. But the loop's body doesn't change the i variable. It looks like this should be happening in the loop condition. But there we have a strange thing: the loop condition assigns i a value of 1 each time. Then it looks if that assignment returns a value under 1000 -- which it of course always is.

What the loop should do is increment i with one with each loop cycle. To implement that fix we add one character, and change i = 1 to i += 1:

int i = 0;

// Loop 1,000 times at most
while ((i += 1) < 1000)
{
    Console.WriteLine($"i = {i}.");

    // ...

    if (i > 125)
    {
        break;
    }
}

Change the loop variable to a new value inside the loop

Usually a variable controls for how long a loop should run. But if we accidentally reset that variable inside the loop, our loop doesn't get closer to its exit condition no matter how many cycles it runs.

Here's an infinite loop example of that scenario:

int i = 0;

while (i < 10)
{
    // ...

    i = 3;

    // ...

    Console.WriteLine($"i = {i}");
    i++;
}

This while loop continues for as long as the i variable is under 10. At the end of the loop's code, we increment (++) that variable with one. That should increase the variable's value all the way up to 10.

But inside the loop we also set the i variable to 3 each time. That always keeps the loop variable under 10, and the loop never ends. Since that statement doesn't seem to serve a purpose, we simply remove it to fix the problem:

int i = 0;

while (i < 10)
{
    // ...

    Console.WriteLine($"i = {i}");
    i++;
}

On a related note, it usually is a good idea to make your loop variable's name different from other variables. That way you don't mistake the loop variable for another local variable.

A loop without an exit condition

Another thing that causes a stuck infinite loop is when we don't have an exit condition. This cause is easy to spot, but unfortunately also a mistake that's quickly to make.

Here's an example:

int i = 0;

while (true)
{
    Console.WriteLine($"i = {i}");
    i++;
}

This while loop is an intentional infinite loop. That's fine, but the loop doesn't have an exit condition. So the loop keeps running forever.

Luckily, to fix this code we just have to add an exit condition. One option is to make one inside the while condition:

int i = 0;

// Fixed: add an exit condition to the loop
while (i < 10)
{
    Console.WriteLine($"i = {i}");
    i++;
}

Or we keep the true loop condition and make the loop stop with the break statement:

int i = 0;

while (true)
{
    Console.WriteLine($"i = {i}");
    i++;

    // Fixed: terminate the loop with 'break'
    if (i > 9)
    {
        break;
    }
}

A loop that doesn't change the loop variable's value

Another thing that causes an infinite C# loop is when we don't change the loop variable. This mistake is easy to make; a quick interruption and this loop component is overlooked. Luckily, the fix is easy and straightforward.

Here's how the issue can look:

int i = 0;

while (i < 10)
{
    // ...

    Console.WriteLine($"i = {i}");
}

This while loop continues as long as the i variable is under 10. However, we don't change that variable's value. And so the loop doesn't progress.

To fix this infinite loop we add a statement to the loop's code that changes that variable. Here's one option:

while (i < 10)
{
    // ...

    Console.WriteLine($"i = {i}");

    // Fixed: increase the loop variable
    i = i + 1;
}

Mixing up the increment (`++`) or decrement (`--`) operators

Sometimes our loop does change the loop variable, but in the wrong direction. One situation in which that can happen is when we accidentally swap the increment operator (++) for the decrement operator (--), or vice versa. When we do, it takes a very long time before the loop variable reaches its 'exit value'.

For example:

// Accidentally decrease, rather than increase, the loop variable
for (int i = 0; i < 10; i--)
{
    Console.WriteLine($"i = {i}");
}

This for loop has a loop variable that starts at 0. The loop itself goes on as long as that variable is under 10. We don't, however, increase that variable after each loop cycle. Instead the i-- expression decreases the variable.

One solution is to increase that variable after each loop cycle:

// Fixed: increase 'i' up to 10
for (int i = 0; i < 10; i++)
{
    Console.WriteLine($"i = {i}");
}

Or, if we meant to make a reversed loop, change the for loop header to this:

// Loop from 10 to 1
for (int i = 10; i > 0; i--)
{
    Console.WriteLine($"i = {i}");
}

Wrong logical comparison in the loop's condition

Another thing that creates an infinite loop is when our loop condition performs the wrong logical comparison. We might, for instance, use > instead of <. Or make a comparison with the wrong variable.

An example of that latter is:

int j = 0;

// ...

int i = 0;

while (j < 10)
{
    Console.WriteLine($"i = {i}");
    i++;
}

This while loop tests the j variable, while the loop itself works with the i variable. That latter variable is what Console.WriteLine() and the increment (++) statement use.

So judging from the loop's code, we probably meant to test the i variable. So to fix it we do:

int j = 0;

// ...

int i = 0;

// Fixed: loop based on the 'i' variable
while (i < 10)
{
    Console.WriteLine($"i = {i}");
    i++;
}

The continue statement at the wrong place

C#'s continue statement makes an early start of the next loop cycle. When our program executes continue, it jumps over the remaining code in the loop and revisits the loop's header.

A possible risk is that we accidentally jump over code that should run with every loop cycle. An example of that issue is:

int i = 0;

while (i < 10)
{
    // Skip all even values
    if (i % 2 == 0)
    {
        continue;
    }

    Console.WriteLine($"i = {i}");
    i++;
}

The if statement in this while loop checks if the i variable has an even value. When it has, the continue statement gives the loop an early start on the next loop cycle.

That, however, also jumps over the statement that changes the loop variable (i++). So whenever the if statement's condition tests true, the i variable doesn't change anymore and we have an infinite loop.

The solution is to move continue after the code that changes the loop variable. Or, alternatively, increase that variable before continue runs. For example:

int i = -1;

while (i < 10)
{
    // Fixed: increase variable before 'continue'
    i++;

    // Skip all even values
    if (i % 2 == 0)
    {
        continue;
    }

    Console.WriteLine($"i = {i}");
}

This ends our discussion of common causes of infinite loops. Thanks for reading and I hope you learned something new.

If you want to learn more, see all my C# programming articles.

Happy holidays!

The four different loops of C#

Jos — Mon, 02 Sep 2019 15:09:01 +0000

This article appeared earlier on my website. It's also my first article here on Dev.to! :-)

To repeat code in C# we can use four different loops. But what loops are there and how do we use them? Let's find out.

Looping in C# programs: four different options

A loop repeats the same code several times. They make calculations and processing elements in a collection possible. Together with if statements they're an essential feature to control how our program executes.

Not every situation requires the same loop. And so C# has several loop options:

The for loop, which counts from one value to another.
The foreach loop, that easily iterates over all elements in a collection.
The while loop, which goes on as long as some condition is true.
And the do-while loop, which always executes at least once.

Let's take a closer look at these loop types.

Make a counting loop: C#'s `for`loop

The for loop repeats code up to a certain number of times. That behaviour is possible because this loop counts from one value to the next. This way we perform calculations and loop over a list or array.

The for loop is also a compact loop. It combines three common loop actions together: declare and initialise the loop variable, check the loop condition before each loop cycle, and update the loop variable after each iteration.

Quick example: the `for`loop in C

Here's how C#'s for loop looks:

    for (int i = 0; i < 5; i++)
    {
        Console.Write(i + "  ");
    }

The header of this for loop has three parts:

First we declare and initialise the i loop variable to a value of 0.
The loop condition checks if the i variable is under (<) 5. When it is, code inside the loop executes. When the condition tests false, the loop ends.
The last part updates the i loop variable with one after each loop cycle (i++). This way we iterate from one value to the next.

See C#'s for loop explained for much more. There's also an article about alternative for loops in C#.

When to use the `for`loop?

These are the situations in which we can use a for loop:

When code needs to execute a specific number of times. Since for automatically creates and updates the loop variable, it's easier to work with than other loops in those situations.
When code inside the loop needs a counting variable. Other C# loops can also use a counting variable, but the for loop manages one for us.
When code should not execute more than a certain number of times. In those cases for can easily count towards those loop limits.

Strengths and weaknesses of C#'s `for`loop

These are the strengths of C#'s for loop:

A for loop makes it easy to modify a collection or examine adjacent (the next or previous) elements.
Once we make the for loop header, we can focus on code inside the loop. There's no need to manage the loop variable inside the loop.
A for loop combines making a loop variable, updating that loop variable, and evaluating the loop's condition into a single line. This makes for a compact loop.
The for loop header always changes the loop variable after each loop cycle. There's no risk that we accidentally jump over the code that changes that variable with the continue statement.

The for loop also has some weaknesses:

If all we need is to loop over a collection, the for loop is more complex than needed. A foreach loop is then easier to work with.
Not every expression can be used in the for loop header to change the loop variable. If we need to change that variable in complex ways, the code for that has to be placed inside the loop.

Easily loop through a collection: C#'s `foreach`loop

The foreach loop elegantly loops through all items in a collection. The key feature of foreach is its loop variable. That variable is set to an element from the collection we loop over during each loop cycle.

Inside the loop we use that variable to work with the element's value. Then after each loop cycle, C# automatically sets that variable to the value of the next element in the collection. This makes foreach a lot easier to work with than C#'s other loops.

Quick example: the `foreach`loop

Here's how C#'s foreach loop looks:

    int[] values = { 0, 1, 2, 3, 4 };

    foreach (int value in values)
    {
        Console.Write(value + " ");
    }

The header of each foreach loop has three components:

First we define the type of loop variable. The loop above uses int because the array we loop over contains integer values.
Then we name the local loop variable. We use value in the above loop. In the loop's body, that variable refers to the element we currently loop over.
With the in keyword we specify the collection of values to loop over. We use values here, which is the integer array that's defined just above the loop.

See C#'s foreach loop explained for more details.

When to use the `foreach`loop?

We use C#'s foreach loop to work with each value from a collection. For that purpose foreach is a more convenient alternative to the for loop.

foreach cannot change the value it loops over. Or only iterate through part of the collection. For those two scenarios we still use the for loop.

Strengths and weaknesses of the `foreach`loop

Here are some advantages of the foreach loop:

It's an easy loop to write; C# automatically manages the loop variable and sets it to an element during each loop cycle. That makes the loop easier to write but also reduces possible mistakes.
foreach automatically goes through all elements in a collection. There's no need to manage the loop's start and end index.

Here are some foreach disadvantages:

Because the foreach loop works with a copy of the element we loop over (rather than the actual element), we cannot make changes to the collection we loop over. To make those changes we need to use a for loop, while loop, or do-while loop instead.
A foreach loop always goes through an entire collection. To process only a part, or skip certain elements, we can make a new collection or use the for loop.
A foreach loop always loops from index 0 to index Length - 1 (or Count - 1). If the loop should iterate backward, it's easier to use a for loop instead.
When our code also has to work with the element's index (besides its value), then the for loop is an easier choice.

Loop as long as something is `true`: the `while`loop

The while loop executes code for as long as some Boolean condition tests true. When that condition becomes false, the loop ends.

The strength of while is that we don't need to know in advance how many loop cycles we need. Instead the loop simply goes on for as long as its condition tests true. We do need some code inside the loop to make that condition false at some point; otherwise, the loop keeps running.

Quick example: C#'s `while`loop

Here's how C#'s while loop looks like:

    int i = 0;
    while (i < 5)
    {
        Console.Write(i + " ");
        i++;
    }

Before the loop we first make our i integer variable with a value of 0. Then the while loop begins. Its condition checks if that variable is under (<) 5. When it is, code inside the loop executes.

That code also increases the value of i with 1 (i++). That makes the loop's condition (i < 5) false after 5 loop cycles. (The alternative is that we get stuck with an infinite loop that doesn't end.)

See C#'s while loop explained to learn more.

When to use the `while`loop?

We use the while loop when we have to repeat code several times, but don't know how many loop cycles we need. This for instance happens when we process user input or crawl a website. In those situations we might need 10 loop cycles or 450 iterations. With a while loop we simply continue until some condition turns up false.

Another use case are complex calculations that don't involve the basic counting that the for loop provides.

Sometimes we also use the while loop to deliberately make an infinite loop. That way we can have our program 'wait' on certain things, like incoming data. In those cases while keeps our program active and ready.

If we have to loop over values of a collection, then it's often easier to use the foreach loop. And looping from one numerical value to another is easier with the for loop.

Strengths and weaknesses of the `while`loop

These things the while loop does well:

The while loop is an intuitive loop that's easy to read and understand. It's also a common loop, so many programmers understand your code when you use while.
The while loop continues until its condition tests false. That helps when we don't know the number of loop cycles in advance.
We can often update the loop variable inside the while loop header for details). That makes the loop's body more compact.

Here are some weaknesses that the while loop has:

The while loop often needs a statement inside its loop body that changes the loop condition. That means extra code. Plus code that we can easily skip over by accident with the continue statement.
The while loop is cumbersome when we need to count values or process collections. The for loop is an easier loop in those cases.

Execute once, then run while `true`: the `do-while`loop

A less common iteration option is C#'s do-while loop. This loop repeats code for as long as a condition tests true. That's similar to the while loop. But here's what makes do-while unique: this loop evaluates its condition after the loop's body executed.

Since that test happens after the loop's code, code inside the loop always runs at least once. If the loop condition is true after that first run, the do-while loop continues. Else it stops. So there's at least one loop cycle, with the possibility of getting more.

Quick example: the `do-while`loop in C

Here's a quick example of the do-while loop:

    int i = 0;
    do
    {
        Console.Write(i + " ");
        i++;
    } while (i < 5);

We first declare the i variable and give it a default of 0. Then we make a do-while loop. First we use the do keyword and then a pair of braces ({ and }). Between them we place our code that should repeatedly execute.

The loop's body has the Console.Write() method output the current value of i. Then the increment operator (++) increases that loop variable with one. That makes the loop condition false at some point.

Then we check that loop condition. We use the while keyword and evaluate whether i is less than (<) 5. As long as it is, code inside this loop executes.

See C#'s do-while loop explained to learn more.

When to use C#'s `do-while`loop?

In general, the do-while loop can handle the same situations as the while loop can. That is, we use do-while to loop for as long as some condition remains true, without necessarily knowing in advance how many loop cycles that takes.

Of course what makes the do-while loop unique is that it always executes once. But because do-while is rather uncommon, chances are that people reading your code find this loop harder to understand. Because of that it's a good idea to use do-while only when you definitely need its unique feature.

Strengths and weaknesses of the `do-while`loop

These are the strengths of the do-while loop:

do-while always executes its loop body once. This way other program can safely assume that the loop's code executed.
Like the while loop, do-while loop runs for as long as its condition tests true. This makes the loop flexible without us specifying in advance how many loop cycles we need.

There are some disadvantages with the do-while loop too:

When we count with the do-while loop, we'll have to use a separate variable to control the loop. We have to manage that variable inside the loop in the right way, and not for instance jump over it with the continue statement. This requires a bit more work than the same behaviour with the for loop, for instance.
The do-while loop is uncommon. That makes mistakes more likely. And increases the odds that people reading your code have trouble understanding the loop well.
The do-while loop is cumbersome when we need to process elements in a collection. For that the foreach loop or the for loop are much better options.
A do-while loop guarantees that the loop's code always runs once. But that's also possible with a regular while loop that has its loop condition initialised to true.

Summary

C# has four types. With the for loop we count from one value to another. This helps when we process elements in a collection and with math.

The foreach loop can also iterate through a collection. This loop is however easier to manage, automatically goes through an entire collection, and updates the loop variable automatically.

If we need to repeat code but don't know how many loop cycles that takes, we use the while loop. Before each loop cycle, while checks a true/false condition. When true, the loop runs; else, the loop ends (or doesn't even start).

Similar is the do-while loop. This loop also keeps running when a condition tests true. What's unique, however, is that do-while always executes once, even when its condition is false the first time.

DEV Community: Jos

8 Common Causes of Infinite C# Loops

Fix infinite loops: 8 causes

An exit condition that's never reached

A condition that makes the loop start over and over again

Change the loop variable to a new value inside the loop

A loop without an exit condition

A loop that doesn't change the loop variable's value

Mixing up the increment (++) or decrement (--) operators

Wrong logical comparison in the loop's condition

The continue statement at the wrong place

The four different loops of C#

Looping in C# programs: four different options

Make a counting loop: C#'s forloop

Quick example: the forloop in C

When to use the forloop?

Strengths and weaknesses of C#'s forloop

Easily loop through a collection: C#'s foreachloop

Quick example: the foreachloop

When to use the foreachloop?

Strengths and weaknesses of the foreachloop

Loop as long as something is true: the whileloop

Quick example: C#'s whileloop

When to use the whileloop?

Strengths and weaknesses of the whileloop

Execute once, then run while true: the do-whileloop

Quick example: the do-whileloop in C

When to use C#'s do-whileloop?

Strengths and weaknesses of the do-whileloop