Övning – Kodblock och variabelomfång

11 minuter

Ett kodblock är en eller flera C#-instruktioner som definierar en körningsväg. Instruktioner utanför ett kodblock påverkar när, om och hur ofta kodblocket körs vid körning. Gränserna för ett kodblock definieras vanligtvis av vågiga klammerparenteser, {}.

Förutom deras effekt på körningssökvägen kan kodblock också påverka omfånget för dina variabler. De kodexempel som du undersöker under den här övningen hjälper dig att förstå relationen mellan kodblock och variabelomfång.

Kodblock påverkar en variabeldeklarations omfång

Variabelomfång refererar till en variabels synlighet för den andra koden i ditt program. Lokalt begränsad variabel är bara tillgänglig i kodblocket där den har definierats. Om du försöker komma åt variabeln utanför kodblocket får du kompileringsfel.

Resten av den här lektionen utforskar relationen mellan kodblock och variabelomfång.

Förbereda din kodningsmiljö

Den här modulen innehåller praktiska aktiviteter som vägleder dig genom processen att skapa och köra demonstrationskod. Du uppmanas att slutföra dessa aktiviteter med Visual Studio Code som utvecklingsmiljö. Genom att använda Visual Studio Code för dessa aktiviteter kan du bli mer bekväm med att skriva och köra kod i en utvecklarmiljö som används av proffs över hela världen.

Öppna Visual Studio Code.

Du kan använda Windows Start-menyn (eller motsvarande resurs för ett annat operativsystem) för att öppna Visual Studio Code.
På menyn Visual Studio Code-fil väljer du Öppna mapp.
I dialogrutan Öppna mapp navigerar du till mappen Windows Desktop.

Om du har en annan mappplats där du behåller kodprojekt kan du använda den mappplatsen i stället. För den här utbildningen är det viktigt att ha en plats som är lätt att hitta och komma ihåg.
I dialogrutan Öppna mapp väljer du Välj mapp.

Om du ser en säkerhetsdialogruta som frågar om du litar på författarna väljer du Ja.
Välj Ny terminal på visual Studio Code-terminalmenyn.

Observera att en kommandotolk i terminalpanelen visar mappsökvägen för den aktuella mappen. Till exempel:
```
C:\Users\someuser\Desktop>
```
Kommentar

Om du arbetar på din egen dator i stället för i en sandbox-miljö eller en värdbaserad miljö och du har slutfört andra Microsoft Learn-moduler i den här C#-serien kanske du redan har skapat en projektmapp för kodexempel. I så fall kan du hoppa över nästa steg, som används för att skapa en konsolapp i mappen TestProject.
I terminalkommandot anger du följande fråga för att skapa ett nytt konsolprogram i en angiven mapp:
```
dotnet new console -o ./CsharpProjects/TestProject
```
Det här .NET CLI-kommandot använder en .NET-programmall för att skapa ett nytt C#-konsolprogramprojekt på den angivna mappplatsen. Kommandot skapar mapparna CsharpProjects och TestProject åt dig och använder TestProject som namnet på filen .csproj .

Om ett meddelande visas som talar om för dig att filerna redan finns fortsätter du med nästa steg. Du återanvänder de befintliga projektfilerna.
I utforskarvyn expanderar du mappen CsharpProjects .

Du bör se mappen TestProject och två filer, en C#-programfil med namnet Program.cs och en C#-projektfil med namnet TestProject.csproj.
På menyn Visual Studio Code-fil väljer du Öppna mapp.
I dialogrutan Öppna mapp väljer du mappen CsharpProjects och väljer sedan Välj mapp.
I explorer-vyn expanderar du mappen TestProject och väljer sedan Program.cs.
Ta bort de befintliga kodraderna.

Du kommer att använda det här C#-konsolprojektet för att skapa, skapa och köra kodexempel under den här modulen.
Stäng terminalpanelen.

Skapa en variabel i ett kodblock

Du börjar med att titta på fallet när en variabel initieras i ett kodblock.

Kontrollera att Visual Studio Code är öppet och Program.cs visas i redigeringspanelen.

Kommentar

Program.cs ska vara tom. Om den inte är det väljer du och tar bort alla kodrader.

Skriv följande kod i Visual Studio Code-redigeraren:

bool flag = true;
if (flag)
{
    int value = 10;
    Console.WriteLine($"Inside the code block: {value}");
}

På menyn Visual Studio Code-fil väljer du Spara.

Filen Program.cs måste sparas innan du skapar eller kör koden.
I explorer-panelen öppnar du en terminal på mappen TestProject genom att högerklicka på TestProject och sedan välja Öppna i integrerad terminal.

En terminalpanel öppnas. Terminalen bör innehålla en kommandotolk som visar att terminalen är öppen för mappen TestProject.
I kommandotolken i Terminal skriver du dotnet run och trycker sedan på Retur för att köra koden.

Kommentar

Om du ser ett meddelande med texten "Det gick inte att hitta ett projekt att köra" kontrollerar du att Terminal-kommandotolken visar den förväntade platsen för TestProject-mappen. Till exempel: C:\Users\someuser\Desktop\csharpprojects\TestProject>

Du bör se följande utdata:
```
Inside the code block: 10
```

Det här är de förväntade utdata. Men vad händer om du vill komma åt variabeln value utanför instruktionskodblocket if ?

Försök att komma åt en variabel utanför kodblocket där den deklareras

I Visual Studio Code-redigeraren skapar du en ny kodrad under instruktionskodblocket if .
På den tomma kodraden som du skapade lägger du till följande kodrad:
```
Console.WriteLine($"Outside the code block: {value}");
```

Kontrollera att den uppdaterade koden ser ut så här:

bool flag = true;
if (flag)
{
    int value = 10;
    Console.WriteLine($"Inside the code block: {value}");
}
Console.WriteLine($"Outside the code block: {value}");

Spara kodfilen och använd sedan Visual Studio Code för att köra koden.

Ange dotnet run från Terminal-kommandotolken för att köra koden.

Observera att när du försöker köra programmet får du ett kompileringsfel:

Program.cs(7,46): error CS0103: The name 'value' does not exist in the current context

Delen Program.cs(7,46) av meddelandet anger att felet är associerat med rad 7 i Program.cs-filen, kolumn 46.

Det här felet genereras eftersom en variabel som deklareras i ett kodblock endast är tillgänglig (kan bara visas) i kodblocket. Eftersom det inte går att komma åt en variabel utanför kodblocket där den deklareras kan value du inte komma åt den från rad 7 i koden.

En variabel som deklareras i ett metodkodblock kallas för en lokal variabel. Du kan se termen lokal variabel som används när du granskar artiklar som diskuterar variabelomfång.

Flytta variabeldeklarationen ovanför kodblocket

För att få åtkomst till en variabel både inom och utanför ett kodblock måste du deklarera variabeln före (ovan) kodblocket så att koden utanför kodblocket kan "se" variabeln.

Uppdatera koden i Visual Studio Code-redigeraren på följande sätt:

bool flag = true;
int value;

if (flag)
{
    Console.WriteLine($"Inside the code block: {value}");
}

value = 10;
Console.WriteLine($"Outside the code block: {value}");

Det tar en minut att granska uppdateringarna.
Observera att value nu har deklarerats (men inte initierats) utanför kodblocket if .
Använd Visual Studio Code för att spara dina uppdateringar och kör sedan koden.
Observera att du fortfarande får ett kompileringsfel.

Den här gången får du följande kompileringsfel när du försöker köra programmet:
```
Program.cs(6,49): error CS0165: Use of unassigned local variable 'value'
```
Felet är associerat med rad 6 i kodblocket eftersom value det är oinitierat (har inte tilldelats något värde). Om kodraden value = 10; fanns ovanför instruktionskodblocket if kompileras programmet korrekt och allt skulle gå bra. Men eftersom value inte har initierats kan den inte nås i kodblocket.

Det här problemet åtgärdas om du ser till att variablerna initieras innan du försöker komma åt dem.

Initiera en variabel som en del av variabeldeklarationen

Om du vill initiera value som en del av variabeldeklarationen uppdaterar du koden på följande sätt:
```
bool flag = true;
int value = 0;

if (flag)
{
    Console.WriteLine($"Inside the code block: {value}");
}

value = 10;
Console.WriteLine($"Outside the code block: {value}");
```
Den här koden åtgärdar kompileringsfelet "otilldelade lokala variabler" genom att initiera value som en del av variabeldeklarationen.
Använd Visual Studio Code för att spara och köra koden.
Observera att nu, när du kör programmet, ser du följande utdata:
```
Inside the code block: 0
Outside the code block: 10
```

Granska kompilatorns tolkning av koden

För att undvika körningsfel analyserar C#-kompilatorn koden i Visual Studio Code-redigeraren och under byggprocessen. Kompilatorn kanske dock inte alltid tolkar koden på samma sätt som du gör.

Överväg följande två kodexempel som verkar ha samma syfte:

// Code sample 1
bool flag = true;
int value;

if (flag)
{
    value = 10;
    Console.WriteLine($"Inside the code block: {value}");
}

Console.WriteLine($"Outside the code block: {value}");

// Code sample 2
int value;

if (true)
{
    value = 10;
    Console.WriteLine($"Inside the code block: {value}");
}

Console.WriteLine($"Outside the code block: {value}");

Du kanske tycker att dessa två exempel alltid ska ge samma resultat, men C#-kompilatorn tolkar dessa två kodexempel på olika sätt.

För det första kodexemplet tolkar flag kompilatorn som en boolesk variabel som kan tilldelas ett värde av antingen true eller false. Kompilatorn drar slutsatsen att om flag är falsevalue , initieras inte när den andra Console.WriteLine() körs. I huvudsak anser kompilatorn att följande två kodkörningssökvägar är möjliga:

// path when flag = true
int value;
value = 10;
Console.WriteLine($"Inside the code block: {value}");
Console.WriteLine($"Outside the code block: {value}");

OCH

// path when flag = false
int value;
Console.WriteLine($"Outside the code block: {value}");

Eftersom kompilatorn betraktar den andra sökvägen som en möjlighet (för kodexempel 1) genererar den ett felmeddelande under byggprocessen. Dessutom varnar kodredigeraren i Visual Studio Code dig om det här problemet genom att visa en röd vågig rad under value (under kodblocket).

För det andra kodexemplet drar överensstämmelsen slutsatsen att innehållet i instruktionskodblocket if alltid kommer att köras (true är alltid true). Kompilatorn genererar inte ett byggfel eftersom det tolkar det andra kodexemplet så att det har en enda körningssökväg enligt följande:

int value;
value = 10;
Console.WriteLine($"Inside the code block: {value}");
Console.WriteLine($"Outside the code block: {value}");

Sammanfattning

Här några viktiga saker att komma ihåg om kodblock:

När du deklarerar en variabel i ett kodblock är dess synlighet lokal för kodblocket och variabeln kan inte nås utanför kodblocket.
För att säkerställa att en variabel visas både inuti och utanför ett kodblock måste du deklarera variabeln före kodblocket (utanför och ovanför kodblocket).
Kontrollera att variabler initieras innan koden försöker komma åt dem (för alla potentiella kodkörningssökvägar).

Feedback

Var den här sidan till hjälp?

Övning – Kodblock och variabelomfång

Kontrollera dina kunskaper

Feedback