Adatok konvertálása

Ahhoz, hogy érdekes programokat kreáljunk, szükségünk van a felhasználók interakciójára. Ehhez pedig adatokat kell bekérnünk a konzolról. A Konzol kétféle beolvasást is biztosít a Read és ReadLine metódusok segítségével.

Általában a ReadLine metódust szoktuk alkalmazni, mivel ez soremelésig (Enter gomb lenyomásáig) olvas szöveget. Viszont ez a metódus mindig fixen szöveget ad vissza, ami az esetek többségében nem lesz nekünk jó.

Ezért konvertálni kell a beolvasott adatainkat. C# esetén három módon konvertálhatjuk a típusainkat:

• Explicit módon
• Implicit módon
• A Convert osztály használatával
• Dinamikusan, futás időben (erről a fajtáról részletesen a vezérlési szerkezetek szekcióban lesz szó)

Explicit konvertálás

Az Explicit konvertálás a nevét onnan kapta, hogy már fordítási időben az egyik típusú adat átkonvertálódik egy másik típusra. Ez a megoldás nem csak alaptípusok esetén alkalmazható, saját egyedi típusainkat is konvertálhatjuk vele. Ebben az esetben van egy-két feltétele a dolognak, de erről majd az operátorok felüldefiniálásánál ejtek szót.

Az Explicit konvertálás szintaxisát az alábbi példa mutatja be:

int x = 22;
double y = (double)x;

A konvertálási szintaxis nagyon egyszerű. A típus konvertálni kívánt változónk elé zárójelbe írjuk az új, kívánt típust. Explicitnek azért nevezzük, mert egyértelműen megadja, hogy mire konvertálódik az adattípusunk. Az alábbi példa a statikus konvertálást szemlélteti:

using System;

namespace PeldaStatkonv
{
    class Program
    {
        static void Main(string[] args)
        {
            //0-t ír ki, mivel x int és a 4 is int
            int x = 3;
            Console.WriteLine(x / 4);

            //0,75 mert az x átkonvertálódik double típusra
            Console.WriteLine((double)x / 4);

            Console.ReadKey();
        }
    }
}

A program kimenete:

0
0,75

A fenti példában az első osztás eredménye egész szám lesz, mivel egészet osztunk egésszel. A második kiírásnál, mivel először átkonvertálódik x típus double-ra, így az eredmény is double típusú lesz.

Implicit konvertálás

Az implicit konvertálás rejtett konverziót jelent. Szintén fordítási időben megtörténik és szintén felüldefiniálható egyedi típusoknál. Ezzel leginkább szám típusok esetén találkozunk. Például akkor, ha egy double típusú változónak egész (int) értéket szeretnénk adni. Ebben az esetben a fordító rejtett módon az egész számot átalakítja double típusra.

byte b = 11; //implicit konverzió ez is. int -> byte
int egesz = b; //implicit konvertálódik
double d = egesz; //szintén implicit mód konvertálódik

Implicit konverziót akkor szoktak típusok közé iktatni, ha programozói beavatkozás, értesítés nélkül is minden esetben probléma nélkül meg tud történni az átalakítás. Ezzel szemben az explicit deklaráció akkor szükséges, ha nem minden esetben garantált a konverzió sikere, illetve akkor ha a konverzió közben adatvesztés történik (pl. double átalakítása int-re.)

double d = 3.14;
//3 lesz, veszteség történik, ezért explicitnek van definiálva a konverzió
int egesz = (int)d; 

Convert osztály

A Convert osztály konverziós metódusokat biztosít. Az esetek többségében ugyanúgy működik, mint az fordítási idejű konvertálás (implicit és explicit). Ezt leírva felmerülhet a kérdés, akkor meg mi értelme van a használatának?

A fordítási idejű konvertálás hatalmas problémája az alaptípusok esetén, hogy nem igen tud mit kezdeni azzal, ha szövegből szeretnénk számokat nyerni, vagy a számokat szeretnénk szöveggé alakítani. A probléma a szöveg típus felépítéséből adódik. Egy számsorozatot például megadhatunk bináris, oktális, vagy akár hexadecimális számrendszerben is. A lebegő pontos számok esetén pedig kezelni kell a tizedes elválasztót¹, és akkor még nem is beszéltünk az ezres csoportosítás problémájáról.

Ezen problémakör orvoslására készült el a Convert osztály, amely különböző alaptípusok közötti konvertálásra lett kitalálva. A Convert osztály teljes dokumentációja a https://msdn.microsoft.com/en-us/library/system.convert%28v=vs.110%29.aspx címen érhető el.

Az alábbiakban a Convert osztály fontosabb metódusaival ismerkedünk meg:

byte Convert.ToByte(value)
sbyte Convert.ToSByte(value)

Byte vagy előjeles byte átalakítás bármilyen alaptípusról.

short Convert.ToInt16(value)
int Convert.ToInt32(value)
long Convert.ToInt64(value)

Előjeles egész átalakítás bármilyen alaptípusról. A metódus nevében a szám a visszaadott bitek számát határozza meg. 16 → short, 32 → int, 64 → long

ushort Convert.ToUInt16(value)
uint Convert.ToUInt32(value)
ulong Convert.ToUInt64(value)

Előjel nélküli egész átalakítás bármilyen alaptípusról. A metódus nevében a szám a visszaadott bitek számát határozza meg. 16 → ushort, 32 → uint, 64 → ulong

bool Convert.ToBoolean(value)

Logikai értékké konvertálás bármilyen alaptípusról.

float Convert.ToSingle(value)
double Convert.ToDouble(value)
decimal Convert.ToDecimal(value)

Lebegő pontos számmá alakítás bármilyen alaptípusról. A Single változat float típust ad vissza.

char Convert.ToChar(value)

Karakterré konvertálás bármilyen alaptípusról.

string Convert.ToString(value)

Bármilyen alaptípus szöveggé alakítása.

string Convert.ToString(szám, számrendszer)

Csak egész és előjel nélküli egész számok esetén használható szöveggé alakító metódus. A második paraméter a számrendszert határozza meg, ami lehet 2, 8, 10 vagy 16.