Iteratie-uitspraken

Tip

Dit artikel maakt deel uit van de sectie Grondbeginselen voor ontwikkelaars die al ten minste één programmeertaal kennen en C# leren. Als u nieuw bent in programmeren, begint u eerst met de Aan de slag-handleidingen. Zie iteratie-instructies in het naslagwerk voor de taal voor de volledige syntax.

Komt u uit een andere taal? Alle vier C#-lussen (foreach, while, do-whileen for) hebben directe equivalenten in Java, C++en JavaScript. U gebruikt foreach het vaakst. Het doorloopt een verzameling zonder index, zoals Java's enhanced for of JavaScripts for...of.

Herhalingsinstructies voeren herhaaldelijk een codeblok uit. Elke keer dat het blok wordt doorlopen, is een iteratie, en een herhalend blok is een lus. C# biedt vier lussen. Begin met foreach verzamelingen, gebruik while en do-while wanneer een voorwaarde de herhaling bepaalt en gebruik for wanneer u een expliciete index nodig hebt.

Een verzameling herhalen met foreach

De foreach instructie voert de hoofdtekst één keer uit voor elk element in een verzameling, in volgorde. Dit is de meest voorkomende keuze voor het lezen van een verzameling, omdat u geen index of een begrenzingscontrole beheert. De foreach instructie voorkomt typische off-by-one-fouten:

string[] names = ["Ana", "Ben", "Cleo"];

// foreach reads each element in order. It's the default loop for
// collections: no index to manage and no off-by-one mistakes.
foreach (string name in names)
{
    Console.WriteLine(name); // => Ana, then Ben, then Cleo
}

foreach werkt met elk type dat C# herkent als een reeks, inclusief matrices, List<T>en Dictionary<TKey,TValue>. De iteratievariabele (name in het vorige voorbeeld) is alleen-lezen, dus kunt u deze binnen de lus niet opnieuw toekennen.

De hoofdtekst van een lus is één instructie, zoals een toewijzing of een methodeaanroep. Een blokinstructie is zelf één instructie die nul of meer instructies tussen accolades ({ }) plaatst.

Veel coderingsstandaarden raden u aan de lustekst tussen accolades te zetten, zelfs voor één instructie. Accolades maken het bereik expliciet. Dit voorkomt een veelvoorkomende fout: later een tweede regel toevoegen waarvan u verwacht dat die bij elke iteratie wordt uitgevoerd, maar die in plaats daarvan één keer na de lus wordt uitgevoerd. Alleen de accolades bepalen welke instructies deel uitmaken van de lus. C# kent geen betekenis toe aan witruimte, dus alleen inspringing doet er nooit toe. Accolades zijn zelfs bij één regel toegestaan: het blok is die ene instructie die door de lus wordt herhaald. Spring je code in voor de leesbaarheid, maar gebruik accolades om het blok af te bakenen.

Herhaal zolang aan een voorwaarde wordt voldaan met while

Een while lus controleert de Boole-voorwaarde vóór elke iteratie. Als de voorwaarde aan het begin staat false , wordt de hoofdtekst nooit uitgevoerd, dus een while lus wordt nul of meer keer uitgevoerd:

int countdown = 3;

// A while loop checks its condition before each iteration, so the body
// runs zero or more times.
while (countdown > 0)
{
    Console.WriteLine(countdown); // => 3, then 2, then 1
    countdown--;
}

Zorg ervoor dat iets in de lus de voorwaarde wijzigt. In het vorige voorbeeld countdown-- wordt uiteindelijk de voorwaarde false. Een lus waarvan de voorwaarde nooit false wordt, blijft voor altijd doorgaan.

Voer de hoofdtekst ten minste één keer uit met do-while

Een do-while lus controleert de voorwaarde na elke iteratie, zodat de hoofdtekst altijd ten minste één keer wordt uitgevoerd. Gebruik deze wanneer de eerste pas moet plaatsvinden voordat u de voorwaarde kunt evalueren, zoals vragen om invoer en vervolgens valideren:

int attempts = 0;

// A do-while loop runs its body once, then checks the condition. Use it
// when the body must run at least one time.
do
{
    attempts++;
    Console.WriteLine($"Attempt {attempts}"); // => Attempt 1, then Attempt 2, then Attempt 3
}
while (attempts < 3);

Tellen met for

Een for lusinstructie bevat drie onderdelen: een initialisatiefunctie die eenmaal vóór de lus wordt uitgevoerd, een voorwaarde die vóór elke iteratie wordt gecontroleerd en een iterator die na elke iteratie wordt uitgevoerd. Gebruik for deze functie wanneer u de index zelf nodig hebt, niet alleen de elementen. Normaal gesproken hebt u de index nodig wanneer u het element wilt wijzigen in plaats van de waarde ervan te lezen.

// A for loop fits when you need an explicit index. The three parts are
// the initializer, the condition, and the iterator.
for (int i = 0; i < 3; i++)
{
    Console.WriteLine(i); // => 0, then 1, then 2
}

Wanneer u alleen de elementen leest en u de posities niet gebruikt of geen nieuwe waarden toekent, gebruikt u bij voorkeur foreach. Het geeft de intentie duidelijker aan en vermijdt indexberekeningen.

Afsluiten of overslaan met break en continue

Twee spronginstructies geven je meer verfijnde controle in elke lus. De break instructie sluit de lus onmiddellijk af, waarbij alle resterende iteraties worden overgeslagen:

int[] numbers = [2, 4, 7, 8];

// break stops the loop immediately, skipping any remaining elements.
foreach (int number in numbers)
{
    if (number % 2 != 0)
    {
        Console.WriteLine($"First odd number: {number}"); // => First odd number: 7
        break;
    }
}

De continue instructie slaat de rest van de huidige iteratie over en gaat verder met de volgende:

int[] values = [1, 2, 3, 4, 5];

// continue skips the rest of the current iteration and moves to the next.
foreach (int value in values)
{
    if (value % 2 == 0)
    {
        continue; // skip even numbers
    }

    Console.WriteLine(value); // => 1, then 3, then 5
}

Een asynchrone stroom herhalen met await foreach

Een asynchrone stroom is een lezer die een asynchrone taak gebruikt om elk volgend element te produceren. C# vertegenwoordigt deze met de IAsyncEnumerable<T> interface. Gegevens die in de loop van de tijd binnenkomen, zoals pagina's van een web-API of rijen uit een database, passen bij dit model: het ophalen van het volgende element is een wachtbare bewerking in plaats van een onmiddellijke terugkeer.

Als u een asynchrone stroom wilt gebruiken, plaatst u het await trefwoord eerder foreach. Elke iteratie wacht op het volgende element, dus de lus wordt onderbroken terwijl dat element wordt geproduceerd in plaats van de thread te blokkeren:

private static async Task AwaitForeachExample()
{
    // await foreach consumes an asynchronous stream. Each iteration can
    // suspend while the next element is produced.
    await foreach (int value in GenerateAsync())
    {
        Console.WriteLine(value); // => 0, then 1, then 2
    }
}

private static async IAsyncEnumerable<int> GenerateAsync()
{
    for (int i = 0; i < 3; i++)
    {
        await Task.Delay(1); // stand-in for real asynchronous work
        yield return i;
    }
}

Asynchrone streams bouwen voort op async en await. Zie Asynchrone streams genereren en gebruiken voor een volledig overzicht.

Zie ook

  • Last updated on