8. diel - Visual Studio - Debugging
V dnešnom Visual Studio tutoriále si ukážeme debuggovanie C# .NET aplikácií. Na praktických príkladoch si osvojíme základné možnosti debuggovania, ako napríklad ako pozastaviť program, nazerať do obsahu premenných a podobne.
Debugging
Debugging je proces odstránenia chýb v programe, ktoré obvykle nie sú na prvý pohľad vidieť. Niekedy sa o ňom hovorí aj ako o ladení programu.
Prečo a kedy debugovať?
Chyby v programe sa väčšinou prejavujú tým, že je v nejakej premennej nesprávna hodnota, ktorá potom zapríčiní nefunkčnosť programu. Určite ste sa už dostali do situácie, keď váš program nefungoval správne. Možno ste vykonávali nejaké zdĺhavé kontrolné výpisy rôznych premenných, aby ste zistili, kde je ešte všetko správne a kde sú už nesprávne hodnoty.
Chybu možno však obvykle nájsť oveľa ľahšie pomocou debuggovania. Program obvykle spustíme v špeciálnom režime, kde máme dovolené určité "cheaty", ako napr. program pozastavovať a nazerať do obsahu premenných. Práve to sa dnes naučíme.
Nie je pravda, že debugger používame len keď program nefunguje! Naopak, používame ho čo najviac to ide a to aj napríklad na kontrolu správnosti na kritických miestach.
Príklad - Krokovanie cyklu
Majme jednoduchý cyklus, v ktorom budeme vypisovať čísla od
0 do 9:
{CSHARP_CONSOLE}
for (int i = 0; i < 10; i++)
{
Console.WriteLine("Číslo: " + i);
}
{/CSHARP_CONSOLE}
Výstup z konzoly:
Konzolová aplikácia
Číslo: 0
Číslo: 1
Číslo: 2
Číslo: 3
Číslo: 4
Číslo: 5
Číslo: 6
Číslo: 7
Číslo: 8
Číslo: 9
Ako môžeme vidieť, program funguje korektne. Napriek tomu si ho skúsime oddebuggovať, než sa pustíme na nefunkčný kód.
Breakpointy
Breakpoint je základný stavebný kameň pri debuggovaní. Je to miesto označujúce riadok, na ktorom sa program zastaví. Nám, ako programátorom, sa v tej chvíli zobrazí kompletný kontext programu, teda napríklad, čo je v tej chvíli kde uložené. Pretože program stojí, môžeme si všetko jednoducho skontrolovať.
Pridanie breakpointu
Teraz sa naučíme vkladať breakpointy a zastavovať na nich program. Vo Visual Studiu sa breakpoint na daný riadok vkladá kliknutím do priestoru vľavo vedľa čísla riadku. Breakpoint potom spoznáme podľa červeného kolieska. Vložme teda breakpoint na riadok, kde sa vypisuje číslo do konzoly:
Debug režim
Breakpoint máme pridaný. Keď však program teraz spustíme, nič zvláštne sa nestane. Aby sa program naozaj zastavil, je potrebné ho spustiť v špeciálnom debuggovacom režime. K tomu slúži tlačidlo ikony spustenia s názvom nášho programu (tu Debug):
Alternatívne je možné spustiť debuggovanie klávesom F5.
Klikneme teda na vyššie spomínané tlačidlo. Program sa spustí a až narazí na náš breakpoint, tak sa zastaví:
Riadok označený breakpointom sa podfarbil žlto. To znamená, že breakpoint je dosiahnuteľný. Zároveň sa nám v hornom menu otvorila nová záložka na debuggovanie av spodnej časti okna Locals a Call Stack. Poďme si všetko vysvetliť.
Okno Locals
V ľavom spodnom okne, na obrázku zvýraznenom zelene, vidíme zoznam všetkých aktuálne viditeľných premenných a ich hodnoty. Hodnoty je možné zmeniť.
Alternatívne je možné zistiť hodnotu premennej tak, že na ňu v okne Program.sk nabehneme kurzorom myši.
Okno Call Stack
V pravom spodnom okne, na obrázku zvýraznenom oranžovo, vidíme zásobník volaní všetkých metód, ktoré sa zavolali pred zastavením na breakpointe.
Záložka na debuggovanie
V hornom menu Visual Studia sa najskôr zameriame na tlačidlá pre ovládanie debuggovania, ktoré na obrázku vyššie sú identifikované identifikátormi 1, 2, 3 a 4:
1 - Continue - uvoľní program z
breakpointu, nechá ho bežať a prípadne ho zastaví o ďalší
breakpoint,
2 - Break All Ctrl + Alt +
Break - pozastaví celý program a čaká na
opätovné spustenie,
3 - Stop Debugging Shift + F5 -
ukončí debuggovanie,
4 - Reštart Ctrl + Shift +
F5 - začne debuggovanie od začiatku.
Krokovanie
Zo záložky na debuggovanie si teraz vysvetlíme tlačidlá na ovládanie krokovania, ktorými môžeme nechať program pokročiť na ďalší riadok a zase ho zastaviť. Tieto tlačidlá na obrázku vyššie sú identifikované identifikátormi A, B, C a D:
A - Show next statement Alt + Num* -
preskočí na ďalší príkaz, ktorý je označený žltou
šípkou a je žlto podfarbený,
B - Step into F11 - skočí na
prvý riadok volané metódy z aktuálneho riadku,
C - Step over F10 - vykoná
príkaz/volanie metódy na aktuálnom riadku a prejde na ďalší riadok, kde sa
zastaví,
D - Step out Shift + F11 -
vystúpi z aktuálne krokovanej metódy.
Dokončenie krokovania cyklu
Vráťme sa k nášmu bežiacemu debuggovaniu. My sa nachádzame v cykle, kde
iba vypisujeme jednu hodnotu. Avšak aj tak môžeme pomocou tlačidla Step
Over krokovať vypisovanie hodnôt do konzoly, sledovať
posun behu programu v cykle a zmenu hodnoty
premennej i v okne Locals. Nakoniec ukončíme
debuggovanie nášho príkladu na krokovanie cyklu stlačením tlačidla
Stop Debugging.
Príklad - Oprava programu
Nakoniec si dáme príklad naozaj na precvičenie debuggovania 
Identifikácia správneho správania programu
Majme dva vnorené cykly, ktoré by mali vypísať malú násobilku:
{CSHARP_CONSOLE}
for (int j = 1; j <= 10; j++)
{
for (int i = 1; j <= 10; j++)
{
Console.Write(i * j + " ");
}
Console.WriteLine();
}
{/CSHARP_CONSOLE}
Výsledok by mal vyzerať takto:
Konzolová aplikácia
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100
Identifikácia chybného správania programu
Problém ale je, že sa vypíšu iba čísla od 1 do
10:
Konzolová aplikácia
1 2 3 4 5 6 7 8 9 10
Chybu budeme samozrejme chcieť nájsť a opraviť za pomoci breakpointov a krokovania.
Aj keď uvidíte chybu na prvý pohľad, aj tak si to odkrokujte! V zložitejších aplikáciách chyba ľahko vidieť nebude a debuggovanie bude nutné.
Debuggovanie
Očakávame, že vonkajší cyklus sa vykoná 10x, zatiaľ čo vnútorný
cyklus sa vykoná celkom 100x. Vložíme breakpoint na riadok s
vonkajším for cyklom:
for (int j = 1; j <= 10; j++)
A spustíme program v debuggovacom režime. Bude nás zaujímať, ako sa
premenné i a j zvyšujú. Tlačidlom Step
into budeme postupne prechádzať cez oba cykly a pozorovať hodnoty
premenných i a j v okne Locals. Vonkajší
cyklus pracuje s premennou j, ktorá by sa mala zmeniť iba 10x.
Vnútorný cyklus pracuje s premennou i, ktorá by sa mala pri
každej zmene j upraviť 10x.
Identifikácia a oprava chýb
Postupným krokovaním však zistíme, že vnútorný cyklus inkrementuje
premennú j namiesto i. Vo vnútornom cykle upravíme
j++ na i++ a program opäť spustíme v debuggovacom
režime:
for (int i = 1; j <= 10; i++)
Krokujeme opäť tlačidlom Step into. Sledujeme premennú
i. Po čase začne nadobúdať neočakávané hodnoty, ktoré sa
neustále o jednotku zvyšujú. Pokiaľ teraz necháme program bežať, začne
sa nám počítač kosiť. To je z dôvodu, že vo vnútornom cykle je
podmienka, ktorá nikdy nebude splnená.
V cykle for (int i = 1; j <= 10; i++) máme premennú
i, ktorú už správne inkrementujeme, ale
podmienka je zlá. Premenná i sa inkrementuje,
pokiaľ platí j <= 10. Táto podmienka nikdy nebude splnená,
pretože premenná j sa modifikuje iba vo vonkajšom cykle.
Opravíme podmienku vnútorného cyklu z j <= 10 na
i <= 10:
{CSHARP_CONSOLE}
for (int j = 1; j <= 10; j++)
{
for (int i = 1; i <= 10; i++)
{
Console.Write(i * j + " ");
}
Console.WriteLine();
}
{/CSHARP_CONSOLE}
Testovanie opraveného programu
Teraz spustíme program bez debuggovania tlačidlom Start without Debugging Ctrl + F5 a necháme program dobehnúť. Výsledkom už je očakávaná malá násobilka:
Konzolová aplikácia
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100
V nasledujúcom kvíze, Záverečný test - Visual Studio, si vyskúšame nadobudnuté skúsenosti z kurzu.
