Voorbeeld 1:while-lus

using System;

namespace Loop
{
	class WhileLoop
	{
		public static void Main(string[] args)
		{
			int i=1;
			while (i<=5)
			{
				Console.WriteLine("C# For Loop: Iteration {0}", i);
				i++;
			}
		}
	}
}

Wanneer we het programma uitvoeren, is de uitvoer:

C# For Loop: Iteration 1
C# For Loop: Iteration 2
C# For Loop: Iteration 3
C# For Loop: Iteration 4
C# For Loop: Iteration 5

Aanvankelijk de waarde van i is 1.

Wanneer het programma de while-lus-instructie bereikt,

• de testuitdrukking i <=5 wordt geëvalueerd. Sinds ik is 1 en 1 <= 5 is true , voert het de body van de while-lus uit. Hier wordt de lijn op het scherm afgedrukt met Iteratie 1 en de waarde van i wordt met 1 verhoogd tot 2.
• Nu, de testuitdrukking (i <=5 ) wordt opnieuw geëvalueerd. Ook deze keer retourneert de uitdrukking true (2 <=5), dus de lijn wordt op het scherm afgedrukt en de waarde van i wordt nu verhoogd naar 3..
• Dit gaat en de while-lus wordt uitgevoerd totdat i wordt 6. Op dit punt evalueert de test-uitdrukking tot false en dus eindigt de lus.

Voorbeeld 2:while-lus om de som van de eerste 5 natuurlijke getallen te berekenen

using System;

namespace Loop
{
	class WhileLoop
	{
		public static void Main(string[] args)
		{
			int i=1, sum=0;

			while (i<=5)
			{
				sum += i;
				i++;
			}
			Console.WriteLine("Sum = {0}", sum);
		}
	}
}

Wanneer we het programma uitvoeren, is de uitvoer:

Sum = 15

Dit programma berekent de som van de eerste 5 natuurlijke getallen.

• Aanvankelijk de waarde van som wordt geïnitialiseerd op 0.
• Bij elke iteratie, de waarde van som is geüpdatet naar sum+i en de waarde van i wordt verhoogd met 1.
• Als de waarde van i bereikt 6, de testuitdrukking i<=5 zal false retourneren en de lus wordt beëindigd.

Laten we eens kijken wat er bij elke iteratie in het gegeven programma gebeurt.

Aanvankelijk, ik =1, som =0

Dus de uiteindelijke waarde van som wordt 15.

C# do...while-lus

De doe en terwijl trefwoord wordt gebruikt om een ​​do...while-lus te maken. Het lijkt op een while-lus, maar er is een groot verschil tussen beide.

In while-lus wordt de voorwaarde gecontroleerd voordat de body wordt uitgevoerd. Het is precies het tegenovergestelde in de do...while-lus, d.w.z. de voorwaarde wordt gecontroleerd nadat de body is uitgevoerd.

Dit is de reden waarom de hoofdtekst van de do...while-lus ten minste één keer wordt uitgevoerd, ongeacht de testexpressie.

De syntaxis voor de do...while-lus is:

do
{
	// body of do while loop
} while (test-expression);

Hoe werkt...while-lus?

1. De hoofdtekst van de do...while-lus wordt eerst uitgevoerd.
2. Vervolgens de test-expression wordt geëvalueerd.
3. Als de test-expression is true , wordt de hoofdtekst van de lus uitgevoerd.
4. Als de test-expression is false , do...while-lus eindigt.

do...while-stroomdiagram

Voorbeeld 3:do...while-lus

using System;

namespace Loop
{
	class DoWhileLoop
	{
		public static void Main(string[] args)
		{
			int i = 1, n = 5, product;

			do
			{
				product = n * i;
				Console.WriteLine("{0} * {1} = {2}", n, i, product);
				i++;
			} while (i <= 10);
		}
	}
}

Wanneer we het programma uitvoeren, is de uitvoer:

5 * 1 = 5
5 * 2 = 10
5 * 3 = 15
5 * 4 = 20
5 * 5 = 25
5 * 6 = 30
5 * 7 = 35
5 * 8 = 40
5 * 9 = 45
5 * 10 = 50

Zoals we kunnen zien, drukt het bovenstaande programma de vermenigvuldigingstabel van een getal (5) af.

• Aanvankelijk was de waarde van i is 1. Het programma, gaat dan de body van de do..while-lus binnen zonder enige voorwaarde te controleren (in tegenstelling tot while-lus).
• In het lichaam, product wordt berekend en op het scherm afgedrukt. De waarde van i wordt dan verhoogd naar 2.
• Na de uitvoering van de hoofdtekst van de lus, de testuitdrukking i <= 10 wordt geëvalueerd. In totaal wordt de do...while-lus 10 keer uitgevoerd.
• Ten slotte, wanneer de waarde van i is 11, de test-uitdrukking evalueert tot false en beëindigt daarmee de lus.

---

Oneindige while en do...while loop

Als de testexpressie in de while- en do...while-lus nooit evalueert tot false , het lichaam van de lus zal voor altijd worden uitgevoerd. Dergelijke lussen worden oneindige lussen genoemd.

Bijvoorbeeld:

Oneindige while-lus

while (true)
{
	// body of while loop
}

Oneindige do...while-lus

do
{
	// body of while loop
} while (true);

De oneindige lus is handig wanneer we een lus nodig hebben om te draaien zolang ons programma loopt.

Als uw programma bijvoorbeeld een animatie is, moet u het constant uitvoeren totdat het wordt gestopt. In dergelijke gevallen is een oneindige lus nodig om de animatie herhaaldelijk te laten lopen.