Gyakorlat – Adattípus-öntés és -átalakítás megismerése

30 perc

Az adattípus-átalakítás több technikával is elvégezhető. A választott technika két fontos kérdésre adott válaszától függ:

Lehetséges-e, hogy az érték adattípusának megváltoztatására tett kísérlet az értéktől függően kivételt eredményez a futtatás során?
Lehetséges-e, hogy az érték adattípusának megváltoztatására tett kísérlet az értéktől függően információvesztést eredményez?

Ebben a gyakorlatban végigvezeti ezeket a kérdéseket, a válaszok következményeit és azt, hogy milyen technikát kell használnia, amikor módosítania kell az adattípust.

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, könnyebben írhat és futtathat kódokat egy olyan fejlesztői környezetben, amelyet világszerte használnak a szakemberek.

Feljegyzés

Ha 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, kihagyhatja a lépések következő szakaszát, és törölheti az Program.cs előző gyakorlathoz használt fájlban lévő kódot.

Feljegyzés

A gyakorlatban szereplő kódminták az USA-beli kulturális beállítások alapján lettek kialakítva, és egy pont (.) tizedesjelet használnak. A kód létrehozása és futtatása olyan kulturális beállítással, amely egy másik tizedeselválasztót (például vesszőt ,) használ, váratlan eredményeket vagy hibákat okozhat. A probléma megoldásához cserélje le a kódmintákban szereplő tizedesjeleket a helyi tizedeselválasztóra (például ,). Másik lehetőségként, ha egy programot az EN-US kulturális beállítással szeretne futtatni, adja hozzá a következő kódot a program elejéhez: using System.Globalization; és az egyéb using utasítások hozzáadása CultureInfo.CurrentCulture = new CultureInfo("en-US");után.

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élda:
```
C:\Users\someuser\Desktop>
```
Ha új konzolalkalmazást szeretne létrehozni egy adott mappában, a terminál parancssori típusánál nyomja dotnet new console -o ./CsharpProjects/TestProject le az Enter billentyűt.

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 .csproj Fájl neveként a TestProjectet használja.
Az EXPLORER panelen 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.
Az EXPLORER panelen válassza a Program.cs lehetőséget, ha meg szeretné tekinteni a kódfájlt a Szerkesztő panelen.
Törölje a meglévő kódsorokat.

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

Kérdés: Lehetséges, hogy az érték adattípusának módosítására tett kísérlet futásidőben kivételt eredményezne?

A C#-fordító megpróbálja kezelni a kódot, de nem fordít le olyan műveleteket, amelyek kivételt eredményezhetnek. Ha tisztában van a C#-fordító elsődleges aggodalmaival, könnyebben megértheti, hogy miért működik egy bizonyos módon.

Olyan kód írása, amely megkísérli hozzáadni `int` és `string` menteni az eredményt egy `int`

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:
```
int first = 2;
string second = "4";
int result = first + second;
Console.WriteLine(result);
```
Itt megkísérli hozzáadni az értékeket 2 és 4a . A 4 típusa string. Vajon működni fog?
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.

Meg kell nyitnia egy terminálpanelt, és 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 dotnet run , majd nyomja le az Enter billentyűt.

A következő hozzávetőleges kimenetnek kell megjelennie
```
C:\Users\someuser\Desktop\csharpprojects\TestProject\Program.cs(3,14): error CS0029: Cannot implicitly convert type 'string' to 'int'
```
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>
Szánjon egy percet annak a megfontolására, hogy a fordító miért nem tudta futtatni az első kódmintát.

A hibaüzenet fontos része azt jelzi, (3,14): error CS0029: Cannot implicitly convert type 'string' to 'int'hogy a probléma az string adattípus használatával van.

De miért nem tudja a C# fordító csak kezelni a hibát? Végül is az ellentétesét is megteheti: összefűzhet egy számot a string értékével, és elmentheti egy sztring változóban. Itt módosíthatja a változó result adattípusát a következőreint: .string>

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

int first = 2;
string second = "4";
string result = first + second;
Console.WriteLine(result);

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

A következő kimenetet kell megfigyelnie:
```
24
```
A kimenet matematikailag helytelen, de az értékek "2" és "4" karakterként való kombinálásával fejeződik be.
Vizsgálja meg ismét az első kód példáját, amelyben a result változó típusa intvan. A hibaüzenetet tartalmazó kód.
```
int first = 2;
string second = "4";
int result = first + second;
Console.WriteLine(result);
```
Miért nem tudja a C#-fordító kitalálni, hogy számként, nem pedig számként szeretné kezelni a változót second4string?

A fordítók biztonságos átalakításokat végezhetnek

A C#-fordító egy probléma lehetőségét fedezi fel. A second változó string típusú, ezért annak más érték, például a "hello" szó is megadható. Ha a C#-fordító a "hello" értéket próbálná számmá konvertálni, akkor ez kivételt eredményezne a futtatáskor. Ennek elkerülése érdekében a C#-fordító nem hajtja végre implicit módon a konvertálást stringint .

A C#-fordító szempontjából biztonságosabb művelet az int típus string típussá konvertálása, majd az összefűzés végrehajtása.

Ha összeadást szeretne végrehajtani sztring használatával, a C#-fordító elvárja, hogy közvetlenebbül avatkozzon be az adatkonverzió folyamatába. Másként fogalmazva kikényszeríti az aktív beavatkozást, hogy Ön megtehesse a megfelelő elővigyázatossági intézkedéseket annak elkerülésére, hogy a konverzió kivételt okozzon.

Ha az eredeti adattípus értékét egy új adattípusra kell módosítania, és a módosítás futásidőben kivételt okozhat, adatkonvertálást kell végrehajtania.

Az adatkonverzió többféle technikával elvégezhető:

Segédmetódus használata az adattípuson
Segédmetódus használata a változón
Convert Az osztály metódusainak használata

A lecke későbbi részében néhány példát tekinthet meg ezekre az adatkonvertálási technikákra.

Kérdés: Lehetséges, hogy az érték adattípusának módosítására tett kísérlet információvesztést eredményez?

Törölje vagy használja a sor-megjegyzés operátort // az előző gyakorlat lépés kódjának megjegyzéséhez, és adja hozzá a következő kódot:
```
int myInt = 3;
Console.WriteLine($"int: {myInt}");

decimal myDecimal = myInt;
Console.WriteLine($"decimal: {myDecimal}");
```
Mentse a kódfájlt, majd a Visual Studio Code használatával futtassa a kódot.

A következő kimenetnek kell megjelennie:
```
int: 3
decimal: 3
```
Ennek a példának a működése az alábbi kódsoron múlik:
```
decimal myDecimal = myInt;
```
Mivel bármely int érték elfér egy decimal típusú változóban, a fordító elvégzi a konvertálást.

A típus bővítési konverziója kifejezés azt jelenti, hogy egy kisebb tárolókapacitású adattípusból próbál értéket konvertálni olyan adattípusba , amely nagyobb tárolókapacitással rendelkezik. Ebben az esetben egy változó típusú int változóban tárolt érték típusváltozóvá decimalalakul, nem vesz el az információ.

Ha tudja, hogy szélesítő átalakítást hajt végre, implicit konverzióra támaszkodhat. A fordító implicit konverziókat kezel.

Leadás végrehajtása

Törölje vagy használja a sor-megjegyzés operátort // az előző gyakorlat lépés kódjának megjegyzéséhez, és adja hozzá a következő kódot:
```
decimal myDecimal = 3.14m;
Console.WriteLine($"decimal: {myDecimal}");

int myInt = (int)myDecimal;
Console.WriteLine($"int: {myInt}");
```
A leadás végrehajtásához az öntvény operátorral () kell körülvennie egy adattípust, majd a konvertálni kívánt változó mellé kell helyeznie (például: (int)myDecimal). Explicit átalakítást hajt végre a specifikált adattípusra (int).
Mentse a kódfájlt, majd a Visual Studio Code használatával futtassa a kódot.

A következő kimenetnek kell megjelennie:
```
decimal: 3.14
int: 3
```
Ennek a példának a működése az alábbi kódsoron múlik:
```
int myInt = (int)myDecimal;
```
A változó myDecimal olyan értéket tartalmaz, amely pontosságot mutat a tizedesvessző után. Az öntvényutasítás (int)hozzáadásával azt mondja a C#-fordítónak, hogy tisztában van azzal, hogy lehetséges, hogy elveszíti ezt a pontosságot, és ebben a helyzetben ez rendben van. Azt mondja a fordítónak, hogy szándékos átalakítást, explicit átalakítást hajt végre.

Annak meghatározása, hogy az átalakítás "szélesítő átalakítás" vagy "szűkülő átalakítás" -e

A szűkítő konverzió kifejezés azt jelenti, hogy olyan adattípusból próbál értéket konvertálni, amely több információt tárolhat olyan adattípussá, amely kevesebb információt tárolhat. Ebben az esetben információ, nevezetesen a pontosság veszhet el (tehát a tizedesjel utáni számjegyek). Ilyen például egy decimal változóban tárolt érték átalakítása típusváltozóvá int. Ha kinyomtatja a két értéket, valószínűleg az információvesztést fogja tapasztalni.

Ha tudja, hogy szűkítő konverziót hajt végre, el kell végeznie egy leadást. Az explicit konverziós utasítással tudatja a C#-fordítóval, hogy Ön tisztában van a pontosság elvesztésének lehetőségével, és elfogadja azt.

Ha nem biztos abban, hogy elveszíti-e az adatokat az átalakítás során, írjon egy kódot a konvertálás végrehajtásához két különböző módon, és figyelje meg a változásokat. A fejlesztők gyakran írnak kisebb teszteket, hogy jobban megértsék a viselkedést, ahogy a következő példában is látható.

Törölje vagy használja a sor-megjegyzés operátort // az előző gyakorlat lépés kódjának megjegyzéséhez, és adja hozzá a következő kódot:

decimal myDecimal = 1.23456789m;
float myFloat = (float)myDecimal;

Console.WriteLine($"Decimal: {myDecimal}");
Console.WriteLine($"Float  : {myFloat}");

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

A következőhöz hasonló kimenetnek kell megjelennie:
```
Decimal: 1.23456789
Float  : 1.2345679
```
A kimenetből megfigyelheti, hogy decimalfloat a leszűkítési konverzió, mert elveszíti a pontosságot.

Adatkonverziók végrehajtása

Korábban azt állították, hogy az egyik adattípus értékének módosítása futásidejű kivételt okozhat, és adatkonvertálást kell végrehajtania. Az adatkonvertáláshoz három módszert használhat:

Segédmetódus használata a változón
Segédmetódus használata az adattípuson
Convert Az osztály metódusainak használata

Szám `ToString()` konvertálása egy számmá `string`

Minden adattípusú változóhoz tartozik egy ToString() metódus. A ToString() metódus működése attól függ, hogy hogyan van implementálva az adott típuson. A primitívek többségén azonban bővítő konverziót végez. Bár ez nem feltétlenül szükséges (mivel a legtöbb esetben implicit átalakításra támaszkodhat), kommunikálhat más fejlesztőkkel, hogy ön megértse, mit csinál, és ez szándékos.

Az alábbi rövid példa a ToString() metódus int értékek string típusra konvertálására való használatát mutatja be.

Törölje vagy használja a sor-megjegyzés operátort // az előző gyakorlat lépés kódjának megjegyzéséhez, és adja hozzá a következő kódot:
```
int first = 5;
int second = 7;
string message = first.ToString() + second.ToString();
Console.WriteLine(message);
```
Mentse a kódfájlt, majd a Visual Studio Code használatával futtassa a kódot. A kód futtatásakor a kimenetnek a két érték összefűzésének kell megjelennie:
```
57
```

Konvertálás segédmetódussá `stringintParse()`

A numerikus adattípusok többsége rendelkezik egy Parse() metódussal, amely egy sztringet a megadott adattípussá alakít át. Ebben az esetben a Parse() metódus használatával két sztringet alakít át értékekké int , majd összeadja őket.

Törölje vagy használja a sor-megjegyzés operátort // az előző gyakorlat lépés kódjának megjegyzéséhez, és adja hozzá a következő kódot:
```
string first = "5";
string second = "7";
int sum = int.Parse(first) + int.Parse(second);
Console.WriteLine(sum);
```
Mentse a kódfájlt, majd a Visual Studio Code használatával futtassa a kódot. A kód futtatásakor a kimenetnek a két érték összegét kell megjelenítenie:
```
12
```
Szánjon egy percet, hogy megpróbálja kiszúrni az előző kód példájával kapcsolatos lehetséges problémát? Mi történne, ha a first és a second változónak is olyan értéket adna, amely nem konvertálható int típusra? A rendszer kivételt jelez futásidőben. A C#-fordító és a futtatókörnyezet várhatóan előre tervez, és megakadályozza az "illegális" konverziókat. A futásidejű kivételt többféleképpen is enyhítheti.

Ennek a helyzetnek a legegyszerűbb módja a módszer jobb verziója, a TryParse() használataParse().

`string` Az osztályt használóvá `int` alakítás `Convert`

Az Convert osztály számos segédmetórával rendelkezik egy érték típusból egy másikba való konvertálásához. Az alábbi példakódban néhány sztringet típusértékekké intalakít át.

Törölje vagy használja a sor-megjegyzés operátort // az előző gyakorlat lépés kódjának megjegyzéséhez, és adja hozzá a következő kódot:
```
string value1 = "5";
string value2 = "7";
int result = Convert.ToInt32(value1) * Convert.ToInt32(value2);
Console.WriteLine(result);
```
Mentse a kódfájlt, majd a Visual Studio Code használatával futtassa a kódot.

A következő kimenetnek kell megjelennie:
```
35
```
Feljegyzés

Miért ToInt32() a metódus neve? Miért nem ToInt()? System.Int32 annak a .NET-osztálytárbeli mögöttes adattípusnak a neve, amelyet a C# programozási nyelv az int kulcsszóra képez le. Mivel a Convert osztály is a .NET-osztálytár része, a teljes nevével, és nem a C#-beli nevével hívjuk. Azáltal, hogy az adattípusok a .NET-osztálytár részeként vannak definiálva, a Visual Basic, az F#, a Python és sok más .NET-nyelv ugyanazokat az adattípusokat, és ugyanazokat a .NET-osztálytárbeli osztályokat használhatja.

A ToInt32() metódus 19 túlterhelt verzióval rendelkezik, amelyek lehetővé teszik, hogy szinte minden adattípust elfogadjon.

itt egy sztringgel használta a Convert.ToInt32() metódust, de célszerű TryParse() , ha lehetséges.

Mikor érdemes használni az osztályt Convert ? Az Convert osztály a tört számokat egész számokká (int) alakítja, mivel az a várt módon kerekít.

A casting és a `decimal` konvertálás összehasonlítása `int`

Az alábbi példa bemutatja, mi történik, ha egy decimal értéket explicit módon próbál int típusúra (szűkítő konverzió), és ha ugyanezt a Convert.ToInt32() értéket a decimal metódussal konvertálja int típusúvá.

Törölje vagy használja a sor-megjegyzés operátort // az előző gyakorlat lépés kódjának megjegyzéséhez, és adja hozzá a következő kódot:

int value = (int)1.5m; // casting truncates
Console.WriteLine(value);

int value2 = Convert.ToInt32(1.5m); // converting rounds up
Console.WriteLine(value2);

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

A következő kimenetnek kell megjelennie:
```
1
2
```

Csonkok kiosztása és kerekítések konvertálása

A formázáskor int value = (int)1.5m;a lebegőpontos érték csonkolva lesz, így az eredmény 1az, ami azt jelenti, hogy a tizedesvessző utáni érték teljesen figyelmen kívül lesz hagyva. Módosíthatja a literális lebegtetést 1.999m , és az öntés eredménye ugyanaz lesz.

Amikor átalakítást használ Convert.ToInt32(), a literális lebegőpontos érték megfelelően felfelé 2kerekítve lesz. Ha a literális értéket 1.499mmódosította, az le lesz kerekítve a következőre 1: .

Összefoglalás

Az adatkonvertálás és -öntés számos fontos fogalmat tárgyalt:

Futásidejű hiba megakadályozása adatkonverzió végrehajtásakor
Explicit módon adja meg a fordítónak, hogy tisztában van az adatok elvesztésének kockázatával
Támaszkodjon a fordítóra, hogy implicit leadást hajtson végre egy bővülő konverzió végrehajtásakor
() Az öntött operátor és az adattípus használata a leadás végrehajtásához (például(int)myDecimal)
Akkor használja az Convert osztályt, ha szűkítő átalakítást szeretne végrehajtani, de kerekítést szeretne végrehajtani, nem pedig az információk csonkolását

Visszajelzés

Hasznosnak találta ezt az oldalt?

Gyakorlat – Adattípus-öntés és -átalakítás megismerése

Tesztelje tudását

Visszajelzés