5. diel - Podmienky (vetvenia) v C# .NET

V predchádzajúcom cvičení, Riešené úlohy k 4. lekcii C# .NET, sme si precvičili získané skúsenosti z predchádzajúcich lekcií.

Aby sme si niečo naprogramovali, potrebujeme nejako reagovať na rôzne situácie. Môže to byť napríklad hodnota zadaná užívateľom, podľa ktorej budeme chcieť meniť ďalší beh programu. Hovoríme, že sa program vetví a na vetvenie používame podmienky. Tým sa budeme venovať celý dnešný C# tutoriál. Vytvoríme program na výpočet odmocniny a vylepšíme našu kalkulačku.

Podmienky

V C# sa podmienky píšu úplne rovnako ako vo všetkých C-like jazykoch, čo začiatočníkom samozrejme vysvetlíme. Pokročilejšie sa asi budú chvíľku nudiť

Podmienky zapisujeme pomocou kľúčového slova if, za ktorým nasleduje logický výraz. Ak je výraz pravdivý, vykoná sa nasledujúci príkaz. Pokiaľ nie, nasledujúci príkaz sa preskočí a pokračuje sa až pod ním.

V nasledujúcej ukážke použijeme znaky väčšie > a menšie <. Ak neviete, kde ich na slovenskej klávesnici nájsť, píšeme ich pomocou Pravého Alt a nasledujúcich klávesov:

Vyskúšajme si to:

{CSHARP_CONSOLE}
if (15 > 5)
    Console.WriteLine("True");
Console.WriteLine("The program continues here...");
Console.ReadKey();
{/CSHARP_CONSOLE}

Výstup programu:

Konzolová aplikácia
True
The program continues here...

Pokiaľ podmienka platí (čo tu áno), vykoná sa príkaz vypisujúci do konzoly text True. V oboch prípadoch program pokračuje ďalej. Súčasťou výrazu samozrejme môže byť aj premenná:

{CSHARP_CONSOLE}
Console.WriteLine("Enter a number");
int a = int.Parse(Console.ReadLine());
if (a > 5)
    Console.WriteLine("The number you entered is greater than 5!");
Console.WriteLine("Thanks for the input!");
Console.ReadKey();
{/CSHARP_CONSOLE}

Ukážme si teraz relačné operátory, ktoré môžeme vo výrazoch používať:

Rovnosť zapisujeme dvoma == preto, aby sa to neplietlo s bežným priradením do premennej, ktoré sa robí len jedným =. Pokiaľ chceme nejaký výraz znegovať, napíšeme ho do zátvorky a pred neho výkričník. Keď budeme chcieť vykonať viac ako len jeden príkaz, musíme príkazy vložiť do bloku zo zložených zátvoriek:

{CSHARP_CONSOLE}
Console.WriteLine("Enter some number and I'll calculate a square root:");
int a = int.Parse(Console.ReadLine());
if (a > 0)
{
    Console.WriteLine("The number you entered is greater than 0, so I can calculate it!");
    double root = Math.Sqrt(a);
    Console.WriteLine("The square root of " + a + " is " + root);
}
Console.WriteLine("Thanks for the input");
Console.ReadKey();
{/CSHARP_CONSOLE}

Výstup programu:

Konzolová aplikácia
Enter some number and I'll calculate a square root:
144
The number you entered is greater than 0, so I can calculate it!
The square root of 144 is 12
Thanks for the input

Program načíta od užívateľa číslo, a ak je väčšie ako 0, vypočíta z neho druhú odmocninu. Okrem iného sme použili triedu Math, ktorá na sebe obsahuje množstvo užitočných matematických metód. Metóda Sqrt() vracia druhú odmocninu ako double. Bolo by pekné, keby nám program vyhuboval v prípade, že zadáme záporné číslo. S doterajšími znalosťami by sme napísali niečo ako:

{CSHARP_CONSOLE}
Console.WriteLine("Enter some number and I'll calculate a square root:");
int a = int.Parse(Console.ReadLine());
if (a > 0)
{
    Console.WriteLine("The number you entered is greater than 0, so I can calculate it!");
    double root = Math.Sqrt(a);
    Console.WriteLine("The square root of " + a + " is " + root);
}
if (a <= 0)
    Console.WriteLine("I can't calculate the square root of a negative number!");
Console.WriteLine("Thanks for the input");
Console.ReadKey();
{/CSHARP_CONSOLE}

Všimnime si, že musíme pokryť aj prípad, keď sa a == 0, nielen keď je menší. Kód však môžeme výrazne zjednodušiť pomocou kľúčového slova else, ktoré vykoná nasledujúci príkaz alebo blok príkazov v prípade, že sa podmienka nevykoná:

{CSHARP_CONSOLE}
Console.WriteLine("Enter some number and I'll calculate a square root:");
int a = int.Parse(Console.ReadLine());
if (a > 0)
{
    Console.WriteLine("The number you entered is greater than 0, so I can calculate it!");
    double root = Math.Sqrt(a);
    Console.WriteLine("The square root of " + a + " is " + root);
}
else
    Console.WriteLine("I can't calculate the square root of a negative number!");
Console.WriteLine("Thanks for the input");
Console.ReadKey();
{/CSHARP_CONSOLE}

Kód je oveľa prehľadnejší a nemusíme vymýšľať opačnú podmienku, čo by v prípade zloženej podmienky mohlo byť niekedy aj veľmi ťažké. V prípade viacerých príkazov by bol za else opäť blok { }.

Kľúčové slovo else sa tiež využíva v prípade, keď potrebujeme v príkaze manipulovať s premennou z podmienky a nemôžeme sa teda na ňu pýtať potom znova. Program si sám pamätá, že sa podmienka nesplnila, a prejde do vetvy else. Ukážme si to na príklade: Majme číslo a, kde bude hodnota 0 alebo 1 a po nás sa bude chcieť, aby sme hodnotu prehodili (ak tam je 0, dosadíme tam 1, ak 1, dosadíme 0). Naivne by sme mohli kód napísať takto:

{CSHARP_CONSOLE}
int a = 0; // the variable is initialized with a value of 0

if (a == 0) // if the value is 0, we change its value to 1
    a = 1;
if (a == 1) // if the value is 1, we change its value to 0
    a = 0;

Console.WriteLine(a);
Console.ReadKey();
{/CSHARP_CONSOLE}

Nefunguje to, že? Poďme si prejsť, čo bude program robiť. Na začiatku máme v a nulu, prvá podmienka sa určite splní a dosadí do a jedničku. No ale razom sa splní aj tá druhá. Čo s tým? Keď podmienky otočíme, budeme mať ten istý problém s jednotkou. Ako z toho von? Áno, použijeme else:

{CSHARP_CONSOLE}
int a = 0; // the variable is initialized with a value of 0

if (a == 0) // if the value is 0, we change its value to 1
    a = 1;
else // if the value is 1, we change its value to 0
    a = 0;

Console.WriteLine(a);
Console.ReadKey();
{/CSHARP_CONSOLE}

Podmienky je možné skladať, a to pomocou dvoch základných logických operátorov:

Na slovenskej klávesnici ich píšeme pomocou Pravého Alt a klávesov W a C, mnemotechnickú pomôcku si k tomu určite domyslíte :

Uveďme si príklad:

{CSHARP_CONSOLE}
Console.WriteLine("Enter a number between 10-20:");
int a = int.Parse(Console.ReadLine());
if ((a >= 10) && (a <= 20))
    Console.WriteLine("The condition has been met.");
else
    Console.WriteLine("You did it wrong.");
Console.ReadKey();
{/CSHARP_CONSOLE}

S tým si zatiaľ vystačíme, operátorov je možné samozrejme pomocou zátvoriek kombinovať.

{CSHARP_CONSOLE}
Console.WriteLine("Enter a number between 10-20 or 30-40:");
int a = int.Parse(Console.ReadLine());
if (((a >= 10) && (a <= 20)) || ((a >=30) && (a <= 40)))
    Console.WriteLine("The condition has been met.");
else
    Console.WriteLine("You did it wrong.");
Console.ReadKey();
{/CSHARP_CONSOLE}

Konštrukcia switch

Konštrukcia switch je prevzatá z jazyka C (ako väčšina gramatiky C#). Umožňuje nám (relatívne) zjednodušiť zápis viacerých podmienok pod sebou. Spomeňme si na našu kalkulačku v prvých lekciách, ktorá načítala 2 čísla a vypočítala všetky 4 operácie. Teraz si ale budeme chcieť zvoliť, ktorú operáciu chceme. Bez konštrukcie switch by sme napísali kód podobný tomuto:

{CSHARP_CONSOLE}
Console.WriteLine("Welcome to our calculator");
Console.WriteLine("Enter the first number:");
double a = double.Parse(Console.ReadLine());
Console.WriteLine("Enter the second number:");
double b = double.Parse(Console.ReadLine());
Console.WriteLine("Choose one of the following operations:");
Console.WriteLine("1 - addition");
Console.WriteLine("2 - subtraction");
Console.WriteLine("3 - multiplication");
Console.WriteLine("4 - division");
int option = int.Parse(Console.ReadLine());
double result = 0;
if (option == 1)
    result = a + b;
else
if (option == 2)
    result = a - b;
else
if (option == 3)
    result = a * b;
else
if (option == 4)
    result = a / b;
if ((option > 0) && (option < 5))
    Console.WriteLine("Result: {0}", result);
else
    Console.WriteLine("Invalid option");
Console.WriteLine("Thank you for using our calculator. Press any key to end the program.");
Console.ReadKey();
{/CSHARP_CONSOLE}

Výstup programu:

Konzolová aplikácia
Welcome to our calculator
Enter the first number:
3,14
Enter the second number:
2,72
Choose one of the following operations:
1 - addition
2 - subtraction
3 - multiplication
4 - division
2
Result: 0,42
Thank you for using our calculator. Press any key to end the program.

Všimnime si, že sme premennú result deklarovali na začiatku, pretože len tak do nej potom môžeme priraďovať. Keby sme ju deklarovali pri každom priradení, C# by kód neskompiloval a vyhodil by chybu redeklarácie premennej. Premenná môže byť deklarovaná (založená v pamäti) vždy len raz. Bohužiaľ C# nie je schopný poznať, či je do premennej result naozaj priradená nejaká hodnota. Ozve sa pri výpise na konzole, kde sa mu nepáči, že môže vypisovať premennú, ktorá nemá priradenú hodnotu. Z tohto dôvodu na začiatku dosadíme do result nulu.

Ďalšia vychytávka je kontrola správnosti voľby. Program by v tomto prípade fungoval rovnako aj bez else, ale načo sa ďalej pýtať, keď už máme výsledok.

Teraz si skúsime napísať ten istý kód pomocou konštrukcie switch:

{CSHARP_CONSOLE}
Console.WriteLine("Welcome to our calculator");
Console.WriteLine("Enter the first number:");
double a = double.Parse(Console.ReadLine());
Console.WriteLine("Enter the second number:");
double b = double.Parse(Console.ReadLine());
Console.WriteLine("Choose one of the following operations:");
Console.WriteLine("1 - addition");
Console.WriteLine("2 - subtraction");
Console.WriteLine("3 - multiplication");
Console.WriteLine("4 - division");
int option = int.Parse(Console.ReadLine());
double result = 0;
switch (option)
{
    case 1:
        result = a + b;
    break;
    case 2:
        result = a - b;
    break;
    case 3:
        result = a * b;
    break;
    case 4:
        result = a / b;
    break;
}
if ((option > 0) && (option < 5))
    Console.WriteLine("Result: {0}", result);
else
    Console.WriteLine("Invalid option");
Console.WriteLine("Thank you for using our calculator. Press any key to end the program");
Console.ReadKey();
{/CSHARP_CONSOLE}

Vidíme, že kód je trochu prehľadnejší. Ak by sme potrebovali v nejakej vetve konštrukcie switch spustiť viac príkazov, prekvapivo ich nebudeme písať do {} bloku, ale rovno pod seba. Blok {} nám tu nahrádza príkaz break, ktorý spôsobí vyskočenie z celej konštrukcie switch. switch môže namiesto case x: obsahovať ešte možnosť default:, ktorá sa vykoná v prípade, že nebude platiť žiadny case. Je len na nás, či budeme switch používať, všeobecne sa oplatí len pri väčšom množstve príkazov a vždy ide nahradiť sekvenciou if a else. Nezabúdajme na príkaz break. Samozrejme je možné použiť switch aj pre hodnoty stringovej premennej.

Pretože je posledný kód dlhší, je ho potrebné zľava správne odsadzovať tabulátormi, aby boli ľahko vidieť jednotlivé vetvy kódu. Zo začiatku pre vás môže byť udržiavanie odsadenia problém, preto pre vás máme vychytávku - autoformat. Klávesová skratka Ctrl + E D naformátuje otvorený dokument vo Visual Studiu do dokonalej podoby. K tejto funkcii sa môžete dostať aj cez menu Edit -> Advanced -> Format Document (funkcia Format Selection potom sformátuje len vybranú časť kódu).

Konštrukcia switch na riadku

Autori C# za posledné roky vychrlili množstvo novej syntaxe. Určite sa jej teraz nenechajme zmiasť, ale pre úplnosť si ukážme, ako sa dá zápis konštrukcie switch ešte zjednodušiť.

Osobne by som odporúčal túto syntax skôr nepoužívať, pretože je pomerne neštandardná, ale môžete na ňu naraziť v cudzích zdrojových kódoch.

Predstavme si, že máme program na vyjadrenie teploty slovami a máme rôzne hodnoty a rozsahy, podľa ktorých chceme povedať, ako vonku je. Od C# 9 môžeme takýto switch napísať oveľa úspornejšie:

int temperature = 12;
string temperatureInWords = temperature switch
{
    < -5 => "It's freezing.",
    0 or 100 => "Freezing or Boiling",
    >= -5 and <= 5 => "Cold",
    > 5 and < 15 => "Cool",
    >= 15 and <= 25 => "Warm",
    > 25 => "Hot"
};

Do novej premennej temperatureInWords ukladáme a z temperature čítame. Môžeme využiť porovnávacie znamienka (>, <, <=, >=) a tiež slová and (a zároveň) a or (alebo). Default by sme nahradili nasledovne pomocou podčiarkovníka _:

_ => Console.WriteLine("Invalid value");

(U tohto ukážkového príkladu konštrukcia switch by sa default samozrejme nikdy nespustil.)

Na slovenskej klávesnici píšeme podčiarknutie _ pomocou Shift a nasledujúce klávesy:

V nasledujúcom cvičení, Riešené úlohy k 5. lekcii C# .NET, si precvičíme nadobudnuté skúsenosti z predchádzajúcich lekcií.

Mal si s čímkoľvek problém? Stiahni si vzorovú aplikáciu nižšie a porovnaj ju so svojím projektom, chybu tak ľahko nájdeš.