Instrukcje warunkowe pozwalają programiście na określenie jednego lub więcej warunków, od których będzie zależał dalszy przebieg programu.

C# dostarcza programistą wielu różnych schematów pozwalających na warunkowe działanie programu. Poniżej lista takich instrukcji wraz z dokładnym opisem i przykładowym kodem.

Instrukcja warunkowa if

Instrukcja warunkowa if składa się z wyrażenia logicznego oraz instrukcji wykonania programu.
Składnia:
if(wyrazenie_logiczne)
{
    // poniższy kod zostanie wykonany, jeżeli warunek będzie spełniony (flaga true)
}
Jeżeli wyrażenie logiczne jest prawdziwe (true) zostanie wykonany kod wewnątrz bloku instrukcji. W przeciwnim razie program nie wykona kodu wewnątrz instrukcji a przejdzie do kolejnej liniki za klamrą zamykającą instrukcję warunkową.
Przykład:
using System;
namespace InstrukcjaWarunkowaIf
{
    class Program
    {
        static void Main(string[] args)
        {
            // Definiujemy zmienną lokalną
            int i = 20;
            // Sprawdzenie warunku przy użyciu instrukcji if
            if (i < 45)
            {
                // Kod zostanie wykonany, jeżeli warunek jest spełniony
                Console.WriteLine("Liczba jest mniejsza niż 45");
            }
            // Instrukcja warunkowa nie przerywa nam działania programu
            // Wykonuje dodatkowy blok w naszym programie (wypisanie w konsoli informacji)
            // A następnie przechodzi do dalszego wykonywania kodu
            Console.ReadKey();
            // UWAGA
            // Dobrą praktyką programistyczną w przypadku, jeżeli w bloku warunkowym mamy jedną linię kodu
            // jest stosowanie skróconego zapisu instrukcji warunkowej
            if (i < 45)
                Console.WriteLine("Liczba jest mniejsza niż 45");
        }
    }
}

Instrukcja warunkowa if…else

Instrukcja warunkowa if…else składa się z wyrażenia logicznego oraz ewentualnego polecenia else, które zostanie wywołane, jeżeli wyrażenie logicznie jest nieprawdziwe (false).
Składnia:
if (wyrazenie_logiczne)
{
    // poniższy kod zostanie wykonany, jeżeli warunek będzie spełniony (flaga true)
}
else
{
    // poniższy kod zostanie wykonany, jeżeli warunek nie będzie spełniony (flaga false)
}
Jeżeli wyrażenie logiczne jest prawdziwe (true) zostanie wykonany kod wewnątrz bloku instrukcji. W przeciwnim razie zostanie wykonany kod wewnątrz bloku else.
Przykład:
using System;
namespace InstrukcjaWarunkowaIf
{
    class Program
    {
        static void Main(string[] args)
        {
            // Definiujemy zmienną lokalną
            int i = 200;
            // Sprawdzenie warunku przy użyciu instrukcji if
            if (i < 45)
            {
                // Kod zostanie wykonany, jeżeli warunek jest spełniony
                Console.WriteLine("Liczba jest mniejsza niż 45");
            }
            else
            {
                Console.WriteLine("Liczba nie jest mniejsza niż 45");
            }
            Console.ReadKey();
            // UWAGA
            // W powyższym przypadku również można zastosować skrócony zapis
            // Zdecydowanie lepsza czytelność kodu
            if (i < 45)
                Console.WriteLine("Liczba jest mniejsza niż 45");
            else
                Console.WriteLine("Liczba nie jest mniejsza niż 45");
        }
    }
}

Instrukcja warunkowa if…else if…else

Instrukcja warunkowa if…else if…else składa się z wyrażenia logicznego oraz ewentualnego polecenia else if używanego do sprawdzenia wielu różnych warunków oraz pojedynczego polecenia else, które zostanie wywołane, jeżeli powyższe wyrażenia logicznie nie są prawdziwe (false).
Używając instrukcji warunkowej if…else if…else warto mieć na uwadze kilka punktów, o których nie wolno zapominać:
  • instrukcja warunkowa może nie mieć żadnego lub posiadać tylko jedno wyrażenie else, ale musi ono wystąpić po wyrażeniu else if;
  • instrukcja warunkowa może nie mieć żadnego lub posiadać wiele wyrażeń else if, ale muszą one występować przed wyrażeniem else;
  • jeżeli wyrażenie else if zostanie spełnione program nie wejdzie do żadnego innego warunku else if lub else.
Składnia:
if (wyrazenie_logiczne_1)
{
    // poniższy kod zostanie wykonany, jeżeli warunek_1 będzie spełniony (flaga true)
}
else if(wyrazenie_logiczne_2)
{
    // poniższy kod zostanie wykonany, jeżeli warunek_2 będzie spełniony (flaga false)
}
else if (wyrazenie_logiczne_3)
{
    // poniższy kod zostanie wykonany, jeżeli warunek_3 będzie spełniony (flaga false)
}
else
{
    // poniższy kod zostanie wykonany, jeżeli żaden powyższy warunek nie będzie spełniony
}
Przykład:
// Definiujemy zmienną lokalną
int i = 200;
// Sprawdzenie warunków przy użyciu instrukcji warunkowej if...else if...else
if (i == 20)
{
    // Kod zostanie wykonany, jeżeli warunek jest spełniony
    Console.WriteLine("Liczba jest równa 20");
}
else if (i == 40)
{
    // Kod zostanie wykonany, jeżeli warunek else if jest spełniony
    Console.WriteLine("Liczba jest równa 40");
}
else if (i == 60)
{
    // Kod zostanie wykonany, jeżeli warunek else if jest spełniony
    Console.WriteLine("Liczba jest równa 60");
}
else
{
    // Kod zostanie wykonany, jeżeli żaden powyższy warunek nie jest spełniony
    Console.WriteLine("Żadna z powyższych liczb nie pasuje");
}

Zagnieżdzona instrukcja warunkowa if

W jęzku C# dopuszczalne jest używanie zagnieżdżonych instrukcji warunkowych. Oznacza to, iż wewnątrz jednej instrukcji warunkowej if możemy używać kolejnych instrukcji warunkowych. Może to być każdy z przedstawionych powyżej schematów instrukcji warunkowej.
Składnia:
if (wyrazenie_logiczne_1)
{
    // poniższy kod zostanie wykonany, jeżeli warunek_1 będzie spełniony (flaga true)
    if (wyrazenie_logiczne_2)
    {
        // poniższy kod zostanie wykonany, jeżeli warunek_1 oraz warunek_2 będzie spełniony
    }
}
Przykład:
// Definiujemy zmienne lokalne
int a = 100;
int b = 200;
// Sprawdzenie warunku przy użyciu instrukcji if 
if (a == 100)
{
    // Jeżeli pierwszy warunek jest spełniony sprawdzamy drugi warunek
    if (b == 200)
    {
        // jeżeli warunek jest prawdziwy wyświetlamy komunikat
        Console.WriteLine("Wartość zmiennej a to 100 a zmiennej b to 200");
    }
}     

Instrukcja wyboru switch

Instrukcja warunkowa switch pozwala na sprawdzenie danej zmiennej w kontekście listy wymienionych wartości. Każda zmienna w tej instrukcji to tzw. przypadek (case). Zmienna jest sprawdzana dla każdego z przypadków w instrukcji warunkowej.
Składnia:
switch (wyrazenie)
{
    case przypadek_pierwszy:
        wykonanie_kodu();
        break;
    case przypadek_drugi:
        wykonanie_kodu();
        break;
    /* można zdefiniować dowolną ilość przypadków */
    default: // może ale nie musi występować
        wykonanie_kodu();
        break;
}            

Używając instrukcji wyboru switch należy stosować się do poniższych zasad:
  • wyrażenie użyte w instrukcji wyboru musi być typu integralnego (sbyte, byte, char, short, ushort, int, uint, long, ulong), typu wyliczeniowego lub może być klasą, która zawiera metodę pozwalającą na konwersję do typu integralnego lub wyliczeniowego;
  • można zdefiniować dowolną liczbę przypadków. Każdy przypadek składa się z wartości oraz znaku porównania (dwukropek);
  • zdefiniowany przez nasz przypadek musi być takiego samego typu jak wyrażenie (switch), musi to być stała lub literał;
  • kiedy wyrażenie będzie sprawdzane pomiędzy kolejnymi przypadkami i dojdzie do dopasowania zostanie wykonany kod wewnątrz bloku case aż do osiągnięcia instrukcji break;
  • nie każdy przypadek musi zawierać instrukcję break;
  • w instrukcji wyboru może być zastosowany opcjonalny operator przypadku domyślnego (default). Przypadek domyślny zostanie wykonany, jeżeli nie zostanie znalezione żadne dopasowanie. Instrukcja break nie jest potrzebna w przypadku domyślnym.
Przykład:
// Definicja zmiennej lokalnej
string marka = "Audi";
switch (marka)
{
    case "BMW":
        Console.WriteLine("Wybrałeś samochód marki BMW");
        break;
    case "Porsche":
        Console.WriteLine("Wybrałeś samochód marki Porsche");
        break;
    case "Audi":
        Console.WriteLine("Wybrałeś samochód marki Audi");
        break;
    default:
        break;
}
Przykład z zastosowaniem typów:
object type = false;
switch (type.GetType().Name)
{
    case "Int32":
        Console.WriteLine("Twój typ danych to Int32");
        break;
    case "String":
        Console.WriteLine("Twój typ danych to String");
        break;
    case "Boolean":
        Console.WriteLine("Twój typ danych to Boolean");
        break;
    default:
        break;
}

Zagnieżdzona instrukcja wyboru switch

Możliwe jest stosowanie zagnieżdżonych instrukcji wyboru switch.
Składnia:
switch (wyrażenie_1)
{
    case 'A':
        Console.WriteLine("A jest cześcią zewnętrzej instrukcji");
        switch (wyrażenie_2)
        {
            case 'A':
                Console.WriteLine("B jest cześcią wewnętrzej instrukcji");
                break;
            case 'B': /* wewnętrzy przypadek dla B */
        }
        break;
    case 'B': /* zewnętrzy przypadek dla B */
}
Przykład:
using System;
namespace InstrukcjaWarunkowaSwitchZagniezdzona
{
    class Program
    {
        static void Main(string[] args)
        {
            // Definicja zmiennych loklanych
            int a = 100;
            int b = 200;
            switch (a)
            {
                case 100:
                    Console.WriteLine("To jest zewnętrzna instrukcja wyboru.");
                    switch (b)
                    {
                        case 200:
                            Console.WriteLine("To jest wewnętrzna instrukcja wyboru.");
                            break;
                    }
                    break;
            }
        }
    }
}