Øvelse – feilsøking med Visual Studio-kode

20 minutter

Det er på tide å sette den nyervervede feilsøkingskunnskapen ut i praksis. Det er din første dag på jobben, og det er på tide å sette dine .NET feilsøking ferdigheter til å fungere ved å fikse en feil i selskapets flaggskip produkt, en Fibonacci kalkulator.

Opprette et eksempel på .NET-prosjekt for feilsøking

Hvis du vil konfigurere Visual Studio Code for .NET-feilsøking, trenger vi først et .NET-prosjekt. Visual Studio Code inkluderer en integrert terminal, noe som gjør det enkelt å opprette et nytt prosjekt.

Velg Fil>Åpne mappei Visual Studio Code.
Opprett en ny mappe med navnet DotNetDebugging på ønsket plassering. Velg deretter Velg mappe.
Åpne den integrerte terminalen fra Visual Studio Code ved å velge Vis>Terminal fra hovedmenyen.
Kopier og lim inn følgende kommando i terminalvinduet:
```
dotnet new console
```
Denne kommandoen oppretter en Program.cs fil i mappen med et grunnleggende «Hello World»-program som allerede er skrevet. Den oppretter også en C#-prosjektfil med navnet DotNetDebugging.csproj.
Kopier og lim inn følgende kommando i terminalvinduet for å kjøre Hello World-programmet.
```
dotnet run
```
Terminalvinduet viser «Hello World!» som utdata.

Konfigurere Visual Studio Code for .NET-feilsøking

Åpne Program.cs ved å velge den.
Første gang du åpner en C#-fil i Visual Studio Code, får du en melding om å installere anbefalte utvidelser for C#. Hvis du ser denne ledeteksten, velger du Installer-knappen i ledeteksten.
Visual Studio Code installerer utvidelsen C# og viser en annen ledetekst for å legge til nødvendige ressurser for å bygge og feilsøke prosjektet. Velg Ja-knappen.
Du kan lukke Extension: C#-fanen for å fokusere på koden vi skal feilsøke.

Legg til Fibonacci-programlogikken

Vårt nåværende prosjekt skriver en «Hello World»-melding til konsollen, som ikke gir oss mye å feilsøke. I stedet bruker du et kort .NET-program til å beregne N^th nummeret til Fibonacci-sekvensen.

Fibonacci-sekvensen er en serie med tall som starter med tallene 0 og 1, der alle andre følgende tall er summen av de to foregående. Sekvensen fortsetter som vist her:

0, 1, 1, 2, 3, 5, 8, 13, 21...

Åpne Program.cs ved å velge den.

Erstatt innholdet i Program.cs med følgende kode:

int result = Fibonacci(5);
Console.WriteLine(result);

static int Fibonacci(int n)
{
    int n1 = 0;
    int n2 = 1;
    int sum;

    for (int i = 2; i < n; i++)
    {
        sum = n1 + n2;
        n1 = n2;
        n2 = sum;
    }

    return n == 0 ? n1 : n2;
}

Notat

Denne koden inneholder en feil, som vi vil feilsøke senere i denne modulen. Vi anbefaler ikke at du bruker den i noen driftskritiske Fibonacci-programmer før vi får løst feilen.

Lagre filen ved å velge CTRL+S for Windows og Linux. Velg Cmd+S for Mac.
La oss ta en titt på hvordan den oppdaterte koden fungerer før vi feilsøker den. Kjør programmet ved å skrive inn følgende kommando i terminalen:
```
dotnet run
```
Resultatet, 3, vises i terminalutdataene. Når du ser dette sekvensdiagrammet for Fibonacci som viser den nullbaserte sekvensposisjonen for hver verdi i parentes, ser du at resultatet skal ha vært 5. Det er på tide å bli kjent med feilsøkingsprogrammet og løse dette programmet.
```
0 (0), 1 (1), 1 (2), 2 (3), 3 (4), 5 (5), 8 (6), 13 (7), 21 (8)...
```

Analysere problemene

Start programmet ved å velge fanen Kjør og Feilsøking til venstre, og velg deretter Start feilsøking-knappen. Det kan hende du må velge Kjør- og Feilsøking--knappen først, og deretter velge Program.cs filen.

Du bør se at programmet avsluttes raskt. Det er normalt fordi du ikke har lagt til noen breakpoints ennå.

Hvis feilsøkingskonsollen ikke vises, velger du CTRL+SKIFT+Y for Windows og Linux eller Cmd+SHIFT+Y for Mac. Du bør se flere linjer med diagnoseinformasjon, etterfulgt av disse linjene på slutten:

...
Loaded 'C:\Program Files\dotnet\shared\Microsoft.NETCore.App\6.0.0\System.Threading.dll'. Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.
Loaded 'C:\Program Files\dotnet\shared\Microsoft.NETCore.App\6.0.0\System.Text.Encoding.Extensions.dll'. Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.
3
The program '[88820] DotNetDebugging.dll' has exited with code 0 (0x0).

Linjene øverst forteller deg at standard feilsøkingsinnstillinger aktiverer alternativet Bare min kode. Dette betyr at feilsøkingsprogrammet bare feilsøker koden og ikke går inn i kildekoden for .NET med mindre du deaktiverer denne modusen. Med dette alternativet kan du fokusere på feilsøking av koden.

På slutten av feilsøkingskonsollutdataene ser du at programmet skriver 3 til konsollen og avslutter deretter med kode 0. Vanligvis angir en programsluttkode på 0 at programmet kjørte og avsluttet uten å krasje. Det er imidlertid en forskjell mellom å krasje og returnere den riktige verdien. I dette tilfellet ba vi programmet om å beregne den femte verdien av Fibonacci-sekvensen:

0 (0), 1 (1), 1 (2), 2 (3), 3 (4), 5 (5), 8 (6), 13 (7), 21 (8)...

Den femte verdien i denne listen er 5, men programmet vårt returnerte 3. La oss bruke feilsøkingsprogrammet til å diagnostisere og løse denne feilen.

Bruke breakpoints og trinnvis kjøring

Legg til et bruddpunkt ved å klikke i venstre marg på linje 1 på int result = Fibonacci(5);.
Start feilsøking på nytt. Programmet begynner å kjøre. Den bryter (stanser kjøringen midlertidig) på linje 1 på grunn av bruddpunktet du angir. Bruk feilsøkingskontrollene til å gå inn i Fibonacci()-funksjonen.

Kontroller variabletilstanden

Ta deg tid til å undersøke verdiene for de ulike variablene ved hjelp av Variabler-panelet.

Skjermbilde av Variabler-panelet.

Hva vises verdien for n-parameteren?
Hva er verdiene for de lokale variablene n1, n2og sumi begynnelsen av funksjonens kjøring?

Deretter går vi videre til for-løkken ved hjelp av Trinn over feilsøkingskontroll.
Fortsett å gå fremover til du treffer den første linjen i for løkke, på linjen som lyder:
```
sum = n1 + n2;
```

Notat

Du har kanskje lagt merke til at for å gå gjennom den for(...) {} linjen krever du flere trinn i kommandoer. Denne situasjonen oppstår fordi det finnes flere setninger på denne linjen. Når du går videre til neste setning i koden. Vanligvis er det én setning per linje. Hvis det ikke er tilfelle, trenger du flere trinn for å gå videre til neste linje.

Tenk på koden

En viktig del av feilsøkingen er å stoppe og ta noen informerte gjetninger om hva du tror deler av koden (både funksjoner og blokker, for eksempel løkker) prøver å gjøre. Det er greit hvis du ikke er sikker, det er en del av feilsøkingsprosessen. Men å være aktivt engasjert i feilsøkingsprosessen vil hjelpe deg med å finne feil mye raskere.

Før vi graver videre, la oss huske at Fibonacci-sekvensen er en serie med tall som starter med tallene 0 og 1, med alle andre følgende tall som summen av de to foregående.

Det betyr at:

Fibonacci(0) = 0
Fibonacci(1) = 1
Fibonacci(2) = 1 (0 + 1)
Fibonacci(3) = 2 (1 + 1)
Fibonacci(4) = 3 (1 + 2)
Fibonacci(5) = 5 (2 + 3)

Når vi forstår definisjonen og ser på denne for løkken, kan vi utlede dette:

Løkken teller fra 2 til n (Fibonacci-sekvensnummeret vi leter etter).
Hvis n er mindre enn 2, kjøres aldri løkken. Den return setningen på slutten av funksjonen returnerer 0 hvis n er 0, og 1 hvis n er 1 eller 2. Dette er null-, første- og andreverdiene i Fibonacci-serien per definisjon.
Det mer interessante tilfellet er når n er større enn 2. I slike tilfeller defineres gjeldende verdi som summen av de to foregående verdiene. Så for denne løkken er n1 og n2 de to foregående verdiene, og sum er verdien for gjeldende gjentakelse. På grunn av dette oppdaterer vi hver gang vi finner ut summen av de to foregående verdiene og setter den til sum, oppdaterer vi n1 og n2 verdier.

Ok, vi trenger ikke å overtenke det forbi det. Vi kan lene oss litt på feilsøkingsknappen vår. Men det er verdt å tenke på koden for å se om den gjør det vi forventer og bli mer informert når den ikke gjør det.

Finn feilen med breakpoints

Å gå gjennom koden kan være nyttig, men kjedelig, spesielt når du arbeider med løkker eller annen kode som kalles gjentatte ganger. I stedet for å gå gjennom løkken om og om igjen, kan vi angi et nytt bruddpunkt på den første linjen i løkken.

Når vi gjør dette, er det viktig å være strategisk om hvor vi setter våre breakpoints. Vi er spesielt interessert i verdien av sum, fordi den representerer den gjeldende maksimale Fibonacci-verdien. På grunn av dette, la oss sette vårt breakpoint på linjen etter atsum er angitt.

Legg til et nytt breakpoint på linje 13.

Notat

Hvis du legger merke til at du fortsetter å kjøre koden og deretter går en linje eller to, kan du enkelt oppdatere breakpoints til mer effektive linjer.
Nå som vi har et godt bruddpunkt angitt i løkken, bruker du Fortsett feilsøkingskontroll for å gå videre til breakpoint er truffet. Når vi ser på de lokale variablene våre, ser vi følgende linjer:
```
n [int]: 5
n1 [int]: 0
n2 [int]: 1
sum [int]: 1
i [int]: 2
```
Alle disse linjene virker riktige. Første gang gjennom løkken er sum av de to foregående verdiene 1. I stedet for å gå gjennom linje for linje, kan vi dra nytte av våre breakpoints for å hoppe til neste gang gjennom løkken.
Velg Fortsett for å fortsette programflyten til neste breakpoint er truffet, som vil være på neste passering gjennom løkken.

Notat

Ikke vær så bekymret for å hoppe over feilen når du bruker Fortsett. Du bør forvente at du ofte vil feilsøke gjennom koden flere ganger for å finne problemet. Det er ofte raskere å kjøre gjennom det et par ganger i motsetning til å være for forsiktig når du går gjennom.

Denne gangen ser vi følgende verdier:
```
n [int]: 5
n1 [int]: 1
n2 [int]: 1
sum [int]: 2
i [int]: 3
```
La oss tenke på det. Gir disse verdiene fortsatt mening? Det virker som de gjør det. For det tredje Fibonacci-nummeret forventer vi å se våre sum lik 2, og det er det.
Ok, la oss velge Fortsett for å gjenta det på nytt.
```
n [int]: 5
n1 [int]: 1
n2 [int]: 2
sum [int]: 3
i [int]: 4
```
Igjen, ting ser bra ut. Den fjerde verdien i serien forventes å være 3.
På dette tidspunktet kan du begynne å lure på om koden var riktig hele tiden, og du forestilte deg feilen! La oss holde oss til det for siste gang gjennom løkken. Velg Fortsett én gang til.

Vent litt. Programmet er ferdig med å kjøre og skrives ut 3! Det stemmer ikke.

Ok, ikke bekymre deg. Vi har ikke mislyktes, vi har lært. Vi vet nå at koden går gjennom løkken riktig til i er lik 4, men så avsluttes den før du beregner den endelige verdien. Jeg begynner å få noen ideer om hvor feilen er. Er du det?
La oss angi enda et bruddpunkt på linje 17, som lyder:
```
return n == 0 ? n1 : n2;
```
Dette breakpointet lar oss undersøke programtilstanden før funksjonen avsluttes. Vi har allerede lært alt vi kan forvente fra våre tidligere breakpoints på linje 1 og 13, slik at vi kan fjerne dem.
Fjern de forrige punktene på linje 1 og 13. Du kan gjøre dette ved å klikke dem i margen ved siden av linjenumrene, eller ved å fjerne merket for avmerkingsboksene for linje 1 og 13 i Breakpoints-ruten nederst til venstre.

Nå som vi forstår hva som skjer mye bedre og har satt et breakpoint designet for å fange vårt program i handlingen av dårlig oppførsel, bør vi være i stand til å fange denne feilen!
Start feilsøkingsprogrammet én siste gang.
```
n [int]: 5
n1 [int]: 2
n2 [int]: 3
sum [int]: 3
```
Vel, det er ikke riktig. Vi ba spesielt om Fibonacci(5), og vi fikk Fibonacci(4). Denne funksjonen returnerer n2, og hver løkke gjentakelse beregner den sum verdien og angir n2 lik sum.

Basert på denne informasjonen, og vår forrige feilsøkingskjøring, kan vi se at løkken gikk ut da i var 4, ikke 5.

La oss se på den første linjen i for løkke litt nærmere.
```
for (int i = 2; i < n; i++)
```
Vent litt! Det betyr at den avsluttes så snart toppen av for loopen ser at i ikke lenger er mindre enn n. Det betyr at løkkekoden ikke kjøres for saken der i er lik n. Det virker som det vi ønsket var å kjøre til i <= n, i stedet:
```
for (int i = 2; i <= n; i++)
```
Så med denne endringen skal det oppdaterte programmet se slik ut:
```
int result = Fibonacci(5);
Console.WriteLine(result);

static int Fibonacci(int n)
{
    int n1 = 0;
    int n2 = 1;
    int sum;

    for (int i = 2; i <= n; i++)
    {
        sum = n1 + n2;
        n1 = n2;
        n2 = sum;
    }

    return n == 0 ? n1 : n2;
}
```
Stopp feilsøkingsøkten hvis du ikke allerede har gjort det.
Deretter gjør du den foregående endringen til linje 10 og lar vårt breakpoint stå på linje 17.
Start feilsøkingsprogrammet på nytt. Denne gangen, når vi treffer breakpoint på linje 17, ser vi følgende verdier:
```
n [int]: 5
n1 [int]: 3
n2 [int]: 5
sum [int]: 5
```
Hei! Det ser ut som vi har det! Flott jobb, du har lagret dagen for Fibonacci, Inc.!
Velg Fortsett bare for å sikre at programmet returnerer riktig verdi.
```
5
The program '[105260] DotNetDebugging.dll' has exited with code 0 (0x0).
```
Og det returnerer riktig utdata.

Du klarte det! Du har feilsøket en kode du ikke skrev ved hjelp av .NET-feilsøkingsprogrammet i Visual Studio Code.

I neste enhet lærer du hvordan du gjør koden du skriver enklere å feilsøke ved hjelp av loggings- og sporingsfunksjonene som er innebygd i .NET.

Tilbakemeldinger

Var denne siden nyttig?