Met stappen door de code

In dit hoofdstuk kijken we naar het 'door de code stappen', wat weer een ander zeer essentieel deel is van het debuggen. Voor dat doel heb ik deze simpele applicatie geschreven:

namespace DebugTest
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 5;
            a = a * 2;
            a = a - 3;
            a = a * 6;
            Console.WriteLine(a);
        }
    }
}

De applicatie manipuleert een paar keer variabele 'a' en laat het uiteindelijke resultaat zien. Probeer een pauzepunt (zie vorig hoofdstuk) op de eerste regel te zetten waar a gebruikt (en gedeclareerd) wordt. Run nu de applicatie. De uitvoering stopt en zweef nu met je muis over de a om er zeker van te zijn dat wat we in het vorige hoofdstuk geleerd hebben, waar is: De variabele bevat alleen maar de default waarde omdat de code die de waarde toekent (in dit geval 5) nog niet is uitgevoerd. Laten we dat veranderen. Selecteer uit het Debug menu de "Step over" optie, of, nog beter, gebruik shortcut F10 van het toetsenbord. De uitvoering gaat nu verder naar de volgende relevante regel, en als je nu je muis over de a variabele zweeft, zul je zien dat hij een waarde heeft. Herhaal dat en je zult zien dat de waarde verandert in overeenstemming met de regels die één voor één worden uitgevoerd, tot je bij het einde bent.

Nou, dat was behoorlijk basaal, maar ook erg nuttig, zoals je je zult realiseren als je meer gecompliceerde code gaat schrijven. In dit voorbeeld was het verloop van de code erg eenvoudig omdat we binnen een enkele functie bleven. Maar wat als de code zich begint uit te spreiden over meerder classes en/of functies? probeer dit voorbeeld:

namespace DebugTest
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 5;
            int b = 2;
            int result = MakeComplicatedCalculation(a, b);
            Console.WriteLine(result);
        }

        static int MakeComplicatedCalculation(int a, int b)
        {
            return a * b;
        }
    }
}

Plaats een pauzepunt op de eerste regel van de Main method en run de applicatie. Gebruik nu de "Step over" functie om regel voor regel af te werken. Je kunt zien dat hij de functie aanroep (call) overslaat; zo werkt debugging nu eenmaal. Probeer het nu opnieuw vanaf het begin, en als je op de regel staat met de MakeComplicatedCalculation() aanroep, kies dan Debug -> Step into, of gebruik de F11 toets. Zoals je je waarschijnlijk kunt voorstellen kun je hiermee door een gecompliceerd block van code heen stappen, terwijl je alleen maar die functie aanroepen uitkiest die je interesseren.

Als je in een functie stapt en je realiseert je ineens dat je liever wil teruggaan naar de vorige context, kun je de optie gebruiken uit het Debug menu met de zeer logische naam "Step out" (of toets Shift+F11). Hiermee ga je terug naar je eerdere context, hetgeen uiteraard betekent dat je in zoveel functie aanroepen kunt stappen als je wilt, en vervolgens de weg terug kunt vinden met behulp van de "Step out" optie.