The while loop could be considered the ultimate in loop simplicity. Essentially, repeat some action, do some stuff until I say otherwise. The syntax is while followed by some Boolean condition that evaluates to true, within brackets and the body of the loop enclosed in braces. Sometimes the Boolean condition may seem a little back to front. For example, while not done, keep doing, and the while condition can be arbitrarily complex. While loops are often used as placeholders, waiting for events to take place.

As an aside, in Windows, each window has an event loop that whirrs away in the background, waiting for user interaction, such as mouse clicks and keyboard presses. Within the loop, some functions will take the appropriate action when one of these events is detected. The Boolean condition for the window's event loop is something like, keep checking for events while the window is not closed.

Because the while loop is so flexible, you could use it like a for-loop where the Boolean condition checks the value of a counter variable against some numerical limit, but let's not dwell on that, as it's the domain of the for-loop.

There is a variation on the while loop called the do-while loop. Essentially, the same as a while loop, except the while condition evaluation is at the end of the loop. The keyword do begins the loop, meaning it's executed at least once no matter the condition evaluation's result. I can't recall a time I've used a do-while loop, as it doesn't add functionality that can't be achieved with a while loop.

Here I have a while loop that checks two conditions. First, we compare the current time with the Now property of .NET's DateTime object with another DateTime variable called endTime, which I've set to be five seconds in the future. The endTime value is set by using the add seconds method of the DateTime class. Secondly, I have a bool variable called finished initialized to false, and I'm using the double ampersand "and" operator to say, while endTime is greater than now and I'm not finished continue looping. As soon as either of these conditions becomes false, the loop will terminate. The state of the finished Boolean is set to true when the integer counter i equals nine. Each time through the loop, we compare i to 9 and then increment it, which is not how it reads. Next, I write out to the console the value of i and the current time formatted as hours, minutes, seconds, and milliseconds. Yes, triple f doesn't immediately spring to mind when thinking of something to represent milliseconds, but obviously, the M is taken for minutes. To introduce some delay in the execution of the loop, so we can see what's happening and the output doesn't disappear off the bottom of the screen, I'll use the sleep method. The sleep method of the system thread object takes an integer value specifying the number of milliseconds to pause the current thread's execution. To introduce some literal randomness, I'm using the Next method of the System.Random object to say return a randomly generated number between 50 and 2500. Each time round the loop execution will pause for between 50 ms and 2 ½ seconds. Okay, let's run that. We can see that the while loop has terminated because now is greater than endTime, five seconds has elapsed. Now, I'll reduce the sleep time by getting the randomly generated milliseconds to be between 10 and 500. When we rerun it, we can deduce that finished has become true because i is now ten, and if we look at the printed out times, less than five seconds has elapsed. What's interesting to note here is the order of operations when assigning the value to finished. Because 10 has been written to the console, we can assume that i is equal to 9, making finished true and then incremented by one.

On its face, while loops appear simple and straightforward, where you update the condition variable, in this case, finished, to terminate the loop. However, where you do that in relation to the other statements being executed does change the code's behavior. If I move the finished evaluation to the end of the loop, I get slightly different behavior. This simple example makes it seem obvious, but in complex code where the variable used for while loop evaluation is also used for conditional branching within the loop, it can have unexpected consequences.