Bánsághi Anna

C# áttekintés - 2

2. előadás

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

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

2015 © Bánsághi Anna

1 of 64

C# áttekintés - 2

2. előadás

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


2 of 64

C# áttekintés - 2

2. 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 64

C# áttekintés - 2

2. előadás

6. VÁLTOZÓK, PARAMÉTEREK változók, konstansok statikus mező példány mező tömb eleme paraméterek érték paraméter referencia paraméter kimenő paraméter lokális paraméter


4 of 64

C# áttekintés - 2

2. előadás

VÁLTOZÓ FAJTÁK statikus változó vagy statikus mező, mely létrejön, amikor az alkalmazás tartomány is, a statikus konstruktorok előtt példány változó vagy mező, akkor jön létre, amikor az objektum példányosul (class esetén), vagy amikor a változó deklarálódik (struct esetén) tömb elem a tömb létrehozásával egy időben jön létre


5 of 64

C# áttekintés - 2

2. előadás

VÁLTOZÓ JELLEMZŐK a változó egy memóriatartalmat reprezentál minden változónak van típusa, ami meghatározza, hogy milyen típusú érték tárolható abban a változóban egy változó típusa nem változtatható meg, míg az értéke igen a változó értékéhez való hozzáférés előtt definiálni kell azt automatikusan alapértelmezett értéket kap, az értéktípusok az alapértelmezett konstruktorban beállított értéket, míg a referencia típusok null-t


6 of 64

C# áttekintés - 2

2. előadás

PARAMÉTER FAJTÁK érték paraméter metódus hívásakor jön létre, klónozódik az aktuális paraméter értéke referencia paraméter metódus hívásakor egy új referenciát állít az aktuális paraméterre, nem jön létre új objektum kimenő paraméter metódus hívásakor egy új referenciát állít az aktuális paraméterre, nem jön létre új objektum lokális paraméter blokkban jön létre, és a blokk végéig él


7 of 64

C# áttekintés - 2

2. előadás

VÁLTOZÓK ÉS PARAMÉTEREK class A { public static int x; private int y;

// x statikus változó // y példány változó

// a érték paraméter // b referencia paraméter // c kimenő paraméter void F( int[] v, int a, ref int b, out int c ) { // i lokális változó int i = v[0]; // v[0] tömb elem c = a + b++; } }


8 of 64

C# áttekintés - 2

2. előadás

VÁLTOZÓK, PARAMÉTEREK DEKLARÁLÁSA class A { void F() { // fordítási időben explicite meghatározott x típusa int x = 12; // fordítási időben implicite meghatározott y típusa var y = new int(); // a C# statikusan típusos nyelv, de a dinamikusnak deklarált változók, // paraméterek vagy objektumok típusa futási időben lesz meghatározva dynamic z = 12; } }


9 of 64

C# áttekintés - 2

2. előadás

7. UTASÍTÁSOK, KIFEJEZÉSEK, OPERÁ‐ TOROK utasítás a program által végrehajtott tevékenység kifejezés operátorok és operandusok kiértékelendő sorozata operátor egy vagy több operandusú művelet névtelen függvény egy vagy több operandusú, helyben kifejtett művelet túlterhelhető operátor felhasználói típusokban túlterhelt statikus operátor konverziós operátor adott típusú objektum konvertálása más típusú objektummá


10 of 64

C# áttekintés - 2

2. előadás

UTASÍTÁSOK általános tevékenységek, úm. változó deklarálás, értékadás, metódushívás, gyűjteményeken való végiglépdelés, feltételtől függő elágazás az utasítások végrehajtási sorrendjét hívjuk vezérlési folyamnak, mely a program különböző bemenő paraméterekkel való futtatásai esetén más és más lehet egysoros utasítás áll egyetlen kódsorból pontosvesszővel a végén blokk utasítás egysoros utasítások szekvenciája


11 of 64

C# áttekintés - 2

2. előadás

UTASÍTÁS FAJTÁK 1. üres nem csinál semmit, egyetlen pontosvesszőből áll deklarációs új változó vagy konstans deklarálása kifejezés egy kifejezés által kiszámított érték változóhoz rendelése feltételes feltételtől függően végrehajtandó kódrészlet (if, switch) iterációs ugyanazon kódrészlet ismételt végrehajtása valamely feltétel fennállásáig (while, do, for, foreach) ugró vezérlésátadó utasítások (break, continue, default, goto, return, yield) kivételkezelő futási időben felmerülő rendkívüli események kezelésére (try-catch-finally, throw)


12 of 64

C# áttekintés - 2

2. előadás

UTASÍTÁS FAJTÁK 2. checked/unchecked az egészek túlcsordulását ellenőrző utasítás pár await aszinkron metódusokban a végrehajtás felfüggesztésére yield return nagy adatfolyamok bejárására, egyszerre csak egy adat van a memóriában fixed a memóriában áthelyezhetetlen változó jelölésére lock több szálú program esetén objektumok zárolására cimkézett azonosítóval ellátott blokk, melyre egy goto utasítással adjuk át a vezérlést using erőforrások megnyitására, hozzáférésére, bezárására


13 of 64

C# áttekintés - 2

2. előadás

UTASÍTÁS JELLEMZŐI beillesztett utasítás a feltételes vagy iterációs utasítások után mindig van egy egysoros utasítás vagy egy blokk illesztmény beágyazott utasítás a blokk utasítások egymásba ágyazhatók elérhetetlen utasítás a vezérlési folyamba soha nem kerülő utasítás, a fordító figyelmeztet, ha ilyennel találkozik


14 of 64

C# áttekintés - 2

2. előadás

KIFEJEZÉSEK egy kifejezés kiértékelés után értéket, objektumot, metódust vagy névteret eredményez kifejezés tartalmazhat literálokat, metódushívásokat, operátorokat és azok operandusait, valamint neveket (változónevet, típus tagot, metódus paramétert, névteret, típust) x + y

// numerikus értéket eredményez

new Osztaly()

// az új példányra való referenciát eredményez

objektum.ToString()

// string típusú értéket eredményez


15 of 64

C# áttekintés - 2

2. előadás

KIFEJEZÉS FAJTÁK metódushívás a metódus nevével és paramétereivel hívható, void visszatérési típusú metódus nem használható kifejezésben lekérdezés LINQ adatbázislekérdezések lambda névtelen függvény hívások kifejezésfa a kifejezéseket fa adatszerkezetben adjuk meg


16 of 64

C# áttekintés - 2

2. előadás

OPERÁTOROK unáris egy operandusú operátorok: ++, new bináris két operandusú operátorok: =, + ternáris egyetlen három operandusú operátor a ?:


17 of 64

C# áttekintés - 2

2. előadás

OPERÁTOROK JELLEMZŐI egy kifejezés több részkifejezésből állhat, és az operátorokat tartalmazó részkifejezések kiértékelési sorrendjét meghatározza három szabály: 1. a nyelv által definiált operátor precedencia 2. azonos precedenciájú operátorok esetén a (bal vagy jobb) asszociativitási szabály 3. és a zárójelezés, mely felülírja az előző két szabály szerinti kiértékelési sorrendet


18 of 64

C# áttekintés - 2

2. előadás

NÉVTELEN FÜGGVÉNYEK ahol delegáltak használhatók, ott használhatók helyben kifejtett utasítások vagy helyben kifejtett kifejezések lambda kifejezések delegáltak vagy kifejezésfák létrehozására. Lokális függvények, melyek paraméterként átadhatók vagy függvényhívás visszatérő értéke lehet névtelen metódusok delegáltak vagy névtelen függvények létrehozására


19 of 64

C# áttekintés - 2

2. előadás

LAMBDA KIFEJEZÉSEK a lambda operátor => baloldalán felsoroljuk a kifejezés bemenő paramétereit, a jobboldalán pedig a kifejezést vagy utasítás blokkot delegate int Delegalt( int i );

// delegált típus deklaráció

static void Main(string[] args) { Delegalt delegalt = x => x * x; int j = delegalt(5); }

// az x paraméter négyzete // j = 25

using System.Linq.Expressions; delegate int Delegalt( int i );

// delegált típus deklaráció

static void Main() { Expression kifejezesfa = x => x * x; }


20 of 64

C# áttekintés - 2

2. előadás

KIFEJEZÉS LAMBDÁK amikor a lambda operátor jobboldalán kifejezést használunk a kifejezés lambda a jobboldálan álló kiértékelt kifejezés eredményével tér vissza (bemenő paraméterek) => kifejezés

x => x * x

// aritmetikai kifejezés

(x, y) => x == y

// értékadó kifejezés

(int x, string s) => s.Length > x

// a paraméterek típusa explicite megadott

() => Metódus()

// paraméter nélküli kifejezés lambda


21 of 64

C# áttekintés - 2

2. előadás

UTASÍTÁS LAMBDÁK amikor a lambda operátor jobboldalán egy utasítás blokkot használunk a blokkban található utasítások hajtódnak végre (bemenő paraméterek) => { utasítás blokk }

n => { Console.WriteLine( n ); } n => { Console.WriteLine( n ); return n; } n => { string s = "Kiírva: " + n + "!"; Console.WriteLine( s ); }


22 of 64

C# áttekintés - 2

2. előadás

BEÉPÍTETT LEKÉRDEZŐ OPERÁTOROK számtalan beépített lekérdező operátor használja a Func típusú generikus delegáltak valamelyikét: using System.Linq; int[] számok = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 }; // a Count metódus a fenti generikus egy példányát várja: Func int páratlanokSzáma = számok.Count( n => n % 2 == 1 ); // a Where metódus példánya: Func var párosak = számok.Where( n => n % 2 == 0 ); // a TakeWhile metódus példánya: Func var hatnálKisebbek = számok.TakeWhile( n => n < 6 ); foreach( var szám in hatnálKisebbek ) { Console.WriteLine( szám ); }


// 5 4 1 3

23 of 64

C# áttekintés - 2

2. előadás

using System; using System.Collections.Generic; using System.Linq; class PontTeszt { static void Main() { List pontok = new List(); pontok.Add( new Pont(1, 2)); pontok.Add( new Pont(2, 3)); pontok.Add( new Pont(1, 1)); // az OrderBy metódus példánya: Func var ySzerintRendezett = pontok.OrderBy( p => p.Y ); foreach( var pont in ySzerintRendezett ) { Console.WriteLine( pont ); } // az Average metódus példánya: Func var atlag = pontok.Average( p => ( p.X + p.Y ) / 2 );

// (1,1) (1,2) (2,3)

// 1.6666667

} }


24 of 64

C# áttekintés - 2

2. előadás

NÉVTELEN METÓDUSOK a delegate kulcsszóval hozunk létre helyben kifejtett névtelen metódusokat delegate( formális paraméterek listája ) { utasítás blokk }

a lambda kifejezések kiszorították a névtelen metódusokat, leegyszerűsítve a névtelen metódusok szintaxisát (formális paraméterek listája) => kifejezés (formális paraméterek listája) => { utasítás blokk }


25 of 64

C# áttekintés - 2

2. előadás

TÚLTERHELHETŐ OPERÁTOROK a felhasználói típusokban felüldefiniálható számos operátor mindig statikusnak kell lennie public static Pont operator + ( Pont p1, Pont p2 )

párban kell implementálni az összehasonlító operátorokat: == és != a relációs operátorokat: < és > a relációs operátorokat: <= és >=


26 of 64

C# áttekintés - 2

2. előadás

class Pont { public double X { get; set; } public double Y { get; set; } public Pont() { ... } public Pont( double x, double y ) { ... } public static Pont operator + ( Pont p1, Pont p2 ) { // túlterhelt + operátor return new Pont( p1.X + p2.X, p1.Y + p2.Y ); } public override string ToString() { return "(" + this.X.ToString() + "," + this.Y.ToString() + ")"; } }

List pontok = new List() { new Pont(1, 2), new Pont(2, 3), new Pont(1, 1) }; Pont ujPont = new Pont(); foreach( var pont in pontok ) { ujPont = ujPont + pont; }


// összeadunk két pontot

27 of 64

C# áttekintés - 2

2. előadás

KONVERZIÓS OPERÁTOROK két osztály vagy rekord közötti konverzió mindig statikusnak kell lennie class Pont_2D { // a konverziót explicite meg kell hívnunk public static explicit operator Pont_2D( Pont_3D pont_3D ) { return new Pont_2D( pont_3D.X, pont_3D.Y ); } }

class Pont_3D { // a konverzió automatikusan végrehajtódik, amikor szükséges public static implicit operator Pont_3D( Pont_2D pont_2D ) { return new Pont_3D( pont_2D.X, pont_2D.Y, 0 ); } }


28 of 64

C# áttekintés - 2

2. előadás

class PontTeszt { static void Main() { Pont_2D pont_2D = new Pont_2D( 1, 2 ); Pont_3D pont_3D = new Pont_3D( 3, 4, 5 ); Console.WriteLine( pont_2D + pont_3D ); // Pont_3D-beli implicit konverzió //

Pont_2D ujPont_2D = pont_3D;

// fordítási hiba

Pont_2D ujPont_2D = (Pont_2D)pont_3D;

// Pont_2D-beli explicit konverzió

} }


29 of 64

C# áttekintés - 2

2. előadás

8. GENERIKUSOK lényege, hogy típus is lehessen paraméter lehetőséget ad arra, hogy létrehozhassunk parametrizált típusokat, azaz olyan generikusokat, melyeknek van egy vagy több ismeretlen típus paramétere, és ezek a típus paraméterek a generikus specializálásakor lesznek konkretizálva public public public public

class Halmaz { ... } struct Lista { ... } interface ICsatorna { ... } delegate TKimenet Konvertalo( TBemenet bemenet );


30 of 64

C# áttekintés - 2

2. előadás

TERMINOLÓGIA típus paraméter a generikus deklarációban megadott egy vagy több ismeretlen típus, pl. a T a List-ben típus argumentum a generikus specializálásakor megadott típus, pl. a Pont vagy az int a List-ben, List-ben konstruált típus a generikus, mely kétféle lehet nyílt List, használható más generikusok deklarációjában zárt vagy specializált List vagy List megszorítás a típus paraméterre vonatkozó korlátozás


31 of 64

C# áttekintés - 2

2. előadás

GENERIKUSOK JELLEMZŐI növelik a kód újrafelhasználhatóságát, típusbiztosságát, teljesítményét legjellemzőbb használatuk gyűjtemény típusok létrehozása ahol csak lehet, ott a System.Collections.Generic névtérbeli osztályok használata javasolt a System.Collections-beliek helyett létrehozhatók saját generikus osztályok, interfészek, delegáltak, metódusok, események megszorítások adhatók a típus paraméterre futási időben, reflection használatával áll elő a típus paraméterre vonatkozó információ


32 of 64

C# áttekintés - 2

2. előadás

GENERIKUS STATIKUS METÓDUS ÉS OSZTÁLY class A { public static void Csere( ref T bal, ref T jobb ) { T temp; temp = bal; bal = jobb; jobb = temp; } }

class B { public static void Csere( ref T bal, ref T jobb ) { T temp; temp = bal; bal = jobb; jobb = temp; } }


33 of 64

C# áttekintés - 2

2. előadás

GENERIKUS STATIKUS METÓDUS ÉS OSZTÁLY class Teszt { public static void Main() { char a = 'a'; char b = 'z'; System.Console.WriteLine( a + " " + b );

// a z

A.Csere( ref a, ref b );

// generikus statikus metódus

System.Console.WriteLine( a + " " + b );

// z a

B.Csere( ref a, ref b );

// generikus osztály

System.Console.WriteLine( a + " " + b );

// a z

} }


34 of 64

C# áttekintés - 2

2. előadás

GENERIKUS PONT TÍPUS class Pont { public T X { get; set; } public T Y { get; set; } public Pont() { this.X = this.Y = default(T); }

// milyen alapértelmezett értéket adjunk?

public Pont( T x, T y ) { this.X = x; this.Y = y; } public static Pont operator + ( Pont p1, Pont p2 ) { // p1.X + p2.X kifejezés típusokkal leírva T + T alakú, // viszont a T csak futási időbn lesz meghatározva. // az + operátor nem értelmezett a T-n (hiszen az csak egy paraméter), // ezért az összeadás eredményének típusát dinamikussá konvertáljuk return new Pont( (dynamic)p1.X + p2.X, (dynamic)p1.Y + p2.Y ); } }


35 of 64

C# áttekintés - 2

2. előadás

GENERIKUS PONT TÍPUS SPECIALIZÁLÁSA class PontTeszt { static void Main() { var diszkretPont = new Pont( 1, 2 ); // típus argumentum: int var folytonosPont = new Pont<double>( 1.1, 2.2 ); // típus argumentum: double Console.WriteLine( diszkretPont ); Console.WriteLine( folytonosPont );

// (1,2) // (1.1,2.2)

} }


36 of 64

C# áttekintés - 2

2. előadás

A TÍPUS PARAMÉTER MEGSZORÍTÁSAI megszoríthatjuk, hogy a kliens kódban milyen jellemzőkkel bíró típus paraméterekkel példányosítható a generikus where T : struct a T típus csak értéktípus lehet (struct, enum) where T : class a T típus csak referencia típus lehet (class, interface, array, delegate) where T : new() a T típusnak kell hogy legyen paraméter nélküli konstruktora where T : ősosztály a T típus az ősosztály leszármazottja kell legyen where T : interfész a T típus maga ez az interfész, vagy megvalósítja azt where T : U a T és az U típusok paraméterek úgy, hogy T leszármazottja U-nak, vagy T = U


37 of 64

C# áttekintés - 2

2. előadás

A DEFAULT KULCSSZÓ generikusok deklarálásakor problémát okoz, hogy milyen alapértelmezett értékeket adhatunk meg, mert fordítási időben nem ismert T konkrét típusa nem tudjuk, hogy T érték- vagy referencia típus nem tudjuk, hogyha T értéktípus, akkor vajon egyszerű vagy összetett (struct) a default kulcsszó visszatérési értéke null, ha T referencia típus 0, ha T numerikus értéktípus minden mező null vagy 0, ha T struct


38 of 64

C# áttekintés - 2

2. előadás

GENERIKUS PONT TÍPUS MEGSZORÍTÁSOKKAL // a T típus csak értéktípus lehet, és meg kell hogy valósítsa a felsorolt // interfészeket, ami fennáll a numerikus típusok esetén // például a System.Int32 (int) és a System.Double (double) megvalósítják // az alábbi interfészeket class Pont where T : struct, IComparable, IFormattable, IConvertible, IComparable, IEquatable { public T X { get; set; } public T Y { get; set; } public Pont() { this.X = this.Y = default(T); } public Pont( T x, T y ) { this.X = x; this.Y = y; } public static Pont operator + ( Pont p1, Pont p2 ) { return new Pont( (dynamic)p1.X + p2.X, (dynamic)p1.Y + p2.Y ); } }


39 of 64

C# áttekintés - 2

2. előadás

9. KIVÉTELKEZELÉS a program futása során számos váratlan és kivételes szituáció következhet be hibák olyan jelenségek, melyeket a program nem tud futás közben kijavítani, ezért abnormális állapotban terminál például elfogy a memória, felforr a processzor kivételek olyan jelenségek, melyeket a program ki tud javítani futás közben, így a normális futás folytatható például tömb határán túli elemre hivatkozunk, nullával osztunk


40 of 64

C# áttekintés - 2

2. előadás

KIVÉTELEK KIVÁLTÁSA ÉS KEZELÉSE a kivételek futás közbeni felismerését, feldolgozását, majd a programfutás megfelelő állapotba való visszaállítását nevezzük kivételkezelésnek kivétel kiváltása kivételek úgy keletkeznek a programban, hogy egy hibához vezető utasítás végrehajtását megakadályozzuk egy kivétel dobásával kivétel kezelése a kiváltott kivételeket hagyhatjuk kezeletlenül, ekkor a program terminál, de általában nem hagyja inkonzisztens állapotban a mentett adatokat a kiváltott kivételeket kezelhetjük is, pl. felhasználónak szóló üzenettel, a kivételt kiváltó utasítások újrafuttatásával (bemeneti adatok ismételt bekérése), vagy a kivétel körülményeinek logolásával


41 of 64

C# áttekintés - 2

2. előadás

KIVÉTEL DOBÁSA ÉS ELKAPÁSA kivétel dobása throw kivétel létrehozása és dobása kivétel figyelése try a felügyelt kódblokk, mely ellenőrzött utasításokat tartalmaz kivétel elkapása, kezelése catch a kivétel elkapó és -kezelő kódblokk definíciója gyakori, hogy nem a közvetlenül meghívott metódus dobja a kivételt, hanem azon metódus is meghív más metódusokat, és végül a több szinttel lejjebbről dobott kivétel kezeletlenül felgyűrűzik az eredeti metódusig


42 of 64

C# áttekintés - 2

2. előadás

SYSTEM.EXCEPTION a kivételek is objektumok, és minden kivétel a System.Exception osztálynak vagy valamely leszármazottjának példánya csak akkor kapjunk el egy kivételt, ha azt kezeljük is a kivételdobás körülményei kinyerhetők az elkapott kivétel objektumból ha egy System.Exception típusú kivételt kapunk el, akkor azt dobjuk tovább


43 of 64

C# áttekintés - 2

2. előadás

TÉGLALAP OSZTÁLY class Teglalap { public double A { get; set; } public double B { get; set; } public Teglalap() { this.A = this.B = 10; } public Teglalap( double a, double b ) { // ha a téglalap valamelyik vagy mindkét oldala 0, // akkor kivételt dobunk if( 0 == a || 0 == b ) { // példányosítunk és dobunk egy kivételt egy értelmes üzenettel // amikor kiváltódik ez a kivétel, akkor a CLR a legközelebbi // kivételkezelő blokkot keresi throw new ElfajuloTeglalapException( "A téglalap oldala nem lehet 0" ); } this.A = a; this.B = b; } }


44 of 64

C# áttekintés - 2

2. előadás

FELHASZNÁLÓI KIVÉTEL OSZTÁLY [Serializable()] // minden kivételnek szerializálhatónak kell lennie // származtatjuk a System.Exception ősből class ElfajuloTeglalapException : Exception { // legalább négy konstruktort kell definiálni: public ElfajuloTeglalapException() : base() {} public ElfajuloTeglalapException( string message ) : base( message ) {} public ElfajuloTeglalapException( string message, Exception inner ) : base( message, inner ) {} // szerializációhoz definiált konstruktor protected ElfajuloTeglalapException( System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context ) {} }


45 of 64

C# áttekintés - 2

2. előadás

KLIENS KÓD - NINCS KIVÉTELKEZELÉS class Teszt { public static void Main() { var t1 = new Teglalap( 1, 2 ); var t2 = new Teglalap( 0, 2 ); var t3 = new Teglalap( 5, 5 ); Console.WriteLine( t1.Kerulet() ); Console.WriteLine( t2.Kerulet() ); Console.WriteLine( t3.Kerulet() ); } }

a dobott kivételt sehol sem kezeltük le, a program hibával terminál


46 of 64

C# áttekintés - 2

2. előadás

KLIENS KÓD - KIVÉTELKEZELÉSSEL class Teszt { public static void Main() { Teglalap t1 = null; Teglalap t2 = null; Teglalap t3 = null; try { t1 = new Teglalap( 1, 2 ); t2 = new Teglalap( 0, 2 ); t3 = new Teglalap( 5, 5 );

// kivételek figyelése // kiváltódik a kivétel // ez az utasítás már nem hajtódik végre

} catch( ElfajuloTeglalapException e ) { Console.WriteLine( e.Message ); }

// adott típusú kivétel elkapása // a kivétel kezelése

Console.WriteLine( t1.Kerulet() ); // null.Kerulet() újabb kivételt vált ki, hibával terminál a program Console.WriteLine( t2.Kerulet() ); Console.WriteLine( t3.Kerulet() ); } }


47 of 64

C# áttekintés - 2

2. előadás

KLIENS KÓD - KIVÉTELKEZELÉSSEL class Teszt { public static void Main() { Teglalap t1 = null; Teglalap t2 = null; Teglalap t3 = null; try { t1 = new Teglalap( 1, 2 ); t2 = new Teglalap( 0, 2 ); t3 = new Teglalap( 5, 5 );

// kivételek figyelése // kiváltódik a kivétel // ez az utasítás már nem hajtódik végre

} catch( ElfajuloTeglalapException e ) { Console.WriteLine( e.Message ); } finally { if( t1 == null ) t1 = new Teglalap(); if( t2 == null ) t2 = new Teglalap(); if( t3 == null ) t3 = new Teglalap(); }

// adott típusú kivétel elkapása // a kivétel kezelése // mindig végrehajtódó ág

Console.WriteLine( t1.Kerulet() ); Console.WriteLine( t2.Kerulet() ); Console.WriteLine( t3.Kerulet() ); } }


48 of 64

C# áttekintés - 2

2. előadás

KIVÉTELEK HIERARCHIÁJA osztályhierarchiát hozhatunk létre a kivételekből [Serializable()] class TeglalapException : Exception { ... } [Serializable()] class ErtelmetlenTeglalapException : TeglalapException { ... } [Serializable()] class ElfajuloTeglalapException : TeglalapException { ... }


49 of 64

C# áttekintés - 2

2. előadás

KIVÉTELEK HIERARCHIÁJA az elkapó ágak sorrendje a specializáltabbtól halad az általánosabb felé az elkapó ágakból továbbdobhatjuk a kivételt class Teszt { public static void Main() { Teglalap t1 = null; try { t1 = new Teglalap( 0, 2 ); } catch( ElfajuloTeglalapException e ) { Console.WriteLine( e.Message ); } catch( ErtelmetlenTeglalapException e ) { Console.WriteLine( e.Message ); } catch( TeglalapException e ) { Console.WriteLine( e.Message ); throw new Exception( e.Message ); } } }


50 of 64

C# áttekintés - 2

2. előadás

10. ATTRIBÚTUMOK a programhoz metaadatok, deklaratív információk rendelhetők, ezeket hívjuk attribúbumoknak, melyekhez futás során a CLR reflection használatával fér hozzá beépített attribútumok a programban definiált elemeket módosítókkal dekorálhatjuk felhasználói attribútumok mi is készíthetünk saját attribútumokat a System.Attribute osztály leszármazottjaként


51 of 64

C# áttekintés - 2

2. előadás

BEÉPÍTETT ATTRIBÚTUMOK public class Osztaly { static void Metodus_1() {...} virtual in Metodus_2() {...} }

// hozzáférés módosító: public // statikus módosító: static // virtuális módosító: virtual

// a felsorolt elemeket biteknek tekintjük, így a bit operátorok értelmezhetők [FlagsAttribute] enum Napok { ... } [Flags] enum Napok { ... }


// az attribútumok neve kötelezően // az Attribute kulcsszóval végződik, // amely el is hagyható

52 of 64

C# áttekintés - 2

2. előadás

ATTRIBÚTUMOK HASZNÁLATA [Attribútum] [Attribútum(paraméter_1, paraméter_2)]

// paraméteres attribútum

[Attribútum_1, Attribútum_2]

// attribútum lista

[célpont: Attribútum_lista]

// a célpont az a programelem, // melyre az attribútum vonatkozik


53 of 64

C# áttekintés - 2

2. előadás

using System.ComponentModel; class Teglalap { [DefaultValue(10)] // jelöljük az alapértelmezett értéket public double A { get; set; } [DefaultValue(10)] public double B { get; set; } public Teglalap() { // az új paraméter nélküli konstruktor // ciklusban végigmegyünk az osztály tulajdonságain foreach( PropertyDescriptor tl in TypeDescriptor.GetProperties( this )) { // lekérdezzük a tuladjonsághoz tartozó DefaultValue attribútumot var attributum = (DefaultValueAttribute)tl.Attributes[ typeof(DefaultValueAttribute)]; // az attribútumban rögzitett értéket hozzárendeljük a tulajdonsághoz if( attributum != null ) { tl.SetValue( this, attributum.Value ); } } } }


54 of 64

C# áttekintés - 2

2. előadás

11. XML DOKUMENTÁCIÓ 1. a C#-ban lehetőség van a dokumentációt speciális XML elemekkel bővíteni /// jelekkel bevezetve, melyek az utána következő programelemre vonatkoznak 2. a kódot a /doc opcióval fordítva, előáll az XML dokumentáció 3. az XML dokumentáció tovább konvertálható megjeleníthető web-oldalakká, például a Doxygen dokumentáció generálóval


55 of 64

C# áttekintés - 2

2. előadás

AZ XML DOKUMENTÁCIÓ /// <summary> /// Generikus 2-dimenziós Pont osztály /// /// A pont koordinátáinak típusa class Pont { /// <summary> /// X koordináta /// /// Beállítja vagy lekérdezi a Pont objektum X koordinátájának értékét public T X { get; set; } /// <summary> /// Y koordináta /// /// Beállítja vagy lekérdezi a Pont objektum Y koordinátájának értékét public T Y { get; set; } }


56 of 64

C# áttekintés - 2

2. előadás

A GENERÁLT XML FÁJL <doc> EVP-01-program-28 <members> <member name="T:Programok.Pont`1"> <summary>Generikus 2-dimenziós Pont osztály A pont koordinátáinak típusa <member name="P:Programok.Pont`1.X"> <summary>X koordináta Beállítja vagy lekérdezi a Pont objektum X koordinátájának értékét <member name="P:Programok.Pont`1.Y"> <summary>Y koordináta Beállítja vagy lekérdezi a Pont objektum Y koordinátájának értékét


57 of 64

C# áttekintés - 2

2. előadás

EXTENSIBLE MARKUP LANGUAGE a deklaratív nyelvek családjába tartozó jelölő nyelv, szöveges és más média együttes kezeléséhez, továbbításához, megjelenítéséhez a néhány egyszerű szabállyal kódolt dokumentum mind a számítógép, mind az ember számára olvasható egy XML dokumentum Unicode karakterek halmaza a különféle típusú dokumentumok szabályhalmazát a séma definíciók rögzítik számos séma rendszer létezik az XML alapú nyelvek definiálására, és számos alkalmazás létezik, mely XML adatokat dolgoz fel


58 of 64

C# áttekintés - 2

2. előadás

XML ALAPFOGALMAK egy XML dokumentum két menetben kerül feldolgozásra: 1. egy XML parser elemzi és dekódolja a dokumentumot, és továbbítja az adatot az alkalmazásnak 2. az alkalmazás feldolgozza a kapott információt egy XML dokumentum két részre osztható: 1. a dokumentumra vonatkozó deklaratív információra, melyet az XML parser használhat fel 2. magára az önleíró dokumentum példányra


59 of 64

C# áttekintés - 2

2. előadás

DEKLARATÍV INFORMÁCIÓ

// XML szabvány verziója, kódolás

DOKUMENTUM PÉLDÁNY a dokumentum példány önleíró, azaz tartalmazza mind a szerkezetét leíró jelölőket, mind a konkrét tartalmat. A jelölők < és >, vagy & és ; között helyezkednek el, minden más karakterlánc a tartalom része egy jelölő típusai: <article>


// kezdő-tag // záró-tag // üres tag

60 of 64

C# áttekintés - 2

2. előadás

a dokumentum logikai komponense az elem, mely vagy egy nyitótaggal kezdődik és egy záró-taggal fejeződik be, vagy egy üres tag <summary>X koordináta

a kezdő- és üres tagok tartalmazhatnak kulcs-érték párokkal definiált attribútumokat // src és alt attribútumok


// szóközökkel elválasztott lista

61 of 64

C# áttekintés - 2

2. előadás

DOKUMENTUM-TÍPUS ÉS VALIDÁCIÓ a dokumentum példányokban megengedett jelölők és attribútumok halmazát, valamint az elemekre vonatkozó nyelvtani szabályokat a dokumentum-típusokban adhatjuk meg egy XML parser felhasználhatja a deklaratív információk között megadott típus információt a példány validálásához a legrégibb dokumentum-típus leíró nyelv a DTD (Document Type Definition) modernebb az XML séma, más néven az XSD (XML Schema Definition)


62 of 64

C# áttekintés - 2

2. előadás

DTD ÉS PÉLDÁNY ]> <mondoka> <sor>Zsipp-zsupp, kenderzsupp <sor>ha megázik kidobjuk! <sor>Zsupsz!


63 of 64

C# áttekintés - 2

2. előadás

XML SÉMA <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> <xs:element name="mondoka"> <xs:complextype> <xs:sequence> <xs:element name="versszak" maxoccurs="unbounded" minoccurs="1"> <xs:complextype> <xs:sequence> <xs:element type="xs:string" name="sor" maxoccurs="unbounded" minoccurs="1">


64 of 64

Bánsághi Anna

Recommend Documents