63 A C# nyelv

2016/12/22 14:46

1/63

A C# nyelv

< CSharp

A C# nyelv Szerző: Sallai András Copyright © Sallai András, 2011, 2013, 2014, 2015 Licenc: GNU Free Documentation License 1.3 Web: http://szit.hu

A C# nyelvről Bevezetés A C# nyelv egy objektumorientált programozási nyelv. Angolos kiejtése szí-sárp. A nyelvet először MS valósította meg a .Net keretrendszeren belül. A .Net keretrendszer teljes értékű szabad szoftveres alternatívája a Mono. A Monot eredetileg a Ximian nevű cég hozta létre, amelyet felvásárolt a Novell. A Mono tehát most a Novell kezelésében áll. A Mono rendszer telepíthető a Linux, Mac OS X és Windows operációs rendszerekre. A C# nyelv szigorúan osztályok halmaza, kis és nagybetű érzékeny, minden utasítást pontosvesszővel zárunk.

Fogalmak Kezelt kód Managed code A C# forráskód lefordítása után kapjuk. Ez egy közbenső nyelv, amely az alacsony szintű gépikód és a magas szintű C# kód között van. A közbenső nyelvet hívjuk angolosan: intermediate language (IL, CIL, MSIL). A Java bájtkódjának feleltethető meg. CLR Közös nyelvű futási idejű környezet Common Language Runtime Ebben a környezetben értelmezi a kezelt kódot futási időben a JIT (Just-in-time) fordító, alacsony szintű gépikódként.

SzitWiki - http://szit.hu/

Last update: 2015/10/22 08:26

oktatas:programozás:csharp:csharp_nyelv http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv

Garbage collector GC Szemétgyűjtő. Felszabadítja helyettünk a nem használt memóriaterületeket.

Gyakorlat 1. 2. 3. 4. 5. 6.

Mi az a kezelt kód? Telepíthető-e a Mono rendszer Solaris operációs rendszerre? Ki fejlesztette ki a .Net keretrendszert? Hogyan nevezik angolul a Közös nyelvű futási idejű környezetet? Nyílt forrású-e a Mono rendszer? Mire jó a Garbage collector?

Első program Helló Világ nevű program Egy szövegszerkesztő programmal készítsd el a következő állományt, az alábbi tartalommal: Az állomány mentése után a fordítsuk le a forráskódot, futtatható állománnyá. Program01.cs using System; class Program01 { static void Main() { Console.WriteLine("Helló Világ!"); } }

Fordítás Windows alatt: csc Program01.cs Fordítás Linux alatt 3.x monoval: gmcs Program01.cs Fordítás Linux alatt 4.x monoval: dmcs Program01.cs

http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

3/63

A C# nyelv

A program ami kiírja a Helló Világ! feliratot. A program megírható, fordítható például Visual 2010 C# Express fejlesztői környezetben is. Ha parancssorból fordítunk, akkor ügyeljünk arra, hogy a csc fordítónak útvonalban kell lenni, vagy fordításkor meg kell adnunk az egész elérési útvonalát, ami nem kényelmes. Linux operációs rendszer alatt a gmcs vagy a dmcs fordítót kell használnunk, amely a Mono keretrendszer része. 2013-ban a LinuxMint rendszereken már telepíthető a mono-dmcs csomag, amely Mono 4.x verzióját tartalmazza. Minimum ennek a csomagnak a használata ajánlott.

Elemzés Létrehoztunk egy Program01 nevű osztályt és abban egy Main metódust. A nyelvben az osztály használata kötelező. A kiinduló osztályunk neve tetszőleges. Egy egyszerű konzolos program esetén a kiinduló osztályunknak van egy kötelező metódusa ez a „Main”. A program végrehajtása ezzel kezdődik. A példaprogramból látszik, hogy a System névtérben lévő osztályokat szeretnénk használni. Létrehoztunk egy prog nevű osztályt, amelynek egyetlen metódusa van a „Main”. A Main metódus egyetlen utasítást tartalmaz, amely kiírja a „Helló Világ!” szöveget. Ha „using System;” sort ha nem használjuk, akkor az utasítást a névtér megadásával kell kezdenünk: Program01.cs class Program01 { static void Main() { System.Console.WriteLine("Helló Világ!"); } }

A példában az utasítást a „System” kulcsszóval kezdjük, amellyel jelezzük, hogy a Console osztály ebben a névtérben van.

Gyakorlat 1. 2. 3. 4. 5.

Mit csinál a System.Console.WriteLine(„H”); utasítás? Milyen parancsot használunk a fordításhoz, ha Mono keretrendszert használunk? Milyen parancsot használunk a fordításhoz, ha .Net keretrendszert használunk? Kötelező a C# nyelvben az osztály használata? Írjon programot, amely saját névjegyét írja a képernyőre (Név, Cím, Telefonszám, e-mail cím, webcím, munkakör) 6. Milyen névteret használtunk eddig.


Last update: 2015/10/22 08:26


Kivitel A System névtéren belül, a Console osztály WriteLine() metódusa a paraméterként megadott kifejezés értékét írja a képernyőre, majd egy sortörést: Program01.cs class Program01 { static void Main() { System.Console.WriteLine("abc"); } }

A fenti példában egy karaktersorozat állandót küldünk a képernyőre és utána sortörés. A szimpla Write() metódus sortörés nélkül ír a képernyőre: Program01.cs class Program01 { static void Main() { System.Console.Write("abc"); } }

Escape szekvenciák Literálok Ha több karaktert akarunk a képernyőre íratni, fentebb láttuk, hogy a karaktereket egyszerűen idézőjelek között felsorolom, mint azt az alábbi program is szemlélteti. Program01.cs class Program01 { static void Main() { System.Console.WriteLine("abc"); } http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

5/63

A C# nyelv

}

Az idézőjelek helyett tehetünk egyszerű aposztrófokat, így azonban csak egy darab karaktert írhatunk közéjük. Program01.cs class prog { static void Main() { System.Console.WriteLine('a'); } }

Ha számokat szeretnénk kiíratni, akkor nem szükséges se aposztróf, se idézőjel. kiszam.cs class Program { static void Main() { System.Console.WriteLine(3); } }

Amikor megadok egy számot, karaktert vagy egy karaktersorozatot ezeket állandóknak hívom. Azért állandó, mert ilyen formában a forráskódba írva, a program további részében az nem változtatható meg. Nem is akármilyen állandóknak, „literális” állandóknak hívjuk őket. Hogy egy állandó literális, annyit jelent, hogy nincs neve, „az ami”. Literális állandó példák: 35 'a' "abc"

Helyettesítő karakter Helyettesítő karakterek vagy Escape sorozatok. Néhány karakternek speciális jelentése is lehet az eredeti szerepe helyett. Ilyen például az „a” karakter. Karaktersorozatban, vagy egy önálló karakterként kiíratva, szimplán megjelenik a képernyőn. Néha lehet azonban más jelentése is. Ha más jelentéssel kívánjuk használni azt valamilyen módon jelezni kell. Erre szolgál a visszaperjel. Ha egy karakterállandóban visszaperjel következik, ezzel jelezzük hogy a következő karakter speciális értelmezésű. A „\a” például megszólaltatja a beépített hangszórót. SzitWiki - http://szit.hu/

Last update: 2015/10/22 08:26


Hajtsuk végre például a következő programot: Program01.cs using System; class Program01 { static void Main() { Console.WriteLine("\a"); } }

Vagy az új sor karakter használata: Program01.cs using System; class prog { static void Main() { Console.WriteLine("Első sor\nMásodik sor"); } }

Vegyük észre hogy az idézőjel a karakter sorozatok kezdését és befejezését jelzi. Így annak kiíratása is problémás lenne escape szekvenciák nélkül: idezojel.cs using System; class prog { static void Main() { Console.WriteLine("\"idézet\""); } }

Az alábbi táblázatban láthatod néhány karakter speciális értelmezését. Escape szekvencia \a \f \n http://szit.hu/

Jelentés Csengőhang Lapdobás Új sor Printed on 2016/12/22 14:46

2016/12/22 14:46

7/63

A C# nyelv

Escape szekvencia Jelentés \r Kocsi vissza \t Vízszintes tabulátor \v Függőleges tabulátor \' Aposztróf \„ Idézőjel \\ Visszaperjel \? Literális kérdőjel \ ooo ASCII karakter oktális jelölése \x hh ASCII karakter hexadecimális jelölés \x hhhh Unicode jelölés

Gyakorlat 1. 2. 3. 4.

Mi a literális állandó. Mondjon példát két escape szekvenciára. Hogyan íratunk escape szekvenciával sortörést? Hogyan mondjuk meg C# nyelven, hogy a következő karakter escape szekvenciaként lesz értelmezve? 5. Írjon programot, amely a következőt írja a képernyőre, egyetlen utasítással: Petőfi „Még nyílnak a völgyben” kezdetű verse

Változók, állandók és a típusok Változó Általában szeretnénk adatokat eltárolni a programírás során. Ezt a memóriában tehetjük meg. A memória egy helyét elnevezem, majd elhelyezek egy értéket az adott helyen. Egy programban mi ennek a memóriahelynek csak a nevével találkozunk és változónak hívjuk. Változónak, mert az adott memóriahely tartalmát lecserélhetem. A változókban többféle típusú értéket tárolhatunk. Lehetnek egész vagy valós számok, karakterek, karaktersorozatok. A C# nyelv típusos nyelv, a változókat használatuk előtt deklarálni kell, ahol megadjuk milyen típusú értéket kívánunk tárolni az adott változóban. valtozok.cs using System; class Prog { static void Main() { int a = 3; int b = 4; SzitWiki - http://szit.hu/

Last update: 2015/10/22 08:26


int c; c = a + b; Console.Write("Összeg: " + c); } }

A C# nyelvben a változók deklarációja a típus megadásával kezdődik. Ezt követi a változó neve. Típus változónév; A változó első karaktere csak betű vagy alulvonás jel (_) lehet. A név többi részében szám is szerepelhet. A C# megengedi az ékezetek használatát is, ezt azonban kerüljük. A változónak rögtön kezdőértéket is adhatunk. Az érték adás egy darab egyenlőség jellel történik.

A C# típusai A C#-ban a következő típusokat imserjük: értéktípusok referencia típusok mutatók Mi most csak az értéktípusokkal foglalkozunk. Az érték típusok lehetnek egyszerűek és összetettek: Egyszerű értéktípusok bool, char sbyte, short, int, long byte, ushort, uint, ulong float, double, decimal Típusok C# kulcsszó .Net típus Tartomány Mérete (byte) sbyte SByte -128 .. 127 1 byte Byte 0 .. 255 1 short Int16 -32768 .. 32767 2 ushort UInt16 0 .. 65535 2 int Int32 -2147483648 .. 2147483647 4 uint UInt32 0 .. 4294967295 4 long

Int64

ulong

UInt64

float

Single

http://szit.hu/

-263 .. 263-1 64

0 .. 2 -1 ±1.5E-45 .. ±3.4E38

8 8 4 Printed on 2016/12/22 14:46

2016/12/22 14:46

9/63

A C# nyelv

Típusok C# kulcsszó .Net típus Tartomány Mérete (byte) double Double ±5E-324 .. ±1.7E308 8 decimal Decimal ±1E-28 .. ±7.9E28 (128 Bit) 16 bool Boolean true, false 1 char Char Unicode karakter 2 string String Unicode karaktersorozat A bool típusban eltárolhatjuk logikai kifejezések eredményét. Legyen például a következő programrész: int a = 3; bool b = a > 5; Az „a > 5” kifejezése értéke hamis, így a b változóban a „false” érték lesz eltárolva. A bool típusú változóknak ennél több haszna van. Egy if()-ben megvizsgálhatjuk az értékét: int a = 3; bool b = a > 5; if(b) Console.WriteLine("Nagyobb 5-nél"); else Console.WriteLine("Kisebb vagy egyenlő 5-el"); A vizsgálat működött volna a „b == true” formában is, de felesleges kiírni a teljes kifejezést. A decimal típusban kisebb értékintervallum tárolható a float típushoz képest, de nagyobb pontossággal tudunk vele számolni. 28-29 értékes jeggyel számolhatunk. Ha egy lebegőpontos típust (float, double) átalakítunk az elvesző pontosság miatt visszaalakítva már nem lesz egyenlő önmagával. Ekkor használhatjuk a deciaml típust. Pénzügyi számításoknál hasznos lehet. Ha állandóként szeretnénk decimálist típussal dolgozni, akkor egy „m” karaktert kell a szám végére tenni: decimal penz = 300.5m; Az egész állandók automatikusan decimalként vannak értelmezve, tört számok esetén használhatjuk az „m” vagy „M” utótagot. Összetett típusok Az összetett típusokat a felhasználók definiálják enum struct Természetesen használhatunk sztringeket és tömböket is, de azok nem típusként vannak deklarálva, hanem osztályként.


Last update: 2015/10/22 08:26


enum

enum.cs using System; class Program { enum MunkaNapok {Hetfő, Kedd, Szerda, Csütörtök, Péntek}; static void Main() { Console.WriteLine(MunkaNapok.Hetfő); } }

struct

A struct szerkezetet különböző típusú értékek tárolására találták ki. A létrehozása metóduson kívül engedélyezett. A metódusban mint egy típust használhatjuk fel. struct.cs using System; class Program { struct Pelda { public string Nev; public int Kor; } static void Main() { Pelda Joska; Joska.Nev = "Nagy József"; Joska.Kor = 35; Console.WriteLine(Joska.Nev); Console.WriteLine(Joska.Kor); } }

Példa az osztályhoz hasonló használatra: struct2.cs using System; http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

11/63

A C# nyelv

class Program { struct Pelda { string Nev; public int Kor; public string lekerNev() { return Nev; } public void beallitNev(string atvettNev) { Nev = atvettNev; } } static void Main() { Pelda Joska = new Pelda(); Joska.beallitNev("Nagy József"); Joska.Kor = 35; Console.WriteLine(Joska.lekerNev()); Console.WriteLine(Joska.Kor); } }

Állandók Ha már változókról beszélünk, beszélhetünk állandókról is. Az állandókkal a foglalkoztunk már az Escape szekvenciák kapcsán. Ott megtanultuk, hogy ha csak úgy leírok egy számot, karaktert vagy karaktersorozatot akkor az egy literális állandó. Azért is tettük a literális jelzőt az állandó elé, mert nem csak literális állandók vannak. Az állandók két félék lehetnek: literális nevesített A literális állandókról tehát már volt szó, de mi a nevesített állandó? Természetesen az amikor egy állandónak nevet adunk. Egy állandó nevének meghatározása hasonló, mint a változóé. Az állandó neve előtt megadjuk annak típusát és a típus előtt egy „const” módosítót írok: const int a = 10; A példában az „a” állandót deklaráljuk. Amikor használom a const módosítót, akkor tulajdonképpen azt vállalom (mint programozó), hogy az „a” értékét a program további részében sosem változtatom meg. Erre persze a fordító sem ad lehetőséget. A változókkal ellentétben az állandók számára azonnal kötelező kezdőértéket megadni. Az alábbiakban egy rossz példát látunk:


Last update: 2015/10/22 08:26


const int a; De új értéket sem adhatunk: const int a = 10; a = 4;

Azonosítók Mint láttuk az általunk létrehozott változók és állandók számára valamilyen nevet, azaz azonosítót kell megadnunk. Van a C# nyelven 77 kulcsszó, amelyet nem használhatunk azonosító létrehozására, mert azt maga a nyelv használja. Szokás ezeket foglalt szavak néven is emlegetni. Foglalt szavak abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

13/63

interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while

Gyakorlat 1. 2. 3. 4.

Írja le, hogyan deklarál egy valós típusú változót, amelynek neve: „homerseklet”. Írja le, hogyan deklarál egy dupla-pontosságú változót, amelynek neve „oszto”. Milyen állandók vannak? A változó deklarálásánál hova tesszük a típust, a változó neve után vagy elé?


A C# nyelv

Last update: 2015/10/22 08:26


5. Írjon példát a literális állanódra! 6. Mik azok a foglalt szavak?

Operátorok Aritmetikai operátorok * szorzás / osztás % maradkék képzés + összeadás - kivonás

Általános . () [] ++ -new

mező- vagy metódus-hozzáférés Console.WriteLine() zárójel (a + b) * 2 tömbindex tomb[0] inkrementáló utasítás szam++ dekrementáló szam-Helyet foglalunk egy objektumnak Object objektum = new Object(); Type tipus = typeof(int); typeof() típusmeghatározó operátor Console.WriteLine(tipus.Name); sizeof() méretmeghatározó int meret = sizeof(long) checked() túlcsordulás ellenőrzés checked(a * b) unchecked() túlcsordulás ellenőrzés mellőzése unchecked(a * b) Ha a checked() operátort használjuk és túlcsordulás történik a következő hibaüzenet kapjuk: "The operation overflows at compile time in checked mode" Például: Console.WriteLine(checked(50000 * 50000)); De unchecked() operátort használva, nem kapunk hibaüzenetet. Console.WriteLine(unchecked(50000 * 50000));

Egyoperandusú operátorok + ! ~ (típus)x http://szit.hu/

pozitív szám negatív szám negálás, ellentétbe fordítás egyes komplemens képzés kasztolás Printed on 2016/12/22 14:46

2016/12/22 14:46

15/63

A C# nyelv

true igaz false hamis & egy objektum címét adja vissza sizeof() típus mérete Írjunk programot például, amely egy „a” nevű logikai változót deklarál, adjuk kezdőértéknek „true”-t, majd kiíratásnál fordítsuk meg az értékét: bool a = true; Console.WriteLine(!a); A fenti operátorok közül talán a kasztolás a legérdekesebb. Tulajdonképpen típuskonverzióról van szó. Adott például egy egész szám, amit valóssá szeretnénk alakítani, ez problémamentesen megtehető így: int a = 3; double b = a; Ha azonban fordítva szeretnénk, a valós számot akarjuk egésszé alakítani hibaüzenetet kapunk. Ezért kasztolnunk kell: double a = 3.5; int b = (int) a; Az „a” változó tartalmát „b” változóba szeretnénk konvertálni, ezért az „a” változó elé zárójelbe megjegyzem, milyen típusúvá szeretnénk átkonvertálni. Ezt nevezzük kasztolásnak. A táblázatból lássuk a sizeof() operátort. Egy típus méretét tudjuk megnézni vele. Eredményül megkapjuk hány bájton tárolódik az adott típus. Lássuk hány byton tárolja értékeit például az int: Console.WriteLine(sizeof(int));

Logikai operátorok ^ Logikai XOR & Logikai AND | Logikai OR int a = 3; int b = 5; int c = a ^ b; Console.WriteLine(c); //6

Feltételes operátorok && Feltételes AND || Feltételes OR int a = 3; SzitWiki - http://szit.hu/

Last update: 2015/10/22 08:26


if(a > && b > ) Console.WriteLine("Pozitív szám"); else Console.WriteLine("Nulla vagy negatív");

Összerendelő operátorok = legyen egyenlő += a = a + b -= a = a - b *= a = a * b /= a = a / b %= a = a % b &= a = a & b |= a = a | b ^= a = a ^ b «= a = a « b »= a = a » b ?? Ha b null, akkor -1 lesz a (a = b ?? -1)

Gyakorlat 1. 2. 3. 4. 5.

Melyik operátorral negálunk? Melyik operátorral képezzük egy szám egyes komplemensét? Melyik operátorral kérjük le egy objektum címét? Hogyan jelezzük egy állítás valós (igaz) létét? Mi a kasztolás?

Formátumozott kivitel Egy vagy akár több változónak megadható a kiírás formátuma. A formátum egy karaktersorozat, ami mindig az első paraméter. Az első paraméterben egy változóra vonatkozó formátum karaktersorozat mindig ”{„ nyitó kapcsos zárójellel kezdődik és egy ”}„ záró kapcsos zárójellel záródik. Minimálisan megadandó karakter egy index. Annak a változónak az indexe, amelyet az adott helyen meg akarunk jeleníteni.

Változók indexe Az alábbi kiíró utasításban az „a” változó indexe 0, a „b” változó indexe 1, mivel az „a” változó előrébb van mint a „b”, az indexelés pedig 0-ától kezdődik. int a = 3, b = 4; Console.WriteLine("{0} {1}", a, b); A kiírás eredménye tehát: http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

17/63

A C# nyelv

3 4 A hármas, utána egy szóköz, majd ezt követi a 4. Megtehetem fordítva is. Az első formátum karakter-sorozatban hivatkozom az 1-s indexű változóra, majd a másikban a 0-ás indexű változóra: int a = 3, b = 4; Console.WriteLine("{1} {0}", a, b); A kiírás eredménye ekkor: 4 3

Formátumkarakterek A formátum karaktersorozatban az indexet követően egy kettőspont után további formátumokat tudok meghatározni egy-egy karakterrel. Az alábbi táblázat ezeket a formátum karaktereket tartalmazza: Formátum karakter Leírás C, c Pénzösszeg (currency) D, d Decimális szám E, e Tudományos (exponenciális) alak F, f Fixpontos alak G, g Általános (general) N, n Szám (number) R, r Eredeti alak X, x Hexadecimális alak

Kiíratás pénznemben A {0:c} formátum-karaktersorozat például pénznemben írja ki az adott értéket: Console.WriteLine("Az ár: {0:c}", 23485);

// 23 485 Ft

A Ft persze csak magyar környezetben lesz kiírva. Más nyelvi környezet más pénznemet eredményez.

Kiíratás hexadecimális alakban Egész számokat hexadecimális formátumban is kiírathatunk: Console.WriteLine("Hex: {0:x}", 10);


// a

Last update: 2015/10/22 08:26


Kiíratás fixpontos alakban Fixpontos alakban kiíratás: Console.WriteLine("Fixpontos alak: {0:f}", 10);

// 10,00

A számítástechnikában a magyarban szokásos tizedesvessző helyett tizedes ponttal dolgozunk, de vegyük észre, hogy a kimenet igazodik, a magyar környezethez és a kiíratás tizedesvesszővel történik.

Kiíratás lebegőpontos alakban Lebegőpontos alak: Console.WriteLine("Lebegőpontos alak: {0:e}", 10);

//

1,000000e+001

Vezető nullák Console.WriteLine("Érték: {0:00000}", 85); Ha a szám kétjegyű mint a példában, akkor a nem létező számjegyek helyén 0-ás karakter fog szerepelni: 00085

Hány helyen legyen ábrázolva Hány helyen ábrázoljunk egy számjegyet, az eddigiektől eltérően kettőspont helyett vesszővel tagolva adjuk meg: Console.WriteLine("Érték: {0,10}", 85); Console.WriteLine("Érték: {0,-10}", 85);

// " // "85

85" "

Ha szeretnénk a már ismertetett például vezető nullákat is, akkor azt következő formában tehetjük meg: Kombinálva a vezető nullákkal: Console.WriteLine("Érték: {0,10:00000}", 85); // " 00085" Console.WriteLine("Érték: {0,-10:00000}", 85); // "00085 " A megjegyzésben a kiíratás formátumát látjuk. Vegyük észre, hogy a -10 alakban a ”-„ azt jelenti a számot balra igazítjuk.

http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

19/63

A C# nyelv

Alternatív ábrázolás Megadhatjuk külön a pozitív értékek, külön a negatív értékek és a nullák formátumát: Console.WriteLine("{0:#;minusz #}", 85); // "85" Console.WriteLine("{0:#;minusz #}", -85); // "minusz 85" Console.WriteLine("{0:#;minusz #;nulla}", ); // "nulla" Az számok helyett szöveg is megjeleníthető.

Szokásos formátumok Ezredesenkénti csoportosítás: Console.WriteLine("{0:+### ### ### ###}", 123456789123); 789 123"

// "+123 456

Telefonszám lehetséges alakja: Console.WriteLine("{0:##-####-#####}", 1234567891); "12-3456-7891"

//

Tizedes jegyek ábrázolása Console.WriteLine("{0:#.##}", 55.3242);

// "55.32"

Például két tizedesjegy ábrázolása

Globalizálás globalizal.cs using System; using System.Globalization; class Program { static void Main() { CultureInfo nezet = CultureInfo.GetCultureInfo("eu-ES"); Console.WriteLine(string.Format(nemzet, "{0:c}", 85)); Console.ReadKey(); }


Last update: 2015/10/22 08:26


}

Használható nemzetnevek: eu-ES en-US en-GB fr-FR hu-HU stb. Nyelv és nyelvterület

Gyakorlat 1. Adott a 0,052134334 literális állandó 1. Írassa ki 20 helyen, jelezve az előjelt. 2. Az alábbi feladatot egyetlen kiírató utasítással oldja meg: 1. van három változónk: max, min, atlag 2. írassuk ki tabulátorral tagolva a min, atlag, max változók értékét 3. a változók tabulátorral tagolva egyetlen sorban jelenjenek meg 4. Mind a három változó 10 helyen legyen ábrázolva, 5 tizedejegy pontossággal.

Math osztály A Math egy matematikai osztály, amely statikus állandókat (konstansokat) és függvényeket (metódusokat) tartalmaz. A függvények trigonometriai, logaritmikus és általánosak. Nem kell példányosítani, azonnal használható.

Abs() Math.Abs(x); X értékének abszolút értékét adja.

PI A PI nem metódus, helyette egy mező. Mező, mert nem csinál semmit csak egy értéket szolgáltat. Math.PI A pi értékét tudjuk kiolvasni ebből a mezőből.

http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

21/63

A C# nyelv

Sin() eredmeny = Math.Sin(x); Az x érték szinuszát adja vissza. Az x radiánban értendő. Ha szöget kell szinuszra váltanunk, akkor át kell azt számoljuk radiánba. Például: radian = szog * Math.PI / 180; eredmeny = Math.Sin(radian);

Cos() eredmeny = Math.Cos(x); Az x érték koszinuszát adja vissza az erdmeny változóban. Az x radiánban értendő.

Tan() Egy szám tangensét adja vissza. eredmeny = Math.Tan(x); Az x érték tangensét adja vissza az eredmeny változóban. Az x radiánban értendő.

Sqrt() Gyökvonás: eredmeny = Math.Sqrt(9); Az eredmeny változóban 3 lesz.

Pow() Hatványozás: eredmeny = Math.Pow(3,2); A három második hatványát adja vissza.

Round() A legközelebbi egészre kerekít. SzitWiki - http://szit.hu/

Last update: 2015/10/22 08:26


Console.WriteLine(Math.Round(3.4));

// "3"


// "4"


// "4"


// "3,124"

Min() Két szám közül a kisebbel tér vissza. Console.WriteLine(Math.Min(3,8)); // "3"

Max() Két szám közül a nagyobbal tér vissza Console.WriteLine(Math.Max(3,8)); // "8"

Truncate() A szám egész részével tér vissza. Console.WriteLine(Math.Truncate(3.12345)); //"3"

Ceiling() Kerekítés felfelé Console.WriteLine(Math.Ceiling(3.1)); //"4"

Floor() Lefele kerekít. Console.WriteLine(Math.Floor(3.9)); //"3"

BigMul() Két nagy szám összeszorzása

http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

23/63

A C# nyelv

int int1 = Int32.MaxValue; int int2 = Int32.MaxValue; long longResult; longResult = Math.BigMul(int1, int2); Console.WriteLine("Számítás két Int32 értékkel:"); Console.WriteLine("{0} * {1} = {2}", int1, int2, longResult); Kimenet: Számítás két Int32 értékkel: 2147483647 * 2147483647 = 4611686014132420609

Log() Egy szám logaritmusával tér vissza Általánosan: Log(Double) A bemenő paraméter egy valós szám. Console.WriteLine(Math.Log(3.5));

// "1,25276296849537"

Egy szám adott alapú logaritmusa Általánosan: Log(Double,Double) A bemenő paraméter két valós szám. Az első számnak a második számon alapuló logaritmusa. Console.WriteLine(Math.Log(3.5,1.2));

// "1,25276296849537"

Sign() Egy szám előjelét adja vissza: Console.WriteLine(Math.Sign()); // "0" Console.WriteLine(Math.Sign(3)); // "1" Console.WriteLine(Math.Sign(-3)); // "-1"

Gyakorlat 1. Írjon programot, amely kiírja 130º koszinuszát. 2. Írjon programot, amely kiírja 30º szinuszát. SzitWiki - http://szit.hu/

Last update: 2015/10/22 08:26


3. Írjon programot, amely megszorozza pi értékét 150-el, az eredményt írassa ki. 4. Írjon programot, amely kiszámítja 235 a 46-dik hatványon értéket, majd az eredményt a képernyőre írja. 5. Írjon programot, amely 529424-nek kiírja a gyökét. 6. Szükséges-e a Math osztály használatához a példányosítás?

Idő lekérdezése Idő egyszerűen using System; class Program { static void Main() { Console.WriteLine(DateTime.Now); } } string ido = DateTime.Now.ToString(); using System; class Program { static void Main() { string datum = DateTime.Now.ToString(); Console.WriteLine(datum); } }

Idő formázva Program.cs using System; class Program { static void Main() { DateTime AktIdo = DateTime.Now; Console.WriteLine("d = {0:d}", AktIdo); Console.WriteLine("D = {0:D}", AktIdo); http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

25/63

Console.WriteLine("f = {0:f}", AktIdo); Console.WriteLine("F = {0:F}", AktIdo); Console.WriteLine("g = {0:g}", AktIdo); Console.WriteLine("G = {0:G}", AktIdo); Console.WriteLine("M = {0:M}", AktIdo); Console.WriteLine("R = {0:R}", AktIdo); Console.WriteLine("s = {0:s}", AktIdo); Console.WriteLine("t = {0:t}", AktIdo); Console.WriteLine("T = {0:T}", AktIdo); Console.WriteLine("u = {0:u}", AktIdo); Console.WriteLine("U = {0:U}", AktIdo); Console.WriteLine("Y = {0:Y}", AktIdo); Console.WriteLine(); Console.WriteLine("Hónap: {0}", AktIdo.Month); Console.WriteLine("A hét napja: {0}", AktIdo.DayOfWeek); Console.WriteLine("A nap ideje: {0}", AktIdo.TimeOfDay); } }

Formázás karaktersorozattal Program.cs using System; class Program { static void Main() { DateTime AktIdo = DateTime.Now; string format = "yyyy.MM.dd HH:mm"; Console.WriteLine(AktIdo.ToString(format)); } }

ToLongTimeString() és ToLongDateString() metódus Program.cs using System; class Program { public static void Main() { SzitWiki - http://szit.hu/

A C# nyelv

Last update: 2015/10/22 08:26


Console.WriteLine(DateTime.Now.ToLongTimeString() + "," + DateTime.Now.ToLongDateString()); } }

Véletlen szám generálás Egész számok Véletlen szám generálására System névtérben lévő Random osztályt használhatjuk. Példányosítása kötelező, azaz ebben a formában kell objektumot generálni: Random random = new Random(); A fenti példában a random nevű objektumot generáltuk, amelynek metódusai képesek egész és valós véletlen számok előállítására. Random veletlen = new Random(); int a = veletlen.Next(5,8); 5 és 7 között generál egy számot. Értéke 5,6 vagy 7. A Next metódus három alakja: Next() Next(Int32) Next(Int32, Int32)

Valós szám Program.cs using System; class Program { public static void Main() { Random random = new Random(); double a = random.NextDouble(); Console.WriteLine(a); } }

http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

27/63

A C# nyelv

Byte-ok A NextBytes() metódus segítségével egy byte tömböt képesek vagyunk egyetlen mozdulattal feltölteni véletlen számokkal. Program.cs using System; class Program { public static void Main() { Random random = new Random(); byte[] tomb = new byte[10]; random.NextBytes(tomb); for(int i=; i<10; i++) Console.Write(tomb[i] + " "); } }

Gyakorlat 1. Szükséges-e a Random osztály példányosítása 2. Írassa ki a 6-os Lottó nyerőszámait, 6 darab véletlen számból, egymás mellé, kettőspontokkal tagolva.

Konverzió Kasztolás int a = 12345678; long b = a; int c = (int) b; //explicit konverzió Az utolsó esetben szükség van a (int) explicit konverzióra, mert c változó kisebb mint a b. Így ha túlcsordulás történik a fordító dob egy kivételt.

Convert osztály A System névtérben találunk egy Convert nevű osztályt, amelynek metódusai a különböző típusokba való konvertálást megoldják. SzitWiki - http://szit.hu/

Last update: 2015/10/22 08:26


using System; class Program { static void Main() { String s = 4; int a = Convert.ToInt32(s); } } A példában a beolvasott érték karaktersorozat, amit átalakítunk egész típusúvá. További lehetőségek Convert.ToInt32() Convert.ToInt64() Convert.ToSingle() Convert.ToDouble() Convert.ToString() Convert.ToChar()

//egészt ad vissza //64-bites egészet ad vissza //float-ot ad vissza //double-t ad vissza //Stringet ad vissza //Karaktertípust ad vissza

A számrendszer alapja is megadható, például a ToInt32() metódus esetén: string str = "a"; Convert.ToInt32(str, 16); Egy 16-os számrendszerbeli szám konvertálása 10-es számrendszerbe.

Adatbekérés Stringek beolvasása Console osztály ReadLine() metódusa egy karaktersorozatot olvas be a billentyűzetről. A karaktersorozatnak akkor van vége, ha „Enter”-t nyomtunk. Adatbekérés a konzolról: prog.cs using System; class Prog { static void Main() { string s; Console.Write("Neved: "); http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

29/63

A C# nyelv

s = Console.ReadLine(); Console.WriteLine("Ezt írtad: " + s); } }

A programban deklaráltunk egy s változót. Viszont fentebb már említettük, hogy a „string” valójában nem típus, hanem osztály. Az „s” egy olyan objektum, amit nem kell példányosítani a new kulcsszóval. Később látni fogjuk, hogy az „s” objektumnak vannak metódusai, amiket használhatunk. Az alábbi utasítás: s = Console.ReadLine(); egy tehát a beolvasott karaktersorozatot az s változóban fogja eltárolni. Az s változó pedig string típussal deklaráltuk.

Számértékek beolvasása Nincs külön számértéket beolvasó függvény. A számértékeket először karaktersorozatként olvassuk be, majd átkonvertáljuk azokat számmá. A konvertálás a Convert osztállyal végezzük. Egész számok Az alábbiakban három módszer látunk a karaktersorozat egész számmá konvertálására: using System; class Program { static void Main() { int a; a = Convert.ToInt32(Console.ReadLine()); } } using System; class Program { static void Main() { int a; a = int.Parse(Console.ReadLine()); } } using System; class Program SzitWiki - http://szit.hu/

Last update: 2015/10/22 08:26


{ static void Main() { int a; a = Int32.Parse(Console.ReadLine()); } } Valós számok using System; class Program { static void Main() { double a, b; a = Double.Parse(Console.ReadLine()); b = Convert.ToDouble(Console.ReadLine()); } }

Gyakorlat 1. 2. 3. 4. 5. 6.

Milyen metódussal kérhetünk be számokat? A metódus amellyel értékeket kérünk be, milyen osztályhoz tartozik. Az osztály amelynek egy metódusát használtuk ebben a fejezetben, melyik névtérben van? Milyen osztály használható stringek számokká konvertálására? Írjon programot, amely bekér két számot, majd kiírja a szorzatukat. Írjon programot, amely bekér két számot, majd az elsőt elosztja a másodikkal, a képernyőre írja az eredményt.

Szekvenciális tevékenység, hatáskör Szekvenciális tevékenység Azok az utasítások, amelyeket egymásután sorba hajtunk végre alkotják a szekvenciális tevékenységeket. Később látni fogjuk, hogy lesz olyan amikor egy utasítást nem biztos, hogy végre szeretnénk hajtani, esetleg csak akkor szeretnénk végrehajtani, ha teljesül valami feltétel. Esetleg egy utasítást többször is szeretnénk végrehajtani, de ha ezen ismétlések száma száz, nem szeretnénk azt százszor leírni.

http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

31/63

A C# nyelv

Változók hatásköre Az eddigi példákban az egyes változókat is a metódusokban hoztuk létre. Néha azonban előfordul, hogy olyan változókat szeretnénk használni amelyhez több metódus is hozzáfér. A változót ilyenkor a metóduson kívül, de az osztályon belül hozzuk létre. Az ilyen változókat mindig a metódusok előtt szoktuk létrehozni az osztály mezőinek nevezzük. Az alábbi példaprogramban létrehozunk például egy „s” nevű mezőt: prog.cs using System; class Prog { static string s; static void Main() { Console.Write("Neved: "); s = Console.ReadLine(); Console.WriteLine("Ezt írtad: " + s); } }

Szelekciós tevékenység Bizonyos esetekben nem szeretnénk, ha minden utasítás végrehajtódna. Csak a kiválasztott utasítások hajtódnak ilyenkor végre. Az utasítás végrehajtását, tehát feltételhez kötjük. A feltétel valójában egy állítás. Az utasításokat pedig akkor hajtjuk végre, ha az állítás igaz. Az állítás mindig valamilyen logikai kifejezés. Például állíthatom azt, hogy: a > 3 Az a változó tartalma nagyobb mint 3. Vagy: a > b Az a változó tartalma nagyobb mint b változóé, stb.

if A szelekcióra az if utasítást használjuk a C# nyelvben. Az alábbiakban az if utasítás általános formáját látjuk: SzitWiki - http://szit.hu/

Last update: 2015/10/22 08:26


if (feltétel) tevékenység; Láthatjuk, hogy az if után zárójelben adjuk meg a feltételt. Fontos, hogy a feltétel után ne zárjuk le a pontosvesszővel az if utasítást. A feltételt követi az utasítás, amelyet végre kell hajtani. Vegyük észre, hogy a példában csak egyetlen utasítás szerepel. Ha a feltétel teljesül az utasítás végrehajtódik. A következőkben általános formában azt látjuk, hogyan lehet megadni, ha a feltétel nem teljesül, akkor mi is történjen. if {feltétel) tevékenység; else tevékenység2; Az else után írt utasítás akkor kerül végrehajtásra, ha a feltétel nem igaz. A következő példák az általános forma helyett már egy konkrét C# megvalósítást mutatnak be. Ha feltétel igaz, akkor teszünk valamit. Ha hamis akkor mást. boole bináris = true; if (bináris == true) { Console.WriteLine("igaz"); } Két elágazásra példa if (bináris == true) { Console.WriteLine("igaz"); } else if (szám > 10) { Console.WriteLine("nagy"); } Többágú elágazást hozhatunk létre, ha az else után ismét egy if utasítást írunk egy újabb feltétellel. Szokás „else if” utasításnak is hívni. Három elágazásra példa: if (bináris == true) { Console.WriteLine("igaz"); } else if (szám > 10) { Console.WriteLine("nagy"); http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

33/63

A C# nyelv

} else { Console.WriteLine("egyébként"); } Az else if esetén kiveszem az else részt akkor az if-től egy önálló if blokk következik. A ”{„ blokk nyitó karakter és ”}„ blokk záró karakterek nem kötelezőek, ha csak egyetlen utasítás szerepel a blokkban. Adott például két szám (3 és 5)

switch A switchet többágú szelekcióra találták ki, de ssak egyszerű változókat fogad el a vizsgálathoz. Legyen például egy „szam” nevű változó, amelynek tartalma alapján különböző szövegeket szeretnénk a képernyőre íratni: int szam = 3; switch(szam) { case 1: Console.WriteLine("Egy"); break; case 2: Console.WriteLine("Kettő"); break; case 3: goto case 2; default: Console.WriteLine("Egyik sem"); break; } Ha a „szam” tartalma 1, akkor az „Egy” szöveget írjuk ki, ha 2, akkor „Kettő”, stb. Ha egyik érték sem volt, akkor az „Egyik sem” szavakat írjuk ki.

Iteráció Az iteráció más néven ciklus vagy ismétlés. Valamilyen tevékenység ismételt végrehajtása. A ciklusoknak két fajtájáról szoktunk beszélni. Ezek: növekményes amíg ciklus A növekményes ciklus esetén mindig tudjuk hányszor kell ismételnünk, de legalábbis valamiből ez előre kiderül. Az „amíg” típusú ciklusok esetén nem tudjuk meddig kell mennünk, mert az vagy a SzitWiki - http://szit.hu/

Last update: 2015/10/22 08:26


felhasználótól, vagy egy adatsorozat hosszától, vagy más külső tényezőtől függ, amit előre nem ismerünk.

for A legáltalánosabb ciklus utasítás a for. Alapvetően növekményes ciklusok létrehozására találták ki, de a C# nyelvben és minden C alapú nyelvben használhatjuk „amíg” típusú ciklus megvalósítására is. for (kezdő_érték; feltétel; növekmény) utasítás; A ciklus fejrésze három részre osztható. A három részt egymástól pontosvesszővel választjuk el. Növekményes ciklusoknál mindig használunk egy ciklusváltozót, amelyben számoljuk, hogy éppen hol járunk a ciklusban. Az fejrész első paramétere ennek a ciklusváltozónak a kezdőértéke. A második a feltétel, azaz meddig menjen a ciklus. A harmadik pedig megmondja számunkra, hogyan növeljük a ciklusváltozót. Egyesével, kettesével vagy más növekményben. A ciklus során végrehajtandó utasításokat nevezzük a ciklus törzsének. Ha egyetlen utasításunk van a ciklus törzsben akkor nem kötelező blokk nyitó és blokk záró kapcsoszárójeleket elhelyeznünk. Több utasítás esetén azonban ez kötelező. Ezzel jelezzük, hogy mely utasítások tartoznak a ciklus törzséhez. for (kezdő_érték; feltétel; növekmény) { utasítás1; utasítás2; ... utasításn; } Egy konkrét példa, amelyben a ciklus változó tartalmát kiíratjuk. A ciklus 0-tól – 9-ig írja a számokat a képernyőre. for ( int i = ; i < 10; i++) { Console.WriteLine(i); }

while A while ciklust alapvetően „amíg” típusú ciklusok létrehozására találták ki, de létrehozható vele növekményes ciklus is. A while ciklus addig ismétlődik, amíg a kifejezés értéke igaz while(kifejezés) { utasítás; http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

35/63

A C# nyelv

} Egy végtelen ciklus: while(true) { }

do while A do while ciklus megegyezik a while ciklussal azzal a különbséggel, hogy hátultesztelő. Ez azt jelenti, hogy a ciklus törzse egyszer mindenképpen végrehajtódik, és csak az után vizsgáljuk meg, hogy a következő ciklus is végrehajtható-e. int i = 1; do { Console.WriteLine("Egyik sem"); i++; }while (i < 10); Vegyük észre, hogy az utolsó sorban le kell zárni a ciklust pontosvesszővel.

foreach A foreach utasítással olyan ciklusokat tudunk létrehozni, amelyek egy lista vagy tömb elemeit bejárják, azaz végig veszik. Lista létrehozása és végigjárása List lista = new List(); lista.Add(15); lista.Add(10); lista.Add(20); lista.Add(42); lista.Add(30); foreach(int i in lista) { Console.WriteLine(i); } A példában a lista elemei egész számok. Az int változót a foreach fejrészében deklaráljuk „int i”, ebben kapjuk vissza az aktuális számot. Az i változót kötelező a foreach fejrészében deklarálnunk! A következő forma helytelen:


Last update: 2015/10/22 08:26


foreach(i in lista) ... Szöveges tömb létrehozása és bejárása string[] tömb = new string[3]; tömb[] = "Máté"; tömb[1] = "Márk"; tömb[2] = "Lukács"; foreach(string str in tömb) { Console.WriteLine(str); }

Sztringek A Sztringekről A sztring adattípus az egyik nagyon fontos adattípus. Elméletileg több milliárd hosszú lehet a mérete, de az operációs rendszer is határt szab számára. A „string” vagy „String” típusként deklaráljuk, az UTF-16 kódolással tárolt karaktereket. A sztringek nem módosíthatók. Módosulás helyett egy új példány jön létre. A string egyik tulajdonsága a Length, amely a szöveg hosszát tartalmazza. Készítsünk egy programot, amelyben a egy s nevű változót deklarálunk, majd kiíratjuk annak hosszát: string s = "Alma"; Console.WriteLine(s.Length); Az s objektumnak lesz egy Length értéke, amelyet lekérdezhetünk. A példában kiíratjuk az eredményt. A „String” osztály használata: String s = "Alma"; Console.WriteLine(s.Length);

Metódusok Concat Az első dolog, amit általában szeretnénk egy sztringgel, összefűzni másik sztringgel. Sztringek összefűzésének művelete a konkatenálás.

http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

37/63

A C# nyelv

Tulajdonképpen ezt csináljuk akkor is, amikor egy sztring változóhoz sztring literális konstanst fűzök: string jarmu = "Opel"; Console.WriteLine("Az " + jarmu + " jó kocsi"); Összefűzés + karakterrel, másik példa: string s1 = "egyik"; string s2 = "másik"; Console.WriteLine(s1 + s2); Az összefűzésre a ”+„ operátort használjuk. Az összefűzésre persze van külön metódus is, amelynek a neve Concat(). string s = "alma"; string s2 = "valami"; Console.WriteLine(String.Concat(s, s2)); Összefűzés A kiíratás helyett eltárolhatjuk: string s3 = String.Concat(s, s2); Compare A következő művelet az összehasonlítás. Az összehasonlítás az ”==„ operátorral nem ajánlott, helyette használjuk az alábbi metódusok valamelyikét. A Compare() metódus, egy 0-át ad vissza, ha egyezik a két összehasonlított sztring, -1-et ha nem egyezik. string s1 = "Alma"; string s2 = "Alba"; Console.WriteLine(String.Compare(s1, s2)); Console.WriteLine(String.Compare(s, "Abba")); Console.WriteLine(String.Compare(s, null)); CompareTo string s1 = "Alma"; string s2 = "Alba"; Console.WriteLine(s1.CompareTo(s2));


Last update: 2015/10/22 08:26


CompareOrdinal string s1 = "alma"; string s2 = "Alma"; Console.WriteLine(String.CompareOrdinal(s, s2)); A két betű különbségét adja. Equal s = "alma"; s2 = "valami"; Console.WriteLine(s.Equals("alma")); Console.WriteLine(String.Equals(s, s2)); Egyenlőség vizsgálata Join System.String.Format(”{0} szorzat {1} = {2}„, a, b, (a * b)); Szövegre értelmezhető műveletek + = != == Contains Egy adott szöveg szerepel-e a sztringünkben string s = "megbízható"; bool tartalmaz = s.Contains("bíza"); Console.WriteLine("Hossz: {0}", tartalmaz); IndexOf Egy adott karakter szerepel-e a sztringünkben string s = "megbízmhatóm"; int hol = s.IndexOf('m'); Console.WriteLine("Hossz: {0}", hol);

http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

39/63

A C# nyelv

Remove A 4-es indextől törlés a végéig string s = "megbízható"; string s2 = s.Remove(4); Console.WriteLine("Hossz: {0}", s2); A 4-es indextől két karakter törlése string s = "megbízható"; string s2 = s.Remove(4, 2); Console.WriteLine("Hossz: {0}", s2); Insert Az Insert() metódussal beszúrhatunk egy szöveget egy String típusú objektumba. mondat2 = mondat.Insert(8, "Kossuth"); A példában a mondat nevű változóhoz fűzzük a „Kossuth” szót, majd eltároljuk a mondat2-ben. ToLower és ToUpper Kis vagy nagybetűvé alakítás string s = "MEGbízható"; string s2 = s.ToLower(); string s3 = s.ToUpper(); Console.WriteLine("Hossz: {0}", s2); Console.WriteLine("Hossz: {0}", s3);

String típusra néhány példa Program1.cs using System; using System.Text; class Program { static void Main() SzitWiki - http://szit.hu/

Last update: 2015/10/22 08:26


{ string s; s = "Valami"; Console.WriteLine(s); Console.WriteLine(s.Substring(2,2)); Console.WriteLine(s.Replace("al","ág")); } }

Program2.cs using System; class str { public static void Main() { Console.WriteLine("Szövegkezelés Java nyelven"); string szoveg = "alma"; Console.WriteLine(szoveg.Equals("almaa")); // true értéket ad vissza, ha egyezik, vagy false Console.WriteLine(szoveg.CompareTo("alma")); // 0-át kapunk, ha egyezik Console.WriteLine(szoveg.IndexOf("alma")); // -1 ha nem található; hanyadik helytől (első index 0) //Szöveg darabolása string sor ="alma:körte:barack:szilva"; string[] tomb = sor.Split(':'); Console.WriteLine(tomb[1]); string mondat = "Ha megint ezért üzen"; Console.WriteLine(mondat.Substring(4)); //Kezdő indextől szeretném a karaktereket Console.WriteLine(mondat.Substring(4, 7)); //Kezdő index és hány darab karakter } }

Tartalmaz-e egy szöveget egy karaktersorozat változó: if(mondat.ToLower().IndexOf("alma")>= ) Console.WriteLine("Tartalmazza az alma szót"); Kisbetűssé alakítás:

http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

41/63

A C# nyelv

string kisbetus = vegyebetus.ToLower();

Módosítható szöveg A szimpla String típusként létrehozott karaktersorozatok valójában nem módosíthatók, mint azt fentebb már tárgyaltuk. A StringBuilder osztállyal módosítható szöveget hozhatunk létre. A StringBuilder osztály a System.Text névtérben található: using System.Text; A használat előtt a new operátorral helyet foglalunk az objektumnak: StringBuilder s = new StringBuilder; A StringBuilder típusú változót egyes részeit például kicserélhetem. A példakedvéért szeretnénk az ékezetes „á” karakteretek egy ékezet nélküli „a” karakterre cserélni. Ekkor ezt írhatom: StringBuilder s = new StringBuilder(); s.Append("almá"); if (s[3] == 'á') s[3] = 'a'; Ezt a műveletet szimpla String típussal nem tehetem meg. A példában láttuk, hogy az „s” StringBuilder változóhoz egy Append() metódussal tudunk egy szimpla karaktersorozat literált, de akár egy változót is hozzáfűzni. Vegyük észre, hogy megoldottuk a String típus StringBuilder típussá konvertálását. Visszafele a ToString() metódussal történik a konverzió: StringBuilder s = new StringBuilder(); s.Append("szilva"); string s2 = s.ToString(); A StringBuilder típusú változókhoz sortörés fűzhető az AppendLine() metódussal: StringBuilder s = new StringBuilder(); s.Append("szilva"); s.AppendLine(); s.Append("Körte"); A sortörés egyetlen mozdulattal is megtehető: StringBuilder s = new StringBuilder(); s.Append("szilva").AppendLine(); Beszúrás StringBuilder s = new StringBuilder(); SzitWiki - http://szit.hu/

Last update: 2015/10/22 08:26


s.Append("Szilvi"); s.Insert(4,"a");

Rendezés Program01.cs using System; class Program { static void Main() { String[] t = {"Szilva", "Körte", "Barack", "Alma"}; Array.Sort(t); foreach(String s in t) Console.WriteLine(s); } }

A stringek kezelése tömbként Hivatkozás egy karakterre A karaktersorozatok minden elemére hivatkozhatunk. Így bármely karaktert elérhetjük a sorozatból. Az első karakter indexe 0-val kezdődik, mint a tömböknél.

Példa Program.cs using System; class tomb { public static void Main() { Console.WriteLine("Szó"); string szo = Convert.ToString(Console.ReadLine()); Console.WriteLine("A beírt szó első betűje: {0}\n\n", szo[]); } http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

43/63

}

Tömbök Egy dimenziós tömbök Vektor: 375286 Számokat tárolunk. Minden számnak adunk egy indexet: [0] [1] [2] [3] [4] [5] 3 7 5 2 8 6 int[] tomb; //Deklaráljuk a tömböt tomb = new int[3]; //Helyet foglalunk a tömbnek tomb[] = 5; //Az első elemnek értéket adunk tomb[1] = 9; //A második elemnek értéket adunk tomb[2] = 8; //A harmadik elemnek értéket adunk A fentiek egy egész számokat tárolni képes tömböt mutat be. Néhány lehetséges tömbtípus: int[] double[] float[] string[] char[] short[] long[] ulong[] sbyte[] byte[] uint[] bool[] A tömbök méretét lekérdezhetjük a Length tulajdonsággal: meret = tomb.Length;

Alternatív megadás A var kulcsszóval is bevezethető a változónév: SzitWiki - http://szit.hu/

A C# nyelv

Last update: 2015/10/22 08:26


var tomb = new int[3]; Egy három elemet tartalmazó tömböt deklaráltunk.

Tömb kezdőértéke int[] tomb = {3, 4, 7}; double[] szam = { 3.5, 3.6}; vagy double[] szam = new double[2]

{ 3.5, 3.6};

vagy double[] szam = new double[]

{ 3.5, 3.6};

int[] tomb1 = Enumerable.Range(5,5).ToArray(); int[] tomb2 = Enumerable.Repeat(, 5).ToArray();

Tömb átméretezése A tömbök átméretezhetők az Array.Resize() utasítással: Program.cs using System; class Program { static void Main() { char[] tomb = new char[4]; tomb[] = 'P'; tomb[1] = 'e'; tomb[2] = 'r'; tomb[3] = 'l'; Console.WriteLine(tomb[2]); Array.Resize(ref tomb, 2); } }

http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

45/63

A C# nyelv

Mátrix 2×2 tömb tömb deklarálása: int[,] tomb = new int[3,3]; Egy értékadás: tomb[2,2] = 3; Program.cs class Program { static void Main() { int[,] tomb = new int[,]{ {3,4,5}, {6,3,2}, {8,2,7} }; } }

Mátrix átméretezése Program.cs using System; class Program { static private void ResizeIntArray(ref int[,] original, int cols, int rows) { int[,] newArray = new int[rows, cols]; Array.Copy(original, newArray, original.Length); original = newArray; } static void Main() { int[,] szamok = new int[3,3]; ResizeIntArray(ref szamok,5,10); }


Last update: 2015/10/22 08:26


}

készítünk egy 2 dimenziós tömböt int[,] newArray = new int[rows, cols]; átmásoljuk az előző tömb tartalmát Array.Copy(original, newArray, original.Length); az eredeti tömbnek átadom az új tömböt. original = newArray;

Több dimenziós tömbök Kettőnél több dimenziós tömbök is használhatók. int[,,] tomb = new int[3,3,3]; tomb[2,2,2] = 3; int[,,,] tomb = new int[3,3,3,3]; tomb[2,2,2,2] = 3; Egy három és egy négy dimenziós tömb: Program.cs using System; class Program { public static void Main() {

//Három dimenzós tömb kezdőértéke int[,,] tomb = new int[,,] { {{1, 2, 3}}, {{4, 5, 6}} };

//Négy dimenzió tömb kezdőértéke int[,,,] tomb4 = new int[,,,] { {{{1, 2, 3, 5}}}, {{{4, 5, 6, 7}}} }; http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

47/63

A C# nyelv

//~ tomb[0, 0, 0] = 3; Console.WriteLine(tomb[1,,]); Console.WriteLine(tomb4[1,,,]); } }

Tömb paraméterként Program.cs using System; class Program { public static void Main() { int[] tomb = {35, 45, 63, 77}; kiir(tomb); } static void kiir(int[] t) { for(int i=; i
Tömben tömb Angolosan: Jagged Array (Array-of-Arrays) Program.cs using System; class Program { public static void Main() { //Tömben tömb vagy egyenletlen tömb (minden sor más elemszámot tartalmazhat int[][] tomb = new int[2][]; tomb[] = new int[3]; tomb[1] = new int[3]; SzitWiki - http://szit.hu/

Last update: 2015/10/22 08:26


tomb[][] = 3; tomb[][1] = 5; tomb[][2] = 8; tomb[1][] = 15; tomb[1][1] = 123; tomb[1][2] = 2; Console.WriteLine(tomb[][1]); } }

Tömbben tömb kezdőértékkel Program.cs using System; class Program { public static void Main() { //Tömben tömb vagy egyenletlen tömb (minden sor más elemszámot tartalmazhat int[][] tomb = new int[2][]; tomb[] = new int[3] {2, 5, 3}; tomb[1] = new int[3] {8, 4, 9}; Console.WriteLine(tomb[][1]); } }

Lista A List osztály a System.Collections.Generic névtérben található, különféle elemeket tárolhatunk benne. Hogy milyen típust szeretnénk benne tárolni meg kell adnunk a deklaráció során kisebb mint és nagyobb mint jelek között. Program01.cs using System; using System.Collections.Generic; class Program01 http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

49/63

A C# nyelv

{ static void Main() { List lista = new List(); lista.Add(35); lista.Add(45); lista.Add(29); Console.WriteLine(lista[]); Console.WriteLine(lista.Count); lista.Clear(); Console.WriteLine(lista.Count); } }

Struktúrák A struktúrák a C nyelvből származnak, de ilyen szerkezet található a Pascal nyelvben, csak ott rekordnak hívják. A struktúrák használatának célja, hogy különböző típusú adatokat tudjunk tárolni. Csak gondoljunk bele, mit tárolhatunk egy tömbbe?! Több azonos típusú adatot. A struktúrában ugyanígy több adat tárolható, de ezek típusa eltérhet egymástól. A C# struktúrái egy kicsit többek a C nyelvben kitalált eredeti verziótól. A struktúrák ugyanis hasonlóan működnek az osztályokhoz. Vagyis nem csak változókat deklarálhatunk bennünk, hanem metódusokat is, amelyek valamilyen műveletet végeznek a változókon. A C# struktúra típusként viselkedik, vagyis egy változót kell vele deklarálnunk a használatához. Az egyes tagokat úgy érjük el, hogy ponttal tagolva leírom a változónév után a struktúrában található változó nevét. Az alábbiakban egy egyszerű példát látunk a használatukra. A struktúrában követelmény, hogy nem hozható létre metóduson belül.

Első példa Program.cs class Program { struct Egyszeru { public int Pozicio; public bool Kesz; public double UtolsoErtek; }; SzitWiki - http://szit.hu/

Last update: 2015/10/22 08:26


static void Main() { Egyszeru s; s.Pozicio = 1; s.Kesz = false; s.UtolsoErtek = 5.5; } }

A példában egy „Egyszeru” nevű struktúrát hozunk létre, amelynek változóit a Main() metódusban értékekkel töltjük fel. Vegyük észre, hogy a struktúrát a az osztályon belül hoztuk létre. A következőkben egy olyan példát látunk, ahol a struktúrát az osztályon kívül hozzuk létre.

Második példa Program.cs using System; struct TEgyszeru { public String nev; public int kor; public long fizetes; } class Program { static void Main() { Console.WriteLine("Hi"); TEgyszeru dolgozo; dolgozo.nev = "Kis János"; dolgozo.kor = 35; dolgozo.fizetes = 370000; Console.ReadKey(); } }

http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

51/63

A C# nyelv

Metódusok Több metódus Eddig egyetlen metódust használtunk, melynek neve a „Main”. Ebbe írtuk utasításainkat. Ha sok egymással összefüggő utasításunk van, akkor azokat metódusokba rendezzük, adunk neki egy nevet. Az utasítást csoportot ezek után a metódus nevének plusz zárójeles rész leírásával hívjuk. Például legyen egy utasítás halmaz amely egy névjegyet ír ki: Program.cs using System; class Program { static void Main() { Console.WriteLine("Nagy József"); Console.WriteLine("1142 Budapest"); Console.WriteLine("Nyár u. 3."); Console.WriteLine("Tel.: +36(1)2345-123"); Console.WriteLine("Fax.: +36(1)2345-124"); } }

Az utasításokat metódusba teszem, melynek neve: „Nevjegy” static void Nevjegy() { Console.WriteLine("Nagy József"); Console.WriteLine("1142 Budapest"); Console.WriteLine("Nyár u. 3."); Console.WriteLine("Tel.: +36(1)2345-123"); Console.WriteLine("Fax.: +36(1)2345-124"); } A Nevjegy metódust így hívom a Main() metóduban: Nevjegy(); Az egész program ezek után: Program.cs using System; class Program { static void Nevjegy() SzitWiki - http://szit.hu/

Last update: 2015/10/22 08:26


{ Console.WriteLine("Nagy József"); Console.WriteLine("1142 Budapest"); Console.WriteLine("Nyár u. 3."); Console.WriteLine("Tel.: +36(1)2345-123"); Console.WriteLine("Fax.: +36(1)2345-124"); } static void Main() { Nevjegy(); } }

A következőkben egy olyan metódust alkotunk amely összead két számot, majd kiírja a képernyőre: Program.cs using System; class Program { static void Osszead() { int eredmeny = 3 + 5; Console.WriteLine(eredmeny); } static void Main() { Osszead(); } }

A metódus 3-hoz 5-öt ad. Az eredményt pedig rögtön a képernyőre írja. Tegyük fel, hogy én most nem 5-öt, hanem valamilyen más számot szeretnék hozzáadni. Egy objektumon vagy osztályon végrehajtható eljárás. Két fajta metódus van, a statikus és a példány.

Statikus metódus A statikus metódust az osztályon hívjuk meg és nem annak egy példányán. Program.cs class Program { static void Kiir() http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

53/63

A C# nyelv

{ System.Console.WriteLine("A metódus meghívása"); } static void Main() { Program.Kiir(); Kiir(); // Mivel osztályon belül vagyunk nem kötelező annak nevét megadni. } }

A fentikben azt írtuk, hogy az osztályon hívjuk meg a statikus metódust: Program.Kiir(); A példában viszont azt látjuk, hogy meghívható az osztály neve nélkül is, mivel osztályon belül vagyunk. Kiir();

Példánymetódus Az osztály egy példányán hívjuk meg. Program.cs class Program { void Kiir() { System.Console.WriteLine("A metódus meghívása"); } static void Main() { Program p = new Program(); p.Kiir(); } }

Az Program osztálynak létrehozzuk egy külön példányát. A példában ez a „p”. A p egy olyan objektum, amely a Program osztályból lett származtatva.


Last update: 2015/10/22 08:26


Fájlkezelés Eddig az adatokat bekértük a felhasználótól, tároltuk azokat a memóriában, de a program befejezése után azok elvesztek. Ha szeretnénk megőrizni az adatokat későbbre is, állományba kell azokat mentenünk valamelyik háttértárolón. A C# nyelvben a fájlokat adatfolyamként kezeljük, a folyamba írunk és abból olvasunk. A következő lépések szükségesek a fájlkezeléshez: 1. Folyam megnyitása 2. Kapcsolódás a folyamhoz 3. Olvasás/Írás a folyamba

Olvasás a fájlból A fájlkezelő osztályok a System.IO névtérben vannak, ezért szükségünk van egy új „using” kezdetű sorra: using System; using System.IO; ... FileStream folyam = new FileStream("adat.txt", FileMode.Open); StreamReader olvaso = new StreamReader(folyam); while (!olvaso.EndOfStream) { Console.WriteLine(olvaso.ReadLine()); } olvaso.Close(); A példában a FileStream és StreamReader osztályokat használjuk. A StreamReader osztállyal létrehozott objektumnak van egy ReadLine() metódusa. Tulajdonképpen ezzel tudunk olvasni. A metódus egy sort olvas, majd a következő sorra ugrik a fájlmutató. A következő olvasás mára második sort fogja olvasni. Mivel nem lehetünk biztosak abban hány sor van egy állományban, az EndOfStream mező olvasásával vizsgáljuk, hogy vége van-e a fájlnak. Egy while ciklussal addig folytatjuk a beolvasást, amíg nem érjük el a fájl végét.

Írás a fájlba Program.cs using System; using System.IO;

http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

55/63

A C# nyelv

class Program { public static void Main() { Console.WriteLine("Hi"); FileStream folyam = new FileStream("adat.txt", FileMode.Create); StreamWriter iro = new StreamWriter(folyam); iro.WriteLine("Alma"); iro.WriteLine("Körte"); iro.Close(); } }

Egyéb módok CreateNew Új fájl létrehozása. A fájlrendszerben írásjog szükséges. Ha fájl léterzik IOExcepton kivétel keletkezik Create Új fájl keletkezik, ha létezik felülíródik. Írási jog szükséges a fájlrendszeren FileIOPermissionAccess.Write. Open Létező fájl megnyitása. System.IO.FileNotFoundException kivétel keletkezik, ha nem létezik a fájl. OpenOrCreate Ha létezik megnyitja, egyébként létrehozza. Truncate Létező fájl megnyitása. Megnyitás után 0 byte nagyságú lesz. Append Megnyit egy fájlt, ha létezik a fájl végéhez fűz, ha nem létrehozza a fájlt.

Hozzáfűzés a fájlhoz Program.cs using System; using System.IO; class Program { static void Main() { Console.WriteLine("Írás");


Last update: 2015/10/22 08:26


FileStream folyam = new FileStream("adat.txt", FileMode.Append); StreamWriter iro = new StreamWriter(folyam); iro.Write("valami"); iro.Write(45); iro.Flush(); iro.Write(60); iro.WriteLine(); iro.Close(); } }

Fájlkezelés egyszerűbben Ha nem szeretnénk fájlmódot megadni, akkor használhatjuk csak a StreamReader osztályt egy állomány olvasásához. StreamReader olvaso = new StreamReader("adat.txt"); while((sor = olvaso.ReadLine()) != null) Console.WriteLine(sor); olvaso.Close(); Program.cs using System; using System.IO; class Program { static void Main() { Console.WriteLine("Olvasás fájlból"); StreamReader olvaso = File.OpenText("adat.txt"); string sor = null; while ((sor = olvaso.ReadLine()) != null) Console.WriteLine(sor); olvaso.Close(); } }

Program.cs using System; using System.IO; http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

57/63

class Program { static void Main() { Console.WriteLine("Olvasás fájlból"); StreamReader olvaso = File.OpenText("adat.txt"); string sorok = olvaso.ReadToEnd(); Console.WriteLine(sorok); olvaso.Close(); } }

Program.cs using System; using System.IO; class Program { static void Main() { Console.WriteLine("Írás fájlba"); FileInfo f = new FileInfo("gy.txt"); StreamWriter iro =f.CreateText(); iro.WriteLine("alma"); iro.WriteLine("körte"); iro.WriteLine("szilva"); iro.Close(); } }

Program.cs using System; using System.IO; class Program { static void Main() { Console.WriteLine("Írás fájlba"); StreamWriter iro =File.CreateText("gy2.txt"); iro.WriteLine("alma"); SzitWiki - http://szit.hu/

A C# nyelv

Last update: 2015/10/22 08:26


iro.WriteLine("körte"); iro.WriteLine("szilva"); iro.Close(); } }

Fájlkezelés objektumainak lezárása A következő példában létrehozzuk a StreamReader egy példányát, a using utasításon belül. A usingnak van egy blokkja. A blokk végén a StreamReader példányán automatikusan meghívódik a Dispose() metódus. using(StreamReader olvaso = new StreamReader("adat.txt");) { while((sor = olvaso.ReadLine()) != null) Console.WriteLine(sor); olvaso.Close(); }

Hibakezelés try { using(StreamReader olvaso = new StreamReader("adat.txt");) { while((sor = olvaso.ReadLine()) != null) Console.WriteLine(sor); olvaso.Close(); } } catch (Exception e) { Console.WriteLine("A fájl nem létezik: "); Console.WriteLine(e.Message); }

Olvasás fájlból kódolás megadásával using System; using System.IO; using System.Text; class Program { static void Main() http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

59/63

A C# nyelv

{ Console.WriteLine("Olvasás fájlból"); StreamReader olvaso = new StreamReader("adat.txt", Encoding.UTF8); string sor = null; while ((sor = olvaso.ReadLine()) != null) Console.WriteLine(sor); olvaso.Close(); } } Megadható kódolások: Encoding.UTF8 Encoding.ASCII Encoding.Unicode Encoding.Default

Egy C# program szerkezete Szerkezet A C# programban metódusokat írunk. Kezdőként természetesen csak egy metódusunk van, ahogy fentebb láttuk ez a Main() metódus. Később azonban, ha már nagyon sok utasításunk lesz, vagy csak mert logikailag ésszerű külön tenni bizonyos utasításokat, újabb metódusokat hozunk létre, ezeket is a főosztályon belül. Ha már nagyon sok metódusunk van, akkor a logikailag összetartozó metódusokat tehetjük külön osztályba is. A forráskódunk, amely tulajdonképpen egy állomány ekkor különálló több osztályból fog állni. Ha már nagyon sok osztályunk egy állományban, azokat névterekbe rendezhetjük. Ha már nagyon sok névterünk azokat pedig újabb állományokba írhatjuk. A C# program tehát egy vagy több állományból áll. Minden állományban lehet egy vagy több névtér. A névtereken belül egy vagy több osztályt hozhatunk létre.


Last update: 2015/10/22 08:26


Az eddigi példákban nem használtunk névtereket. Ebből is következik, hogy az nem kötelező. A névtér használata azért lehet, hasznos mert így egy osztálynevét többször is használhatunk, a soksok osztály pedig csoportosíthatjuk. A „Helló Világ” nevű program saját névtérbe helyezve így nézhetne ki: hello3.cs using System; namespace Elso { class Program { static void Main() { Console.WriteLine("Helló Világ!"); } } }

A példában a saját Main() metódusunkat egy „Elso” nevű névtérbe helyeztük. A névterek használatával, tulajdonképpen összefoghatjuk, illetve csoportosíthatjuk az osztályokat.

Több forrásfájl használata Ha már nagyon sok osztályunk van, szeretnénk egy részét külön állományokban tartani. Az alábbiakban készítek egy állományt amelynek sajat.cs lesz a neve. Elhelyezek benne egy Elelem nevű névteret, a névtérben lesz egy Gyumolcs nevű osztályunk, az pedig tartalmaz egy kiir() metódust, amely gyümölcsök neveit írja a képernyőre: sajat.cs http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

61/63

A C# nyelv

using System; namespace Elelem { class Gyumolcs { public static void kiir() { Console.WriteLine("alma\nkörte\nbarack"); } } }

Ezek után létrehozunk egy állományt, amely használni fogja az Elelem névteret, benne a Gyumolcs osztály kiir() metódusát: main.cs using Elelem; class Belepesipont { static void Main() { Gyumolcs.kiir(); } }

Mono 2.0 használata esetén a fordítás: gmcs sajat.cs main.cs

DLL-ek használata Az alábbiakban egy DLL-t készítünk amely tartalmaz egy számláló és egy érték visszaadó metódust.

Forrás Szamlalo.cs public class Szamlalo { int val = ; public void Hozzaad (int x) SzitWiki - http://szit.hu/

Last update: 2015/10/22 08:26


{ val = val + x; } public int Ertek() { return val; } }

Lényeges, hogy a Szamlalo osztály public előtaggal legyen megadva! Prog.cs using System; class Prog { static void Main() { Szamlalo szamol = new Szamlalo(); szamol.Hozzaad(4); szamol.Hozzaad(3); Console.WriteLine("Érték: " + szamol.Ertek()); } }

Fordítás MS keretrendszerrel Elsőként elkészítjük a .dll állományt: csc /target:library Szamlalo.cs Ez után lefordítjuk a programot: csc /reference:Szamlalo.dll Prog.cs Mono rendszerrel Elsőként elkészítjük a .dll állományt:

http://szit.hu/

Printed on 2016/12/22 14:46

2016/12/22 14:46

63/63

gmcs /target:library Szamlalo.cs Ez után lefordítjuk a programot: gmcs /reference:Szamlalo.dll Prog.cs

From: http://szit.hu/ - SzitWiki Permanent link: http://szit.hu/doku.php?id=oktatas:programoz%C3%A1s:csharp:csharp_nyelv Last update: 2015/10/22 08:26


A C# nyelv

63 A C# nyelv

Recommend Documents