6. Pętle – Jeden ze sposobów skrócenia powtarzalności kodu (for, foreach, while, do..while, break, continue, pętle zagnieżdżone)

for (int i = 0; i < 20; i++)
    Console.WriteLine(i);

Podana pętla wykona się 20 razy wyświetlając wartość zmiennej i, czyli 0, 1, 2, 3, 4…

for (int i = 0; i < 20;)
    Console.WriteLine(i++);

Sytuacja podobna do powyższej z taką różnicą, że pominięto trzeci człon w pętli, mianowicie przeniesiono inkrementację zmiennej i do miejsca wyświetlania w konsoli.

int inicjalizacja = 0;
for (; inicjalizacja < 20;)
    Console.WriteLine(inicjalizacja++);

Podobnie jak powyżej tylko tym razem jeszcze pominięto lewą część i zostawiono jedynie warunek do spełnienia

// Ręczne podejście
int[] ints = { 1, 2, 3, 4, 5, 6 };
ints[0] = 1;
ints[1] = 2;
ints[2] = 3;
ints[3] = 4;
ints[4] = 5;
ints[5] = 6;

// Powyższa czynność zrealizowana przy pomocy pętli
for (int i = 0; i < ints.Length; i++)
     ints[i] = i + 1;

Prosty przykład korzyści płynącej z korzystania z pętli. Mamy tablicę liczb całkowitych z 6 elementami, chcemy przypisać wartości od 1 do 6, gdybyśmy ręcznie to robili to zajęłoby to 6 linii kodu. Gdy skorzystamy z pętli, ilość kodu zostaje zredukowana tylko do dwóch linii:)

int number = 0;
while (number < 5)
      Console.WriteLine(number++);

// Zwróci
// 1
// 2
// 3
// 4
// 5

W podanym przykładzie, pętla będzie wykonywana aż zmienna number będzie miała wartość <5. Dodatkowo żeby kod wewnątrz pętli został wykonany, warunek przynajmniej raz musi zostać spełniony.

int number = 5;
do
     Console.WriteLine(number++);
while (number < 5);

// Zwróci tylko jedną wartość
5

// lub z klamrami
do
{
     Console.WriteLine(number++);
}
while (number < 5);

W podanym przykładzie wyświetli liczbę 5 i dopiero sprawdzi warunek, drugiego podejścia nie będzie, ponieważ zmienna number, będzie miała już wartość 5. Gdyby to była pętla while z identycznym sprawdzeniem to ani razu by nie wykonało kodu i nie wyświetliło wartości ze zmiennej number.

// Przykładowe dane
List<MyVeryLongNamedClass> items = new List<MyVeryLongNamedClass>()
{
    new MyMyVeryLongNamedClass("Tajko"),
    new MyMyVeryLongNamedClass("Goku"),
    new MyMyVeryLongNamedClass("Naruto"),
    new MyMyVeryLongNamedClass("Rias"),
}

foreach (MyMyVeryLongNamedClass item in items)
   Console.WriteLine(item.Name);

// lub skrócona wersja podawania typu elementu z listy
foreach (var item in items)
   Console.WriteLine(item.Name);

Pętla foreach jest świetna przy pracy przy kolekcjach. Pozwala w bardzo przyjemny sposób iterować po elementach bez potrzeby sprawdzania indeksów i martwienia się czy indeks nie wyjdzie poza tablicę / kolekcję. Dodatkowo nie trzeba dodawać żadnego warunku sprawdzającego.

W podanym przykładzie mamy listę z czterema elementami klasy MyVeryLongNamedClass. W pierwszej pętli, jako typ elementy podajemy nazwę klasy, gdybyśmy mieli klasę z jeszcze większą nazwą to średnio by to wyglądało. W drugiej pętli korzystamy ze słowa kluczowego var, pętla dalej działa tak samo, ponieważ visualka z automatu rozpozna typ tego elementu na podstawie tego jakie elementy są w kolekcji po której będzie iterować

for (int i = 0; i < 10; i++)
{
    for (int j = 0; j < 10; j++)
    {
        Console.WriteLine($"{i} + {j} = {i + j}");

        if (j > 8)
        {
            Console.WriteLine("...");
            break;
        }
    }
    break;
}

Console.WriteLine("Prosta tabliczka mnożenia: ");
for (int y = 1; y <= 10; y++)
{
    for (int x = 1; x <= 10; x++)
        Console.Write($"{x * y}".PadRight(4));
    Console.WriteLine();
}