Bánsághi Anna anna.bansaghi@mamikon.net

ESEMÉNYVEZÉRELT PROGRAMOZÁS Bánsághi Anna anna.bansaghi@mamikon.net 1. ELŐADÁS - C# ÁTTEKINTÉS - 1 2015 Bánsághi Anna 1 of 84

TEMATIKA I. C# ÁTTEKINTÉS II. WPF III. Modern UI 2015 Bánsághi Anna 2 of 84

1. 2. 3. 4. 5. I. C# ÁTTEKINTÉS Szoftver keretrendszer A C# lényegi elemei A C# program Érték- és referencia típusok Típuskonstrukciók 6. Változók, paraméterek 7. Utasítások, kifejezések, operátorok 8. Generikusok 9. Kivételkezelés 10. Attribútumok 11. XML dokumentáció 2015 Bánsághi Anna 3 of 84

1. SZOFTVER KERETRENDSZER 1980-ban jelent meg a SmallTalk, az első tisztán objektumorienált nyelv minden elem objektum és egyben egy osztály példánya az osztályok teljes származtatási hierarchiában helyezkednek el virtuális gépen futó teljesen hordozható kód memóriafelügyelet, szemétgyűjtés 2015 Bánsághi Anna 4 of 84

SZOFTVER KERETRENDSZER a programkönyvtárak és a virtuális gép együttese, mely tartalmazza a fejlesztéshez szükséges gépfüggetlen API-kat és felügyeli a programok futásának folyamatát 2015 Bánsághi Anna 5 of 84

1. 2. 3. FORDÍTÁS ÉS FUTTATÁS a programnyelvi kód egy alacsonyszintű, gépfüggetlen köztes nyelvre fordul, ez a köztes nyelvű kód a köztes nyelvű kód hordozhatóságát, gyorsaságát, hibamentességét, memóriafelügyeletét a virtuális gép, és azon belül a futattó környezet biztosítja, amely platformfüggő gépi kódot állít elő az ellenőrzött és biztonságos gépi kódot az operációs rendszer futtatja 2015 Bánsághi Anna 6 of 84

2015 Bánsághi Anna 7 of 84

.NET 1.0-2001.NET KERETRENDSZER virtuális gép: Common Language Runtime (CLR) köztes nyelv: Common Intermediate Language (CIL) egységes típusrendszer: Common Type System (CTS) teljes körű programkönyvtár: Framework Class Library (FCL) 2015 Bánsághi Anna 8 of 84

1.1-2003 kliens-szerver alkalmazások (ASP.NET), relációs adatbáziskezelés (ADO.NET), kódbiztonság: Code Access Security (CAS) 2.0-2005 grafikus felhasználói felület (WinForms), Microsoft SQL Server integráció 3.0-2007 technológiák egységesítése: grafikus felhasználói felület (WPF), szolgáltatás orientált üzenetkezelés (WCF), folyamatkezelés (WWF), biztonságos adatkezelés (Windows CardSpace) 3.5-2008 nyelvbe ágyazott adatbázis lekérdezések (LINQ), funkcionális programozás, AJAX támogatás 4.0-2010 párhuzamos lekérdezések (PLINQ), nyelvi szintű párhuzamosítás (TPL), szerződés alapú programozás 4.5-2012 platform független alkalmazás architektúra (Windows Runtime), grafikus felhasználói felület (Modern UI) 2015 Bánsághi Anna 9 of 84

GRAFIKUS FELHASZNÁLÓI FELÜLETEK Windows Forms (WinForms) az elsőként kifejlesztett felület, amely raszteres grafikára épül, és teljes mértékben processzor által vezérelt Windows Presentation Foundation (WPF) a később kifejlesztett felület, mely vektoros grafikára épül, célja a 3D gyorsítókártyák lehetőségeinek kihasználása Modern UI hordozható eszközökre szánt, egyszerűsített, letisztult felület, amely a WPF architektúrára épít 2015 Bánsághi Anna 10 of 84

2. A C# LÉNYEGI ELEMEI a C# egy általános célú, típusbiztos, objektumorientált nyelv célja a programozói produktivitás elősegítése, ezért az egyszerűség, a kifejezőerő és a teljesítmény hármasa között egyensúlyoz platform-független, de legjobban a.net keretrendszerben működik 2015 Bánsághi Anna 11 of 84

OBJEKTUMORIENTÁLTSÁG az OO paradigma három fő pillére (egységbezárás, származtatás, polimorfizmus) mellett a C# nyelv specialitásai: egységes típusrendszer új típuskonstrukciós eszközök (interface, delegate) új tagfüggvények (tulajdonság, esemény, indexelő) 2015 Bánsághi Anna 12 of 84

EGYSÉGES TÍPUSRENDSZER a C# alapvető építőeleme az adatokat és az azokon végezhető műveleteket egységbezáró típus minden típus egyetlen közös ősből (System.Object) származik, ezért minden típus rendelkezik bizonyos alapvető funkciókkal, pl. a ToString metódussal tetszőleges típus példánya string-é konvertálható 2015 Bánsághi Anna 13 of 84

SYSTEM.OBJECT TAGJAI var objektum = new Object(); Type tipus = objektum.gettype(); foreach( MemberInfo tag in tipus.getmembers() ) { Console.WriteLine( tag ); Boolean Equals(System.Object) Boolean Equals(System.Object, System.Object) Int32 GetHashCode() System.Type GetType() System.String ToString() Boolean ReferenceEquals(System.Object, System.Object) Void.ctor() 2015 Bánsághi Anna 14 of 84

ÚJ TÍPUSKONSTRUKCIÓS ESZKÖZÖK a hagyományos OO paradigma szerint az egyetlen típuskonstrukciós eszköz az osztály deklarálása (class) a C#-ban más típuskonstrukciók is vannak, például az interfész, mely annyiban különbözik az osztálytól, hogy csupán deklarálja a tagokat, de nem implementálja azokat az interfészek a többszörös öröklődés kiváltására használhatók 2015 Bánsághi Anna 15 of 84

ÚJ TAGFÜGGVÉNYEK a műveletek nemcsak metódusokat, hanem tulajdonságokat és eseményeket is magukba foglalnak a tulajdonság valamely objektum állapotának egy darabkáját testesíti meg az esemény az objektum állapotváltozásáért felelős 2015 Bánsághi Anna 16 of 84

TÍPUSBIZTOSSÁG egy példányhoz csak a típusán megvalósított műveleteken keresztül férhetünk hozzá, ezzel őrizve meg a példány belső konzisztenciáját a C# statikusan típusos nyelv, azaz fordítási időben kerül kikényszerítésre a típusbiztosság a C# erősen típusos nyelv is, azaz az objektumokat deklarálnunk kell, illetve csak a típuson megengedett műveletek hajthatók végre 2015 Bánsághi Anna 17 of 84

MEMÓRIAGAZDÁLKODÁS a C# programok az automatikus memóriagazdálkodást a futtató környezetre bízzák a CLR tartalmaz egy szemétgyűjtő algoritmust, mely időről időre felszabadítja a referencia nélküli memóriaszeleteket nincs szükség explicit (programozó által kezdeményezett) memóriafelszabadításra a mutató típus megmaradt, de csak unsafe blokkon belül használható 2015 Bánsághi Anna 18 of 84

PLATFORMOK a C# tipikusan Windows platformokon futó programok írására alkalmas több platformon futó alkalmazásokhoz a Java-t érdemes választani 2015 Bánsághi Anna 19 of 84

WINDOWS RUNTIME a Windows 8-ban megjelentek az érintőképernyős Metro stílusú alkalmazások a mobil és az érintőképernyős grafikus alkalmazások fejlesztéséhez szükséges könyvtárakat tartalmazza a WinRT 2015 Bánsághi Anna 20 of 84

3. A C# PROGRAM a program logikai tagolását az egymásba ágyazható biztosítják névterek a program fizikai tagolását az assembly -k biztosítják, melyek tartalmazhatnak típusokat, típusok megvalósítását, valamint más assembly-kre történő referenciákat alkalmazás könyvtár ASSEMBLY FAJTÁK belépési ponttal rendelkezik,.exe kiterjesztésű nincs belépési pontja, általában.dll kiterjesztésű 2015 Bánsághi Anna 21 of 84

ALKALMAZÁS FUTTATÁS az alkalmazás futása egy különálló alkalmazás tartományban történik, melybe minden hivatkozott típus és osztálykönyvtár betöltődik ha egy alkalmazást több példányban futtatunk, akkor minden példánynak saját alkalmazás tartománya jön létre, ahova a hivatkozott típusok és osztálykönyvtárak külön-külön betöltődnek így az egyes alkalmazások futása teljesen szeparált módon történik ugyanazon vagy más alkalmazások futásától 2015 Bánsághi Anna 22 of 84

BELÉPÉSI PONT az alkalmazás indítás akkor történik, amikor a futtató környezet meghív egy speciális metódust, az alkalmazás belépési pontját, a statikus Main metódust habár létezik a metódusnevek túlterhelése, a Main metódusból kizárólag egyetlen létezhet egy alkalmazáson belül ha az alkalmazás olyan könyvtárakat tölt be, melyek szintén tartalmaznak Main metódust, akkor kívülről kell megadni, hogy melyik lesz az alkalmazás belépési pontja a futtató környezet mindig látja a Main metódust, annak láthatóságától függetlenül 2015 Bánsághi Anna 23 of 84

ALKALMAZÁS TERMINÁLÁSA az alkalmazás terminálása visszaadja a vezérlést a futtató környezetnek a terminálás előtt az alkalmazás objektumain automatikusan lefutnak a destruktorok, hacsak nem hívtuk meg explicite a szemétgyűjtő eljárást, például a GC.SuppressFinalize metódussal 2015 Bánsághi Anna 24 of 84

AUTOMATIKUS MEMÓRIAKEZELÉS 1. 2. 3. 4. 5. amikor egy objektum létrejön, akkor lefoglalódik számára egy memóriaszelet, lefut a konstruktor, és az objektum élővé válik ha egy objektum vagy bármely része elérhetetlenné válik futási időben, akkor az objektum megsemmisítésre lesz kijelölve ha egy objektum megsemmisítésre lett jelölve, akkor valamikor később lefut a destruktora amint az objektum destruktora lefutott vagy az objektum sérülése miatt nem tudott lefutni, akkor az objektum gyűjtésre lesz kijelölve valamikor később a szemétgyűjtő felszabadítja azokat a memóriaszeleteket, ahol gyűjtésre kijelölt objektumok helyezkednek el 2015 Bánsághi Anna 25 of 84

DEKLARÁCIÓK a program építőköveit, elemeit deklarálnunk kell a C# program névterekbe szervezett, ahol egy névtéren belül lehetnek típus deklarációk és beágyazott névtér deklarációk névtér deklaráció típus deklarációk: namespace osztály deklaráció class rekord deklaráció struct interfész deklaráció interface felsorolási típus deklaráció enum delegált deklaráció delegate 2015 Bánsághi Anna 26 of 84

TAGOK a névterek és a különféle típusok tagokból épülnek fel, melyeket az adott elem utáni pont és a tag nevével érünk el valamely típus tagjait vagy a típus deklarációban adjuk meg, vagy származtatjuk az őstípusból a konstruktorokat és a destruktorokat kivéve minden tag öröklődik az öröklött tagok nem feltétlenül érhetők el a származtatott típusban, ez függ az ősben megadott láthatóságtól public, protected, internal, protected internal, private 2015 Bánsághi Anna 27 of 84

SZIGNATÚRA ÉS TÚLTERHELÉS a metódusok, a példány konstruktorok, az indexelők és az operátorok szignatúrájuk alapján azonosíthatók be szignatúra = metódus/operátor neve + formális paraméterek típusa és fajtája * az egyedileg beazonosítható szignatúra teszi lehetővé a fenti tagok túlterhelését osztályokban, rekordokban és interfészekben a visszatérési típus és a params módosító nem része a szignatúrának * formális paraméterek fajtája: érték, referencia, output, tömb 2015 Bánsághi Anna 28 of 84

HATÓKÖRÖK egy név hatóköre az a programrész, ahonnan az adott néven deklarált elem elérhető a hatókörök egymásba ágyazhatók, és egy belső hatókörben használt név felüldefiniálja a külső hatókörben használt nevet, így a külső név rejtett lesz a belső hatókörben névtéren, osztályon, rekordon vagy felsorolási típuson belül deklarált tag - a deklarálás helyétől függetlenül - elérhető ugyanazon típus egy másik tagján belül adott nevet mindig el lehet érni a minősítők megadásával 2015 Bánsághi Anna 29 of 84

MINŐSÍTETT NEVEK class A { namespace X { class B { class C { // A // X // X.B // X.B.C namespace Y { class D { // X.Y // X.Y.D namespace X.Y { class E { // X.Y // X.Y.E 2015 Bánsághi Anna 30 of 84

NEVEK ELREJTÉSE EGYMÁSBA ÁGYAZÁSSAL class A { void F() { int i = 1; // lokális változó, elfedi az i tagot this.i = 5; // az i tag elérhető a this minősítővel void G() { i = 1; int i = 0; // az i tag deklarálása utoljára történik, // de hatóköre a teljes A osztályra kiterjed NEVEK ELREJTÉSE SZÁRMAZTATÁSSAL class A { public void F() { class B : A { new public void F() { // az A.F tag elfedett a new módosítóval 2015 Bánsághi Anna 31 of 84

4. TÍPUSOK érték közvetlenün tartalmazza az adatot struct, enum, bool, integral, floating-point két azonos értékű adatot tároló változó két különböző adatot jelent, így az egyik változón végzett művelet semmilyen haátssal nincs a másik változóban tárolt adatra referencia az adatra mutató referenciát tartalmazza class, interface, array, delegate két referencia mutathat ugyanazon objektumra, így az egyik referencián keresztül végrehajtott művelet eredeménye a másik referencián keresztül is érzékelhető mutató csak unsafe környezetben használható a szemétgyűjtő nem működik rajta 2015 Bánsághi Anna 32 of 84

2015 Bánsághi Anna 33 of 84

2015 Bánsághi Anna 34 of 84

ÉRTÉKTÍPUSOK egy értéktípusú változó értéket tárol, nem lehet null vagy referencia változóhoz történő hozzárendelés esetén létrejön az érték egy újabb másolata minden értéktípus a System.ValueType-ból származik az értéktípusok lezártak (sealed), tehát nem lehet belőlük származtatni az értéktípusok implicite rendelkeznek paraméternélküli konstruktorral, mely a változókat inicializálja a struct típusoknak nem lehet paraméternélküli konstruktort deklarálni, mivel az már létezik implicite az egyszerű típusok két néven érhetők el, például int és System.Int32 2015 Bánsághi Anna 35 of 84

TÍPUSKONSTRUKCIÓS ESZKÖZÖK enum nevesített konstansokat tartalmazó típus. Minden felsorolt típus valamely egész típuson (kivéve char) alapul struct felhasználói értéktípusok létrehozására 2015 Bánsághi Anna 36 of 84

REFERENCIA TÍPUSOK egy referencia típusú változó referenciát tárol, mely egy adott típus egy példányára, azaz egy objektumra mutat a null minden esetben azt jelzi, hogy az objektum nem létezik változóhoz történő hozzárendelés esetén a referencia másolódik le, nem az objektum az object egy álnév a System.Object típusra, minden C#-beli típus ősére két object típusú kifejezés pontosan akkor egyenlő, ha ugyanarra az objektumra mutatnak vagy mindkettő null két string típusú kifejezés pontosan akkor egyenlő, ha minden karakterpozícióban megegyeznek vagy mindkettő null 2015 Bánsághi Anna 37 of 84

TÍPUSKONSTRUKCIÓS ESZKÖZÖK class adattagokat és tagfüggvényeket tartalmazó típusok deklarálására való. Támogatja az egyszeres öröklődést interface egy szerződést definiál. Az az osztály vagy rekord, mely megvalósít egy interfészt, be kell hogy tartsa ezt a szerződést. Támogatja a többszörös öröklődést delegate egy vagy több alprogram vagy metódus összekapcsolására szolgáló adatszerkezet. Egy delegate hívásakor a listájában lévő összes metódus meghívódik a megadott paraméterre array azonos típusú elemek tárolására szolgáló adatszerkezet. A deklaráció az elemek megadásával történik 2015 Bánsághi Anna 38 of 84

BOXING ÉS UNBOXING a C#-ban az egységes típusrendszer központi fontosságú minden típus, még az értéktípusok is a System.Object leszármazottai tehát bármely értéktípuson értelmezett a ToString metódus vagy egészeken a MaxValue tulajdonság ez egy kis zavart eredményez, hiszen az értéktípusok lényege, hogy a hatékony kezelés érdekében kizárólag értéket tárolnak, nincsenek adattagjaik vagy tagfüggvényeik a megoldást a boxing művelet jelenti, amely tetszőleges értéktípusnak megengedi, hogy úgy viselkedjen mint egy referencia típus 2015 Bánsághi Anna 39 of 84

BOXING amellett, hogy a memóriában megtalálható a változó az értékével, a CLR karbantart a változónak egy "dobozt", amely tartalmazza az eredeti változó adatait, és minden olyan további információt, ami ahhoz szükséges, hogy a változó referencia típusként tudjon működni úgy tűnhet, hogy drága dolog az egységes típusrendszer, valójában azonban a fordító nagyon jól optimalizál 2015 Bánsághi Anna 40 of 84

BOXING PÉLDA static void Main() { // a 3 egy int értéktípusú konstans, // ám itt objektumként hivatkozunk rá, meghívjuk a ToString metódusát Console.WriteLine( 3.ToString() ); 2015 Bánsághi Anna 41 of 84

BOXING ÉS UNBOXING MANUÁLISAN static void Main() { int x = 10; object xbox = x; // az x változó értéktípus // xbox az x bedobozolt másolata // Console.WriteLine( Object v ) hívódik meg Console.WriteLine( "x értéke: {0", xbox ); // Console.WriteLine( int v ) hívódik meg Console.WriteLine( "x értéke: {0", x ); static void Main() { object box = 10; int x = (int)box; // a box referencia típus, és egy objektumra mutat // x a box kidobozolt értéke, értéktípus 2015 Bánsághi Anna 42 of 84

5. TÍPUSKONSTRUKCIÓK értéktípusok deklarálására struct enum referencia típusok deklarálására array class interface delegate 2015 Bánsághi Anna 43 of 84

STRUCT kis, egyszerű adatszerkezetek deklarálására megvalósíthatnak interfészt nincs közöttük öröklődés, implicite lezártak (sealed) a static vagy const mezőket kivéve nem lehet inicializálni a mezőket nem definiálható paraméter nélküli konstruktor vagy destruktor definiálhatók paraméteres konstruktorok a new operátor nélkül is példányosíthatók a ValueType.Equals metódussal hasonlítható össze, hogy két példány azonos értékű mezőkkel rendelkezik-e 2015 Bánsághi Anna 44 of 84

STRUCT DEKLARÁLÁSA [attribútumok] módosítók struct Név : interfészek { tag_deklarációk (alapértelmezetten private hozzáférésűek) módosítók new, public, protected, internal, private 2015 Bánsághi Anna 45 of 84

// a Pont adatszerkezetet tartalmazó rekord struct Pont { public double x, y; // a mezők általában publikusak // nem jellemzők a tulajdonságok (get, set) public Pont( double x, double y ) { // két paraméteres konstruktor this.x = x; this.y = y; // a Main belépési pontot tartalmazó osztály class PontTeszt { static void Main() { var p1 = new Pont( 2, 3 ); Pont p2; p2.x = 2; p2.y = 3; // változó deklarálása és inicializálása // változó deklarálása Console.WriteLine( p1.equals(p2) ); // a mezők érték szerint összehasonlítása 2015 Bánsághi Anna 46 of 84

ENUM felsorolható elemek deklarálására csak class-ba vagy struct-ba ágyazható az első elem értéke alapértelmezettan a 0, a többié 1-gyel növekszik inicializálással a fenti sorrend felüldefiniálható az alapértelmezett egész alaptípus az int 2015 Bánsághi Anna 47 of 84

ENUM DEKLARÁLÁSA [attribútumok] módosítók enum Név : alaptípus { tag_deklarációk (kizárólag public hozzáférésűek) módosítók new, public, protected, internal, private alaptípus byte, sbyte, short, ushort, int, uint, long, ulong 2015 Bánsághi Anna 48 of 84

enum Színek { Piros, Zöld, Kék class FelsoroltTeszt { static void Main() { Színek szin = Színek.Piros; int sorszam = (int)szin; Console.WriteLine( "{0 {1", szin, sorszam ); // Piros 0 2015 Bánsághi Anna 49 of 84

// Flags attribútum használata, kiiratásnál a ToString metódus másképp működik [Flags] enum Napok : byte { // az alaptípus byte-ra állítva Hétfő = 1, // az értékek 2 hatványai a bitműveletek miatt Kedd = 2, Szerda = 4, Csütörtök = 8, Péntek = 16, Szombat = 32, Vasárnap = 64 class FelsoroltTeszt { static void Main() { Napok hétvége = Napok.Szombat Napok.Vasárnap; // bitenkénti VAGY operátor Console.WriteLine( hétvége ); // Szombat, Vasárnap 2015 Bánsághi Anna 50 of 84

ARRAY azonos típusú elemek tárolására egy tömb lehet egy- vagy többdimenziós, illetve egyenetlen a dimenziók száma és elemszáma deklaráláskor rögzítődik, és nem változhat meg az értéktípusú elemeket tartalmazó tömb 0-kal, míg a referencia típusú elemeket tartalmazó tömb null elemekkel inicializálódik az egyenetlen tömb elemei tömbök, azaz referencia típusú elemek, így null-lal inicializálódnak egy n elemű tömb indextartománya 0 és n-1 közé esik minden tömb a System.Array őstípus valamely leszármazottjának példánya, tehát objektum 2015 Bánsághi Anna 51 of 84

TÖMBÖK MINT OBJEKTUMOK using System.Linq; public static void Main() { // 2-dimenziós tömb, azaz mátrix var t1 = new int[2, 4] { {1,2,3,4, {5,6,7,8 ; // egyenetlen tömb var t2 = new int[2][] { new int[] {1,2, new int[] {3,4,5 ; Console.WriteLine( t1[0,1] ); Console.WriteLine( t2[0][1] ); Console.WriteLine( "A tömb {0 dimenziós", t1.rank ); Console.WriteLine( "Az első rész-tömb elemeinek összege {0", t2[0].sum() ); 2015 Bánsághi Anna 52 of 84

CLASS komplex felhasználói típusok létrehozására a nem-statikus osztályokból példányosítással hozhatók létre az objektumok (new), és az egyes objektumok állapota változik meg valamely tag hívásával egy tipikus C# programban különféle objektumok kommunikálnak egymással a statikus osztályok nem példányosíthatók, és mivel nincs objektum, melyen keresztül elérhetők lennének a tagok, ezért magán az osztályon keresztül érjük el a tagokat az Object.Equals metódussal hasonlítható össze, hogy két, azonos típusú példány ugyanazon a memóriacímen helyezkedik-e el (a referenciák megegyeznek) egy osztály példányait a mezők értéke alapján összehasonlítandó, felül kell definiálni vagy az Object.Equals metódust, vagy az == és!= operátorokat 2015 Bánsághi Anna 53 of 84

CLASS DEKLARÁLÁSA [attribútumok] módosítók class Név : ősosztály, interfészek { tag_deklarációk (alapértelmezetten private hozzáférésűek) módosítók new, public, protected, abstract, sealed internal, private, 2015 Bánsághi Anna 54 of 84

// a Pont adatszerkezetet tartalmazó osztály class Pont { public double X { get; set; // általában tulajdonságokat használunk public double Y { get; set; // mezők helyett public Pont() { // felüldefiniálható paraméter nélküli konstruktor this.x = this.y = 0; public Pont( double x, double y ) { this.x = x; this.y = y; // a Main belépési pontot tartalmazó osztály class PontTeszt { static void Main() { Pont p1 = new Pont( 2, 3 ); // objektum példányosítása és inicializálása Pont p2 = p1; // p2 egy álnév az előzőleg létrehozott objektumra Console.WriteLine( p1.equals(p2)); // referenciák összehasonlítása 2015 Bánsághi Anna 55 of 84

CLASS - SZÁRMAZTATÁS más osztályok viselkedésének újrafelhasználására, kiterjesztésére, módosítására szolgál újrafelhasználás a példány konstruktorokat, a statikus konstruktorokat és a destruktorokat kivéve minden ősosztálybeli tag implicite öröklődik, így azok implementálás nélkül újra felhasználhatók a származtatott osztályban kiterjesztés a származtatott osztályban új tagokat lehet deklarálni, így az ősosztály egy kiterjesztett változatát kapjuk módosítás az öröklött tagok elfedhetők vagy felüldefiniálhatók (újra implementálhatók), így módosítva az ősosztálybeli tagok jelentését 2015 Bánsághi Anna 56 of 84

SZÁRMAZTATÁS JELLEMZŐI egy osztálynak csak egyetlen közvetlen őse lehet, bár maga a származtatás tranzitív művelet: A B B C A C tetszőleges ősosztálybeli tag elfedhető (new) a származtatott osztályban, bár a polimorfizmus megszűnik az ősosztálybeli virtual tagok felüldefiniálhatók (override) a származtatott osztályban az absztrakt osztályok nem példányosíthatók, és a metódusok csak szignatúrával szerepelnek, implementáció nélkül az ősosztálybeli absztrakt tagokat kötelező felüldefiniálni az első közvetlen, nem-absztrakt származtatott osztályban az interfész hasonlít egy kizárólag absztrakt metódusokat tartalmazó absztrakt osztályra, melyet implementálni kell az interfészt megvalósító osztályban a származtatott osztály minden ősbeli tagot örököl, viszont csak a nem private tagokhoz fér hozzá 2015 Bánsághi Anna 57 of 84

POLIMORFIZMUS JELLEMZŐI jelentése: többalakúság fordítási és futási idejű típus egy származtatott osztálybeli objektum a program futásának bizonyos pontjain viselkedhet úgy, mintha ősosztálybeli objektum volna. Ilyenkor az objektum fordítási idejű típusa különbözik az objektum futási idejű típusától korai és késői kötés az ősben definiált vagy implementált virtuális metódusok felüldefiniálhatók a leszármazottban, azaz saját definíció és implementáció adható. Futás alatt a CLR a futási idejű típus alapján hívja meg a metódusokat, tehát fordítási időben az ős metódusát hívjuk, míg futási időben a leszármazottét 2015 Bánsághi Anna 58 of 84

származtatás felüldefiniálás felüldefiniálása elfedés TAGOK TÖBBALAKÚSÁGA az ős tagjainak átvétele minden módosítás nélkül az ősosztálybeli virtual vagy abstract tagok nem virtuális tagok elfedése új implementációval 2015 Bánsághi Anna 59 of 84

FELÜLDEFINIÁLÁS, ELFEDÉS mezők nem lehetnek virtuálisak, csak a tulajdonságok, metódusok, események, indexelők az ősosztálybeli implementáció megmarad, a közvetlen ős tagja hívható a base kulcsszóval ha A B és B C, és B-ben felüldefináltunk egy A-beli virtuális tagot, az a C szempontjából virtuális, tehát felüldefiniálható C-ben ha C-ben meg akarjuk akadályozni a B-ben felüldefiniált tag újbóli felüldefiniálását, azt a sealed módosítóval jelezzük ha meg akarjuk szüntetni az ős és a leszármazott közötti virtuális hívást, akkor a leszármazottban a new módosítóval fedjük el az ősosztálybeli tagot 2015 Bánsághi Anna 60 of 84

public class A { public virtual void Egyik() { public virtual void Masik() { public virtual void Harmadik() { public virtual void Negyedik() { public class B : A { public override void Egyik() { // új funkcionalitás... public override void Masik() { // új funkcionalitás... base.masik(); // A.Egyik felüldefiniálása // A.Masik felüldefiniálása // A.Masik hívása public sealed override void Harmadik() { // A.Harmadik lezárása // új funkcionalitás... public new void Negyedik() { // új funkcionalitás... // A.Negyedik elfedése 2015 Bánsághi Anna 61 of 84

INTERFACE olyan, mint egy absztrakt ősosztály, nem tartalmaz implementációt az interfészt megvalósító osztálynak vagy rekordnak implementálnia kell az interfész tagjait nem példányosítható tagjai lehetnek események, metódusok, indexelők, tulajdonságok egy osztály vagy rekord egy vagy több interfészt is megvalósíthat az explicite megvalósított tagok publikusak és nem-statikusak kell hogy legyenek 2015 Bánsághi Anna 62 of 84

INTERFACE DEKLARÁLÁSA [attribútumok] módosítók interface Név : interfészek { tag_deklarációk (kizárólag public hozzáférésűek) módosítók new, public, protected, internal, private 2015 Bánsághi Anna 63 of 84

FONTOSABB BEÉPÍTETT INTERFÉSZEK IEnumerable, IEnumerable<T> esetén IDisposable IQueryable<T> INotifyPropertyChange foreach és LINQ használata using utasítással használt erőforrások esetén lekérdezhető adatforrások kéréseihez IComparable<T>, IComparer<T> grafikus felületek adatkötéseihez IEquatable<T>, IEqualityComparer<T> egyenlőség-vizsgálatokhoz IList<T>, ICollection<T> IDictionary<K, T> általánosított rendezésekhez általánosított változékony gyűjteményekhez gyűjteményekben való keresésekhez 2015 Bánsághi Anna 64 of 84

PONTOK RENDEZÉSE class Pont : IComparable<Pont> { public double X { get; set; public double Y { get; set; public Pont( double x, double y ) { this.x = x; this.y = y; // a System.IComparable.CompareTo<T> metódus megvalósítása public int CompareTo( Pont that ) { if( that == null ) return 1; // a System.Double.CompareTo megvalósított metódusok hívása return this.x.compareto( that.x ) + this.y.compareto( that.y ); // a System.Object.ToString metódus felüldefiniálása public override string ToString() { return "(" + this.x.tostring() + "," + this.y.tostring() + ")"; 2015 Bánsághi Anna 65 of 84

class Teszt { static void Main() { List<Pont> pontok = new List<Pont>(); pontok.add( new Pont(1, 2)); pontok.add( new Pont(2, 3)); pontok.add( new Pont(1, 1)); // a List generikus típus Sort metódusát hívjuk, mely // az imént megvalósított Pont.CompareTo metódust használja pontok.sort(); foreach( var pont in pontok ) { Console.WriteLine( pont ); // a Pont.ToString metódus hívása 2015 Bánsághi Anna 66 of 84

DELEGATE arra szolgálnak, hogy metódusokat adhassunk át paraméterként más metódusoknak a delegált deklaráció egy függvény-szignatúra típust definiál egy delegált példány egységbezár egy hívási listát, melyben egy vagy több, azonos szignatúrájú és visszatérési típusú metódus referencia található egy delegált példány hívása során az argumentumain meghívódnak a listában található metódusok 2015 Bánsághi Anna 67 of 84

DELEGATE DEKLARÁLÁSA [attribútumok] módosítók delegate visszatérési_típus Név ( formális_paraméterek ); módosítók new, public, protected, internal, private 2015 Bánsághi Anna 68 of 84

class Szoveg { public string Mondat { get; set; public Szoveg( string mondat ) { this.mondat = mondat; public void Kettospont() { this.mondat = this.mondat.replace( ' ', ':' ); public void Nagybetus() { this.mondat = this.mondat.toupper(); public void Kisbetus() { this.mondat = this.mondat.tolower(); 2015 Bánsághi Anna 69 of 84

// delegált deklaráció a megfelelő visszatérési típussal és szignatúrával delegate void AtalakitoDelegate(); class Teszt { static void Main() { var szoveg = new Szoveg( "Delegált teszt" ); // delegált típusú referencia létrehozása AtalakitoDelegate atalakito; // a "szoveg" objektum néhány metódusát felvesszük a delegált metódusok közé atalakito = szoveg.kettospont; atalakito += szoveg.nagybetus; // meghívjuk a delegáltat, melyhez hozzá van rendelve // a "szoveg" objektum és annak néhány metódusa atalakito(); Console.WriteLine( szoveg.mondat ); // DELEGÁLT:TESZT 2015 Bánsághi Anna 70 of 84

PÉLDA 1. Tegyük fel, hogy egy netes vásárlást megvalósító alkalmazáson dolgozunk, és feladatunk a kosárban található áruk ellenértékenek számítása. A számítás egyik lépése a kedvezmények kalkulációja. class Kosar { public void Feldolgozas() { int kedvezmeny = 5; // a feldolgozás során beállítjuk a kedvezményt //... class KosarTeszt { static void Main() { var kosar = new Kosar(); kosar.feldolgozas(); // külső programból hívódik meg a Feldolgozás metódus 2015 Bánsághi Anna 71 of 84

2. Egy idő utána az üzlet oldaláról kérés érkezik, hogy a délelőtti vásárlásokra nagyobb kedvezményt adjunk Módosítjuk tehát a Feldolgozás metódust class Kosar { public void Feldolgozas() { int kedvezmeny = 5; if( DateTime.Now.Hour < 12 ) { kedvezmeny = 10; //... 2015 Bánsághi Anna 72 of 84

3. A következő héten újabb kérés érkezik az üzlet oldaláról, hogy módosítsunk a kedvezmények számításán Ekkor arra gondolunk, hogy jó lenne a kedvezmény kalkulációt delegálni oda, ahol kitalálják class KosarTeszt { static void Main() { var kosar = new Kosar(); // paramétere egy int típusú értékkel kosar.feldolgozas( 5 ); // paramétere egy kulcs-érték párokat tartalmazó asszociatív tömb kosar.feldolgozas( new Dictionary ); // paramétere egy kedvezményt számító metódus kosar.feldolgozas( kedvezmenykalkulacio ); 2015 Bánsághi Anna 73 of 84

DELEGATE DEKLARÁCIÓ, PÉLDÁNYOSÍTÁS, HÍVÁS delegate int KedvezmenyDelegate(); // delegált típus deklarálása class KosarTeszt { static void Main() { // delegált explicit példányosítása, és egy metódus hozzárendelése var delegalt_1 = new KedvezmenyDelegate( class.method ); // delegált implicit példányosítása, és egy metódus hozzárendelése KedvezmenyDelegate delegalt_2 = class.method; var kosar = new Kosar(); // a delegált példány paraméterként való átadása kosar.feldolgozas( delegalt_1 ); class Kosar { public void Feldolgozas( KedvezmenyDelegate kedvezmenyszamitas ) { // a delegált példányhoz rendelt metódusok hívása int kedvezmeny = kedvezmenyszamitas(); 2015 Bánsághi Anna 74 of 84

delegate int KedvezmenyDelegate(); class Kalkulacio { public static int Szamitas() { int kedvezmeny = 5; if( DateTime.Now.Hour < 12 ) { kedvezmeny = 10; else if( DateTime.Now.Hour < 20 ) { kedvezmeny = 15; return kedvezmeny; class Kosar { public void Feldolgozas( KedvezmenyDelegate kedvezmenyszamitas ) { int kedvezmeny = kedvezmenyszamitas(); class KosarTeszt { static void Main() { var kosar = new Kosar(); KedvezmenyDelegate delegalt = Kalkulacio.Szamitas; kosar.feldolgozas( delegalt ); 2015 Bánsághi Anna 75 of 84

NÉVTELEN PÉLDÁNYOSÍTÁS minden objektum létrehozható név nélkül is, ekkor a kódban nem tudunk hivatkozni rá var pont = new Pont(); // nevesített Pont objektum new Pont(); // név nélküli Pont objektum // nevesített delegáltak példányosítása var delegalt_1 = new KedvezmenyDelegate( Kalkulacio.Szamitas ); KedvezmenyDelegate delegalt_2 = Kalkulacio.Szamitas; kosar.feldolgozas( delegalt_1 ); // explicit // implicit // név nélküli delegáltak példányosítása kosar.feldolgozas( new KedvezmenyDelegate( Kalkulacio.Szamitas )); // explicit kosar.feldolgozas( Kalkulacio.Szamitas ); // implicit 2015 Bánsághi Anna 76 of 84

GENERIKUS ACTION ÉS FUNC OSZTÁLYOK ha.net 1.1-et használnánk, meg is állhatnánk, de a.net 3.5-re kiforrott a generikusok és az Action és a Func osztályok technikája mindenhol, ahol delegate típusú paramétert várunk, ott használható a megfelelő szignatúráju Func vagy Action ez azt jelenti, hogy a fenti példában nincs szükség a delegate típusra, helyette használhatjuk a Func<int>-et kosar.feldolgozas( new KedvezmenyDelegate( Kalkulacio.Szamitas )); // explicit kosar.feldolgozas( new Func<int>( Kalkulacio.Szamitas )); // explicit kosar.feldolgozas( Kalkulacio.Szamitas ); // implicit 2015 Bánsághi Anna 77 of 84

class Kalkulacio { public static int Szamitas() { int kedvezmeny = 5; if( DateTime.Now.Hour < 12 ) { kedvezmeny = 10; else if( DateTime.Now.Hour < 20 ) { kedvezmeny = 15; return kedvezmeny; class Kosar { public void Feldolgozas( Func<int> kedvezmenyszamitas ) { int kedvezmeny = kedvezmenyszamitas(); class KosarTeszt { static void Main() { var kosar = new Kosar(); kosar.feldolgozas( Kalkulacio.Szamitas ); 2015 Bánsághi Anna 78 of 84

4. Tegyük fel, hogy a menedzsment újra módosít a kedvezmények számításán, és bevezet egy "különleges" státuszt, ami a kosár tartalma alapján határozott meg 2015 Bánsághi Anna 79 of 84

class Kalkulacio { public static int Szamitas( bool kulonleges ) { int kedvezmeny = 5; if( kulonleges ) { kedvezmeny = 40; else if( DateTime.Now.Hour < 12 ) { kedvezmeny = 10; else if( DateTime.Now.Hour < 20 ) { kedvezmeny = 15; return kedvezmeny; class Kosar { public void Feldolgozas( Func<bool, int> kedvezmenyszamitas ) { int kedvezmeny = kedvezmenyszamitas( true ); class KosarTeszt { static void Main() { var kosar = new Kosar(); kosar.feldolgozas( Kalkulacio.Szamitas ); 2015 Bánsághi Anna 80 of 84

NÉVTELEN FÜGGVÉNYEK.NET 3.5-ben a delegate kulcsszó két jelentéssel bír 1. függvény-szignatúra típus deklarálására (ahogy eddig) 2. helyben kifejtett névtelen függvény deklarálására tovább finomítva a kódot, ahelyett, hogy létrehoznánk egy új osztályt a kedvezmények számítására, használhatunk névtelen függvényeket is, megelőzve a névtereink elszennyeződését // Func<string, int> szignatúrájú névtelen függvény explicit példányosítása new Func<string, int> delegate(string s) { Console.WriteLine( s ); return 0; // Func<string, int> szignatúrájú névtelen függvény implicit példányosítása delegate(string s) { Console.WriteLine( s ); return 0; 2015 Bánsághi Anna 81 of 84

class Kosar { public void Feldolgozas( Func<bool, int> kedvezmenyszamitas ) { int kedvezmeny = kedvezmenyszamitas( true ); class KosarTeszt { static void Main() { var kosar = new Kosar(); kosar.feldolgozas( delegate( bool kulonleges ) { int kedvezmeny = 5; if( kulonleges ) { kedvezmeny = 40; else if( DateTime.Now.Hour < 12 ) { kedvezmeny = 10; else if( DateTime.Now.Hour < 20 ) { kedvezmeny = 15; return kedvezmeny; )); 2015 Bánsághi Anna 82 of 84

LAMBDA KIFEJEZÉSEK a delegált névtelen metódusok haszna a.net beépített metódusainál kézzelfogható, viszont a mi kódunk tovább egyszerűsíthető a delegált névtelen függvényt lecserélhetjük egy megfelelő paraméterekkel rendelkező lambda kifejezésre delegate(string s) { Console.WriteLine( s ); return 0; s => { Console.WriteLine( s ); return 0; 2015 Bánsághi Anna 83 of 84

class Kosar { public void Feldolgozas( Func<bool, int> kedvezmenyszamitas ) { int kedvezmeny = kedvezmenyszamitas( true ); class KosarTeszt { static void Main() { var kosar = new Kosar(); kosar.feldolgozas( kulonleges => { int kedvezmeny = 5; if( kulonleges ) { kedvezmeny = 40; else if( DateTime.Now.Hour < 12 ) { kedvezmeny = 10; else if( DateTime.Now.Hour < 20 ) { kedvezmeny = 15; return kedvezmeny; ); 2015 Bánsághi Anna 84 of 84