ESEMÉNYVEZÉRELT PROGRAMOZÁS Bánsághi Anna anna.bansaghi@mamikon.net 2. ELŐADÁS - C# ÁTTEKINTÉS - 2 2015 Bánsághi Anna 1 of 64
TEMATIKA I. C# ÁTTEKINTÉS II. WPF III. Modern UI 2015 Bánsághi Anna 2 of 64
I. C# ÁTTEKINTÉS 1. Szoftver keretrendszer 2. A C# lényegi elemei 3. A C# program 4. Érték- és referencia típusok 5. Típuskonstrukciók 6. 7. 8. 9. 10. 11. Változók, paraméterek Utasítások, kifejezések, operátorok Generikusok Kivételkezelés Attribútumok XML dokumentáció 2015 Bánsághi Anna 3 of 64
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 2015 Bánsághi Anna 4 of 64
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 2015 Bánsághi Anna 5 of 64
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 2015 Bánsághi Anna 6 of 64
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 2015 Bánsághi Anna 7 of 64
VÁLTOZÓK ÉS PARAMÉTEREK class A { public static int x; // x statikus változó private int y; // 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++; 2015 Bánsághi Anna 8 of 64
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; 2015 Bánsághi Anna 9 of 64
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á 2015 Bánsághi Anna 10 of 64
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 végén blokk utasítás áll egyetlen kódsorból pontosvesszővel a egysoros utasítások szekvenciája 2015 Bánsághi Anna 11 of 64
üres kifejezés rendelése feltételes switch) UTASÍTÁS FAJTÁK 1. nem csinál semmit, egyetlen pontosvesszőből áll deklarációs új változó vagy konstans deklarálása egy kifejezés által kiszámított érték változóhoz feltételtől függően végrehajtandó kódrészlet (if, 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) 2015 Bánsághi Anna 12 of 64
checked/unchecked pár await UTASÍTÁS FAJTÁK 2. az egészek túlcsordulását ellenőrző utasítás 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 lock a memóriában áthelyezhetetlen változó jelölésére 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 2015 Bánsághi Anna 13 of 64
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 2015 Bánsághi Anna 14 of 64
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 new Osztaly() // numerikus értéket eredményez // az új példányra való referenciát eredményez objektum.tostring() // string típusú értéket eredményez 2015 Bánsághi Anna 15 of 64
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 lambda kifejezésfa LINQ adatbázislekérdezések névtelen függvény hívások a kifejezéseket fa adatszerkezetben adjuk meg 2015 Bánsághi Anna 16 of 64
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?: 2015 Bánsághi Anna 17 of 64
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. 3. azonos precedenciájú operátorok esetén a (bal vagy jobb) asszociativitási szabály és a zárójelezés, mely felülírja az előző két szabály szerinti kiértékelési sorrendet 2015 Bánsághi Anna 18 of 64
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 létrehozására delegáltak vagy névtelen függvények 2015 Bánsághi Anna 19 of 64
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; // az x paraméter négyzete int j = delegalt(5); // j = 25 using System.Linq.Expressions; delegate int Delegalt( int i ); // delegált típus deklaráció static void Main() { Expression<Delegalt> kifejezesfa = x => x * x; 2015 Bánsághi Anna 20 of 64
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 (x, y) => x == y // aritmetikai kifejezés // é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 2015 Bánsághi Anna 21 of 64
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 ); 2015 Bánsághi Anna 22 of 64
BEÉPÍTETT LEKÉRDEZŐ OPERÁTOROK számtalan beépített lekérdező operátor használja a Func<T, TResult> 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, bool> int páratlanokszáma = számok.count( n => n % 2 == 1 ); // a Where metódus példánya: Func<int, bool> var párosak = számok.where( n => n % 2 == 0 ); // a TakeWhile metódus példánya: Func<int, bool> var hatnálkisebbek = számok.takewhile( n => n < 6 ); foreach( var szám in hatnálkisebbek ) { Console.WriteLine( szám ); // 5 4 1 3 2015 Bánsághi Anna 23 of 64
using System; using System.Collections.Generic; using System.Linq; class PontTeszt { 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)); // az OrderBy metódus példánya: Func<Pont, Pont> var yszerintrendezett = pontok.orderby( p => p.y ); foreach( var pont in yszerintrendezett ) { Console.WriteLine( pont ); // (1,1) (1,2) (2,3) // az Average metódus példánya: Func<Pont, double> var atlag = pontok.average( p => ( p.x + p.y ) / 2 ); // 1.6666667 2015 Bánsághi Anna 24 of 64
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 2015 Bánsághi Anna 25 of 64
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 >= 2015 Bánsághi Anna 26 of 64
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<Pont> pontok = new List<Pont>() { 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 2015 Bánsághi Anna 27 of 64
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 ); 2015 Bánsághi Anna 28 of 64
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ó 2015 Bánsághi Anna 29 of 64
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 class Halmaz<T> {... public struct Lista<T> {... public interface ICsatorna<TElem> {... public delegate TKimenet Konvertalo<TBemenet, TKimenet>( TBemenet bemenet ); 2015 Bánsághi Anna 30 of 64
TERMINOLÓGIA típus paraméter a generikus deklarációban megadott egy vagy több ismeretlen típus, pl. a T a List<T>-ben típus argumentum a generikus specializálásakor megadott típus, pl. a Pont vagy az int a List<Pont>-ben, List<int>-ben konstruált típus nyílt zárt a generikus, mely kétféle lehet List<T>, használható más generikusok deklarációjában vagy megszorítás specializált List<Pont> vagy List<int> a típus paraméterre vonatkozó korlátozás 2015 Bánsághi Anna 31 of 64
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ó 2015 Bánsághi Anna 32 of 64
GENERIKUS STATIKUS METÓDUS ÉS OSZTÁLY class A { public static void Csere<T>( ref T bal, ref T jobb ) { T temp; temp = bal; bal = jobb; jobb = temp; class B<T> { public static void Csere( ref T bal, ref T jobb ) { T temp; temp = bal; bal = jobb; jobb = temp; 2015 Bánsághi Anna 33 of 64
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<char>( ref a, ref b ); // generikus statikus metódus System.Console.WriteLine( a + " " + b ); // z a B<char>.Csere( ref a, ref b ); // generikus osztály System.Console.WriteLine( a + " " + b ); // a z 2015 Bánsághi Anna 34 of 64
GENERIKUS PONT TÍPUS class Pont<T> { 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<T> operator + ( Pont<T> p1, Pont<T> 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<T>( (dynamic)p1.x + p2.x, (dynamic)p1.y + p2.y ); 2015 Bánsághi Anna 35 of 64
GENERIKUS PONT TÍPUS SPECIALIZÁLÁSA class PontTeszt { static void Main() { var diszkretpont = new Pont<int>( 1, 2 ); // típus argumentum: int var folytonospont = new Pont<double>( 1.1, 2.2 ); // típus argumentum: double Console.WriteLine( diszkretpont ); // (1,2) Console.WriteLine( folytonospont ); // (1.1,2.2) 2015 Bánsághi Anna 36 of 64
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 array, delegate) where T : new() a T típus csak referencia típus lehet (class, interface, a T típusnak kell hogy legyen paraméter nélküli konstruktora where T : ősosztály where T : interfész a T típus az ősosztály leszármazottja kell legyen 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 2015 Bánsághi Anna 37 of 64
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 2015 Bánsághi Anna 38 of 64
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<T> where T : struct, IComparable, IFormattable, IConvertible, IComparable<T>, IEquatable<T> { 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<T> operator + ( Pont<T> p1, Pont<T> p2 ) { return new Pont<T>( (dynamic)p1.x + p2.x, (dynamic)p1.y + p2.y ); 2015 Bánsághi Anna 39 of 64
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 2015 Bánsághi Anna 40 of 64
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 2015 Bánsághi Anna 41 of 64
kivétel dobása throw kivétel figyelése try utasításokat tartalmaz KIVÉTEL DOBÁSA ÉS ELKAPÁSA kivétel elkapása, kezelése catch kódblokk definíciója kivétel létrehozása és dobása a felügyelt kódblokk, mely ellenőrzött a kivétel elkapó és -kezelő 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 2015 Bánsághi Anna 42 of 64
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 2015 Bánsághi Anna 43 of 64
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; 2015 Bánsághi Anna 44 of 64
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 ) { 2015 Bánsághi Anna 45 of 64
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 2015 Bánsághi Anna 46 of 64
KLIENS KÓD - KIVÉTELKEZELÉSSEL class Teszt { public static void Main() { Teglalap t1 = null; Teglalap t2 = null; Teglalap t3 = null; try { // kivételek figyelése t1 = new Teglalap( 1, 2 ); t2 = new Teglalap( 0, 2 ); // kiváltódik a kivétel t3 = new Teglalap( 5, 5 ); // ez az utasítás már nem hajtódik végre catch( ElfajuloTeglalapException e ) { // adott típusú kivétel elkapása Console.WriteLine( e.message ); // 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() ); 2015 Bánsághi Anna 47 of 64
KLIENS KÓD - KIVÉTELKEZELÉSSEL class Teszt { public static void Main() { Teglalap t1 = null; Teglalap t2 = null; Teglalap t3 = null; try { // kivételek figyelése t1 = new Teglalap( 1, 2 ); t2 = new Teglalap( 0, 2 ); // kiváltódik a kivétel t3 = new Teglalap( 5, 5 ); // ez az utasítás már nem hajtódik végre catch( ElfajuloTeglalapException e ) { // adott típusú kivétel elkapása Console.WriteLine( e.message ); // a kivétel kezelése finally { // mindig végrehajtódó ág if( t1 == null ) t1 = new Teglalap(); if( t2 == null ) t2 = new Teglalap(); if( t3 == null ) t3 = new Teglalap(); Console.WriteLine( t1.kerulet() ); Console.WriteLine( t2.kerulet() ); Console.WriteLine( t3.kerulet() ); 2015 Bánsághi Anna 48 of 64
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 {... 2015 Bánsághi Anna 49 of 64
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 ); 2015 Bánsághi Anna 50 of 64
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 2015 Bánsághi Anna 51 of 64
BEÉPÍTETT ATTRIBÚTUMOK public class Osztaly { // hozzáférés módosító: public static void Metodus_1() {... // statikus módosító: static virtual in Metodus_2() {... // virtuális módosító: virtual // a felsorolt elemeket biteknek tekintjük, így a bit operátorok értelmezhetők [FlagsAttribute] enum Napok {... // az attribútumok neve kötelezően // az Attribute kulcsszóval végződik, [Flags] enum Napok {... // amely el is hagyható 2015 Bánsághi Anna 52 of 64
ATTRIBÚTUMOK HASZNÁLATA [Attribútum] [Attribútum(paraméter_1, paraméter_2)] // paraméteres attribútum [Attribútum_1, Attribútum_2] [célpont: Attribútum_lista] // attribútum lista // a célpont az a programelem, // melyre az attribútum vonatkozik 2015 Bánsághi Anna 53 of 64
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 ); 2015 Bánsághi Anna 54 of 64
1. 11. XML DOKUMENTÁCIÓ 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 2015 Bánsághi Anna 55 of 64
AZ XML DOKUMENTÁCIÓ /// <summary> /// Generikus 2-dimenziós Pont osztály</summary> /// <typeparam name="t"> /// A pont koordinátáinak típusa</typeparam> class Pont<T> { /// <summary> /// X koordináta</summary> /// <value> /// Beállítja vagy lekérdezi a Pont objektum X koordinátájának értékét<value> public T X { get; set; /// <summary> /// Y koordináta</summary> /// <value> /// Beállítja vagy lekérdezi a Pont objektum Y koordinátájának értékét<value> public T Y { get; set; 2015 Bánsághi Anna 56 of 64
A GENERÁLT XML FÁJL <!--?xml version="1.0"?--> <doc> <assembly> <name>evp-01-program-28</name> </assembly> <members> <member name="t:programok.pont`1"> <summary>generikus 2-dimenziós Pont osztály</summary> <typeparam name="t">a pont koordinátáinak típusa</typeparam> </member> <member name="p:programok.pont`1.x"> <summary>x koordináta</summary> <value> Beállítja vagy lekérdezi a Pont objektum X koordinátájának értékét </value> </member> <member name="p:programok.pont`1.y"> <summary>y koordináta</summary> <value> Beállítja vagy lekérdezi a Pont objektum Y koordinátájának értékét </value> </member> </members> </doc> 2015 Bánsághi Anna 57 of 64
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 2015 Bánsághi Anna 58 of 64
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 2015 Bánsághi Anna 59 of 64
DEKLARATÍV INFORMÁCIÓ <?xml version="1.0" encoding="utf-8"?> // 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> </article> <line-break /> // kezdő-tag // záró-tag // üres tag 2015 Bánsághi Anna 60 of 64
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</summary> <line-break /> a kezdő- és üres tagok tartalmazhatnak kulcs-érték párokkal definiált attribútumokat <img src="nike.jpg" alt='pythokritos' /> // src és alt attribútumok <div class="inner greeting-box"></div> // szóközökkel elválasztott lista 2015 Bánsághi Anna 61 of 64
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) 2015 Bánsághi Anna 62 of 64
DTD ÉS PÉLDÁNY <?xml version = 1.0?> <!DOCTYPE mondoka[ <!ELEMENT mondoka (versszak+)> <!ELEMENT versszak (sor+)> <!ELEMENT sor (#PCDATA)>]> <mondoka> <versszak> <sor>zsipp-zsupp, kenderzsupp</sor> <sor>ha megázik kidobjuk!</sor> <sor>zsupsz!</sor> </versszak> </mondoka> 2015 Bánsághi Anna 63 of 64
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"> </xs:element></xs:sequence> </xs:complextype> </xs:element> </xs:sequence> </xs:complextype> </xs:element> </xs:schema> 2015 Bánsághi Anna 64 of 64