Poznámka
Přístup k této stránce vyžaduje autorizaci. Můžete se zkusit přihlásit nebo změnit adresáře.
Přístup k této stránce vyžaduje autorizaci. Můžete zkusit změnit adresáře.
Iterační příkazy -
Příkazy iterace opakovaně spouštějí příkaz nebo blok příkazů. Příkaz for
spustí jeho tělo, zatímco zadaný logický výraz se vyhodnotí jako true
. Příkaz foreach
vyčíslí prvky kolekce a spustí jeho tělo pro každý prvek kolekce. Příkaz do
podmíněně provede jeho tělo jednou nebo vícekrát. Příkaz while
podmíněně provede jeho tělo nula nebo vícekrát.
V jakémkoli okamžiku v těle příkazu iterace můžete pomocí příkazu přerušit smyčkubreak
. Pomocí příkazu můžete přejít k další iteraci ve smyčcecontinue
.
Příkaz for
Příkaz for
spustí příkaz nebo blok příkazů, zatímco zadaný logický výraz se vyhodnotí jako true
. Následující příklad ukazuje for
příkaz, který provede své tělo, pokud je celočíselný čítač menší než tři.
for (int i = 0; i < 3; i++)
{
Console.Write(i);
}
// Output:
// 012
Předchozí příklad ukazuje prvky for
příkazu:
Část inicializátoru, která se spustí pouze jednou, před vstupem do smyčky. Obvykle deklarujete a inicializujete proměnnou místní smyčky v této části. Deklarovaná proměnná nemůže být přístupná z vnějšku
for
příkazu.Část inicializátoru v předchozím příkladu deklaruje a inicializuje celočíselnou čítačovou proměnnou.
int i = 0
Část podmínky , která určuje, jestli se má provést další iterace ve smyčce. Pokud se vyhodnotí na
true
nebo není přítomné, provede se další iterace; v opačném případě se smyčka ukončí. Oddíl podmínky musí být logickým výrazem.Část podmínky v předchozím příkladu zkontroluje, jestli je hodnota čítače menší než tři:
i < 3
Oddíl iterátoru který definuje, co se stane po každém spuštění těla smyčky.
Sekce iterátoru v předchozím příkladu zvyšuje čítač:
i++
Tělo smyčky, které musí být příkazem nebo blokem příkazů.
Oddíl iterátoru může obsahovat nula nebo více následujících výrazů příkazů oddělených čárkami:
- prefixový nebo postfixový výraz inkrement, například
++i
neboi++
- výraz s dekrementací jako předponou nebo příponou, například
--i
neboi--
- přiřazení
- vyvolání metody
-
await
výraz - vytvoření objektu pomocí operátoru
new
Pokud v oddílu inicializátoru nevyhlásíte proměnnou smyčky, můžete také použít nula nebo více výrazů z předchozího seznamu v oddílu inicializátoru. Následující příklad ukazuje několik méně běžných použití oddílů inicializátoru a iterátoru: přiřazení hodnoty externí proměnné v oddílu inicializátoru, vyvolání metody v oddílech inicializátoru i iterátoru a změna hodnot dvou proměnných v oddílu iterátoru:
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
Všechny oddíly for
příkazu jsou volitelné. Například následující kód definuje nekonečnou for
smyčku:
for ( ; ; )
{
//...
}
Příkaz foreach
Příkaz foreach
spustí příkaz nebo blok příkazů pro každý prvek v instanci typu, který implementuje System.Collections.IEnumerable nebo System.Collections.Generic.IEnumerable<T> rozhraní, jak ukazuje následující příklad:
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
Příkaz foreach
není omezen na tyto typy. Můžete ho použít s instancí libovolného typu, který splňuje následující podmínky:
- Typ má veřejnou metodu bez
GetEnumerator
parametrů. MetodaGetEnumerator
může být rozšiřující metodou typu. - Návratový
GetEnumerator
typ metody má veřejnou vlastnost a veřejnouCurrent
bezparametrovouMoveNext
metodu, jejíž návratový typ jebool
.
Následující příklad používá foreach
příkaz s instancí System.Span<T> typu, která neimplementuje žádná rozhraní:
Span<int> numbers = [3, 14, 15, 92, 6];
foreach (int number in numbers)
{
Console.Write($"{number} ");
}
// Output:
// 3 14 15 92 6
Pokud vlastnost enumerátoru Current
vrátí návratovou hodnotu odkazu (ref T
kde T
je typ prvku kolekce), můžete deklarovat iterační proměnnou pomocí ref
nebo ref readonly
modifikátoru, jak ukazuje následující příklad:
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
Pokud je zdrojová kolekce příkazu foreach
prázdná, tělo příkazu foreach
se nespustí a je přeskočeno. Pokud je na foreach
aplikován null
, je vyvolána výjimka NullReferenceException.
await foreach
Tento příkaz můžete použít await foreach
k využívání asynchronního datového proudu, tj. typu kolekce, která implementuje IAsyncEnumerable<T> rozhraní. Každá iterace smyčky může být pozastavena, zatímco další prvek je načten asynchronně. Následující příklad ukazuje, jak použít await foreach
příkaz:
await foreach (var item in GenerateSequenceAsync())
{
Console.WriteLine(item);
}
Také můžete použít příkaz await foreach
s instancí libovolného typu, který splňuje následující podmínky:
- Typ má veřejnou metodu bez
GetAsyncEnumerator
parametrů. Tato metoda může být rozšiřující metodou typu. - Návratový typ metody
GetAsyncEnumerator
má veřejnou vlastnostCurrent
a veřejnou bezparametrovou metoduMoveNextAsync
, jejíž návratový typ jeTask<bool>
,ValueTask<bool>
nebo jakýkoli jiný typ, který je awaitable, jehož metodaGetResult
v awaiteru vrací hodnotubool
.
Ve výchozím nastavení se prvky streamu zpracovávají v zachyceného kontextu. Pokud chcete zakázat zachytávání kontextu, použijte metodu TaskAsyncEnumerableExtensions.ConfigureAwait rozšíření. Další informace o kontextech synchronizace a zachycení aktuálního kontextu naleznete v tématu Využívání asynchronního vzoru založeného na úlohách. Další informace o asynchronních datových proudech najdete v kurzu asynchronních datových proudů.
Typ iterace proměnné
Klíčové slovo můžete použít var
k tomu, aby kompilátor odvodil typ proměnné iterace v foreach
příkazu, jak ukazuje následující kód:
foreach (var item in collection) { }
Poznámka:
Typ var
může být odvozen kompilátorem jako odkazový typ s možností null, v závislosti na tom, zda je aktivován kontext s podporou null a zda typ inicializačního výrazu je odkazový typ.
Další informace naleznete v tématu Implicitně typované místní proměnné.
Můžete také explicitně zadat typ proměnné iterace, jak ukazuje následující kód:
IEnumerable<T> collection = new T[5];
foreach (V item in collection) { }
V předchozím formuláři musí být typ T
elementu kolekce implicitně nebo explicitně konvertibilní na typ V
proměnné iterace. Pokud explicitní převod z T
na V
selže za běhu, příkaz foreach
vyvolá InvalidCastException výjimku. Pokud T
je například nezapečetěný typ třídy, V
může to být jakýkoli typ rozhraní, i ten, který T
neimplementuje. Během běhu může být typ elementu kolekce takový, který je odvozen od T
a skutečně implementuje V
. Je-li tomu jinak, je vyvolán InvalidCastException.
Příkaz do
Příkaz do
spustí příkaz nebo blok příkazů, zatímco zadaný logický výraz se vyhodnotí jako true
. Vzhledem k tomu, že se tento výraz vyhodnotí po každém spuštění smyčky, spustí se smyčka do
jednou nebo vícekrát. Smyčka do
se liší od smyčky while
, která se může provést nula nebo vícekrát.
Následující příklad ukazuje použití do
příkazu:
int n = 0;
do
{
Console.Write(n);
n++;
} while (n < 5);
// Output:
// 01234
Příkaz while
Příkaz while
spustí příkaz nebo blok příkazů, zatímco zadaný logický výraz se vyhodnotí jako true
. Vzhledem k tomu, že se tento výraz vyhodnotí před každým spuštěním smyčky, smyčka while
se provede nula nebo vícekrát. Smyčka while
se liší od do
smyčky, která se spouští jednou nebo vícekrát.
Následující příklad ukazuje použití while
příkazu:
int n = 0;
while (n < 5)
{
Console.Write(n);
n++;
}
// Output:
// 01234
Specifikace jazyka C#
Další informace najdete v následujících částech specifikace jazyka C#:
Další informace o těchto funkcích najdete v následujících poznámkách k návrhu funkcí:
Viz také
- Deklarace
- iterátory