Bánsághi Anna

C# áttekintés - 1

1. előadás

ESEMÉNYVEZÉRELT PROGRAMOZÁS © Bánsághi Anna [email protected]

1. ELŐADÁS - C# ÁTTEKINTÉS - 1

2015 © Bánsághi Anna

1 of 84

C# áttekintés - 1

1. előadás

TEMATIKA I. C# ÁTTEKINTÉS II. WPF III. Modern UI


2 of 84

C# áttekintés - 1

1. előadás

I. C# ÁTTEKINTÉS 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.


Szoftver keretrendszer A C# lényegi elemei A C# program Érték- és referencia típusok Típuskonstrukciók Változók, paraméterek Utasítások, kifejezések, operátorok Generikusok Kivételkezelés Attribútumok XML dokumentáció

3 of 84

C# áttekintés - 1

1. előadás

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


4 of 84

C# áttekintés - 1

1. előadás

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


5 of 84

C# áttekintés - 1

1. előadás

FORDÍTÁS ÉS FUTTATÁS 1. a programnyelvi kód egy alacsonyszintű, gépfüggetlen köztes nyelvre fordul, ez a köztes nyelvű kód 2. 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ő 3. az ellenőrzött és biztonságos gépi kódot az operációs rendszer futtatja


6 of 84

C# áttekintés - 1


1. előadás

7 of 84

C# áttekintés - 1

1. előadás

.NET KERETRENDSZER .NET 1.0 - 2001 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)


8 of 84

C# áttekintés - 1

1. előadás

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)


9 of 84

C# áttekintés - 1

1. előadás

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


10 of 84

C# áttekintés - 1

1. előadás

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


11 of 84

C# áttekintés - 1

1. előadás

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ő)


12 of 84

C# áttekintés - 1

1. előadás

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ó


13 of 84

C# áttekintés - 1

1. előadás

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()


14 of 84

C# áttekintés - 1

1. előadás

Ú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


15 of 84

C# áttekintés - 1

1. előadás

Ú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


16 of 84

C# áttekintés - 1

1. előadás

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


17 of 84

C# áttekintés - 1

1. előadás

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ó


18 of 84

C# áttekintés - 1

1. előadás

PLATFORMOK a C# tipikusan Windows platformokon futó programok írására alkalmas több platformon futó alkalmazásokhoz a Java-t érdemes választani


19 of 84

C# áttekintés - 1

1. előadás

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


20 of 84

C# áttekintés - 1

1. előadás

3. A C# PROGRAM a program logikai tagolását az egymásba ágyazható névterek biztosítják 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

ASSEMBLY FAJTÁK alkalmazás belépési ponttal rendelkezik, .exe kiterjesztésű könyvtár nincs belépési pontja, általában .dll kiterjesztésű


21 of 84

C# áttekintés - 1

1. előadás

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


22 of 84

C# áttekintés - 1

1. előadás

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


23 of 84

C# áttekintés - 1

1. előadás

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


24 of 84

C# áttekintés - 1

1. előadás

AUTOMATIKUS MEMÓRIAKEZELÉS 1. 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 2. 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 3. ha egy objektum megsemmisítésre lett jelölve, akkor valamikor később lefut a destruktora 4. 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 5. valamikor később a szemétgyűjtő felszabadítja azokat a memóriaszeleteket, ahol gyűjtésre kijelölt objektumok helyezkednek el


25 of 84

C# áttekintés - 1

1. előadás

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ó namespace típus deklarációk: 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


26 of 84

C# áttekintés - 1

1. előadás

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


27 of 84

C# áttekintés - 1

1. előadás

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


28 of 84

C# áttekintés - 1

1. előadás

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


29 of 84

C# áttekintés - 1

1. előadás

MINŐSÍTETT NEVEK class A {}

// A

namespace X {

// X

class B { class C {} }

// X.B // X.B.C

namespace Y { class D {} }

// X.Y // X.Y.D

} namespace X.Y { class E {} }


// X.Y // X.Y.E

30 of 84

C# áttekintés - 1

1. előadás

NEVEK ELREJTÉSE EGYMÁSBA ÁGYAZÁSSAL class A { void F() { int i = 1; this.i = 5; } void G() { i = 1; } int i = 0;

// lokális változó, elfedi az i tagot // az i tag elérhető a this minősítővel

// 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

31 of 84

C# áttekintés - 1

1. előadás

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


32 of 84

C# áttekintés - 1


1. előadás

33 of 84

C# áttekintés - 1


1. előadás

34 of 84

C# áttekintés - 1

1. előadás

É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


35 of 84

C# áttekintés - 1

1. előadás

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


36 of 84

C# áttekintés - 1

1. előadás

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


37 of 84

C# áttekintés - 1

1. előadás

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


38 of 84

C# áttekintés - 1

1. előadás

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


39 of 84

C# áttekintés - 1

1. előadás

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


40 of 84

C# áttekintés - 1

1. előadás

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() ); }


41 of 84

C# áttekintés - 1

1. előadás

BOXING ÉS UNBOXING MANUÁLISAN static void Main() { int x = 10;

// az x változó értéktípus

object xBox = x;

// 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;

// a box referencia típus, és egy objektumra mutat

int x = (int)box;

// x a box kidobozolt értéke, értéktípus

}


42 of 84

C# áttekintés - 1

1. előadás

5. TÍPUSKONSTRUKCIÓK értéktípusok deklarálására struct enum referencia típusok deklarálására array class interface delegate


43 of 84

C# áttekintés - 1

1. előadás

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


44 of 84

C# áttekintés - 1

1. előadás

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


45 of 84

C# áttekintés - 1

1. előadás

// 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 ) { this.x = x; this.y = y; }

// két paraméteres konstruktor

}

// a Main belépési pontot tartalmazó osztály class PontTeszt { static void Main() { var p1 = new Pont( 2, 3 );

// változó deklarálása és inicializálása

Pont p2; p2.x = 2; p2.y = 3;

// változó deklarálása

Console.WriteLine( p1.Equals(p2) );

// a mezők érték szerint összehasonlítása

} }


46 of 84

C# áttekintés - 1

1. előadás

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


47 of 84

C# áttekintés - 1

1. előadás

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


48 of 84

C# áttekintés - 1

1. előadás

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

} }


49 of 84

C# áttekintés - 1

1. előadás

// 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

} }


50 of 84

C# áttekintés - 1

1. előadás

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


51 of 84

C# áttekintés - 1

1. előadás

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() ); }


52 of 84

C# áttekintés - 1

1. előadás

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

C# áttekintés - 1

1. előadás

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, internal, private, abstract, sealed


54 of 84

C# áttekintés - 1

1. előadás

// 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

} }


55 of 84

C# áttekintés - 1

1. előadás

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


56 of 84

C# áttekintés - 1

1. előadás

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á


57 of 84

C# áttekintés - 1

1. előadás

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


58 of 84

C# áttekintés - 1

1. előadás

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


59 of 84

C# áttekintés - 1

1. előadás

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


60 of 84

C# áttekintés - 1

public class A { public virtual public virtual public virtual public virtual }

1. előadás

void void void void

Egyik() { } Masik() { } Harmadik() { } Negyedik() { }

public class B : A { public override void Egyik() { // új funkcionalitás ... }

// A.Egyik felüldefiniálása

public override void Masik() { // új funkcionalitás ... base.Masik(); }

// A.Masik felüldefiniálása

public sealed override void Harmadik() { // új funkcionalitás ... }

// A.Harmadik lezárása

public new void Negyedik() { // új funkcionalitás ... }

// A.Negyedik elfedése

// A.Masik hívása

}


61 of 84

C# áttekintés - 1

1. előadás

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


62 of 84

C# áttekintés - 1

1. előadás

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) }



63 of 84

C# áttekintés - 1

1. előadás

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


64 of 84

C# áttekintés - 1

1. előadás

PONTOK RENDEZÉSE class Pont : IComparable { 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 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() + ")"; } }


65 of 84

C# áttekintés - 1

1. előadás

class Teszt { static void Main() { List pontok = new pontok.Add( new Pont(1, pontok.Add( new Pont(2, pontok.Add( new Pont(1,

List(); 2)); 3)); 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 } } }


66 of 84

C# áttekintés - 1

1. előadás

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


67 of 84

C# áttekintés - 1

1. előadás

DELEGATE DEKLARÁLÁSA [attribútumok] módosítók delegate visszatérési_típus Név ( formális_paraméterek );



68 of 84

C# áttekintés - 1

1. előadás

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(); } }


69 of 84

C# áttekintés - 1

1. előadás

// 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

} }


70 of 84

C# áttekintés - 1

1. előadás

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 } }


71 of 84

C# áttekintés - 1

1. előadás

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; } // ... } }


72 of 84

C# áttekintés - 1

1. előadás

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 ); } }


73 of 84

C# áttekintés - 1

1. előadás

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(); } }


74 of 84

C# áttekintés - 1

1. előadás

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 ); } }


75 of 84

C# áttekintés - 1

1. előadás

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(); new Pont();

// nevesített Pont objektum // 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 );

// név nélküli delegáltak példányosítása kosar.Feldolgozas( new KedvezmenyDelegate( Kalkulacio.Szamitas )); kosar.Feldolgozas( Kalkulacio.Szamitas );


// explicit // implicit

// explicit // implicit

76 of 84

C# áttekintés - 1

1. előadás

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-et kosar.Feldolgozas( new KedvezmenyDelegate( Kalkulacio.Szamitas )); kosar.Feldolgozas( new Func( Kalkulacio.Szamitas ));

// explicit // explicit

kosar.Feldolgozas( Kalkulacio.Szamitas );

// implicit


77 of 84

C# áttekintés - 1

1. előadás

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 kedvezmenySzamitas ) { int kedvezmeny = kedvezmenySzamitas(); } } class KosarTeszt { static void Main() { var kosar = new Kosar(); kosar.Feldolgozas( Kalkulacio.Szamitas ); } }


78 of 84

C# áttekintés - 1

1. előadás

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


79 of 84

C# áttekintés - 1

1. előadás

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 kedvezmenySzamitas ) { int kedvezmeny = kedvezmenySzamitas( true ); } } class KosarTeszt { static void Main() { var kosar = new Kosar(); kosar.Feldolgozas( Kalkulacio.Szamitas ); } }


80 of 84

C# áttekintés - 1

1. előadás

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; }


81 of 84

C# áttekintés - 1

1. előadás

class Kosar { public void Feldolgozas( Func 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; })); } }


82 of 84

C# áttekintés - 1

1. előadás

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; }


83 of 84

C# áttekintés - 1

1. előadás

class Kosar { public void Feldolgozas( Func 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; }); } }


84 of 84

Bánsághi Anna

Recommend Documents