Pętle w języku C#

Pętle w języku C# są używane do wielokrotnego wykonywania określonego bloku kodu. Pozwalają na automatyzację powtarzalnych zadań, przetwarzanie kolekcji danych i ogólnie na kontrolowanie przepływu programu w zależności od określonych warunków.

Istnieją różne rodzaje pętli w C#, z których każda ma swoje własne zastosowania i cechy. W tym opisie szczegółowo omówię trzy podstawowe rodzaje pętli w C#:
for, while i do...while, foreach a także przedstawię kilka zaawansowanych technik i praktyk z nimi związanych.

Pętla for

Pętla for jest często używana, gdy znana jest liczba iteracji i zdefiniowany jest warunek zakończenia pętli.
Składnia pętli for jest następująca:

for (inicjalizacja; warunek; iteracja)
{
    // Blok kodu do wykonania w każdej iteracji
}

• inicjalizacja: Określa początkowe ustawienia, takie jak inicjalizacja licznika pętli.
• warunek: Określa warunek zakończenia pętli. Pętla będzie kontynuowana, dopóki ten warunek jest prawdziwy.
• iteracja: Określa, jak zmieniać licznik pętli w każdej iteracji.

Przykład pętli for:

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

Pętla while

Pętla while jest używana, gdy liczba iteracji nie jest znana z góry, ale warunek zakończenia jest sprawdzany na początku każdej iteracji.
Składnia pętli while wygląda tak:

while (warunek)
{
    // Blok kodu do wykonania w każdej iteracji
}

Pętla while może być użyteczna, gdy chcesz, aby pętla działała tak długo, jak dany warunek jest spełniony.

Przykład pętli while:

int i = 0;
while (i < 50)
{
    Console.WriteLine($"Iteracja {i}");
    i++;
}

Pętla do...while

Pętla do...while jest podobna do pętli while, ale warunek jest sprawdzany na końcu każdej iteracji. To oznacza, że blok kodu w pętli do...while zawsze zostanie wykonany przynajmniej raz, niezależnie od warunku.
Składnia pętli do...while wygląda tak:

do
{
    // Blok kodu do wykonania w każdej iteracji
} while (warunek);

Pętla do...while może być przydatna, gdy chcesz, aby blok kodu był wykonany przynajmniej raz, a potem ewentualnie wielokrotnie, w zależności od warunku.

Przykład pętli do...while:

int i = 0;
do
{
    Console.WriteLine($"Iteracja {i}");
    i++;
} while (i < 50);

Przerwanie i kontynuacja pętli

W trakcie działania pętli możesz używać instrukcji break do przerwania pętli lub continue do przejścia do kolejnej iteracji.

for (int i = 0; i < 10; i++)
{
    if (i == 5)
    {
        break; // Przerwanie pętli w momencie i = 5
    }
    Console.WriteLine($"Iteracja {i}");
}

for (int i = 0; i < 10; i++)
{
    if (i % 2 == 0)
    {
        continue; // Przejście do kolejnej iteracji, jeśli i jest parzyste
    }
    Console.WriteLine($"Liczba nieparzysta: {i}");
}

Pętle zagnieżdżone

Możesz również zagnieżdżać pętle, co oznacza, że jedna pętla znajduje się wewnątrz innej. To pozwala na bardziej skomplikowane struktury iteracyjne.

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

Pętle nieskończone

Pętle nieskończone są pętlami, które nie mają wyraźnego warunku zakończenia i wykonują się w nieskończoność. Aby wyjść z pętli nieskończonej, często używa się instrukcji break.

while (true)
{
    // Wykonywane w nieskończoność, do momentu użycia break
    if (warunek)
    {
        break; // Wyjście z pętli
    }
}

Enumeratory i pętle foreach

Enumeratory (typy wyliczeniowe) w C# pozwalają na iterację przez zestaw stałych wartości. Pętla foreach jest używana do iteracji przez kolekcje i enumeratory.

enum DniTygodnia
{
    Poniedzialek,
    Wtorek,
    Sroda,
    Czwartek,
    Piatek,
    Sobota,
    Niedziela
}

foreach (DniTygodnia dzien in Enum.GetValues(typeof(DniTygodnia)))
{
    Console.WriteLine(dzien);
}

Powyższy kod iteruje przez wartości w enumie DniTygodnia i wyświetla je w konsoli.

Pętle równoległe

W języku C# istnieje biblioteka Parallel pozwalająca na wykonywanie pętli równolegle, co może przyspieszyć przetwarzanie w wielordzeniowych procesorach.

Parallel.For(0, 10, i =>
{
    Console.WriteLine($"Iteracja {i}");
});

Pętle rekurencyjne

Pętle rekurencyjne są pętlami, które wywołują same siebie w celu rozwiązania problemu. To zaawansowany sposób rozwiązywania problemów i wymaga ostrożności, aby uniknąć zapętleń nieskończonych.

void RekurencyjnaMetoda(int n)
{
    if (n > 0)
    {
        Console.WriteLine(n);
        RekurencyjnaMetoda(n - 1);
    }
}

Użycie break w blokach switch

Instrukcja break jest również używana w blokach switch do przerwania przepływu sterowania i wyjścia z bloku switch.

int dzienTygodnia = 3;
string nazwaDnia;

switch (dzienTygodnia)
{
    case 1:
        nazwaDnia = "Poniedziałek";
        break; // Po wykonaniu instrukcji break, kontrola przechodzi poza blok switch
    case 2:
        nazwaDnia = "Wtorek";
        break;
    // ...
    default:
        nazwaDnia = "Nieznany";
        break;
}

Przykład pętli w praktyce

Poniżej znajduje się prosty przykład użycia pętli do wygenerowania i wyświetlenia tabliczki mnożenia:

for (int i = 1; i <= 10; i++)
{
    for (int j = 1; j <= 10; j++)
    {
        int wynik = i * j;
        Console.Write($"{wynik,4}");
    }
    Console.WriteLine(); // Przejście do nowego wiersza po każdym rzędzie
}

Ten kod wykorzystuje zagnieżdżone pętle for, aby wygenerować i wyświetlić tabliczkę mnożenia od 1 do 10.

Używanie wyjątków w pętlach

Wyjątki mogą być używane w pętlach do obsługi nieoczekiwanych sytuacji lub błędów i umożliwiają przerwanie przetwarzania i przejście do obsługi błędu.

try
{
    for (int i = 0; i < 10; i++)
    {
        if (i == 5)
        {
            throw new Exception("Błąd w pętli.");
        }
        Console.WriteLine(i);
    }
}
catch (Exception ex)
{
    Console.WriteLine("Wystąpił błąd: " + ex.Message);
}

Testowanie pętli

Testowanie pętli jest ważne, aby upewnić się, że działają zgodnie z oczekiwaniami. Używanie testów jednostkowych i różnych scenariuszy testowych może pomóc w znalezieniu i rozwiązywaniu problemów związanych z pętlami.

Podsumowanie

Pętle są niezbędnym narzędziem w programowaniu, pozwalającym na wielokrotne wykonywanie kodu. Warto zrozumieć różne rodzaje pętli, jak również umieć używać przerwań i kontynuacji, aby kontrolować ich zachowanie. Pętle pozwalają na efektywne przetwarzanie danych i automatyzację powtarzalnych czynności, co jest kluczowe w programowaniu.

Oto kilka zaawansowanych technik i praktyk związanych z pętlami w języku C#:

Wyrażenia LINQ w pętlach

Język C# oferuje bogate wsparcie dla Language Integrated Query (LINQ), co pozwala na przetwarzanie danych w kolekcjach w bardziej zaawansowany sposób. Możesz używać wyrażeń LINQ w pętlach, aby filtrować, mapować i grupować dane.

List<int> liczby = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var wynik = from liczba in liczby
            where liczba % 2 == 0
            select liczba;

foreach (int parzystaLiczba in wynik)
{
    Console.WriteLine(parzystaLiczba);
}

Optymalizacja pętli

Optymalizacja pętli jest ważna w celu zwiększenia wydajności programu. Oto kilka technik optymalizacyjnych:

• Unikaj zbędnych operacji wewnątrz pętli, takich jak alokacje pamięci.
• Używaj pętli foreach, gdy nie zmieniajesz kolekcji. Pętle foreach są bardziej wydajne niż pętle for w takich przypadkach.
• Wartości stałe, które można obliczyć przed wejściem do pętli, oblicz raz i używaj w pętli, zamiast obliczać je w każdej iteracji.

Pętle równoległe

Jeśli masz wiele niezależnych operacji, które można przetwarzać równocześnie, możesz użyć pętli równoległych do zwiększenia wydajności. Biblioteka Parallel umożliwia łatwe tworzenie pętli równoległych.

Parallel.For(0, 1000, i =>
{
    Console.WriteLine($"Iteracja {i}");
});

Użycie Task w pętlach

W programowaniu asynchronicznym (async/await), możesz używać typu Task w pętlach do równoczesnego wykonywania operacji i przetwarzania wyników w miarę ich pojawiania się.

List<Task<int>> tasks = new List<Task<int>>();

for (int i = 0; i < 10; i++)
{
    tasks.Add(ObliczCosAsync(i));
}

await Task.WhenAll(tasks);

foreach (var task in tasks)
{
    Console.WriteLine(task.Result);
}

Wyrażenia Lambda w pętlach

Możesz używać wyrażeń lambda w pętlach do definiowania niestandardowych operacji na elementach w kolekcji lub innych danych wejściowych.

List<int> liczby = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
List<int> wynik = new List<int>();

liczby.ForEach(liczba =>
{
    wynik.Add(liczba * 2);
});

Iteratory

Iteratory są używane do tworzenia niestandardowych iteratorów, które pozwalają na niestandardowe przeglądanie danych w pętli foreach. Dzięki nim możesz przetwarzać dane w bardziej zaawansowany sposób.

public class MojKontener
{
    private int[] dane = { 1, 2, 3, 4, 5 };

    public IEnumerable<int> Iteruj()
    {
        foreach (int element in dane)
        {
            yield return element * 2;
        }
    }
}

MojKontener kontener = new MojKontener();
foreach (int wartosc in kontener.Iteruj())
{
    Console.WriteLine(wartosc);
}

Pętle w programowaniu funkcyjnym

Jeśli jesteś fanem programowania funkcyjnego, możesz eksperymentować z podejściem funkcyjnym do pętli w C#. Wyrażenia lambda i funkcje wyższego rzędu mogą być użyteczne w bardziej funkcyjnym stylu programowania.

List<int> liczby = new List<int> { 1, 2, 3, 4, 5 };
List<int> wynik = liczby.Select(liczba => liczba * 2).ToList();

Użycie Tokenów do Anulowania Pętli

W przypadku bardziej zaawansowanych scenariuszy możesz używać tokenów do anulowania działania pętli, gdy zachodzi taka potrzeba. Tokeny te pozwalają na eleganckie i kontrolowane zatrzymywanie pętli w odpowiedzi na zewnętrzne zdarzenia lub warunki.

CancellationTokenSource tokenSource = new CancellationTokenSource();
CancellationToken token = tokenSource.Token;

for (int i = 0; i < 1000; i++)
{
    if (token.IsCancellationRequested)
    {
        // Anulowanie pętli
        break;
    }
    // Wykonywanie operacji
}

Pętle i operacje na wielu wątkach

W wielowątkowych aplikacjach możesz napotkać problemy z równoczesnym dostępem do danych w pętlach. Należy zastosować odpowiednie mechanizmy synchronizacji lub wykorzystać równoległe pętle Parallel w celu zapewnienia bezpieczeństwa operacji na danych współdzielonych przez różne wątki.

Unikanie pętli, jeśli to możliwe

Czasami można uniknąć użycia pętli poprzez wykorzystanie wbudowanych funkcji języka C#, takich jak metody kolekcji, wyrażenia LINQ, refleksja, itp. Unikanie pętli może prowadzić do bardziej zwięzłego i czytelnego kodu.

Testowanie pętli

Pętle wymagają odpowiedniego testowania, szczególnie jeśli są kluczowym elementem programu. Tworzenie testów jednostkowych i testów akceptacyjnych dla pętli może pomóc w wykrywaniu błędów i zagwarantować ich poprawne działanie.

Zarządzanie wyjątkami w pętlach

Jeśli używasz pętli wrażliwych na wyjątki, upewnij się, że masz odpowiednie mechanizmy obsługi błędów i że pętle są zabezpieczone przed zapętleniem nieskończonym.

Przyjmowanie dobrych praktyk

Przestrzegaj ogólnych zasad dobrego programowania, takich jak
DRY (Don’t Repeat Yourself) i KISS (Keep It Simple, Stupid), także w kontekście pętli. Stosowanie dobrych praktyk pomaga utrzymać kod klarownym i łatwym do zrozumienia.

Biblioteki i narzędzia do przetwarzania danych

Jeśli masz do czynienia z dużymi ilościami danych, warto zainteresować się bibliotekami i narzędziami do przetwarzania danych, takimi jak LINQ to SQL, Entity Framework, czy narzędzia do przetwarzania Big Data.

To tylko kilka zaawansowanych technik i praktyk związanych z pętlami w języku C#. Ostatecznie zaawansowane techniki i praktyki związane z pętlami w C# zależą od konkretnych wymagań projektu i rodzaju operacji, jakie są wykonywane w pętlach. Ważne jest, aby dostosować techniki do potrzeb projektu, zwracając uwagę na wydajność i czytelność kodu.