Gyakorlat – Kódblokkok és a változók hatóköre

11 perc

Egy kódblokk egy vagy több, végrehajtási útvonalat definiáló C#-utasítás. A kódblokkon kívüli utasítások hatással vannak arra, hogy a kódblokk futásidőben mikor, mikor és milyen gyakran lesz végrehajtva. A kódblokkok határait általában kapcsos zárójelek határozzák meg. {}

A kódblokkok a végrehajtási útvonalra gyakorolt hatásuk mellett a változók hatókörére is hatással lehetnek. A gyakorlat során megvizsgált kódminták segítenek megérteni a kódblokkok és a változók hatóköre közötti kapcsolatot.

A kódblokkok hatással vannak a változók deklarációjának hatókörére

A változó hatóköre egy változónak az alkalmazás másik kódjára való láthatóságára utal. Egy helyi hatókörű változó csak abban a kódblokkban érhető el, amelyben definiálva van. Ha a változóhoz a kódblokkon kívül próbál hozzáférni, fordítási hibába ütközik.

Az egység fennmaradó része a kódblokkok és a változók hatóköre közötti kapcsolatot vizsgálja.

A kódolási környezet előkészítése

Ez a modul gyakorlati tevékenységeket tartalmaz, amelyek végigvezetik a bemutatókód létrehozásának és futtatásának folyamatán. Javasoljuk, hogy fejlesztési környezetként a Visual Studio Code használatával végezze el ezeket a tevékenységeket. Ha a Visual Studio Code-ot használja ezekhez a tevékenységekhez, azzal kényelmesebbé válik a kódírás és -futtatás egy olyan fejlesztői környezetben, amelyet világszerte használnak a szakemberek.

Nyissa meg a Visual Studio Code-ot.

A Visual Studio Code megnyitásához használhatja a Windows Start menüjét (vagy egy másik operációs rendszer egyenértékű erőforrását).
A Visual Studio Code File menüben válassza a Mappa megnyitása lehetőséget.
A Mappa megnyitása párbeszédpanelen lépjen a Windows Desktop mappába.

Ha más mappahelyen tartja a kódprojekteket, használhatja inkább ezt a mappahelyet. Ebben a képzésben az a fontos, hogy legyen egy könnyen megtalálható és megjegyezhető hely.
A Mappa megnyitása párbeszédpanelen válassza a Mappa kiválasztása lehetőséget.

Ha megjelenik egy biztonsági párbeszédpanel, amely megkérdezi, hogy megbízik-e a szerzőkben, válassza az Igen lehetőséget.
A Visual Studio Code Terminál menüjében válassza az Új terminál lehetőséget.

Figyelje meg, hogy a Terminál panelen egy parancssor megjeleníti az aktuális mappa elérési útját. Például:
```
C:\Users\someuser\Desktop>
```
Feljegyzés

Ha nem tesztkörnyezetben vagy üzemeltetett környezetben, hanem saját PC-n dolgozik, és ebben a C#-sorozatban más Microsoft Learn-modulokat is elvégzett, előfordulhat, hogy már létrehozott egy projektmappát a kódmintákhoz. Ha ez a helyzet, átugorhatja a következő lépést, amellyel konzolalkalmazást hozhat létre a TestProject mappában.
Ha új konzolalkalmazást szeretne létrehozni egy adott mappában a Terminál parancssorában, írja be a következő parancssort:
```
dotnet new console -o ./CsharpProjects/TestProject
```
Ez a .NET CLI-parancs .NET-programsablon használatával hoz létre egy új C#-konzolalkalmazás-projektet a megadott mappahelyen. A parancs létrehozza Önnek a CsharpProjects és a TestProject mappákat, és a Fájl neveként .csproj a TestProjectet használja.

Ha megjelenik egy üzenet, amely közli, hogy a fájlok már léteznek, folytassa a következő lépésekkel. A meglévő projektfájlokat újra felhasználja.
Az EXPLORER nézetben bontsa ki a CsharpProjects mappát.

Ekkor megjelenik a TestProject mappa és két fájl, egy Program.cs nevű C# programfájl és egy TestProject.csproj nevű C# projektfájl.
A Visual Studio Code File menüben válassza a Mappa megnyitása lehetőséget.
A Mappa megnyitása párbeszédpanelen válassza a CsharpProjects mappát, majd válassza a Mappa kijelölése lehetőséget.
Az EXPLORER nézetben bontsa ki a TestProject mappát, majd válassza Program.cs.
Törölje a meglévő kódsorokat.

Ebben a C#-konzolprojektben kódmintákat hozhat létre, hozhat létre és futtathat a modul során.
Zárja be a Terminál panelt.

Változó létrehozása kódblokkon belül

Először azt az esetet fogja áttekinteni, amikor egy változó inicializálódik egy kódblokkban.

Győződjön meg arról, hogy meg van nyitva a Visual Studio Code, és Program.cs jelenik meg a Szerkesztő panelen.

Feljegyzés

Program.cs üresnek kell lennie. Ha nem, jelölje ki és törölje az összes kódsort.

Írja be a következő kódot a Visual Studio Code Editorba:

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

A Visual Studio Code File menüben válassza a Mentés lehetőséget.

A Program.cs fájlt a kód létrehozása vagy futtatása előtt menteni kell.
Az EXPLORER panelen nyissa meg a Terminált a TestProject mappa helyén, kattintson a jobb gombbal a TestProject elemre, majd válassza a Megnyitás az integrált terminálban lehetőséget.

Ekkor megnyílik egy terminálpanel. A terminálnak tartalmaznia kell egy parancssort, amely azt mutatja, hogy a terminál nyitva van a TestProject mappa helye előtt.
A terminál parancssorában a kód futtatásához írja be a dotnet run parancsot, majd nyomja le az Enter billentyűt.

Feljegyzés

Ha "Nem található futtatandó projekt" üzenet jelenik meg, győződjön meg arról, hogy a Terminál parancssora megjeleníti a TestProject mappa várt helyét. Például: C:\Users\someuser\Desktop\csharpprojects\TestProject>

A következő kimenetnek kell megjelennie:
```
Inside the code block: 10
```

Ez a várt kimenet. De mi a teendő, ha az utasításkódblokkon kívül szeretné elérni a változót valueif ?

Egy változó elérése azon a kódblokkon kívül, amelyben deklarálva van

A Visual Studio Code Editorban hozzon létre egy új kódsort az if utasításkódblokk alatt.
A létrehozott üres kódsorban adja hozzá a következő kódsort:
```
Console.WriteLine($"Outside the code block: {value}");
```

Ellenőrizze, hogy a frissített kód a következőhöz hasonlóan néz-e ki:

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

Mentse a kódfájlt, majd a Visual Studio Code használatával futtassa a kódot.

Írja be dotnet run a terminál parancssorából a kód futtatásához.

Figyelje meg, hogy az alkalmazás futtatásakor fordítási hiba jelenik meg:

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

Az Program.cs(7,46) üzenet része azt jelzi, hogy a hiba a Program.cs fájl 46. oszlopának 7. sorához van társítva.

Ez a hiba azért jön létre, mert egy kódblokkban deklarált változó csak az adott kódblokkon belül érhető el (csak látható). Mivel egy változó nem érhető el azon a kódblokkon kívül, amelyben deklarálta, value nem érhető el a kód 7. sorából.

A metóduskódblokkban deklarált változókat helyi változónak nevezzük. A változó hatókörét bemutató cikkek áttekintésekor a helyi változó kifejezés is megjelenik.

A változódeklaráció áthelyezése a kódblokk fölé

Egy kódblokkon belüli és kívüli változó eléréséhez a kódblokk előtt (fent) deklarálnia kell a változót, hogy a kódblokkon kívüli kód "láthassa" a változót.

Frissítse a kódot a Visual Studio Code Editorban az alábbiak szerint:

bool flag = true;
int value;

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

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

Szánjon egy percet a frissítések áttekintésére.
Figyelje meg, hogy value most már deklarálva van (de nem inicializálva) a if kódblokkon kívül.
Mentse a frissítéseket a Visual Studio Code használatával, majd futtassa a kódot.
Figyelje meg, hogy továbbra is fordítási hibát kap.

Ezúttal az alkalmazás futtatásakor a következő fordítási hiba jelenik meg:
```
Program.cs(6,49): error CS0165: Use of unassigned local variable 'value'
```
A hiba a kódblokkon belüli 6. sorhoz van társítva, mert value nem inicializálva van (nincs hozzárendelve értékhez). Ha a kódsor value = 10; az if utasításkódblokk felett található, az alkalmazás megfelelően fordítana, és minden rendben lenne. Mivel value azonban nincs inicializálva, nem érhető el a kódblokkon belül.

A probléma megoldásához a változók inicializálásának biztosítása a hozzáférésük megkísérlése előtt.

Változó inicializálása változódeklaráció részeként

A változódeklaráció részeként történő inicializáláshoz value frissítse a kódot az alábbiak szerint:
```
bool flag = true;
int value = 0;

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

value = 10;
Console.WriteLine($"Outside the code block: {value}");
```
Ez a kód a változódeklaráció részeként történő inicializálással value kezeli a "nem hozzárendelt helyi változó" fordítási hibát.
A Visual Studio Code használatával mentse és futtassa a kódot.
Figyelje meg, hogy az alkalmazás futtatásakor a következő kimenet jelenik meg:
```
Inside the code block: 0
Outside the code block: 10
```

A kód fordító általi értelmezésének vizsgálata

A futtatókörnyezeti hibák elkerülése érdekében a C#-fordító elemzi a kódot a Visual Studio Code Editorban és a buildelési folyamat során. Előfordulhat azonban, hogy a fordító nem mindig ugyanúgy értelmezi a kódot, mint ön.

Fontolja meg a következő két kódmintát, amelyek úgy tűnik, hogy ugyanazt a célt szolgálják:

// 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}");

Úgy érezheti, hogy ennek a két mintának mindig ugyanazt az eredményt kell eredményeznie, de a C#-fordító másképp értelmezi ezt a két kódmintát.

Az első kódminta esetében a fordító logikai változóként értelmezi flag azokat, amelyek bármelyik vagy truefalse. A fordító arra a következtetésre jut, hogy ha flag igen false, value akkor a második Console.WriteLine() végrehajtásakor nem inicializálódik. A fordító lényegében a következő két kódvégrehajtási útvonalat tekinti lehetségesnek:

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

ÉS

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

Mivel a fordító a második elérési utat lehetőségnek tekinti (az 1. kódminta esetében), hibaüzenetet generál a buildelési folyamat során. Emellett a Visual Studio Code kódszerkesztője egy piros hullámos vonallal value figyelmezteti a problémára (a kódblokk alatt).

A második kódminta esetében a megfelelőségért felelős azt a következtetést vonja le, hogy az if utasításkódblokk tartalma mindig végrehajtásra kerül (true mindig true). A fordító nem generál buildelési hibát, mert a második kódmintát úgy értelmezi, hogy egyetlen végrehajtási útvonal legyen az alábbiak szerint:

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

Összefoglalás

Íme néhány fontos szempont a kódblokkokkal kapcsolatban:

Ha egy kódblokkon belül deklarál egy változót, annak láthatósága helyi a kódblokkban, és a változó nem érhető el a kódblokkon kívül.
Ahhoz, hogy egy változó látható legyen a kódblokkon belül és kívül is, deklarálnia kell a változót a kódblokk előtt (a kódblokkon kívül és felett).
Győződjön meg arról, hogy a változók inicializálva vannak, mielőtt a kód megpróbálja elérni őket (az összes lehetséges kódvégrehajtási útvonal esetében).

Visszajelzés

Hasznosnak találta ezt az oldalt?

Gyakorlat – Kódblokkok és a változók hatóköre

Tesztelje tudását

Visszajelzés