Drop hier links of afbeeldingen om ze aan de editor toe te voegen.

Bij de gewone while-lus wordt de voorwaarde eerst gecontroleerd, nog voor de code tussen de accolades ook maar één keer is uitgevoerd. Soms is dat lastig: je moet er dan zelf voor zorgen dat aan de voorwaarde voldaan is voordat de lus voor het eerst draait (bijvoorbeeld door een variabele vooraf een geschikte beginwaarde te geven).

Om dat probleem op te lossen bestaat er een tweede vorm van de herhalingslus: de do-while-lus. Hierbij wordt de voorwaarde pas gecontroleerd na het uitvoeren van de code tussen de accolades. Het gevolg is belangrijk:

Bij een do-while-lus wordt de code tussen de accolades altijd minstens één keer uitgevoerd, ongeacht of de voorwaarde waar is of niet.

De structuur

Een do-while-lus ziet er zo uit:

do
{
    // Hier komen de instructies van het programma
} while (voorwaarde);

Merk twee dingen op:

Bij do staat geen voorwaarde. De code tussen de accolades wordt sowieso één keer uitgevoerd.
De voorwaarde staat onderaan, achter het woord while. Wanneer die voorwaarde waar is, wordt de code tussen de accolades opnieuw uitgevoerd; is ze niet langer waar, dan stopt de lus.

Schematisch ziet een do-while-lus er zo uit. Merk op dat het lichaam vóór de voorwaarde staat, en dus altijd minstens één keer draait:

Let op de puntkomma achter while (voorwaarde);. Bij een gewone while-lus is die puntkomma niet nodig, maar bij een do-while-lus dus wel. Vergeet je ze, dan krijg je een foutmelding.

Het verschil met de while-lus

Dezelfde herhaling, twee vormen:

	while-lus	do-while-lus
Voorwaarde wordt getest	vóór de body	na de body
Body draait minstens	0 keer	1 keer
Puntkomma achter `while(...)`	nee	ja

Kies een do-while-lus wanneer de body sowieso minstens één keer moet draaien. Een typisch voorbeeld: je vraagt iets aan de gebruiker en herhaalt de vraag zolang het antwoord niet voldoet. De eerste vraag moet je altijd stellen, dus de body moet sowieso één keer lopen, voordat je de voorwaarde kunt controleren.

Een uitgewerkt voorbeeld

We schrijven een programma dat na afloop vraagt: “Wil je het programma nog eens uitvoeren?” Zolang de gebruiker J (van ja) antwoordt, wordt de body opnieuw uitgevoerd. De vraag moet sowieso één keer gesteld worden, dus een do-while-lus past hier perfect.

// declaratie van variabelen
string antwoord;

// hoofdstructuur van het programma
do
{
    // Hier komen de instructies van het programma

    Console.Write("Wil je het programma nog eens uitvoeren? (J/N) ");
    antwoord = Console.ReadLine();
} while (antwoord.ToUpper().Substring(0, 1) == "J");

// Resultaat weergeven
Console.WriteLine();
Console.WriteLine("Bedankt om dit programma te gebruiken");

Bespreking van de code

De variabele antwoord wordt gedeclareerd. We hoeven er geen beginwaarde aan te geven: de do-while-lus voert de body sowieso één keer uit, en daar krijgt antwoord zijn eerste waarde via Console.ReadLine(). Bij een gewone while-lus zou dat niet kunnen, want die test de voorwaarde al voordat antwoord een waarde heeft.
Achter do staat geen voorwaarde. De instructies tussen de accolades worden dus altijd minstens één keer uitgevoerd.
Onderaan staat de voorwaarde terug. Zolang die waar is, wordt de code tussen de accolades opnieuw uitgevoerd. Vergeet ook hier de puntkomma niet.

De voorwaarde antwoord.ToUpper().Substring(0, 1) == "J" is wat technischer:

antwoord.ToUpper() zet het antwoord om naar hoofdletters, zodat zowel j als J als ja tellen.
.Substring(0, 1) neemt enkel het eerste teken, zodat ook ja of Ja als ja tellen.
== "J" controleert of dat eerste teken een J is.

Met een do-while-lus hoef je geen kunstmatige beginwaarde te verzinnen om de lus voor het eerst te laten draaien: de body draait altijd al één keer, en pas daarna beslis je of je nog eens herhaalt.