Stepping through the code

ఈ chapter లో, మీ code గుండా ఎలా అడుగులు వేయాలో, debugging లో మరో ముఖ్యమైన అవసరమైన భాగాన్ని చూస్తాము. ఈ అవసరం కోసం ఈ క్రింది simple application ని వ్రాయబడింది.

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

ఇది variable ‘a’ ని రెండు సార్లు మార్చి final result ని output ఇస్తుంది. క్రింది chapter లో చెప్పినట్లు ఎక్కడైతే a ని use (declare) చేశారో ఆ first line పై breakingpoint ని పెట్టండి. ఇప్పుడు application ని run చేయండి. Execution stop అవుతుంది, గత chapter లో నేర్చుకొన్నవి నిజమని నిర్ధారించేందుకు a పై mouse ని పెట్టండి. ఈ variable కేవలం default value ని మాత్రమే కలిగి ఉంటుంది, ఎందుకంటే value ని దానికి assign చేసిన (ఈ సందర్భంలో 5) దానిని ఇప్పటి వరకు execute చేయలేదు, కాని దాన్ని మార్చుదాము. Debug menu నుండి "Step over" option ని లేదా ఇంకా better గా keyboard లోని shortcut అయిన F10 ని click చేసి select చేయండి. ఇప్పుడు execution తర్వాత line కి కదులుతుంది, మీరు a variable పై mouse ని ఉంచితే, దానిలో value ఉండటాన్ని చూస్తారు. మళ్ళీ ఒకసారి ప్రయత్నించండి, ఒక line తర్వాత మరో line చివరి దాకా execute అవుతున్నట్టుగా value మారుతూ ఉండటాన్ని గమనిస్తారు.

అది చాలా సాధారణమైనప్పటికీ, complicated code ని write చేసేటప్పుడు ఎంతో ఉపయోగం అని గుర్తిస్తారు. ఈ example code లో ప్రయాణం ఒకే function లో ఉన్నందున very simple గా ఉంది, కానీ మీ code ఎన్నో classes మరియు functions తో విస్తరిస్తే ఎలా ఉంటుందో? ఈ example ని try చేయండి.

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;
        }
    }
}

Main Method యొక్క first line మీద breakpoint ని పెట్టి application ని run చేయండి. ఇప్పుడు ప్రతి line గుండా వెళ్ళేందుకు "Step over" function ని use చేయండి. ఎలాంటి notice లేకుండా function call పైకి కదలటాన్ని మీరు చూస్తారు – అది debugging ఎంత simple గా పనిచేస్తుందో చెబుతుంది. ఇప్పుడు మరోసారి MakeComplicatedCalculation() లోని line కి వెళ్ళగానే Debug -> Step into ని select చేసి లేదా keyboard short F11 ని use చేసి మొదటి నుండి ప్రయత్నించండి. ఇప్పుడు debugger వీలైన మొదటి function call వద్దకు వెళ్ళి ఆ function గుండా వెళ్ళేలా చేస్తుంది. మీరు సంక్లిష్టమైన code ద్వారా అడుగు పెట్టడానికి అనుమతిస్తుంది, అదే సమయంలో మీకు interest ఉన్న function call కి మాత్రమే వెళ్ళేలా చేస్తుంది.

మీరు ఒక function లోనికి అడుగుపెట్టి, ఆపై మీరు మునుపటి సందర్భానికి తిరిగి వస్తారని గ్రహించినట్లయితే, మీరు Debug menu లోని తార్కికంగా పెట్టిన పేరు "step out" ని ఉపయోగిస్తారు (keyboard యొక్క shortcut : Shift + F11). ఇది మిమ్మల్ని మీ మునుపటి సందర్భానికి తీసుకొని వెళ్తుంది, దీని అర్థం మీరు కోరుకున్నన్ని function calls లోనికి అడుగు పెట్టవచ్చు, ఆపై step out option ని ఉపయోగించడం ద్వారా మీ మార్గాన్ని తిరిగి కనుగొనవచ్చు.