Oefening - "do" en "while" iteratielussen maken

10 minuten

Op het eerste gezicht zijn de do-while en while instructies nog een iteratie-instructie waarmee u een codeblok kunt doorlopen en zo de stroom van de uitvoering van uw code kunt wijzigen. Zodra we echter onderzoeken hoe elk werkt, kunnen we de nuances van elke iteratie-instructie beter identificeren en wanneer ze moeten worden gebruikt.

Wat is de do-while-lus?

Met de do-while instructie wordt een instructie of een blok instructies uitgevoerd, zolang een opgegeven Booleaanse expressie waar is. Omdat deze expressie na elke uitvoering van de lus wordt geëvalueerd, voert een do-while-lus één of meerdere keren uit.

do
{
    // This code executes at least one time
} while (true);

De uitvoeringsstroom begint binnen de accolade. De code wordt ten minste één keer uitgevoerd en vervolgens wordt de Boole-expressie naast het while trefwoord geëvalueerd. Als de Boole-expressie wordt geretourneerd true, wordt het codeblok opnieuw uitgevoerd.

Door de Boole-expressie hard te coderen, truehebben we een oneindige lus gemaakt. Een lus die nooit eindigt, in ieder geval, niet zoals deze momenteel is geschreven. We hebben een manier nodig om de lus binnen het codeblok uit te breken. We bespreken binnenkort de afsluitcriteria van een do-while.

We gaan nu onze codeomgeving voorbereiden en beginnen met het onderzoeken van codevoorbeelden die een do-while instructie implementeren.

Uw coderingsomgeving voorbereiden

Deze module bevat praktische activiteiten die u begeleiden bij het bouwen en uitvoeren van demonstratiecode. We raden u aan om deze activiteiten uit te voeren met behulp van Visual Studio Code als uw ontwikkelomgeving. Het gebruik van Visual Studio Code voor deze activiteiten helpt u om comfortabeler code te schrijven en uit te voeren in een ontwikkelomgeving die wordt gebruikt door professionals wereldwijd.

Open Visual Studio Code.

U kunt de Windows-Startmenu (of een equivalente resource voor een ander besturingssysteem) gebruiken om Visual Studio Code te openen.
Selecteer Map openen in het menu Visual Studio Code-bestand.
Navigeer in het dialoogvenster Map openen naar de map Windows Desktop.

Als u een andere maplocatie hebt waar u codeprojecten bewaart, kunt u die maplocatie gebruiken. Voor deze training is het belangrijk om een locatie te hebben die gemakkelijk te vinden en te onthouden is.
Selecteer in het dialoogvenster Map openen de optie Selecteer Map.

Als u een beveiligingsdialoogvenster ziet waarin u wordt gevraagd of u de auteurs vertrouwt, selecteert u Ja.
Selecteer In het menu Visual Studio Code Terminalde optie Nieuwe terminal.

U ziet dat in een opdrachtprompt in het terminalvenster het mappad voor de huidige map wordt weergegeven. Voorbeeld:
```
C:\Users\someuser\Desktop>
```
Opmerking

Als u op uw eigen pc werkt in plaats van in een sandbox of gehoste omgeving en u andere Microsoft Learn-modules in deze C#-serie hebt voltooid, hebt u mogelijk al een projectmap gemaakt voor codevoorbeelden. Als dat het geval is, kunt u de volgende stap overslaan, die wordt gebruikt om een console-app te maken in de map TestProject.
Voer bij de terminalopdrachtprompt de volgende prompt in om een nieuwe consoletoepassing in een opgegeven map te maken:
```
dotnet new console -o ./CsharpProjects/TestProject
```
Deze .NET CLI-opdracht maakt gebruik van een .NET-programmasjabloon om een nieuw C#-consoletoepassingsproject te maken op de opgegeven maplocatie. Met de opdracht worden de mappen CsharpProjects en TestProject voor u gemaakt en wordt TestProject gebruikt als de naam van uw .csproj bestand.

Als er een bericht wordt weergegeven waarin wordt aangegeven dat de bestanden al bestaan, gaat u verder met de volgende stappen. U gebruikt de bestaande projectbestanden opnieuw.
Vouw in de EXPLORER-weergave de map CsharpProjects uit .

U ziet de map TestProject en twee bestanden, een C#-programmabestand met de naam Program.cs en een C#-projectbestand met de naam TestProject.csproj.
Selecteer Map openen in het menu Visual Studio Code-bestand.
Selecteer in het dialoogvenster Map openen de map CsharpProjects en klik vervolgens op Map selecteren.
Vouw in de explorer-weergave de map TestProject uit en selecteer Program.cs.
Verwijder de bestaande coderegels.

U gebruikt dit C#-consoleproject om codevoorbeelden te maken, te bouwen en uit te voeren tijdens deze module.
Sluit het deelvenster Terminal.

Schrijf een do-while-instructie die stopt als een specifiek willekeurig nummer gegenereerd wordt

We gaan code schrijven die willekeurige getallen tussen 1 en 10 blijft genereren totdat we het getal 7 genereren. Het kan slechts één iteratie duren om een 7 te krijgen, of het kan tientallen iteraties duren.

Zorg ervoor dat Visual Studio Code is geopend en Program.cs weergegeven in het deelvenster Editor.

Opmerking

Program.cs moet leeg zijn. Als dat niet zo is, selecteert en verwijdert u alle coderegels.

Typ de volgende code in de Visual Studio Code Editor.

Random random = new Random();
int current = 0;

do
{
    current = random.Next(1, 11);
    Console.WriteLine(current);
} while (current != 7);

Selecteer Opslaan in het menu Visual Studio Code File.

Het Program.cs-bestand moet worden opgeslagen voordat u de code bouwt of uitvoert.
Klik in het deelvenster EXPLORER om een Terminal te openen op de locatie van de map TestProject met de rechtermuisknop op TestProject en selecteer Vervolgens Openen in geïntegreerde terminal.

Er wordt een Terminal paneel geopend. De Terminal moet een opdrachtprompt bevatten waarin wordt aangegeven dat de terminal is geopend voor de locatie van de map TestProject.
Typ dotnet-run bij de Terminal-opdrachtprompt en druk op Enter om uw code uit te voeren.

Opmerking

Als er een bericht wordt weergegeven met de tekst 'Kan een project niet vinden om uit te voeren', controleert u of in de Terminal-opdrachtprompt de verwachte locatie van de testprojectmap wordt weergegeven. Bijvoorbeeld: C:\Users\someuser\Desktop\csharpprojects\TestProject>
Controleer de uitvoer.

Omdat de gegenereerde getallen willekeurig zijn, zijn uw resultaten anders. De waarde 7 zal echter het laatste getal zijn dat wordt afgedrukt, omdat de Booleaanse expressie evalueert tot false wanneer er een 7 wordt gegenereerd en de uitvoeringsstroom het codeblok zal verlaten.
```
2
5
8
2
7
```
Neem even de tijd om uw code te controleren.

Een belangrijk leerproces voor deze eerste taak is dat het codeblok van een do-while lus ten minste één keer wordt uitgevoerd. Het kan een groot aantal keren herhalen en het is onwaarschijnlijk dat we van tevoren weten hoeveel iteraties er zullen zijn.

Het is ook belangrijk te beseffen dat de code binnen het codeblok beïnvloedt of er verder wordt geïtereerd of niet. Een codeblok dat invloed heeft op de afsluitcriteria is een primaire reden om een do-while- of while-instructie te selecteren in plaats van een van de andere iteratie-instructies. Zowel foreach als for zijn afhankelijk van factoren die zich buiten het codeblok bevinden om het aantal iteraties van het codeblok te bepalen.

Schrijf een tijdje-instructie die alleen wordt herhaald wanneer een willekeurig getal groter is dan een bepaalde waarde

Laten we nu eens kijken naar de while verklaring.

Gebruik de Visual Studio Code-editor om uw code als volgt bij te werken:
```
Random random = new Random();
int current = random.Next(1, 11);

/*
do
{
    current = random.Next(1, 11);
    Console.WriteLine(current);
} while (current != 7);
*/

while (current >= 3)
{
    Console.WriteLine(current);
    current = random.Next(1, 11);
}
Console.WriteLine($"Last number: {current}");
```
Opmerking

In dit geval positioneren we het while trefwoord en de Boole-expressie vóór het codeblok. Hierdoor verandert de betekenis van de code en fungeert het als een 'toegangspoort' zodat alleen het uitvoeringsproces kan beginnen als de booleaanse expressie waar oplevert.
Sla uw codebestand op en gebruik Visual Studio Code om uw code uit te voeren.

Voer dotnet run vanaf de Terminal-opdrachtprompt in om uw code uit te voeren.
Controleer de weergegeven uitvoerwaarden.

Omdat de getallen willekeurig zijn, zal uw code dus een andere reeks produceren.
```
9
7
5
Last number: 1
```
Neem even de tijd om uw code te controleren.

In de bovenste code gebruiken random we om de int variabele met de naam currentte initialiseren. Onze volgende actieve coderegel is onze while instructie.

Onze while instructie wordt herhaald op basis van de Boole-expressie (current >= 3). We weten niet aan welke waarde wordt toegewezen current, maar er zijn mogelijkheden die van invloed zijn op onze while lus:
- Als current wordt geïnitialiseerd naar een waarde die groter is dan of gelijk is aan 3, retourneert truede Booleaanse expressie en wordt het codeblok ingevoerd door de uitvoeringsstroom. Het eerste wat we doen in het codeblok is het schrijven van de waarde naar current de console. Vervolgens werken we, nog steeds in het codeblok, de waarde van current bij met een nieuwe willekeurige waarde. Op dit moment gaat het besturingselement terug naar het begin van de while instructie waar de Boole-expressie wordt geëvalueerd. Dit proces wordt voortgezet totdat de Boole-expressie wordt geretourneerd false en de uitvoeringsstroom wordt verbroken van het codeblok.
- Als current wordt geïnitialiseerd (boven aan de code) naar een waarde kleiner dan 3, retourneert falsede Boole-expressie en wordt het codeblok nooit uitgevoerd.
De laatste coderegel schrijft de waarde van current naar de console. Deze code wordt uitgevoerd, ongeacht of het iteratiecodeblok is uitgevoerd, en biedt ons de mogelijkheid om de uiteindelijke waarde van current naar de console te schrijven.

Gebruik de continue-statement om rechtstreeks naar de booleaanse expressie te gaan

In bepaalde gevallen willen we de rest van de code in het codeblok kortsluiten en doorgaan naar de volgende iteratie. Dat kunnen we doen met behulp van de continue instructie.

Gebruik de Visual Studio Code-editor om uw code als volgt bij te werken:

Random random = new Random();
int current = random.Next(1, 11);

do
{
    current = random.Next(1, 11);

    if (current >= 8) continue;

    Console.WriteLine(current);
} while (current != 7);

/*
while (current >= 3)
{
    Console.WriteLine(current);
    current = random.Next(1, 11);
}
Console.WriteLine($"Last number: {current}");
*/

Neem even de tijd om uw code te controleren.

U ziet dat we terug zijn geschakeld naar een do-while. Een do-while zorgt ervoor dat de lus ten minste één keer wordt herhaald.

Het eerste wat we in het codeblok doen, is door een nieuwe willekeurige waarde toe te wijzen aan current. Vervolgens controleren we of current deze groter is dan of gelijk is aan 8. Als deze expressie true oplevert, zal het continue sleutelwoord de controle overdragen naar het einde van het codeblok en zal while(current != 7) evalueren. De lus blijft dus herhalen zolang de waarde current niet gelijk is aan 7.

De sleutel tot deze stap van de oefening is de coderegel die het continue sleutelwoord bevat:
```
if (current >= 8) continue;
```
Omdat onze code die de waarde van current naar de console schrijft zich bevindt na de if (current >= 8) continue;, zorgt onze code ervoor dat een waarde van current groter dan of gelijk aan 8 nooit naar het outputvenster wordt geschreven.

Laten we het eens proberen.
Sla uw codebestand op en gebruik Visual Studio Code om uw code uit te voeren.

Voer dotnet run vanaf de Terminal-opdrachtprompt in om uw code uit te voeren.
Controleer de weergegeven uitvoerwaarden.
```
5
1
6
7
```
U ziet waarschijnlijk andere resultaten dan hieronder wordt weergegeven. U ziet echter geen waarden 8 of hoger in het uitvoervenster voordat de uitvoering van de code eindigt op de waarde 7.
Houd rekening met het verschil tussen de continue en break instructies.

Zoals u in deze laatste stap hebt gezien, wordt de uitvoering door de continue instructie overgedragen naar het einde van de huidige iteratie. Dit gedrag verschilt van het gedrag dat we met de break instructie hebben gezien. De break instructie beëindigt de iteratie (of switch) en brengt het besturingselement over naar de instructie die volgt op de beëindigde instructie. Als er geen instructie na de beëindigde instructie is, gaat de uitvoering verder naar het einde van het bestand of de methode.

Samenvatting

Er zijn enkele belangrijke ideeën die u uit deze les moet meenemen:

De do-while instructie doorloopt ten minste één keer een codeblok en blijft mogelijk herhalen op basis van een Boole-expressie. De evaluatie van de Boole-expressie is meestal afhankelijk van een waarde die is gegenereerd of opgehaald in het codeblok.
De while instructie evalueert eerst een Boolese expressie en blijft het codeblok doorlopen zolang de Boolese expressie evalueert tot true.
Het continue trefwoord om onmiddellijk naar de Boolean-expressie te springen.

Feedback

Is deze pagina nuttig?

Oefening - "do" en "while" iteratielussen maken

De kennistoets

Feedback