02_191095 ftocP.qxp:Layout 1 7/20/09 4:08 PM Page xi
Tartalomjegyzék Bevezetés .................................................................. 1 A C# 3.0 újításai ............................................................................................. 2 A könyvről ...................................................................................................... 3 Amire a könyv használatához szükséged lesz ........................................... 3 A könyv használatáról................................................................................... 4 A könyv felépítése ......................................................................................... 5 I. rész: Ismerkedés a C#-pal ................................................................ 5 II. rész: A C#-programozás elemei...................................................... 5 III. rész: Objektumok használata ........................................................ 5 IV. rész: Objektumorientált programozás ......................................... 5 V. rész: Most pedig… a C# 3.0! ........................................................... 6 VI. rész: Top 10 ..................................................................................... 6 A könyvben használt ikonok ........................................................................ 6 Hasznos tudnivalók a könyv olvasásához.................................................. 7 Hol találom a programokat?......................................................................... 7 A szerző honlapjáról ..................................................................................... 8 Hol is kezdjük? ............................................................................................... 9
I. rész: Ismerkedés a C#-pal...................................... 11 1. fejezet: Első konzolos C#-alkalmazásunk elkészítése ................................. 13 Mik is azok a programnyelvek, a C# és a .NET?....................................... 13 Mi az a program?................................................................................ 14 Mi az a C#? .......................................................................................... 14 Mi az a .NET? ...................................................................................... 15 Mi az a Visual Studio 2008? És a Visual C#?.................................... 17 Első konzolos alkalmazásod elkészítése .................................................. 17 A forráskód létrehozása.................................................................... 18 Próbáld is ki egyből a programodat! ............................................... 21 Tedd hasznossá konzolos alkalmazásodat!.............................................. 21 A konzolos alkalmazás áttekintése............................................................ 22 A program kerete ............................................................................... 22 Megjegyzések ..................................................................................... 23 A program lényege............................................................................. 24 A Toolbox használata.................................................................................. 25 Kódrészlet mentése a Toolboxszal .................................................. 25 A Toolboxba elmentett kód újrafelhasználása............................... 26
02_191095 ftocP.qxp:Layout 1 7/20/09 4:08 PM Page xii
xii
C# 2008
II. rész: A C#-programozás elemei ............................. 27 2. fejezet: A változás korában – érték típusú változók deklarálása............... 29 Változó deklarálása ..................................................................................... 29 Mi az az int?.................................................................................................. 30 A változódeklarálás szabályai .......................................................... 31 Változatok egy témára – az egész számok különböző típusai...... 32 Új típus: a BigInteger ......................................................................... 33 Törtek ábrázolása........................................................................................ 34 Lebegőpontos változók kezelése............................................................... 35 Lebegőpontos változók deklarálása................................................ 35 Vissza a hőmérséklet-átváltáshoz.................................................... 36 A lebegőpontos változókra vonatkozó korlátozások .................... 37 A decimal típus használata – egész vagy valós?...................................... 38 Decimal típusú változó deklarálása................................................. 39 A decimal, az int és a float típusok összehasonlítása ................... 39 A bool típus vizsgálata – logikus, nem? .................................................... 40 Ismerkedés a karaktertípusokkal .............................................................. 40 A char változótípus ........................................................................... 41 Különleges karakterek....................................................................... 41 A string típus ...................................................................................... 42 Mi is az az értéktípus?................................................................................. 43 A string és a char összehasonlítása .......................................................... 43 Idén szökőév van? – A DateTime típus ..................................................... 44 Numerikus konstansok deklarálása .......................................................... 47 Típuscsere – a konverzió............................................................................ 47 Új technika: majd a C#-fordító kitalálja változóink típusát! ................... 49
3. fejezet: Mit operál az operátor?..................................................................... 53 Aritmetikai műveletek................................................................................. 53 Egyszerű operátorok ......................................................................... 54 Operátorok sorrendje........................................................................ 55 Az értékadó operátor ........................................................................ 56 Az inkrementáló operátor................................................................. 57 Logikai összehasonlítások elvégzése – logikus, nem igaz? .................... 58 Lebegőpontos számok összehasonlítása........................................ 59 Tovább bonyolítjuk a helyzetet – összetett logikai kifejezések ... 60 Kifejezések típusainak egyeztetése ........................................................... 61 Művelet eredményének típusa ......................................................... 62 Típus-hozzárendelés ......................................................................... 64
4. fejezet: Vezérlőszerkezetek a programban.................................................... 65 Elágazás a programban – az if és a switch ............................................... 66 Az if utasítás részletes bemutatása ................................................. 67 Az else utasítás vizsgálata ................................................................ 70 Az else-ág kikerülése ......................................................................... 71
02_191095 ftocP.qxp:Layout 1 7/20/09 4:08 PM Page xiii
Tartalomjegyzék if utasítások egymásba ágyazása ..................................................... 71 A C#-program kapcsolótáblája: a switch utasítás.......................... 74 A C# ciklusai................................................................................................. 76 Határozatlan ciklus: a while utasítás............................................... 77 A do...while ciklus használata .......................................................... 81 (Meg)szakítópróba ............................................................................ 81 Ciklus a bemenet beolvasására – előbb-utóbb csak sikerül!........ 83 Középpontban a hatókörszabályok................................................. 86 Határozott lépésszámú ciklus: a for.......................................................... 87 Egy példa............................................................................................. 87 Miért van szükség még egy ciklusfajtára? ...................................... 88 Beágyazott ciklusok .................................................................................... 89 A goto utasítás ............................................................................................. 90
5. fejezet: Egy bárány, két bárány, sok bárány… – avagy a kollekciók .......... 93 A C# tömbjei................................................................................................. 94 A tömb argumentuma........................................................................ 94 Rögzített méretű tömbök.................................................................. 95 Változó hosszúságú tömbök............................................................. 96 A Length tulajdonság ........................................................................ 99 Hogyan inicializálhatom a tömbömet?.......................................... 100 Ciklus a tömb minden egyes elemére: a foreach ................................... 100 Adattömbök rendezése............................................................................. 101 Újdonság: a var használata tömbökkel ................................................... 106 A C# kollekciói – avagy lazítsunk a szabályzaton!................................. 107 A kollekciók szintaxisának áttekintése ................................................... 108 A C# kollekcióosztályai ................................................................... 108 Mi az a
? ...................................................................................... 108 Generikus típusok............................................................................ 109 Listák használata ....................................................................................... 110 Szótárak használata .................................................................................. 113 Újdonság: tömb- és kollekcióinicializálók .............................................. 115 Tömbök inicializálása...................................................................... 115 Kollekciók inicializálása.................................................................. 115 Újdonság: halmazok használata .............................................................. 117 A régimódi kollekciókról – avagy mit nem célszerű használnod......... 121
6. fejezet: A sztringek........................................................................................ 123 Az atomok oszthatatlanok – ja, és a sztringek is ................................... 124 Általános sztringműveletek...................................................................... 126 Sztringek összehasonlítása ...................................................................... 126 Egyenlőséget a sztringeknek! – a Compare( ) metódus .............. 127 Összehasonlítás: kis- és nagybetűk ............................................... 130 Kis- és nagybetűk közötti konverzió ....................................................... 131 Csupa nagy-, illetve kisbetűs sztringek megkülönböztetése...... 131 Sztring konvertálása kis- vagy nagybetűssé................................. 132
xiii
02_191095 ftocP.qxp:Layout 1 7/20/09 4:08 PM Page xiv
xiv
C# 2008 Ciklusban lépkedünk végig a sztring karakterein.................................. 133 Keresés sztringekben ................................................................................ 133 Hogy találom meg? .......................................................................... 134 Üres a sztringem?............................................................................. 134 Beolvasás a parancssorból ...................................................................... 135 Felesleges karakterek eltávolítása ................................................. 135 Numerikus bemenet feldolgozása ................................................. 135 Több bemenő szám kezelése ......................................................... 139 Sztringek összefűzése egyetlen sztringgé..................................... 141 A kimenet egyéni kezelése........................................................................ 141 A Trim( ) és a Pad( ) metódusok használata................................ 141 A Concat ( ) metódus használata................................................... 144 Alkalmazzuk a Split( )-et az összefűző programban!................... 146 Formázd sztringjeidet úgy, ahogy akarod!.............................................. 147 A StringBuilder: sztringek hatékonyabb kezelése ................................. 151
III. rész: Objektumok használata............................. 155 7. fejezet: Osztályon felüli módszerek.............................................................. 157 Mi az az objektum? És az osztály?........................................................... 158 Osztálydefiníciók ............................................................................. 158 Mi az az objektum? .......................................................................... 159 Objektumtagok elérése ............................................................................. 160 Példa objektumalapú programra............................................................ 161 Objektumok megkülönböztetése............................................................. 163 Tudna adni néhány referenciát? .............................................................. 163 Osztályokat tartalmazó osztályok – avagy kinek mi jut osztályrészül... 165 Statikus osztálytagok kialakítása............................................................. 167 Konstansok és csak olvasható adattagok definiálása........................... 168
8. fejezet: Megvannak a módszereink… akarom mondani metódusaink...... 171 Metódusok definiálása és használata ..................................................... 171 Példametódus az állományaidhoz........................................................... 173 Metódusargumentumok ........................................................................... 181 Argumentum átadása a metódusnak............................................. 182 Több argumentum átadása a metódusnak ................................... 183 Paraméterek és argumentumok egyeztetése................................ 184 Metódusok túlterhelése – ez nem azonos a kifárasztással!............ 185 Alapértelmezett argumentumok implementálása ....................... 187 Érték és referencia típusú argumentumok átadása............................... 189 Érték típusú argumentumok érték szerinti átadása .................... 189 Érték típusú argumentumok referencia szerinti átadása............ 190 Referencia típusú argumentumok átadása ................................... 192 Ne add át kétszer ugyanazt a változót referencia szerint a metódushívásban!..................................................................... 192
02_191095 ftocP.qxp:Layout 1 7/20/09 4:08 PM Page xv
Tartalomjegyzék A visszatérési érték ................................................................................... 194 Érték visszaadása a return utasítás segítségével ........................ 195 Érték visszaadása referencia szerinti átadással .......................... 196 Mikor return és mikor out?............................................................. 196 Érték nélküli metódus deklarálása ................................................ 197
9. fejezet: A this kulcsszó és társai................................................................. 203 Objektum átadása metódusoknak........................................................... 203 Metódusdefiníciók..................................................................................... 205 Statikus metódus definiálása ......................................................... 205 Példánymetódus definiálása .......................................................... 207 A metódus teljes nevének kifejtése ............................................... 209 Hozzáférés az aktuális objektumhoz....................................................... 210 Mire jó a this kulcsszó? ................................................................... 211 Mikor explicit a this? ....................................................................... 212 Mi történik, ha nem alkalmazom a this-t?..................................... 215 Újdonság: bővítő metódusok ................................................................... 217
IV. rész: Objektumorientált programozás .................. 221 10. fejezet: Objektumorientált programozás – ez meg mi a szösz?.............. 223 Az objektumorientáltság 1. elve – az absztrakció ................................. 223 Eljárásalapú kukoricapattogtatás .................................................. 224 Objektumorientált kukoricapattogtatás ....................................... 225 Az objektumorientáltság 2. elve – a klasszifikáció ................................ 225 Miért klasszifikáljak? ................................................................................. 226 Az objektumorientáltság 3. elve – használható interfészek ................. 227 Az objektumorientáltság 4. elve – a hozzáférés szabályozása............. 228 A C# és az objektumorientált elvek......................................................... 229
11. fejezet: Felelősségteljes osztályok............................................................. 231 Osztálytagok elérésének korlátozása...................................................... 231 A BankAccount program publikus változata................................ 232 Egy kis ugrás előre – további biztonsági szintek ......................... 235 Miért fontos a hozzáférés korlátozása? .................................................. 235 Hozzáférő metódusok ..................................................................... 236 Mikor válhat hasznodra a hozzáférés-korlátozás – példa .......... 237 És akkor mi van? .............................................................................. 241 Osztálytulajdonságok definiálása............................................................ 241 Statikus tulajdonságok .................................................................... 243 Tulajdonságok mellékhatásokkal................................................... 243 Újdonság: a fordító megírja a tulajdonságokat helyetted........... 244 Biztonsági szint megadása a hozzáférőkben................................ 245 Objektumok kezdeti előnnyel – avagy a konstruktorok ....................... 245 A C# konstruktorai .................................................................................... 246
xv
02_191095 ftocP.qxp:Layout 1 7/20/09 4:08 PM Page xvi
xvi
C# 2008 Az alapértelmezett konstruktor felülírása.............................................. 247 Na, akkor lássunk neki a konstruálásnak!..................................... 249 A konstruktor végrehajtása a hibakeresőből ............................... 251 Objektuminicializálás közvetlenül, inicializáló használatával ... 254 Egy kis konstruálás inicializálókkal ............................................... 255 Újdonság: objektuminicializálás konstruktor nélkül................... 255 A konstruktor túlterhelése ...................................................................... 257 Kódismétlés elkerülése a konstruktorokban ......................................... 260 Fukarkodás az objektumokkal ................................................................. 264
12. fejezet: Öröklődés – avagy mi áll a végrendeletben? .............................. 265 Osztályöröklés ........................................................................................... 266 Miért van szükség öröklődésre? ............................................................. 267 Egy kidolgozottabb probléma – származtatás a BankAccount osztályból..................................................................... 269 AZ_EGY és TARTALMAZ_EGY – melyik melyik? .................................... 272 AZ_EGY viszony ............................................................................... 272 Hozzáférés a BankAccount-hoz tartalmazással ........................... 273 TARTALMAZ_EGY viszony .............................................................. 274 Mikor használjak AZ_EGY, és mikor TARTALMAZ_EGY viszonyt? ...... 275 További, öröklődéssel kapcsolatos funkcionalitások ........................... 276 Helyettesíthető osztályok ............................................................... 276 Futási idejű érvénytelen konverziók ............................................ 277 Érvénytelen konverziók elkerülése az „is” operátorral .............. 278 Érvénytelen konverziók elkerülése az „as” operátorral ............. 279 Az object osztály ....................................................................................... 279 Öröklődés és a konstruktor...................................................................... 280 Az alapértelmezett alaposztály-konstruktor meghívása ............ 281 Argumentumok átadása az alaposztály-konstruktornak ............ 282 Az alaposztály specifikálása........................................................... 283 A BankAccount osztály korszerűsített változata .................................. 285
13. fejezet: Polimorfizmicsoda?........................................................................ 289 Örökölt metódusok túlterhelése.............................................................. 290 A metódustúlterhelés egyszerű esete ........................................... 290 Más osztály, más metódus.............................................................. 290 Bújócska – az alaposztály metódusainak elrejtése ..................... 291 Vissza az ősökhöz ............................................................................ 296 Polimorfizmus ........................................................................................... 298 Miért baj, hogy mindig a deklarált típust használjuk? ................ 299 Hozzáférés rejtett metódushoz az „is” segítségével, polimorfizmus révén .................................................................... 301 Virtuális metódus deklarálása és felülírása ................................. 302 A polimorfizmus kiaknázása – az „egyenként sorra vesszük”-módszer............................................................... 305 Az osztály névjegykártyája: a ToString( )............................................... 305
02_191095 ftocP.qxp:Layout 1 7/20/09 4:08 PM Page xvii
Tartalomjegyzék A C# absztrakt időszaka ........................................................................... 306 Osztályok faktorizálása ................................................................... 306 Absztrakt osztályok......................................................................... 312 Hogyan használhatok absztrakt osztályokat?.............................. 312 Létrehozhatok absztrakt objektumot? Nem! ................................ 315 Osztály lezárása......................................................................................... 315
14. fejezet: Interfészek ...................................................................................... 317 Mi az a HASZNÁLHATÓ_MINT viszony? ................................................. 317 Mi az az interfész? ..................................................................................... 319 Interfészek implementálása............................................................ 320 Interfészed elnevezése .................................................................... 321 Szóval, miért van szükség interfészekre? ..................................... 321 Az öröklődés és az interfész-implementáció kombinálása......... 321 A módszer haszna............................................................................ 322 Interfészek használata .............................................................................. 323 Metódus visszatérési típusa........................................................... 323 Tömb vagy kollekció alaptípusa .................................................... 324 Általános típusú objektumreferencia ............................................ 324 A C# beépített interfésztípusainak használata ...................................... 325 Kellene egy program, ami HASZNÁLHATÓ_MINT példa…................... 325 Egyéni interfész létrehozása – remek szabadidős program! ...... 326 Az IComparable interfész ......................................................... 327 És most az egészet egyben! ............................................................ 329 Visszatérve a főprogramhoz: a Main( )......................................... 332 Osztályhierarchiák egyesítése ................................................................. 333 Rejtőzködés interfészek mögött .............................................................. 335 Interfészöröklés ......................................................................................... 338 Objektumorientált programok módosítása interfészek segítségével ..... 339 Rugalmas függőség kialakítása interfészek segítségével ............ 340 Absztrakt vagy konkrét? Mikor absztrakt osztály, és mikor interfész?........................................................................ 341 A TARTALMAZ_EGY kapcsolat ábrázolása interfészekkel.......... 342 A Stratégia tervezési minta............................................................. 343 Miért olyan hasznos ez a minta?.................................................... 344
V. rész: Most pedig… a C# 3.0! .............................. 347 15. fejezet: Delegáltak és események ............................................................. 349 E. T. hazatelefonál — avagy a visszahívási probléma........................... 349 Mi az a delegált? ........................................................................................ 350 Passzold át a metódust! – Példák ............................................................ 352 Delegáltak alkalmazási módjai ....................................................... 353 Első lépés: egy nagyon egyszerű példa......................................... 353
xvii
02_191095 ftocP.qxp:Layout 1 7/20/09 4:08 PM Page xviii
xviii
C# 2008 Vegyünk egy valószerűbb példát! ............................................................ 355 A példaprogram áttekintése ........................................................... 355 Az alkalmazás összeállítása............................................................ 356 A kód részletes bemutatása ........................................................... 357 A delegált életciklusának nyomon követése ................................ 359 Anonim metódusok ................................................................................... 362 A C# eseményei.......................................................................................... 363 A Megfigyelő tervezési minta ......................................................... 363 Mi az az esemény? Kiadó és Előfizető ........................................... 364 Hogyan hirdeti a kiadó az eseményeit?......................................... 364 Hogyan iratkozhatnak fel az előfizetők egy eseményre? ............ 366 Hogyan értesíthetem az előfizetőket egy eseményről? .............. 366 Hogyan adhatok át extra információt az eseménykezelőnek?...... 367 Az eseményküldés ajánlott módja................................................. 368 Hogyan „kezelik” a megfigyelők az eseményt?............................. 369
16. fejezet: Lambda-kifejezések ........................................................................ 371 A kollekciók és az „egyenként sorra vesszük”-probléma ..................... 371 Újdonság: lambda-kifejezések használata .............................................. 372 A C# és az „egyenként sorra vesszük”-módszer .......................... 372 Búza a malomba – adatok a példákhoz......................................... 373 Keresés: néhány Find( )-példa........................................................ 374 Műveletek végrehajtása: néhány ForEach( ) példa ..................... 377 Egyéni delegáltra alapuló lambda-kifejezés ................................. 380 A példák összefoglalása .................................................................. 382 A lambda-kifejezések szintaxisának részletei............................... 382 Lambda-kifejezések használata tetszőleges delegáltban ..................... 385
17. fejezet: A LINQ és a lekérdező kifejezések ............................................... 387 A C# 3.0 funkcionalitásai .......................................................................... 388 Mi az a lekérdezés egyáltalán?................................................................. 388 Miért fontos a „nyelvbe épített” lekérdezés? ............................... 390 A C#-lekérdezés általános alakja.................................................... 390 A LINQ áttekintése........................................................................... 391 Lekérdezések a C# 3.0-ban ....................................................................... 391 A három legfontosabb lekérdező operátor .................................. 393 Mit jelent a késleltetett lekérdezés-végrehajtás? ......................... 395 Lekérdezések azonnali kiértékelése .............................................. 396 Mire használhatom a lekérdezéseket? .................................................... 397 Szűrés lekérdezésekben............................................................................ 398 1. példa: Mely vásárlók laknak Coloradóban?.............................. 398 Kiválasztás és csoportosítás kedved szerint ......................................... 400 2. példa: A bemenő egész számoknál kettővel nagyobb számok listájának előállítása ..................................................... 401 3. példa: A vásárlók adatai közül csak a névre és a telefonszámra vagyok kíváncsi ............................................... 401 Anonim típusok használata ............................................................ 402
02_191095 ftocP.qxp:Layout 1 7/20/09 4:08 PM Page xix
Tartalomjegyzék 4. példa: Számok átalakítása neveikké .......................................... 404 5. példa: Nevek csoportosítása kezdőbetűjük szerint ................ 405 6. példa: Egyes csoportok kiszűrése ............................................. 407 7. példa: Termékek csoportosítása kategória szerint ................ 409 A kiválasztott elemek rendezése ............................................................. 411 8. példa: Az 5. és 6. példa csoportjainak sorba rendezése ......... 411 9. példa: Rendezés a csoportokon belül ....................................... 412 10. példa: Még egy kétszintű rendezés.......................................... 412 11. példa: Rendezés csökkenő sorrendbe .................................... 413 Lekérdezés metódusokkal ........................................................................ 414 12. példa: Lekérdezések kulcsszavak helyett metódusokkal ..... 415 Néhány szó a vagonokról: egy kis kitérő kezdőknek .................. 416 A kitérő vége..................................................................................... 417 Generikus metódusok .................................................................... 418 Mi van a Where( ) belsejében?....................................................... 418 13. példa: Lekérdezzük az összes vásárlót, de csak nevükre és telefonszámaikra vagyunk kíváncsiak ................................ 420 Számlálás, összegzés, átlagolás és hasonlók ......................................... 420 14. példa: A leltár terméktípusainak megszámolása ................... 421 15. példa: A numbers tömb elemeinek összeadása..................... 421 16. példa: Egy adott rendelés teljes összegének kiszámítása .... 422 17. példa: 9 faktoriálisának (9!) kiszámítása................................. 422 Objektumok kezelése kollekcióként........................................................ 424
VI. rész: Top 10...................................................... 425 18. fejezet: Tíz gyakori fordítási hiba (és azok kijavítása) ............................ 427 The name ’tagNev’ does not exist in the class or namespace ’osztalyNev’........................................................................ 428 Cannot implicitly convert type ’x’ into ’y’.............................................. 429 ’osztalyNev.tagNev’ is inaccessible due to its protection level........... 432 Use of unassigned local variable ’n’........................................................ 433 Unable to copy the file ’programNev.exe’ to ’programNev.exe’. The process cannot… .......................................................................... 433 ’alOsztalyNev.metodusNev’ hides inherited member ’alaposztalyNev.metodusNev’. Use the new keyword if hiding was intended .............................................................................. 434 ’alOsztalyNev’: cannot inherit from sealed class ’alaposztalyNev’..... 436 ’osztalyNev’ does not implement interface member ’metodusNev’ ... 436 ’metodusNev’: not all code paths return a value .................................. 437 } expected................................................................................................... 438
Függelék ............................................................... 439 Tárgymutató .......................................................... 441
xix
