Øvelse – fejlfinding med Visual Studio Code

20 minutter

Det er tid til at omsætte din nyerhvervede fejlfindingsviden til praksis. Det er din første dag på jobbet, og det er tid til at sætte dine .NET-fejlfindingsfærdigheder på arbejde ved at rette en fejl i virksomhedens flagskibsprodukt, en Fibonacci-lommeregner.

Opret et eksempel på et .NET-projekt til fejlfinding

Hvis du vil konfigurere Visual Studio Code til .NET-fejlfinding, skal vi først bruge et .NET-projekt. Visual Studio Code indeholder en integreret terminal, hvilket gør det nemt at oprette et nyt projekt.

I Visual Studio Code skal du vælge Filer>Åbn mappe.
Opret en ny mappe med navnet DotNetDebugging på den placering, du vælger. Vælg derefter Vælg mappe.
Åbn den integrerede terminal fra Visual Studio Code ved at vælge Vis>Terminal- i hovedmenuen.
I terminalvinduet skal du kopiere og indsætte følgende kommando:
```
dotnet new console
```
Denne kommando opretter en Program.cs fil i mappen med et grundlæggende "Hello World"-program, der allerede er skrevet. Der oprettes også en C#-projektfil med navnet DotNetDebugging.csproj.
I terminalvinduet skal du kopiere og indsætte følgende kommando for at køre programmet "Hello World".
```
dotnet run
```
Terminalvinduet viser "Hello World!" som output.

Konfigurer Visual Studio Code til .NET-fejlfinding

Åbn Program.cs ved at vælge det.
Første gang du åbner en C#-fil i Visual Studio Code, modtager du en meddelelse om at installere anbefalede udvidelser til C#. Hvis du får vist denne prompt, skal du vælge knappen Installér i prompten.
Visual Studio Code installerer udvidelsen C# og viser en anden prompt for at tilføje påkrævede aktiver for at bygge og foretage fejlfinding af projektet. Vælg knappen Ja.
Du kan lukke fanen extension: C# for at fokusere på den kode, vi foretager fejlfinding af.

Tilføj Fibonacci-programlogikken

Vores aktuelle projekt skriver en "Hello World"-meddelelse til konsollen, som ikke giver os meget at foretage fejlfinding af. Du skal i stedet bruge et kort .NET-program til at beregne N- nummer på Fibonacci-sekvensen.

Fibonacci-sekvensen er en pakke med tal, der starter med tallene 0 og 1, hvor hvert andet efterfølgende tal er summen af de to forrige. Sekvensen fortsætter som vist her:

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

Åbn Program.cs ved at vælge det.

Erstat indholdet af 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;
}

Seddel

Denne kode indeholder en fejl, som vi foretager fejlfinding af senere i dette modul. Vi anbefaler ikke, at du bruger den i nogen missionskritiske Fibonacci-programmer, før vi får rettet fejlen.

Gem filen ved at vælge Ctrl+S- til Windows og Linux. Vælg Cmd+S- til Mac.
Lad os se på, hvordan den opdaterede kode fungerer, før vi foretager fejlfinding af den. Kør programmet ved at angive følgende kommando i terminalen:
```
dotnet run
```
Resultatet 3vises i terminaloutputtet. Når du ser i dette Fibonacci-sekvensdiagram, der viser den nulbaserede sekvensposition for hver værdi i parentes, kan du se, at resultatet skulle have været 5. Det er tid til at blive fortrolig med fejlfindingsprogrammet og løse dette program.
```
0 (0), 1 (1), 1 (2), 2 (3), 3 (4), 5 (5), 8 (6), 13 (7), 21 (8)...
```

Analysér problemerne

Start programmet ved at vælge fanen Kør og Foretag fejlfinding til venstre, og vælg derefter knappen Start fejlfinding. Du skal muligvis først vælge knappen Kør og foretag fejlfinding og derefter vælge filen Program.cs.

Du bør se programmet afsluttes hurtigt. Det er normalt, fordi du endnu ikke har tilføjet nogen pausepunkter.

Hvis fejlfindingskonsollen ikke vises, skal du vælge Ctrl+Skift+Y- til Windows og Linux eller Cmd+Skift+Y til Mac. Du bør kunne se flere linjer med diagnosticeringsoplysninger efterfulgt af disse linjer i slutningen:

...
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).

Linjerne øverst fortæller dig, at standardindstillingerne for fejlfinding aktiverer indstillingen "Just My Code". Det betyder, at fejlfindingsprogrammet kun foretager fejlfinding af din kode og ikke træder ind i kildekoden for .NET, medmindre du deaktiverer denne tilstand. Denne indstilling giver dig mulighed for at fokusere på fejlfinding af din kode.

I slutningen af outputtet af fejlfindingskonsollen kan du se, at programmet skriver 3 til konsollen og derefter afslutter med kode 0. Normalt angiver en programafslutningskode på 0, at programmet kørte og afsluttede uden at gå ned. Der er dog en forskel mellem at gå ned og returnere den korrekte værdi. I dette tilfælde har vi bedt programmet om at beregne den femte værdi af Fibonacci-sekvensen:

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

Den femte værdi på denne liste er 5, men vores program returnerede 3. Lad os bruge fejlfindingsprogrammet til at diagnosticere og løse denne fejl.

Brug pausepunkter og trinvis udførelse

Tilføj et pausepunkt ved at klikke på venstre margen ved linje 1 på int result = Fibonacci(5);.
Begynd at foretage fejlfinding igen. Programmet begynder at blive udført. Den pauser (afbryder udførelsen) på linje 1 på grund af det pausepunkt, du har angivet. Brug kontrolelementerne til fejlfinding til at gå ind i funktionen Fibonacci().

Kontrollér variablernes tilstand

Brug nu lidt tid på at undersøge de forskellige variablers værdier ved hjælp af panelet Variabler.

Skærmbillede af panelet Variabler.

Hvad er den værdi, der vises for parameteren n?
Hvad er værdierne for de lokale variabler n1, n2og sumi starten af funktionens udførelse?

Derefter går vi videre til for-løkken ved hjælp af Step Over fejlfindingskontrolelement.
Fortsæt fremad, indtil du rammer den første linje i for-løkken på den linje, der lyder:
```
sum = n1 + n2;
```

Seddel

Du har måske bemærket, at hvis du vil flytte gennem for(...) {}-linjen, kræver det flere trin i kommandoer. Denne situation opstår, fordi der er flere -sætninger på denne linje. Når du træder, går du videre til den næste sætning i din kode. Normalt er der én sætning pr. linje. Hvis det ikke er tilfældet, skal du bruge flere trin for at gå videre til næste linje.

Tænk på koden

En vigtig del af fejlfindingen er at stoppe og tage nogle velinformerede gæt på, hvad du mener, dele af koden (både funktioner og blokke, f.eks. løkker) forsøger at gøre. Det er okay, hvis du ikke er sikker, det er en del af fejlfindingsprocessen. Men at være aktivt engageret i fejlfindingsprocessen vil hjælpe dig med at finde fejl meget hurtigere.

Før vi går videre, skal vi huske på, at Fibonacci-sekvensen er en serie af tal, der starter med tallene 0 og 1, hvor hvert andet efterfølgende tal er summen af de to forrige.

Det betyder, 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)

Hvis vi forstår denne definition og ser på denne for løkke, kan vi udlede følgende:

Løkken tæller fra 2 til n (det Fibonacci-sekvensnummer, vi leder efter).
Hvis n er mindre end 2, køres løkken aldrig. return-sætningen i slutningen af funktionen returnerer 0, hvis n er 0, og 1, hvis n er 1 eller 2. Dette er nul, første og anden værdi i Fibonacci-serien pr. definition.
Den mere interessante sag er, når n er større end 2. I disse tilfælde defineres den aktuelle værdi som summen af de to foregående værdier. Så for denne løkke er n1 og n2 de to foregående værdier, og sum er værdien for den aktuelle gentagelse. Derfor opdaterer vi vores sum og n1 værdier, hver gang vi finder summen af de to foregående værdier og angiver dem til n2.

Okay, vi behøver ikke at overt tænke over det. Vi kan læne os lidt op ad vores fejlfindingsprogram. Men det er værd at tænke på koden for at se, om den gør, hvad vi forventer, og være mere informeret, når den ikke gør det.

Find fejlen med pausepunkter

Det kan være nyttigt, men kedeligt at gennemgå din kode, især når du arbejder med løkker eller anden kode, der kaldes gentagne gange. I stedet for at gå gennem løkken igen og igen kan vi angive et nyt pausepunkt på den første linje i løkken.

Når vi gør det, er det vigtigt at være strategisk om, hvor vi placerer vores pausepunkter. Vi er især interesseret i værdien af sum, da den repræsenterer den aktuelle maksimale Fibonacci-værdi. På grund af det, lad os sætte vores pausepunkt på linjen eftersum er indstillet.

Tilføj endnu et pausepunkt på linje 13.

Seddel

Hvis du bemærker, at du bliver ved med at køre din kode og derefter træder en linje eller to, kan du nemt opdatere dine pausepunkter til mere effektive linjer.
Nu, hvor der er angivet et godt pausepunkt i løkken, skal du bruge Fortsæt fejlfindingskontrolelement for at gå videre, indtil pausepunktet er nået. Når vi ser på vores lokale variabler, kan vi se følgende linjer:
```
n [int]: 5
n1 [int]: 0
n2 [int]: 1
sum [int]: 1
i [int]: 2
```
Disse linjer virker alle korrekte. Første gang gennem løkken er sum af de to foregående værdier 1. I stedet for at gå gennem linje for linje kan vi drage fordel af vores pausepunkter for at gå til næste gang gennem løkken.
Vælg Fortsæt for at fortsætte programflowet, indtil næste pausepunkt er nået, hvilket vil være på det næste gennemløb gennem løkken.

Seddel

Vær ikke alt for bekymret for at springe over fejlen, når du bruger Fortsæt. Du bør forvente, at du ofte foretager fejlfinding gennem koden flere gange for at finde problemet. Det er ofte hurtigere at gennemgå det et par gange i modsætning til at være for forsigtig, når du træder igennem.

Denne gang kan vi se følgende værdier:
```
n [int]: 5
n1 [int]: 1
n2 [int]: 1
sum [int]: 2
i [int]: 3
```
Lad os tænke over det. Giver disse værdier stadig mening? Det ser ud til, at de gør. For det tredje Fibonacci-nummer forventer vi at se vores sum lig med 2, og det er det.
Lad os vælge Fortsæt for at løkke den igen.
```
n [int]: 5
n1 [int]: 1
n2 [int]: 2
sum [int]: 3
i [int]: 4
```
Igen ser det godt ud. Den fjerde værdi i serien forventes at være 3.
På dette tidspunkt kan du begynde at undre dig over, om koden var korrekt hele tiden, og du forestillede dig fejlen! Lad os holde med det for sidste gang gennem løkken. Vælg Fortsæt en gang til.

Vent et minut. Programmet er færdig med at køre og udskrevet 3! Det er ikke rigtigt.

Okay, bare rolig. Vi har ikke fejlet, vi har lært det. Vi ved nu, at koden kører korrekt gennem løkken, indtil i er lig med 4, men derefter afsluttes den, før den endelige værdi regnes ud. Jeg begynder at få nogle ideer om, hvor fejlen er. Er det dig?
Lad os angive endnu et pausepunkt på linje 17, som lyder:
```
return n == 0 ? n1 : n2;
```
Dette pausepunkt giver os mulighed for at undersøge programtilstanden, før funktionen afsluttes. Vi har allerede lært alt, hvad vi kan forvente af vores tidligere pausepunkter på linje 1 og 13, så vi kan rydde dem.
Fjern de forrige pausepunkter på linje 1 og 13. Det kan du gøre ved at klikke på dem i margenen ud for linjenumrene eller ved at fjerne markeringen i afkrydsningsfelterne for pausepunkter for linje 1 og 13 i ruden pausepunkter nederst til venstre.

Nu, hvor vi forstår, hvad der foregår meget bedre og har sat et breakpoint designet til at fange vores program i den handling af misbehaving, bør vi være i stand til at fange denne fejl!
Start fejlfindingsprogrammet en sidste gang.
```
n [int]: 5
n1 [int]: 2
n2 [int]: 3
sum [int]: 3
```
Det er ikke rigtigt. Vi bad specifikt om Fibonacci(5), og vi fik Fibonacci(4). Denne funktion returnerer n2, og hver gentagelse af løkken beregner den sum værdi og angiver n2 lig med sum.

Baseret på disse oplysninger og vores tidligere fejlfindingskørsel kan vi se, at løkken blev afsluttet, da i var 4, ikke 5.

Lad os se nærmere på den første linje i for-løkken.
```
for (int i = 2; i < n; i++)
```
Okay, vent et øjeblik! Det betyder, at den afsluttes, så snart toppen af for-løkken kan se, at i ikke længere er mindre end n. Det betyder, at løkkekoden ikke kører for det tilfælde, hvor i er lig med n. Det ser ud som om, hvad vi ønskede var at køre indtil i <= n, i stedet:
```
for (int i = 2; i <= n; i++)
```
Så med denne ændring bør dit opdaterede program se ud som i dette eksempel:
```
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;
}
```
Stop fejlfindingssessionen, hvis du ikke allerede har gjort det.
Derefter skal du foretage den foregående ændring af linje 10 og lade vores pausepunkt være på linje 17.
Genstart fejlfindingsprogrammet. Når vi denne gang rammer pausepunktet på linje 17, får vi vist følgende værdier:
```
n [int]: 5
n1 [int]: 3
n2 [int]: 5
sum [int]: 5
```
Hej! Det ser ud til, at vi har det! Fantastisk stykke arbejde, du har gemt dagen for Fibonacci, Inc.!
Vælg Fortsæt bare for at sikre, at programmet returnerer den korrekte værdi.
```
5
The program '[105260] DotNetDebugging.dll' has exited with code 0 (0x0).
```
Og det returnerer det korrekte output.

Det var dig, der gjorde det! Du har foretaget fejlfinding af en kode, du ikke har skrevet, ved hjælp af .NET-fejlfindingsprogrammet i Visual Studio Code.

I det næste undermodul lærer du, hvordan du gør det nemmere at foretage fejlfinding af den kode, du skriver, ved hjælp af de logførings- og sporingsfunktioner, der er indbygget i .NET.

Feedback

Var denne side nyttig?