Oefening: variabelen en uitvoeringsstroom bewaken

13 minuten

De weergave RUN AND DEBUG biedt ontwikkelaars een eenvoudige manier om variabelen en expressies te bewaken, de uitvoeringsstroom te observeren en onderbrekingspunten te beheren tijdens het foutopsporingsproces.

Onderzoek de secties van de weergave voor Uitvoeren en foutopsporing

Elke sectie van de weergave RUN AND DEBUG biedt unieke mogelijkheden. Het gebruik van een combinatie van deze secties tijdens het foutopsporingsproces is vaak handig.

Sectie VARIABELEN

De status van de bewakingsvariabele is een belangrijk aspect van codeopsporing. Onverwachte wijzigingen in de variabelestatus helpen vaak bij het identificeren van logische fouten in uw code.

De sectie VARIABLES ordent uw variabelen op bereik. Het Locals bereik geeft de variabelen weer in het huidige bereik (de huidige methode).

Opmerking

De sectie met instructies op het hoogste niveau van een consoletoepassing wordt beschouwd als een eigen methode. Een methode met de naam Main.

U kunt de weergegeven scopes uitbreiden door de pijl links van de scopenaam te selecteren. U kunt ook variabelen en objecten uitvouwen. In de volgende schermopname ziet u de numbers matrix die is uitgevouwen onder het Locals bereik.

Schermopname van een uitgevouwen variabele in de sectie Variabelen van de weergave Uitvoeren en Foutopsporing.

Het is ook mogelijk om de waarde van een variabele tijdens runtime te wijzigen met behulp van de sectie VARIABELEN. U kunt dubbelklikken op de naam van de variabele en vervolgens een nieuwe waarde invoeren.

Kijk-sectie

Wat moet u doen als u een variabelestatus wilt bijhouden in de tijd of op verschillende methoden? Het kan vervelend zijn om elke keer naar de variabele te zoeken. Dat is waar de WATCH-sectie handig is.

U kunt de knop Expressie toevoegen selecteren (wordt weergegeven als plusteken: +) om een variabelenaam of een expressie in te voeren die u wilt bekijken. Als alternatief kunt u met de rechtermuisknop op een variabele klikken in de sectie VARIABELEN en selecteren Add to watch.

Alle expressies in de WATCH-sectie worden automatisch bijgewerkt wanneer uw code wordt uitgevoerd.

OPROEPSTACKSECTIE

Telkens wanneer uw code een methode van een andere methode invoert, wordt er een aanroeplaag toegevoegd aan de aanroepstack van de toepassing. Wanneer uw toepassing complex wordt en u een lange lijst met methoden hebt die door andere methoden worden aangeroepen, vertegenwoordigt de aanroepstack het spoor van methode-aanroepen.

De sectie CALL STACK is handig wanneer u de bronlocatie voor een uitzondering of WATCH-expressie zoekt. Als uw toepassing een onverwachte uitzondering genereert, ziet u vaak een bericht in de console die er ongeveer als volgt uitziet:

Exception has occurred: CLR/System.DivideByZeroException
An unhandled exception of type 'System.DivideByZeroException' occurred in Debug1.dll: 'Attempted to divide by zero.'
    at Program.<<Main>$>g__WriteMessage|0_1() in C:\Users\howdc\Desktop\Debug1\Program.cs:line 27
    at Program.<<Main>$>g__Process1|0_0() in C:\Users\howdc\Desktop\Debug1\Program.cs:line 16
    at Program.<Main>$(String[] args) in C:\Users\howdc\Desktop\Debug1\Program.cs:line 10

De ingesprongen groep van at Program ... regels onder het foutbericht wordt een stack trace genoemd. De stacktracering bevat de naam en oorsprong van elke methode die werd aangeroepen voorafgaand aan de uitzondering. De informatie kan echter een beetje moeilijk te ontcijferen zijn, omdat deze ook informatie uit de .NET-runtime kan bevatten. In dit voorbeeld is de stack-trace vrij schoon en kunt u zien dat er een uitzondering is opgetreden in een methode met de naam WriteMessage. De stack is afkomstig uit een methode met de naam Main, de sectie met instructies op het hoogste niveau van de consoletoepassing.

De CALL STACK-sectie kan u helpen de moeilijkheid te vermijden van het ontcijferen van een stacktracering die volgestopt is met informatie over de .NET-runtime. Hiermee worden ongewenste informatie gefilterd om alleen de relevante methoden van uw eigen code standaard weer te geven. U kunt de aanroepstack handmatig uitdraaien om erachter te komen waar de uitzondering vandaan komt.

Breakpoints-sectie

In de sectie BREAKPOINTS worden de huidige instellingen voor onderbrekingspunten weergegeven en kan worden gebruikt om specifieke onderbrekingspunten in of uit te schakelen tijdens een foutopsporingssessie.

Uw toepassing configureren en configuratie starten

Wanneer u werkt aan een consoletoepassing die gebruikersinvoer leest, moet u waarschijnlijk het opstartconfiguratiebestand bijwerken.

Werk de code in het Program.cs-bestand als volgt bij:

string? readResult;
int startIndex = 0;
bool goodEntry = false;

int[] numbers = { 1, 2, 3, 4, 5 };

// Display the array to the console.
Console.Clear();
Console.Write("\n\rThe 'numbers' array contains: { ");
foreach (int number in numbers)
{
    Console.Write($"{number} ");
}

// To calculate a sum of array elements, 
//  prompt the user for the starting element number.
Console.WriteLine($"}}\n\r\n\rTo sum values 'n' through 5, enter a value for 'n':");
while (goodEntry == false)
{
    readResult = Console.ReadLine();
    goodEntry = int.TryParse(readResult, out startIndex);

    if (startIndex > 5)
    {
        goodEntry = false;
        Console.WriteLine("\n\rEnter an integer value between 1 and 5");
    }
}

// Display the sum and then pause.
Console.WriteLine($"\n\rThe sum of numbers {startIndex} through {numbers.Length} is: {SumValues(numbers, startIndex)}");

Console.WriteLine("press Enter to exit");
readResult = Console.ReadLine();

// This method returns the sum of elements n through 5
static int SumValues(int[] numbers, int n)
{
    int sum = 0;
    for (int i = n; i < numbers.Length; i++)
    {
        sum += numbers[i];
    }
    return sum;
}

Neem even de tijd om de code te controleren.

Enkele zaken die opvallen:
- De code specificeert een matrix met een geheel getal dat vijf getallen bevat.
- De code toont uitvoer in de console.
- De code vraagt de gebruiker om een beginelementnummer n in te voeren dat wordt gebruikt om matrixelementen n op te sommen via 5.
- De code berekent de som in een methode, geeft de resultaten weer in de console en onderbreekt.
Opmerking

Het paneel DEBUG CONSOLE biedt geen ondersteuning voor gebruikersinvoer van de console.
Selecteer Opslaan in het menu Visual Studio Code File.
Selecteer Alle onderbrekingspunten verwijderen in het menu Uitvoeren.

Hiermee worden eventuele onderbrekingspunten uit de vorige oefening verwijderd.
Selecteer in de weergave UITVOEREN EN DEBUGGEN Debuggen starten.
U ziet dat er een fout optreedt wanneer de Console.Clear(); coderegel wordt uitgevoerd.
Selecteer Stoppen op de werkbalk Foutopsporing.
Ga naar de EXPLORER-weergave en open het bestand launch.json in de editor.
Werk de waarde van het console kenmerk als volgt bij:
```
"console":"integratedTerminal",
```
Selecteer Opslaan in het menu Visual Studio Code-bestand en sluit het launch.json bestand.

Uitvoer van toepassingen controleren en problemen identificeren

Als u de uitvoer van uw toepassing bekijkt, kunnen logische problemen worden weergegeven die u over het hoofd hebt gezien bij het schrijven van uw code.

Ga terug naar de RUN EN DEBUG weergave.
Selecteer in de weergave UITVOEREN EN DEBUGGEN Debuggen starten.

In de berichten die worden weergegeven in het deelvenster DEBUG CONSOLE, wordt het foutopsporingsprogramma weergegeven dat aan de Debug101.dll toepassing wordt gekoppeld.
U ziet dat er geen foutberichten worden weergegeven.

Het wijzigen van de waarde van het console kenmerk van internalConsole in integratedTerminal in het startconfiguratiebestand heeft de consolefout opgelost. Maar nu moet u de console zoeken die uw uitvoer bevat.
Schakel in het deelvenster Panels onder de Editor over van het paneel DEBUG CONSOLE naar het TERMINAL-deelvenster.
U ziet dat de uitvoering van code is onderbroken in het bericht waarin de gebruiker wordt gevraagd een waarde voor nin te voeren.

De uitvoer in het TERMINAL-paneel moet als volgt uitzien:
```
The 'numbers' array contains: { 1 2 3 4 5 }

To sum values 'n' through 5, enter a value for 'n':
```
Voer bij de TERMINAL-opdrachtprompt 3 in

Controleer de uitvoer van de toepassing.

De uitvoer in het TERMINAL-paneel moet als volgt uitzien:


The 'numbers' array contains: { 1 2 3 4 5 }

To sum values 'n' through 5, enter a value for 'n':
3

The sum of numbers 3 through 5 is: 9
press Enter to exit

Neem even de tijd om na te denken over de gerapporteerde waarde van sum en de waarden van matrixelementen 3 tot en met 5 die bovenaan de console worden weergegeven.

Het bericht zegt: The sum of numbers 3 through 5 is: 9. Matrixelementen 3 tot en met 5 zijn echter 3, 4 en 5. Mag de gerapporteerde som niet 12 zijn?

U kunt de sectie VARIABELEN van de weergave RUN AND DEBUG gebruiken om het probleem te onderzoeken.

Status van variabele bewaken

In sommige gevallen is het eenvoudig controleren van de variabelestatus voldoende om het logische probleem in uw toepassing te identificeren.

Stel een onderbrekingspunt in op de volgende coderegel:

Console.WriteLine($"\n\rThe sum of numbers {startIndex} through {numbers.Length} is: {SumValues(numbers, startIndex)}");

Selecteer in de weergave UITVOEREN EN DEBUGGEN Debuggen starten.
Schakel over van het paneel DEBUG CONSOLE naar het paneel TERMINAL.
Voer bij de TERMINAL-opdrachtprompt 3 in

De uitvoering van de code wordt gepauzeerd bij het breekpunt.
Neem even de tijd om de sectie VARIABELEN van de weergave RUN AND DEBUG te bekijken.

Zoals u ziet, startIndex is de waarde die u hebt ingevoerd, toegewezen.3
Selecteer Stap in.
U ziet dat de secties VARIABLES en CALL STACK zijn bijgewerkt.

In de sectie CALL STACK ziet u dat de uitvoering van code is verplaatst naar de SumValues methode.

In de sectie VARIABELEN, waarin de lokale variabelen worden weergegeven, wordt de waarde van het gehele getal nweergegeven. De methodeparameter n krijgt zijn waarde toegewezen vanuit het argument startIndex van de methodeaanroep. In dit geval maakt de wijziging in variabelenamen duidelijk dat de waarde is doorgegeven, niet een verwijzingswijzer.

Opmerking

In dit geval ziet u de meeste code in de editor, dus u hebt de sectie OPROEPSTACK mogelijk niet nodig, maar wanneer u aan grotere toepassingen met diep geneste en onderling verbonden methodeaanroepen werkt, kan het uitvoeringspad in de sectie CALL STACK zeer nuttig zijn.
Ga door met het selecteren van Stap in totdat de waarde waaraan is toegewezen sum niet meer 0is.
Neem even de tijd om de informatie te bekijken die wordt weergegeven in de sectie VARIABELEN.

U ziet het volgende:

Let op dat de waarde toegekend aan sum is veranderd van 0 naar 4.
Als u de numbers matrix wilt uitbreiden, selecteert u getallen [int[]]..
U herinnert zich nog dat matrixelementen worden geopend met behulp van op nul gebaseerde indexnummers.

In dit geval is de logische fout een discrepantie tussen de instructies in de gebruikersinterface en de onderliggende code. De gebruikersinterface verwijst naar matrixitems 1-5. De code gebruikt echter de waarde die de gebruiker heeft ingevoerd om toegang te krijgen tot de matrixelementen op basis van nul. Het matrixelement met een index van 3 slaat een waarde op van 4. De code compenseert geen indexnummers op basis van nul.
Als u de foutopsporingssessie wilt beëindigen, selecteert u Stoppen.
Neem even de tijd om na te gaan hoe u het probleem kunt oplossen.

Dit probleem kan worden gecorrigeerd in de gebruikersinterface door de gebruiker te vragen een waarde tussen 0 en 4 in te voeren. Het kan ook in code worden gecorrigeerd door 1 af te trekken van de ingevoerde waarde. Over het algemeen moet uw doel een duidelijke en eenvoudige gebruikersinterface zijn. In dit geval is het misschien beter om de code als volgt bij te werken:
```
Console.WriteLine($"\n\rThe sum of numbers {startIndex} through {numbers.Length} is: {SumValues(numbers, startIndex - 1)}");
```
Als u de bijgewerkte code uitvoert, wordt de volgende uitvoer gegenereerd:
Werk uw code bij met behulp van de voorgestelde benadering en sla het Program.cs bestand op.
Wis uw breakpunt, voer de toepassing opnieuw uit in de debugger en controleer of het beoogde resultaat wordt weergegeven in de terminal.

U hebt zojuist de variabelestatus gebruikt om een logisch probleem te identificeren en op te lossen. Geweldig werk.

Bewaak observatie-expressies

De sectie WATCH kan worden gebruikt om expressies te bewaken die zijn gebaseerd op een of meer variabelen.

Stel dat u werkt aan een toepassing die numerieke berekeningen uitvoert voor een gegevensset. U denkt dat uw code onbetrouwbare resultaten produceert wanneer de verhouding tussen twee numerieke variabelen groter is dan 5. U kunt de sectie WATCH gebruiken om de berekende verhouding te bewaken.

Werk het Program.cs-bestand bij met de volgende code:

bool exit = false;
var rand = new Random();
int num1 = 5;
int num2 = 5;

do
{
    num1 = rand.Next(1, 11);
    num2 = num1 + rand.Next(1, 51);

} while (exit == false);

Sla het Program.cs bestand op.
Stel een onderbrekingspunt in op de laatste coderegel.
Stel de volgende WATCH-expressie in:
```
num2 / num1 > 5
```
Selecteer in de weergave UITVOEREN EN DEBUGGEN Debuggen starten.
Let op de waarden die worden weergegeven in de secties VARIABELEN en WATCH.
Selecteer Doorgaan totdat de WATCH-uitdrukking wordt geëvalueerd naar true.

Als de WATCH-expressie tijdens de eerste iteratie wordt geëvalueerd tot true, selecteert u een paar keer Doorgaan of totdat u true voor de tweede keer ziet.
Neem even de tijd om na te gaan hoe de WATCH-sectie wordt gebruikt.

In dit scenario hebt u vastgesteld dat uw code onbetrouwbare resultaten produceert wanneer de verhouding tussen twee numerieke variabelen groter is dan 5. U hebt een expressie gemaakt in de sectie WATCH die deze voorwaarde vertegenwoordigt. U kunt nu gebruikmaken van de sectie WATCH om die conditie bij te houden.

De waarde wijzigen die is toegewezen aan een variabele in de sectie VARIABELEN

Het kan voorkomen dat u handmatig een programmatische voorwaarde wilt maken. In de sectie VARIABELEN van de weergave RUN AND DEBUG kunt u dit doen door de status van een variabele tijdens runtime te wijzigen.

Neem even de tijd om de code te bekijken die u uitvoert.

Merk op dat de code de do lus nooit zal verlaten, omdat exit nooit true zal zijn. Dit is geen programmatische voorwaarde die u nodig hebt om te veranderen in een echte toepassing, maar het demonstreert de mogelijkheid.
Klik in de sectie VARIABELEN met de rechtermuisknop exit [bool]en selecteer Waarde instellen.

Met de sectie VARIABLES kunt u de waarde wijzigen die tijdens runtime is toegewezen aan een variabele. Dit kan handig zijn als u wilt zien hoe uw code reageert op een bepaalde voorwaarde.
Als u de waarde van exit op true wilt instellen, typt u true en drukt u vervolgens op Enter.

In dit geval zal het wijzigen van de waarde van exit naar true ervoor zorgen dat de toepassing wordt gesloten wanneer de while instructie wordt uitgevoerd.
Klik op Doorgaan.
U ziet dat in het deelvenster DEBUG CONSOLE een bericht wordt weergegeven waarin wordt aangegeven dat het programma is afgesloten.

Gefeliciteerd! U hebt met succes de secties VARIABELEN en CONTROLE van de weergave UITVOEREN EN DEBUGGEN gebruikt.

Samenvatting

Hier volgen enkele belangrijke dingen die u in deze les moet onthouden:

Bewaak de status van de variabele met behulp van de sectie VARIABELEN van de weergave RUN AND DEBUG.
Houd een expressie door de tijd heen of via verschillende methoden bij door de weergave RUN AND DEBUG te gebruiken, sectie WATCH.
Gebruik de sectie CALL STACK van de weergave RUN AND DEBUG om de bronlocatie van een uitzondering of een WATCH-expressie te vinden.
Gebruik de sectie VARIABLES om de toegewezen waarde van een variabele tijdens runtime te wijzigen.

Feedback

Is deze pagina nuttig?