.NET Array Dictionary List String 2D Async DataTable Dates DateTime Enum File For Foreach Format IEnumerable If IndexOf Lambda LINQ Parse Path Process Property Regex Replace Sort Split Static StringBuilder Substring Switch Tuple


C#: Foreach
Do-keyword

Do begins a loop. The loop body comes before its condition. Every looping construct has advantages. This loop is rarely needed—it probably has more disadvantages than advantages. We use the do-while loop.

While
Array

Example. First, we use the do-while loop to sum the values of the elements in an int array. The int array here is guaranteed to have four elements. You can avoid checking the length before starting checking its elements in do-while.

Int ArrayArray Length
C# program that uses do-while loop

class Program
{
    static void Main()
    {
	int[] ids = new int[] { 6, 7, 8, 10 };

	//
	// Use do-while loop to sum numbers in 4-element array.
	//
	int sum = 0;
	int i = 0;
	do
	{
	    sum += ids[i];
	    i++;
	} while (i < 4);

	System.Console.WriteLine(sum);
    }
}

Output

31
Squares

The example code declares an integer array of four values. A do-while loop is executed, summing each value in the array. The length of the array is not checked before adding the first element's value to the sum.

Note: This code would throw an exception if the array was empty. The array would be accessed out-of-range.

IndexOutOfRangeException

For the do-while loop, you just use the "do" keyword before the loop block curly brackets. After the brackets, you specify the condition while. The while is executed after the code is run.

Tip: The difference with do-while is that no condition is tested before the statements in the loop are executed the first time.


Example 2. The most common type of loop (other than foreach) is the for-loop. It allows you to specify the three conditions right at the start. In these examples, we modify a for-loop. We turn it into a do-while loop.

For-loop: C#

static int SumFor()
{
    //
    // Sum numbers 0 .. 4
    //
    int sum = 0;
    for (int i = 0; i < 5; i++)
    {
	sum += i;
    }
    return sum;
}

Do-while loop: C#

static int SumDoWhile()
{
    //
    // Sum numbers 0 .. 4
    //
    int sum = 0;
    int i = 0;
    do
    {
	sum += i;
	i++;
    } while (i < 5);
    return sum;
}

While-loop: C#

static int SumWhile()
{
    //
    // Sum numbers 0 .. 4
    //
    int sum = 0;
    int i = 0;
    while (i < 5)
    {
	sum += i;
	i++;
    }
    return sum;
}
Steps

For loop. This loop walks through the indexes 0, 1, 2, 3 and 4. The sum of these numbers is 10, which is the result of the SumFor method. The loop is very compact: it requires three lines of C# code.

For

Do-while: This loop also walks through the indexes 0, 1, 2, 3 and 4. But it will test the index 0 without checking any bounds.

While: The body statements of this loop are the same as in the do-while loop. It has the iteration statement at the start.


Cover-logo

Discussion. The critical difference between the for loop and the do-while loop is that in do-while, no conditions are checked before entering the loop. The while-loop is the same as the do-while loop, but with the condition at the start.

This difference in the first iteration is important. It is also the reason why do-while loops are probably less useful than other loop constructs. All other loops have a test before the first iteration.

Caution: The do-while loop is much less common. This makes errors due to human factors more likely.


Abstract squares

MSIL. We inspected the MSIL generated with for and do-while loops. With for, there is an additional "br.s" statement, which "unconditionally transfers control" to somewhere else. Testing revealed no difference in performance between the loops.

So: It is likely that the JIT optimized the loops to the same machine instructions.

MSIL

Summary. It is reasonable to avoid do-while loops. They are less familiar to developers. They do not measurably change performance. The three loops had no performance difference, and the for-loop had shorter syntax.