Az alapvető input- output, vagyis a Konzol alkalmazások ki- és bemenetének tárgyaláshoz elsőként meg kell ismernünk néhány C#-ban használatos változó típust. A változók, a változó típusok ismerete nagyon fontos, bármely programozási nyelvet szeretnénk elsajátítani, mivel a programban használt adatokat változókban és konstansokban tudjuk tárolni. A program ezekkel számol, és segítségükkel kommunikál a felhasználóval. A kommunikáció a programozási nyelvek esetében körülbelül azt jelenti, hogy adatokat olvasunk be a billentyűzetről, s a munka végeztével a kapott eredményt kiírjuk a képernyőre.

Minden változónak van neve, vagy más néven azonosítója, típusa, és tartalma, vagyis aktuális értéke. Ezeken kívül rendelkezik élettartammal és hatáskörrel. Az élettartam azt jelenti, hogy az adott változó a program futása során mikor és meddig, a hatókör azt adja, hogy a program mely részeiben használható. A változók névének kiválasztása során ügyelnünk kell a nyelv szintaktikai szabályainak betartására.

Az alábbiakban megvizsgálunk néhány példát a helyes és helytelen névadásokra:

Valtozo

valtozo

Valtozónév

szemely_2_neve

int

alma#fa

10szemely

Az első négy névadás helyes. Vegyük észre, hogy a valtozo és a Valtozo azonosítók két külön változót jelölnek, mivel a C# nyelv érzékeny a kis-nagybetűk különbségére. Az angol terminológia ezt Case- sensitive nyelvnek nevezi.

A negyedik elnevezés helytelen, mivel az int foglalt kulcsszó. Az ötödik névben a # karakter szerepel, ami nem használható. Az utolsó elnevezés számmal kezdődik, mely szintén hibás.

A változókat a programban bevezetjük, vagyis közöljük a fordító rendszerrel, hogy milyen nével milyen típusú változót kívánunk használni a programban. Ezt a folyamatot deklarációnak nevezzük.

valtozo_nev tipus;

A típus határozza meg a változó lehetséges értékeit, értéktartományait, illetve azt, hogy, milyen műveleteket lehet értelmezni rajta, és milyen más típusokkal kompatibilis, a névvel pedig a változóra hivatkozhatunk. A kompatibilitás akkor fontos, mikor az egyik változót értékül akarjuk adni egy másiknak. Inkompatibilitás esetén a .NET fordító hibát jelez.

Más nyelvektől eltérően a C#-ban az ékezetes betűket is használhatjuk névadásra.

char ékezetes_betű;

int egész;

A változók a memóriában tárolódnak, vagyis minden azonosítóhoz hozzárendeljük a memória egy szeletét, melyet a rendszer lefoglalva tart a változó teljes életciklusa alatt. (Néhány változó típus esetén, mint a pointerek, valamivel bonyolultabb a helyzet, de a .NET rendszerben nem kell törődnünk a memória kezelésével, mivel a .NET felügyeli, lefoglalja és felszabadítja a memóriát.) Vizsgáljunk meg néhány, a C# nyelvben használatos, egyszerű típust!

A táblázatban felsorolt típusokkal deklarálhatunk változókat. Az alábbi példa bemutatja a deklaráció pontos szintaktikáját.

int i;

char c;

string s;

A változóinkat kezdőértékkel is elláthatjuk. A kezdőérték adása azért is fontos, mert az érték nélkül használt változók kifejezésekben való szerepeltetése esetén a fordító hibát jelez.

int k=0;

char c=’a’;

string z=”alma”;

A következő program bemutatja, hogyan lehet a változókat deklarálni, és kezdőértékkel ellátni. A képernyőn nem jelenik meg semmi, mivel kiíró és beolvasó utasításokat nem használunk. Ezeket a fejezet későbbi részeiben tárgyaljuk.

namespace deklaracio

{

class valtozok_

{

[STAThread]

static void Main(string[] args)

{

int r=0;

float h,l;

int a=0,b=1,c=0;

int d=a+b;

int k=a+10;

float f;

char ch;

char cr='a';

bool bo=true;

bool ba;

string s1;

string s2="Hello!";

}

}

}

Gyakran előforduló hiba, hogy a deklaráció során nem adunk nevet vagy típust a változónak, vagy egyáltalán nem deklaráljuk, de a programban próbálunk hivatkozni rá. Ekkor a .NET fordító a futtatáskor hibát jelez. Előfordul, hogy nem megfelelő típusú kezdő értékkel látjuk el a változókat. Ebben az esetben a következő hibaüzenetek jelenhetnek meg a képernyőn:

- Cannot implicitly convert type 'string' to 'int'

- Cannot implicitly convert type 'int' to 'string'

Azonos változónevek esetén is hibaüzenetet kapunk. Gyakori hiba az is, hogy az osztály, vagyis a class neve megegyezik valamely változó nevével, esetleg lefoglalt kulcsszót akarunk alkalmazni a névadásnál.

Bizonyos esetekben, amikor nem Error, hanem Warning típusú hibaüzenetet kapunk, a fordító olyan hibát talál a programunkban, amitől az még működőképes, de hatékonyságát csökkenti. Ilyen hiba lehet, ha egy változót deklarálunk, de nem használunk fel.

A következő példában láthatunk néhány rossz deklarációt. (- hogy a programozás során ne kövessünk el hasonló hibákat.)

int a="alma"; az int típus nem kompatibilis a string konstanssal

string f=2; az s változóba számot akarunk elhelyezni

int class=10; a class foglalt szó

int void=10; a void az eljárásoknál használatos cimke

A következő példa megmutatja, hogy a programjaink mely részeiben deklarálhatunk.

using System;

namespace AlapIO

{

class IO_

{

int a,b;

int d=10;

char c;

bool t,f=false;

string s;

int y = (int)3.0;

[STAThread]

static void Main(string[] args)

{

int l;

string s="ez egy string konstans";

int a = 12;

int b = a + 10;

bool t = true;

bool f = !t;

char c = 'a';

}

}

}

A fenti változók (a, b, c, d, t, f) a programunk futása közben használhatóak, az értékadások után tartalommal, értékkel rendelkeznek, melyet a program futása alatt, vagy a változóra vonatkozó következő értékadásig meg is tartanak. A felhasználó még mindig nem láthatja őket, és az értéküket nem tudja módosítani. Ahhoz, hogy lehetővé tegyük a program használójának a változók értékének manipulálását, nekünk kell a megfelelő utasításokat beépíteni a forráskódba. Amennyiben ezt tesszük, ügyelnünk kell a programkód helyességére.

Az értékadásnak jól meghatározott szintaktikája van. Az értékadó utasítás bal oldalán a változó azonosítója áll, középen egyenlőség jel, a jobb oldalon pedig az érték, vagy kifejezés, melynek az aktuális értékét a változóban tárolni szeretnénk.

int d=2;

c=a+40;

k=(10+4)/2;

int y = (int)3.0;

A helytelenül felírt értékadást a fordító hibaüzenettel jelzi.

A példában az y változónak egy valós típust adunk értékül, de ebben az esetben az (int)3.0 típus kényszerítéssel nem okozunk hibát. Ez egy ún.: explicit konverzió. A változók egy érdekes típusa a literál. Akkor használjuk, mikor a programban egy konkrét értéket szeretnénk szerepeltetni, pl.:

hibauzenet_1 = ”Helytelen Értékadás”;

max_Db = 20;

A literálok alapértelmezés szerint int típusúak, ha egészek, és double, ha valósak. Amennyiben float típust szeretnénk készíteni, az érték után kell írni az f karaktert, long típus esetén az l, illetve ulong esetén az ul karakterpárt, stb.

Float_literal = 4.5f;

Long_literal = 4l;

A C# programokban állandókat, vagy más néven konstansokat is definiálhatunk. A konstansok a program futása alatt megőrzik értéküket, s nem lehet felüldefiniálni őket, illetve értékadó utasítással megváltoztatni értéküket. Más nyelvektől eltérően, itt a konstansnak is van típusa.

const int a=10;

const string s=”string típusú konstans”;

A programjainknak fontos része a felhasználóval való kommunikáció. Adatokat kell kérni tőle, vagy közölnünk kell, mi volt a program futásának eredménye. Ahhoz, hogy az adatokat, vagyis a változók tartalmát be tudjuk olvasni vagy meg tudjuk jeleníteni a képernyőn, a .NET rendszerben igénybe vehetjük a C# alapvető I/O szolgáltatásait, a System névtérben található Console osztály ide tartozó metódusait (függvények és eljárások).

System.Console.Read();

System.Console.Write();

System.Console.ReadLine();

System.Console.WriteLine();

A Console.Write() és a Console.WriteLine() a kiírásra, míg a Console.Read() és a Console.ReadLine() a beolvasásra használható. A beolvasás azt jelenti, hogy az ún.: standard input stream –ről várunk adatokat. Amennyiben a Read() beolvasó utasítást használjuk, int típusú adatot kapunk, a ReadLine() metódus esetében viszont stringet. Ez kiderül, ha megnézzük a két metódus prototípusát.

public static string ReadLine();

public static int Read();

Jól látszik, hogy a Read() int típusú, a ReadLine() viszont string. Adat beolvasásakor természetesen nem csak erre a két típusra van szükségünk, ezért az input adatokat konvertálnunk kell a megfelelő konverziós eljárásokkal, melyekre később bővebben kitérünk.

A System hivatkozás elhagyható a metódusok hívásakor, amennyiben azt a program elején, a using bejegyzés után felvesszük a következő módon:

using System;

Ezt a műveletet névtér importálásnak nevezzük és a könyv későbbi fejezeteiben bővebben olvashatunk a témáról.

Mikor eltekintünk a névtér importálástól, akkor az adott metódus teljes, minősített, vagy q nevéről beszélünk, ami a függvény névtérben elfoglalt helyével kezdődik. Ez a minősítő előtag (pl.: System.Console…), így a program bármely részéből meghívhatjuk az adott függvényt, vagy eljárást. Erre szükség is lehet, mivel a System névtér is több fájlból (DLL) ál, amelyeket a fordító nem biztos, hogy megtalál a hivatkozás nélkül. Ez nem csak a System -re, hanem valamennyi névtérre igaz.

Pl.:System.Thread.Threadpool.QueueUserWorkItem();

(a többszálú programok készítésénél van jelentősége, később még visszatérünk rá)

Ahhoz, hogy használni tudjuk a Consol metódusait, meg kell vizsgálnunk néhány példát. A következő program bemutatja a beolvasás és a kiírás mechanizmusát.

using System;

namespace ConsoleApplication7

{

class Class1

{

[STAThread]

static void Main(string[] args)

{

int a=0,b=0;

Console.Write("a erteke : ");

a=Convert.ToInt32(Console.ReadLine());

Console.Write("b erteke : ");

b=Convert.ToInt32(Console.ReadLine());

Console.WriteLine("\n a={0}\n b={1}\n a+b={2}",a,b,a+b);

Console.ReadLine();

}

}

}

Amennyiben futtatjuk a programot a képernyőn a következő output (kimenet) jelenik meg:

A System.Console.WriteLine() metódussal a standard output - ra, vagyis a képernyőre tudunk írni, pontosabban a képernyőn megjelenő Consol alkalmazás ablakába. A metódusban ún.: formátum string - et, vagy más néven maszkot alkalmaztunk, hogy a változók értékeit formázottan, vagyis a számunkra megfelelő alakban tudjuk megjeleníteni.

A formátum string tartalmaz konstans részeket (a=, b=, a+b=) ami változatlan formában kerül a képernyőre. A {0}, {1}, {2} bejegyzéseket arra használjuk, hogy a formátum string megfelelő pontjaira behelyettesítsük a paraméterlistában felsorolt változók értékeit: a {0} jelenti a nulladik, vagyis a sorban az első változó helyét, a {1} a második változó helyét, és így tovább. Amennyiben a {} zárójelek között olyan értéket adunk meg, mely nem létező változóra hivatkozik, a program leáll.

Console.WriteLine("{1} {3}",i);

A példában az első és a harmadik változóra hivatkoztunk (sorrendben a második és a negyedik), de ilyenek nem léteznek, mivel az egyetlen változó a kiíró utasításban az i, mely a nulladik helyen áll. A helyes hivatkozás tehát:

Console.WriteLine("{0}",i);

Ezek a bejegyzések nem hagyhatóak el, mivel csak így tudjuk a változók tartalmát a képernyőre írni. A sorrendjük sem mindegy. Vegyük észre, hogy a példaprogramban a második Console.WriteLine() paraméter listájában a változók fel vannak cserélve, a kiírási sorrend mégis megfelelő, mivel a formátum definiálja, a változók helyét a kiírt szövegben.

(Érdekes kérdés lehet, hogy a {, }, {0} karaktereket hogyan írjuk a képernyőre. A Console.WriteLine(”{} {0} = {0}”,a); nem megfelelő. A kedves olvasó kipróbálhatja a Console.WriteLine(”{{0}} = {0}”,a); utasítást…)

A formátum maszkjába a következő vezérlő karaktereket helyezhetjük el:

Vegyük észre, hogy a programunk megjeleníti a tárolt értékeket, s azok összegét is, de nem ad lehetőséget felhasználónak a változók értékének a megváltoztatására.

Ahhoz, hogy tovább tudjunk lépni, el kell sajátítanunk, hogyan kezelhetjük le a felhasználótól érkező inputot, vagyis a billentyűzetről bevitt adatokat.

A felhasználói input kezelésére lehetőséget biztosítanak a Console.Read() ,és a Console.ReadLine() metódusok. Mindkettő esetében adatokat olvashatunk be a standard inputról, vagyis a billentyűzetről, s ha megtámogatjuk a két metódust a Convert osztály konverziós függvényeivel, nemcsak int és string típusú adatokat, hanem szám típusú, vagy logikai értékeket is beolvashatunk a felhasználótól. A példaprogramban a Convert.ToInt32() metódust használjuk az input 32-bites int típussá konvertálására. Ha a beolvasás során az input stream –ről hibás adatot kapunk, mely nem konvertálható, a programunk leáll.

Az ilyen jellegű hibákra megoldás lehet a kivételek kezelése, melyről a későbbi fejezetekben szót ejtünk majd.

Nézzünk meg a példát a beolvasásra és a konverzióra!

using System;

namespace ConsoleApplication7

{

class Class1

{

[STAThread]

static void Main(string[] args)

{

int a=0,b=0;

Console.Write("a erteke : ");

a=Convert.ToInt32(Console.ReadLine());

Console.Write("b erteke : ");

b=Convert.ToInt32(Console.ReadLine());

Console.WriteLine("\n a={0}\n b={1}\n a+b={2}",a,b,a+b);

Console.ReadLine();

}

}

}

Ebben az alkalmazásban a változók a felhasználói inputról nyernek értéket, így a beolvasott adatok változtatásával minden lefutásnál más-más eredményt kapunk. A program végén a Console.ReadLine() utasítást arra használjuk, hogy a Consol ablak ne tűnjön el a képernyőről, miután a program lefutott. Ez fontos a Consol alkalmazások esetén, mivel ezek nem esemény vezérelt működésűek. A programok elindulnak, végrehajtják a programozó által definiált utasításokat, majd leállnak, és a kimeneti képernyőt is bezárják. Így a felhasználó nem lát szinte semmit az egészből.

A fentiek ismeretében vegyük sorra, hogy a változók milyen módon kaphatnak értéket!

Egyszerű értékadással:

A=2;

B=”alma”;

C=A+B;

E=2*A;

A standard inputról:

A=Convert.ToInt32(Console.ReadLine());

B=Console.ReadLine();

Kezdőérték adásával:

int D=10;

char c=”a”

A változókba beolvasott értékeket fel is tudjuk használni, és legtöbbször ez is a célunk. Miért is olvasnánk be értékeket, ha nem kezdünk velük semmit? A következő program két változó értékéről eldönti, hogy melyik a nagyobb. Ez a program viszonylag egyszerű, és jól bemutatja a billentyűzetről nyert adatok egész számmá konvertálását. A Convert osztály ToInt32() metódusával alakítjuk a beolvasott, itt még String típusként szereplő számot, majd azt konvertáljuk egész számmá (int), s adjuk értékül az a változónak. A b változóval ugyanígy járunk el. A beolvasást követően megvizsgáljuk, hogy a számok egyenlők-e, ha ez a feltétel nem teljesül, megnézzük, hogy melyik változó értéke a nagyobb, majd az eredményt kiírjuk a képernyőre. Nézzük meg a forráskódot!

using System;

namespace Convert

{

class KN

{

[STAThread]

static void Main(string[] args)

{

int a=0,b=0;

Console.Write("a értéke? = ");

a=Convert.ToInt32(Console.ReadLine());

Console.Write("b értéke? = ");

b=Convert.ToInt32(Console.ReadLine());

if (a==b)

{

Console.WriteLine("{0} és {1} egyenlőek",a,b);

}

else

{

if (a>b)

{

Console.WriteLine("{0} a nagyobb mint {1}",a,b);

}

else

{

Console.WriteLine("{0} a nagyobb mint {1}",b,a);

}

}

Console.ReadLine();

}

}

}

Az alkalmazás kimenetére kerek mondat formájában írjuk ki az eredményt úgy, hogy a kiírt string konstanst konkatenáljuk a változók értékével, így foglalva mondatba a program futásának eredményét. Ez gyakori megoldás a felhasználóval történő kommunikáció megvalósítására. Mindenképpen jobb, ha összefüggő szöveg formájában beszélgetünk. A hétköznapi kommunikáció során is jobb, ha kerek mondatokat használunk, hogy jobban megértsenek minket.

A program használhatóságát növeli, vagyis felhasználóbarát programokat készíthetünk.

Biztosan sokan emlékeznek a következő párbeszédre:

- Mennyi?

- Harminc.

- Mi harminc?

- Mi mennyi?

Az ilyen és hasonló párbeszédek érthetetlenné teszik a kommunikációt mind a valós életben, mind a programok világában. Az elsőben már egész jól megtanultuk a társas érintkezés formáit, tanuljuk meg a másodikban is!

A kiíratás és beolvasás mellett a műveletvégzés is fontos része a programoknak. A műveleteket csoportosíthatjuk a következő módon:

A műveleti jelek alapján három kategóriát hozhatunk létre. Unáris, bináris és ternáris műveletek. Az elnevezések arra utalnak, hogy a műveletben hány operandus szerepel.

Az aritmetikai értékadásokat rövid formában is írhatjuk. A következő táblázat bemutatja a rövidítések használatát, és azt, hogy a rövidített formulák mivel egyenértékűek.

Most, hogy elegendő tudással rendelkezünk a Consol I/O parancsairól és a műveletek használatáról, készítsünk programot, mely a felhasználótól bekéri egy tetszőleges kör sugarát, majd kiszámítja annak kerületét és területét.

A programhoz szükséges ismeretek: a kör kerülete: 2r*∏, és a területe: r*r*∏, vagy r2*∏.

A feladat az, hogy egy változóba beolvassuk az adott kör sugarát, majd a képernyőre írjuk a körhöz tartozó kerületet és a területet. A kifejezések kiszámítását elvégezhetjük a kiíró utasításban is, csak a megfelelő formátum string-et kell elkészítenünk, és a pí értékét behelyettesítenünk a képletekbe.

Honnan vegyük a pí-t? Írhatnánk egyszerűen azt, hogy 3.14, de ebben az esetben nem lenne elég pontos a számításunk eredménye. Használjuk inkább a C# math osztályban definiált PI konstanst!

Ekkor a program a következő módon írható le:

using System;

namespace ConsoleApplication7

{

class Class1

{

[STAThread]

static void Main(string[] args)

{

int r=0;

Console.WriteLine("kör sugara : ");

r=Convert.ToInt32(Console.ReadLine());

Console.WriteLine("A kör kerülete : {0}, területe : {1} ",2*r*Math.PI,r*r*Math.PI);

Console.ReadLine();

}

}

}

Vizsgáljuk meg, hogyan működik a program! Az r változóban tároljuk a billentyűzetről beolvasott értéket, a kör sugarát, majd a Console.WriteLine() – metódusban kiszámoljuk a megadott kifejezés alapján a kör kerületét és területét. Az eredmény kiíródik a képernyőre, s a program az enter leütése után befejezi futását.

Az egész típusú számokkal már jól boldogulunk, de sajnos az élet nem ilyen egyszerű. A legtöbb alkalmazásban szükség van a típusok közti konverzióra.

A fejezetben már szóltunk a típusok konverziójáról, és a Convert osztályról, de a teljesség kedvéért vegyük sorra a fontosabb metódusait!

Az alábbi felsorolás tartalmazza azokat a konvertáló metódusokat, melyeket az alapvető I/O alkalmazása során használni fogunk:

ToBoolean()

ToByte()

ToChar()

ToString()

ToInt32()

ToDateTime()

A ToBoolean() metódus logikai értékkel tér vissza.

Console.WriteLine("{0}",Convert.ToBoolean(1));

Bool b=Convert.ToBoolean(Console.ReadLine());

Logikai true értéket kapunk eredményül. Nullánál false visszatérési értéket kapnánk.

A ToByte() metódus byte típust ad vissza, de ez a fenti kiíró utasításban nem követhető nyomon, mivel a kiírt érték byte típusban is 1, viszont az értéktartomány megváltozik. Egy bájtnál nagyobb érték nem fér el a byte típusban. Nagyobb szám konvertálása hibához vezet.

Console.WriteLine("{0}",Convert.ToByte(1));

A ToChar() metódus a karakter ASCII kódjával tér vissza. Ez a metódus jól használható a számrendszerek közti átváltások programozására, mivel a kilences számrendszertől fölfelé történő konvertáláskor a 9-nél nagyobb számok esetén az ABC nagy betűit használjuk.

10=A, 11=B,…,15=F.

Az átváltáskor, ha az adott számjegy nagyobb, mint 9, átalakíthatjuk a következő módon:

Convert.ToChar(szamjegy+55);

A példában a számjegy ASCII kódját toltuk el annyival, hogy az megegyezzen a megfelelő tizenhatos számrendszerbeli számjegy ASCII kódjával. A kódot ezután karakterré konvertáltuk. A következő programrészlet a fent említett eljárás használatával a 10 szám helyett egy A betűt ír a képernyőre.

Console.WriteLine("{0}",Convert.ToChar(10+55));

Amennyiben a ToChar() bemenő paramétere a 11+55 lenne, a B betű jelene meg a képernyőn.

A ToString() string-et konvertál a bemenő paraméterből.

string s=Convert.ToString(1.23);

Console.WriteLine("{0}",s);

Eredménye az 1.23 szám string-ként. Konvertálás után 1.23-al nem végezhetünk aritmetikai műveletet, mivel string típust készítettünk belőle, de alkalmas string-ekhez való hozzáfűzésre.

A ToInt32() metódust már használtuk az előző programokban, de álljon itt is egy példa a használatára.

int a=Convert.ToInt32(Console.ReadLine());

A kódrészletben az int típusú változóba a billentyűzetről olvasunk be értéket. A Console.ReadLine() metódust ”paraméterként” átadjuk a Convert.ToInt32() függvénynek, így a beolvasott érték egész típusú számként (int) kerül a memóriába.

Másik lehetőség a konverzióra az i=Int32.Parse(Console.ReadLine()); forma használata. A két megoldás azonos eredményt szolgáltat.

A felsorolás végére hagytuk a ToDateTime() metódust, mivel a dátum típussal még nem foglalkoztunk.

Előfordulnak programok, ahol a felhasználótól a születési dátumát, vagy éppen az aktuális dátumot szeretnénk megkérdezni. Amennyiben ki akarjuk íratni a képernyőre amit beolvastunk, nincs szükség konverzióra, de ha dátum típusként tárolt adattal szeretnénk összehasonlítani azt, vagy adatbázisban tárolni, akkor használnunk kell a ToDateTime() függvényt.

Console.WriteLine("dátum :{0}",Convert.ToDateTime("2004/12/21"));

A fenti programrészlet futásának az eredménye a következő:

Látható, hogy a dátum mellett az aktuális idő is megjelenik, ami alapértelmezésként 0:00:00. Ebből következik, hogy ToDateTime() paraméterében megadott string-ben az aktuális időt is fel tudjuk venni a következő módon:

Console.WriteLine("datum + idő : {0}

",Convert.ToDateTime("2004/12/21 1:10:10"));

Ennek a kódrészletnek az eredményeként a dátum mellett az idő is kiíródik a képernyőre. Természetesen a C# -ban sokkal több konverziós metódus létezik, de a programjaink megírásához a felsoroltak elegendőek. (Amennyiben a többire is kíváncsiak vagyunk, használjuk a .NET dinamikus HELP rendszerét!)

A példákban a konvertálást a kiíró utasítással kombináltuk, hogy az eredmény megjelenjen a képernyőn, de a metódusokat változók értékének a beállításakor, vagy típus konverzió esetén is használhatjuk.

string s=Convert.ToString(1.23);

int k=Convert.ToInt32('1');

k=2+Convert.ToInt32(c);

char c=Convert.ToChar(1);

bool b=Convert.ToBoolean(1);

Logikai érték esetén a beolvasás a következő módon oldható meg:

bool b;

b=Convert.ToBoolean(Console.ReadLine());

Ennél a programrészletnél a true szót kell begépelni a billentyűzeten. Ez kicsit eltér a fent bemutatott bool b=Convert.ToBoolean(1); értékadástól. A beolvasásnál az 1 érték nem megfelelő. Nem szerencsés a logikai értékek beolvasásakor a Read() metódust használni, mivel az int típust olvas be.

A standard Input/Output kezelésének alapjait elsajátítottuk. A következő fejezetben a szelekcióval ismerkedünk meg. A szelekció, vagyis a feltételes elágazások témakörét ez a fejezet is érintette, de nem merítette ki. A teljes körű megismeréshez mindenképpen fontos a következő fejezet tanulmányozása.

A szintaktika mellett fontos megemlíteni, hogy a programozás folyamata nem a fejlesztői eszköz kód editorában kezdődik. Elsőként fel kell vázolni a születendő programok működését, tervezni kell, meg kell keresni a lehetséges matematikai megoldásokat (persze, csak ha erre szükség van). A tervek leírása sok esetben már a program vázlatát adja. (Egyszerűbb programok esetén elég, ha a felhasználói igényeket papírra vetjük .) A tervezés, előkészítés lépésekeit soha nem szabad kihagyni. A megfelelően átgondolt, megtervezett programok elkészítése a későbbiekben felgyorsítja a programozási folyamatot, egyszerűbbé teszi a hibák keresését, javítását.