Delen via

Iteratie-instructies - for, foreach, do, en while

De iteratie-instructies voeren herhaaldelijk een instructie of een blok instructies uit. De for instructie voert de hoofdtekst uit terwijl een opgegeven Boole-expressie resulteert in true. Met de foreach instructie somt men de elementen van een verzameling op en wordt de bijbehorende code voor elk element van de verzameling uitgevoerd. De do instructie voert de hoofdtekst een of meer keren voorwaardelijk uit. De while instructie voert voorwaardelijk de hoofdtekst nul of meer keren uit.

Op elk punt in de hoofdtekst van een iteratie-instructie kunt u de lus verbreken met behulp van de break instructie. U kunt stap voor stap naar de volgende iteratie in de lus gaan met behulp van de continue instructie.

De for-verklaring

Met de for instructie wordt een instructie of een blok instructies uitgevoerd terwijl een opgegeven Boole-expressie resulteert in true. In het volgende voorbeeld ziet u de for instructie die zijn inhoud uitvoert zolang de integer teller kleiner is dan drie.

for (int i = 0; i < 3; i++)
{
    Console.Write(i);
}
// Output:
// 012

In het voorgaande voorbeeld ziet u de elementen van de for verklaring.

  • De initialisatiesectie die slechts één keer wordt uitgevoerd, voordat je de lus ingaat. Normaal gesproken declareert en initialiseert u een lokale lusvariabele in die sectie. De gedeclareerde variabele kan niet worden geopend van buiten de for instructie.

    De initialisatiesectie in het vorige voorbeeld declareert en initialiseert een tellervariabele voor gehele getallen:

    int i = 0

  • De voorwaardesectie die bepaalt of de volgende iteratie in de lus moet worden uitgevoerd. Als deze evalueert naar true of niet aanwezig is, wordt de volgende iteratie uitgevoerd; anders wordt de lus beëindigd. De voorwaardesectie moet een Boole-expressie zijn.

    In de sectie Voorwaarde in het voorgaande voorbeeld wordt gecontroleerd of een tellerwaarde kleiner is dan drie:

    i < 3

  • De iteratorsectie die definieert wat er gebeurt na elke uitvoering van de hoofdtekst van de lus.

    In de iteratorsectie in het vorige voorbeeld wordt de teller verhoogd:

    i++

  • De hoofdtekst van de lus, die een instructie of een blok instructies moet zijn.

De iteratorsectie kan nul of meer van de volgende instructieexpressies bevatten, gescheiden door komma's:

Als u geen lusvariabele declareert in de sectie Initializer, kunt u ook nul of meer expressies uit de voorgaande lijst in de sectie Initializer gebruiken. In het volgende voorbeeld ziet u verschillende minder gangbare gebruikswijzen van de initialisatie- en iteratorsecties: het toewijzen van een waarde aan een externe variabele in de initialisatiesectie, het aanroepen van een methode in zowel de initialisatiefunctie als de iterator-secties, en het wijzigen van de waarden van twee variabelen in de iteratorsectie:

int i;
int j = 3;
for (i = 0, Console.WriteLine($"Start: i={i}, j={j}"); i < j; i++, j--, Console.WriteLine($"Step: i={i}, j={j}"))
{
    //...
}
// Output:
// Start: i=0, j=3
// Step: i=1, j=2
// Step: i=2, j=1

Alle secties van de for instructie zijn optioneel. Met de volgende code wordt bijvoorbeeld de oneindige for lus gedefinieerd:

for ( ; ; )
{
    //...
}

De foreach-verklaring

Met foreach de instructie wordt een instructie of een blok instructies uitgevoerd voor elk element in een exemplaar van het type dat de System.Collections.IEnumerable of System.Collections.Generic.IEnumerable<T> interface implementeert, zoals in het volgende voorbeeld wordt weergegeven:

List<int> fibNumbers = new() { 0, 1, 1, 2, 3, 5, 8, 13 };
foreach (int element in fibNumbers)
{
    Console.Write($"{element} ");
}
// Output:
// 0 1 1 2 3 5 8 13

De foreach instructie is niet beperkt tot deze typen. U kunt het gebruiken met een exemplaar van elk type dat voldoet aan de volgende voorwaarden:

  • Een type heeft een openbare methode GetEnumerator zonder parameters. De GetEnumerator methode kan de extensiemethode van een type zijn.
  • Het retourtype van de GetEnumerator methode heeft de openbare Current eigenschap en de openbare parameterloze MoveNext methode waarvan het retourtype is bool.

In het volgende voorbeeld wordt de foreach instructie gebruikt met een exemplaar van het System.Span<T> type, waarmee geen interfaces worden geïmplementeerd:

Span<int> numbers = [3, 14, 15, 92, 6];
foreach (int number in numbers)
{
    Console.Write($"{number} ");
}
// Output:
// 3 14 15 92 6

Als de eigenschap van Current de enumerator een referentie-retourwaarde retourneert (ref T waarbij T het type van een verzamelingselement is), kunt u een iteratievariabele declareren met de ref of ref readonly modifier, zoals in het volgende voorbeeld wordt weergegeven.

Span<int> storage = stackalloc int[10];
int num = 0;
foreach (ref int item in storage)
{
    item = num++;
}
foreach (ref readonly var item in storage)
{
    Console.Write($"{item} ");
}
// Output:
// 0 1 2 3 4 5 6 7 8 9

Als de bronverzameling van de foreach instructie leeg is, wordt de hoofdtekst van de foreach instructie niet uitgevoerd en overgeslagen. Als de foreach instructie wordt toegepast op null, wordt er een NullReferenceException gegenereerd.

wacht foreach op

U kunt de await foreach instructie gebruiken om een asynchrone gegevensstroom te gebruiken, dat wil zeggen het verzamelingstype waarmee de IAsyncEnumerable<T> interface wordt geïmplementeerd. Elke iteratie van de lus kan worden onderbroken terwijl het volgende element asynchroon wordt opgehaald. In het volgende voorbeeld ziet u hoe u de await foreach instructie gebruikt:

await foreach (var item in GenerateSequenceAsync())
{
    Console.WriteLine(item);
}

U kunt ook de await foreach uitdrukking gebruiken met een instantie van ieder type dat aan de volgende voorwaarden voldoet:

  • Een type heeft een openbare methode GetAsyncEnumerator zonder parameters. Deze methode kan de extensiemethode van een type zijn.
  • Het retourtype van de GetAsyncEnumerator-methode heeft de openbare Current eigenschap en de openbare parameterloze MoveNextAsync-methode waarvan het retourtype Task<bool>, ValueTask<bool> of een ander awaitable type is waarvan de GetResult-methode van de awaiter een bool waarde retourneert.

Stream-elementen worden standaard verwerkt in de vastgelegde context. Als u het vastleggen van de context wilt uitschakelen, gebruikt u de TaskAsyncEnumerableExtensions.ConfigureAwait extensiemethode. Zie Het gebruik van het asynchrone patroon op basis van taken voor meer informatie over synchronisatiecontexten en het vastleggen van de huidige context. Voor meer informatie over asynchrone streams, zie de zelfstudie Asynchrone streams.

Type van een iteratievariabele

U kunt het var trefwoord gebruiken om het type iteratievariabele in de foreach instructie te laten afleiden door de compiler, zoals in de volgende code wordt weergegeven:

foreach (var item in collection) { }

Opmerking

var Het type kan door de compiler als een null-referentietype worden afgeleid, afhankelijk van of de nullable context is ingeschakeld en of het type van een initialisatie-expressie een verwijzingstype is. Zie Impliciet getypte lokale variabelen voor meer informatie.

U kunt ook expliciet het type iteratievariabele opgeven, zoals in de volgende code wordt weergegeven:

IEnumerable<T> collection = new T[5];
foreach (V item in collection) { }

In het voorgaande formulier moet het type T verzamelingselement impliciet of expliciet worden omgezet in het type V iteratievariabele. Als een expliciete conversie van T naar V runtime mislukt, genereert de foreach instructie een InvalidCastException. Als T bijvoorbeeld een niet-verzegeld klassetype is, kan V elk interfacetype zijn, zelfs het type dat T niet implementeert. Tijdens runtime kan het type verzamelingselement het element zijn dat is afgeleid van T en daadwerkelijk implementeert V. Als dat niet het geval is, wordt er een InvalidCastException gegooid.

De do-verklaring

Met de do instructie wordt een instructie of een blok instructies uitgevoerd terwijl een opgegeven Boole-expressie resulteert in true. Omdat deze expressie wordt geëvalueerd na elke uitvoering van de lus, wordt de do-lus een of meer keren uitgevoerd. De do lus verschilt van de while lus, die nul of meer keer wordt uitgevoerd.

In het volgende voorbeeld ziet u het gebruik van de do opdracht:

int n = 0;
do
{
    Console.Write(n);
    n++;
} while (n < 5);
// Output:
// 01234

De while-verklaring

Met de while instructie wordt een instructie of een blok instructies uitgevoerd terwijl een opgegeven Boole-expressie resulteert in true. Omdat deze expressie wordt geëvalueerd voordat elke uitvoering van de lus wordt uitgevoerd, wordt een while lus nul of meer keren uitgevoerd. De while lus verschilt van de do lus, die een of meer keren wordt uitgevoerd.

In het volgende voorbeeld ziet u het gebruik van de while opdracht:

int n = 0;
while (n < 5)
{
    Console.Write(n);
    n++;
}
// Output:
// 01234

C#-taalspecificatie

Zie de volgende secties van de C#-taalspecificatie voor meer informatie:

Zie ook