Instrukcje warunkowe if i else w C#

Instrukcje warunkowe w C#

Instrukcje warunkowe pozwalają na wykonanie określonych bloków kodu tylko wtedy, gdy pewien warunek jest spełniony. W C# najczęściej używane instrukcje warunkowe to “if“, “else if“, “else“, “switch“.

Instrukcja warunkowa if

Instrukcja warunkowa if pozwala na wykonanie określonego bloku kodu tylko wtedy, gdy warunek jest prawdziwy (true).

int liczba = 100;
if (liczba > 80)
{
    Console.WriteLine("Liczba jest większa niż 80.");
}

Jeśli warunek (liczba > 80) jest spełniony, to blok kodu wewnątrz nawiasów klamrowych zostanie wykonany, a w konsoli zostanie wyświetlony napis “Liczba jest większa niż 80.”

Instrukcja warunkowa else

Instrukcja else jest używana po instrukcji if i pozwala na wykonanie innego bloku kodu, jeśli warunek w instrukcji if nie jest spełniony.

int liczba = 35;
if (liczba > 50)
{
    Console.WriteLine("Liczba jest większa niż 50.");
}
else
{
    Console.WriteLine("Liczba nie jest większa niż 50.");
}

W tym przypadku, ponieważ liczba nie jest większa niż 50, zostanie wykonany blok kodu po instrukcji else, a w konsoli zostanie wyświetlony napis “Liczba nie jest większa niż 50.”

Instrukcja warunkowa else if

Instrukcja else if pozwala na sprawdzenie wielu warunków po kolei. Można używać jej, gdy mamy wiele warunków do sprawdzenia.

int liczba = 100;
if (liczba > 100)
{
    Console.WriteLine("Liczba jest większa niż 100.");
}
else if (liczba < 100)
{
    Console.WriteLine("Liczba jest mniejsza niż 100.");
}
else
{
    Console.WriteLine("Liczba jest równa 100.");
}

W powyższym przykładzie, zostanie sprawdzony warunek w instrukcji if. Jeśli jest on niespełniony, zostanie sprawdzony warunek w instrukcji else if. Jeśli żaden z warunków nie zostanie spełniony, zostanie wykonany blok kodu po instrukcji else.

Instrukcje warunkowe zagnieżdżone

Możesz również zagnieżdżać instrukcje warunkowe, co oznacza umieszczenie jednej instrukcji warunkowej wewnątrz innej. To pozwala na bardziej skomplikowane decyzje w zależności od wielu warunków.

int wiek = 18;
bool maKarte = true;

if (wiek >= 18)
{
    if (maKarte)
    {
        Console.WriteLine("Możesz wejść do klubu.");
    }
    else
    {
        Console.WriteLine("Potrzebujesz karty, aby wejść do klubu.");
    }
}
else
{
    Console.WriteLine("Jesteś za młody, aby wejść do klubu.");
}

W tym przykładzie, zagnieżdżone instrukcje warunkowe sprawdzają wiek i dostępność karty, aby określić, czy osoba może wejść do klubu.

Operator ternarny

Operator ternarny (? :) pozwala na zapisanie instrukcji warunkowej w bardziej zwięzły sposób, szczególnie gdy chcemy przypisać wartość do zmiennej w zależności od warunku.

int liczba = 75;
string wynik = (liczba > 50) ? "Większa niż 50" : "Mniejsza lub równa 50";
Console.WriteLine(wynik); // "Większa niż 50"

Operator ternarny pozwala na określenie wartości zmiennej wynik w jednej linii kodu w zależności od warunku (liczba > 50).

Gdy warunków robi się dużo, warto przejść na instrukcję switch — zobacz Switch w C#, gdzie pokazujemy też nowoczesny pattern matching. Pełny przegląd operatorów logicznych i ternary znajdziesz w Operatory w C#.

Instrukcje switch

Instrukcja switch pozwala na porównanie wartości wyrażenia z zestawem możliwych przypadków i wykonać odpowiedni kod w zależności od spełnionego przypadku.

int dzienTygodnia = 3;
string nazwaDnia;

switch (dzienTygodnia)
{
    case 1:
        nazwaDnia = "Poniedziałek";
        break;
    case 2:
        nazwaDnia = "Wtorek";
        break;
    case 3:
        nazwaDnia = "Sroda";
        break;
    // ...
    default:
        nazwaDnia = "Nieznany";
        break;
}

Console.WriteLine("Dzień tygodnia to: " + nazwaDnia);

Operator null-coalescing chroni przed jednym z najczęstszych wyjątków w C# — jeśli już się z nim spotkałeś, zobacz NullReferenceException w C# — jak naprawić?.

Operator ?? (null-coalescing)

Operator ?? pozwala na określenie wartości domyślnej, która ma być używana, gdy zmienna jest równa null.

int? liczba = null;
int wynik = liczba ?? 0; // Jeśli liczba jest null, wynik wynosi 0

Instrukcje warunkowe inline

C# pozwala na stosowanie instrukcji warunkowych w jednej linii kodu za pomocą operatora ? : i ?? oraz wyrażeń lambda.

int wiek = 17;
string komunikat = (wiek >= 18) ? "Pełnoletni" : "Niepełnoletni";

Instrukcje warunkowe asercji

W programowaniu często stosuje się asercje do sprawdzania poprawności założeń i wywoływania wyjątków w przypadku niespełnienia warunku.

Debug.Assert(wiek >= 18, "Osoba musi być pełnoletnia.");

Kaskadowe instrukcje warunkowe

Możesz łączyć instrukcje warunkowe w taki sposób, aby tworzyły kaskadę warunków.

if (warunek1)
{
    // Kod dla warunku 1
}
else if (warunek2)
{
    // Kod dla warunku 2
}
else if (warunek3)
{
    // Kod dla warunku 3
}
else
{
    // Kod dla innych przypadków
}

To podstawowe koncepcje instrukcji warunkowych w języku C#. Instrukcje warunkowe są kluczowe do podejmowania decyzji w programach, stanowią kluczową część wielu programów, umożliwiając programistom kontrolowanie przepływu logiki programu w zależności od warunków. Ważne jest, aby je dobrze rozumieć i używać w odpowiednich miejscach, aby tworzyć wydajne i niezawodne oprogramowanie.

Zaawansowane techniki

Instrukcje warunkowe z wykorzystaniem wyrażeń lambda

Możesz używać wyrażeń lambda jako wartości przypisywanej do zmiennych lub argumentów funkcji, co pozwala na tworzenie bardziej dynamicznych i elastycznych instrukcji warunkowych.

Func<int, string> warunek = x => (x > 50) ? "Większe niż 50" : "Mniejsze lub równe 50";
string wynik = warunek(70); // Wynik: "Większe niż 50"

Wyrażenia pattern matching (od C# 7.0)

Pattern matching pozwala na bardziej zaawansowane porównywanie i dopasowywanie wzorców w instrukcjach warunkowych.

object obiekt = "Tekst";
if (obiekt is string tekst && tekst.Length > 8)
{
    Console.WriteLine("Długi tekst: " + tekst);
}

Instrukcje warunkowe w LINQ (Language Integrated Query)

Możesz wykorzystywać instrukcje warunkowe w zapytaniach LINQ do filtrowania i przekształcania danych.

var wynik = from liczba in liczby
            where liczba % 2 == 0
            select liczba;

Użycie wyjątków w instrukcjach warunkowych

W niektórych przypadkach, używanie wyjątków do obsługi określonych sytuacji może być bardziej czytelne niż tradycyjne instrukcje warunkowe. Jednak powinno się to stosować z umiarem, ponieważ wyjątki są kosztowne pod względem wydajności.

try
{
    int wynik = Dzielenie(10, 0);
    Console.WriteLine(wynik);
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("Nie można dzielić przez zero.");
}

int Dzielenie(int x, int y)
{
    if (y == 0)
    {
        throw new DivideByZeroException();
    }
    return x / y;
}

Instrukcje warunkowe w asynchronicznych metodach

W asynchronicznych metodach możesz używać instrukcji warunkowych do zarządzania przepływem asynchronicznym, na przykład do obsługi błędów lub podjęcia decyzji na podstawie wyników asynchronicznych operacji.

async Task PrzykladowaMetoda()
{
    try
    {
        int wynik = await WykonajCosAsync();
        if (wynik > 0)
        {
            Console.WriteLine("Wynik jest dodatni.");
        }
        else
        {
            Console.WriteLine("Wynik jest niedodatni.");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine("Wystąpił błąd: " + ex.Message);
    }
}

Pułapki, które łapią przy instrukcjach warunkowych

Pułapka #1: switch bez break — to błąd kompilacji, nie fall-through

W C, C++ czy JavaScript brak break w gałęzi switch powoduje “przelanie się” do kolejnego case (fall-through) — to częsty, cichy błąd logiczny w tych językach. W C# jest inaczej: kompilator nie pozwoli na niepustą gałąź case bez break, return, goto lub throw na końcu.

switch (dzien)
{
    case 1:
        Console.WriteLine("Poniedziałek");
        // ❌ error CS0163: Control cannot fall through from one case label ('case 1:') to another
    case 2:
        Console.WriteLine("Wtorek");
        break;
}

To ochrona, nie ograniczenie — C# wymusza jawną decyzję, więc nie da się przypadkiem “przelecieć” do kolejnej gałęzi tak, jak w C.

Pułapka #2: dangling else — zagnieżdżony if bez klamer

if (wiek >= 18)
    if (maBilet)
        Console.WriteLine("Wchodzisz");
else
    Console.WriteLine("Za młody");

Wcięcie sugeruje, że else należy do zewnętrznego if (wiek >= 18) — ale kompilator wiąże else zawsze z najbliższym poprzedzającym if bez else, czyli tutaj z if (maBilet). Efekt: dla pełnoletniej osoby bez biletu program nic nie wypisze, zamiast “Za młody”. Klamry { } przy zagnieżdżonych instrukcjach nie są kosmetyką — eliminują tę niejednoznaczność.

Pułapka #3: operator ternarny wymaga wspólnego typu obu gałęzi

var wynik = warunek ? 1 : "tekst";
// ❌ error CS0173: Type of conditional expression cannot be determined
// because there is no implicit conversion between 'int' and 'string'

W przeciwieństwie do if/else, obie gałęzie operatora ternarnego muszą dać się sprowadzić do jednego wspólnego typu — kompilator sprawdza to w czasie kompilacji, nie w runtime.

Checklist — który wybrać?

Instrukcje warunkowe są potężnym narzędziem w programowaniu, pozwalającym na elastyczne zarządzanie przepływem kodu i podejmowanie decyzji na podstawie różnych warunków. Ich zrozumienie i umiejętne wykorzystanie może znacząco poprawić jakość i czytelność kodu źródłowego.