C# Zero.4 Overview of.net and introducing Visual C# 1.2

•

Session Code: N/A

C# Zero.4 Overview of .NET and introducing Visual C# 1.2 Fülöp Dávid MCT, MCPD [email protected]

Témák • A .NET Framework bemutatása – Mi az a .NET? – Milyen szolgáltatásai vannak? – Hogy épülnek egymásra a verziók?

• A C# 1.0/1.2 nyelvi elemeinek áttekintése – Típusok, általános szintaktika, események, kivételkezelés, attribútumok, gyűjtemények

A .NET FRAMEWORK BEMUTATÁSA

Mi a .Net Framework?

http://www.nevron.com/gallery/FullGalleries/diagram/miscellaneous/images/dotNetFramework.png

A .NET előnyei • Konzisztens, egyszerűsített • programozási modell • Ami egyszer futott, mindig fog futni • • Egyszerűsített • telepítés • • Széles platform-elérés • • Programnyelvek •

integrálása Automatikus memóriamenedzsment Típusbiztonság Könnyebb hibakeresés Kivételkezelés Biztonság Interoperabilitás

Mi a CLR és a CTS? • Common Language Runtime – A menedzselt (IL) kód futásáért felelős, fejlesztési szolgáltatásokat biztosít

• Common Type System – Meghatározza, hogy a CLR hogyan definiálja és használja a típusokat Jitter • Forráskód (C#)

CSC

• assembly (IL, Meta)

• Gépi kód

CLR

A CLR szolgáltatásai Base Class Library Support Thread Support

COM Marshaler

Type Checker

Exception Manager

Security Engine

Debug Engine

MSIL to Native Compilers

Code Manager

Class Loader

Garbage Collector

A Base Class Library • Osztálykönyvtárak, melyek alapból részei a .NET-nek. • Objektum-orientáltak • Általunk kiterjeszthető típusok • Megvalósítják a Microsoft által is javasolt konvenciókat – Jó esetben…

A GC – szemétgyűjtés • Minden menedzselt objektumért felel • „Nincs” destruktor – Van finalizer, IDisposable pattern…

• Futása automatikus, adaptív – Kikényszeríthető, de ronthatja a teljesítményt

• A rövidebb életű objektumokat gyorsabban felszabadítja • A nem-menedzselt erőforrások felszabadítása a programozó feladata!!!

.NET-verziók .NET Framework 3.5 “Servicing Release” WPF Enhancements

Entity Framework

ADO. NET Data Services

ASP.NET MVC

.NET Framework 3.5 WPF 3.5

LINQ

Add-in Framework

.NET Framework 3.0 WPF

WCF

WF

.NET Framework 2.0

WF & WCF Enhancements

SP1 CardSpace

SP1

A CLR verziói

SP1 3.5 3.0

.NET 1.0

.NET 1.1

.NET 2.0

.NET 4

2002

2003

2005-08

2010

CLR 1.0

CLR 1.1

CLR 2.0

CLR 4

A C# 1.2 ÁTTEKINTÉSE

Elnevezési konvenciók I. • A típusnevek nagybetűvel kezdődnek – String, Int32, Byte, CultureAndRegionInfoBuilder

• A változók nevének első betűje kicsi – MyClass myClass = new MyClass();

• Az interfészek neve elé I betűt teszünk – IDisposable, IEnumerable, IPhone…

• Primitív típusok esetén, ha lehet, a CLS által meghatározott nevet használjuk – int Int32, string String, float Single – De ugyanarra a típusra mutatnak, felcserélhetők

Elnevezési konvenciók II. • Ne használjunk rövidítéseket – Van néhány kivétel: Async

• • • •

Több szóból álló neveknél: PascalCasing Egy név ne kezdődjön számmal, aláhúzással Ne álljon csupa nagybetűből egy név Programunk névterének neve ne egyezzen meg egy referált névterével se

• … de úgyis a cég dönt az elnevezésekről. 

Névterek • A logikai csoportosítás egységei – Hierarchikus csoportok – Egy névtér több assemblyre lehet szétosztva – Egy assembly több névteret is tartalmazhat

• Egy típus egyetlen assemblyben lehet • Egy típusnak egyetlen névtere lehet – Teljes név, Fully Qualified Name • Pl.: System.Text.StringBuilder

A futtatható program belépési pontja • A programnak kell tartalmaznia egy Main nevű, static metódust – Visszatérési érték: void vagy int – Paramétermentes, vagy string[]-öt fogad – Ajánlott private-nek hagyni

• Ha több is van, nem fordítható a program – csc /main kapcsolóval megadható az igazi

Lokális változók • Használat előtt deklarálni kell őket – Egyszerre többet is lehet – Erősen típusosak • Nem mindegy, hogy ref. vagy értéktípusúak! – Az értéktípusúak automatikusan megsemmisülnek, ha a program kijut a metódusból – A referenciatípusúakról a GC gondoskodik – nem tudni, mikor

A változók hatóköre • Egy adattag abban a blokkban látható, ahol deklarálták • Egy blokk nem deklarálhat olyan változót, melynek neve megegyezik az őt tartalmazó blokk egy változójának nevével • Két egy szinten lévő blokk deklarálhat azonos nevű változót

Tömbök • Nincs dinamikus tömb! – Példányosításkor meg kell adni az elemszámot, vagy az elemeket.

• Van kovariancia – Futásidejű hiba lehet belőle!

Tömbök deklarációja és valódi tartalma class Ős ,...class Leszármazott : Ős ,...... Ős*+ ősök = new Leszármazott*2];

//OK

Leszármazott*+ lidércek = new Ős*3];

//fordítási hiba

//Viszont: ősök*0+ = new Ős();

//futásidejű hiba!

FELADAT

Önálló feladat – Tömbök • Hozz létre egy saját osztályt (Celeb). Mezői: – Név – string, Id Iq – int, alapértéke: 50

• A Main metódusban… – Hozz létre egy Celeb tömböt, 5 elemmel – Töltsd fel kedvenc celebeiddel! A nevüket a felhasználótól kérd be! • A Console.ReadLine() a barátod

– Ha kész a tömb, írd ki mindegyik elem tulajdonságait a képernyőre – Aki már ismeri a ciklusokat, ne fogja vissza magát! 

Gyűjtemények: alapvetések • A C#-ban nincsenek dinamikus tömbök – A tömb méretét a készítésekor kell megadni

• Dinamikus tömbök helyett: gyűjtemények – A System.Array osztályhoz nincs közük – Add, AddRange, Remove, RemoveAt metódus…

• Két altípusra oszthatók – Listák • Index-alapúak, olvasásuk a tömbökével egyező

– Szótárak • Kulcs-alapúak, DictionaryEntryt tartalmaznak, a bennük lévő értékeket kulcsaikkal lehet olvasni

Gyűjtemények használata • A C#1.2-ben a gyűjtemények… – …vagy nem típus biztosak (ArrayList), – …vagy egy osztályra korlátozottak (StringCollection)

• Van Queue és Stack osztály!

Elágazások: if • Az if kulcsszó – Az elágazás elejét jelzi – Mindenképpen követnie kell egy feltételnek

• Az else kulcsszó – Nem kötelező, az elágazás utolsó eleme – Nincs mögötte feltétel int i = 2;

• Több feltétel is lehet – && és || operátorok

string s = ”Hello”; if (i > 2) { … } else if ((i == 2) && s == ””) { … } else { … }

Elágazások: switch • A switch kulcsszó – A vizsgált változó követi • Egész szám, char, enum, string

• A case kulcsszó – Egy literál vagy konstans követi • A típusa meg kell egyezzen a vizsgált változóéval

• A default kulcsszó •

– Nem kötelező A break kulcsszó (lehet goto, return vagy throw is) – Nem kötelező, kilép a switchből • Nincs „cascading”, de van „fallthrough”

A switch használata enum Suit { Clubs, Hearts, Diamonds, Spades } Suit trumps = Suit.Hearts;

switch (trumps) { case Suit.Clubs : case Suit.Spades : color = "Black"; break; case Suit.Hearts : case Suit.Diamonds : color = "Red"; break; default: color = "ERROR"; break; }

FELADAT

Önálló feladat – Elágazások • Fejleszd tovább a „Tömbök” feladatot – Ha a felhasználó tiltott nevet* ad meg, ne jöjjön létre a Celeb objektum – *: Kiszel Tünde, Fekete Pákó…

Ciklusok: while • A while kulcsszó vezeti be – A kulcsszót követő blokk tartalmazza a feltételt – A blokk futtatása előtt vizsgálja a feltételt int i = 0; while (i < 10) { Console.WriteLine(i); i++; } // 0-tól 9ig írja ki a számokat

Ciklusok: do while • A do kulcsszó vezeti be • A while kulcsszó zárja – A kulcsszót követő blokk tartalmazza a feltételt – A blokk futtatása után vizsgálja a feltételt int i = 0; do { Console.WriteLine(i); i++; } while (i < 10)

// 0-tól 9ig írja ki a számokat

Ciklusok: for • A for kulcsszó vezeti be – A kulcsszót követő blokk tartalmazza a feltételt és a ciklusváltozót • A ciklusváltozó csak az if blokkján belül érvényes

– A blokk futtatása előtt vizsgálja a feltételt for (int i = 0; i < 10; i++) Console.WriteLine(i); Console.WriteLine(i); //Hiba!

– Több ciklusváltozó is megengedett for (int i = 0, j = 0; ... ; i++, j++) { … }

Ciklusok: foreach • A foreach kulcsszó vezeti be – Gyűjtemények végigfuttatására – Előre megválasztható a ciklusváltozó típusa és neve – Kevesebb a hibalehetőség ArrayList numbers = new ArrayList( ); for (int i = 0; i < 10; i++) numbers.Add(i);

foreach (int number in numbers) Console.WriteLine(number);

Ciklusok: break, continue • A break kulcsszóra kilép az iterációból • A continue kulcsszó – Az iteráció következő lépésére ugrik int i = 0; while (true) { Console.WriteLine(i); i++; if (i < 10) continue; else break; }

FELADAT

Önálló feladat – Ciklusok • Fejleszd tovább az „Elágazások” feladatot – Az egész beolvasásos dolgot rakd át egy ciklusba – Bónusz: használj dinamikus tömböt, és a ciklus addig olvassa be az új Celebeket, amíg azt nem írja be a felhasználó, hogy „ELÉG” – Ha ezzel már mind megvoltál, visszatérhetsz a farmville-hez. 

Típusok • A .NET-beli objektumok leírása – Egységbe zárják az adatokat és a rajtuk értelmezett műveleteket

• Összefoglaló név – class, struct, interface, enum, delegate, event…

• Minden típus önleíró: metaadatok

Osztályok • A class kulcsszó vezeti be • Egységbezárás – Tagok: adatok és rajtuk végzett műveletek

• Öröklés – Minden osztály a System.Object leszármazottja – Minden osztálynak csak egy őse lehet…

• Polimorfizmus – Őstípusként deklarált objektum értékül kaphat utódtípusút, fordítva nem!

Osztály/objektum kulcsszavai • Osztály/objektum szintű kulcsszavak – static • Tag: osztályszintű tag • C# 2.0-tól osztály is lehet…

– this • Példányszintű metódusokban az aktuális objektumra mutat, mely meghívta a metódust

– base • Az ősre, annak metódusaira, mezőire, tulajdonságaira hivatkozhatunk vele

A metódusok paraméterei és visszatérése • Csak -1-nél több paraméter lehet  – A params kulcsszóval dinamikussá tehető a lista – Alapvetően érték szerint adódnak át

• A return kulcsszóval tér vissza a függvény – Ha a függvény void, üres return • Ilyenkor akár el is hagyható

– Lehet throw is...

Function overlading • Egy metódusból több is lehet! – Megegyezik a nevük, de különböznie kell a szignatúrájuknak • Különböző számú ésvagy típusú paraméter

– A visszatérési típus nem része a szignatúrának – Először mindig a fix paraméterlistájút értékeli ki

FELADAT

Önálló feladat – Metódusok • Fejleszd tovább a „Ciklusok” feladatot – Írj egy metódust (Tanít) a Celeb osztályba • A metódus írja át a Celeb Iqját a valós értékre (negatív), és adja vissza ezt az értéket egy mondatban, pl.: „XY” iqja mostantól -3.

– Írj egy overloadot a metódusnak, ami fogad egy integer értéket, és erre állítja be az Iqt, majd a fentihez hasonlóan visszaadja a mondatot – A Main metódusban, miután létrejött minden Celeb, egy úthenger ciklus menjen végig rajtuk, és hívja meg ezt a metódust.

Önálló feladat – Metódusok II. • Fejleszd tovább az előző feladatot – Készíts egy metódust, ami két vagy több Celeb objektumot kap paraméterként, és visszaadja közülük a legalacsonyabb Iqval rendelkezőt. – Készíts egy metódust, ami egy alapértelmezett Celeb tömböt ad vissza. • Néhány kész Celeb, megkönnyíti a további munkát.

Adattagok láthatóságai (C#) • public: bárki, bárhol bármit láthat  • private: csak az osztály/objektum maga éri el • protected: csak az osztály/objektum, illetve leszármazottai érik el • internal: csak az osztály és a vele egy assemblyben lévő osztályok érik el • protected internal: csak az osztály, annak leszármazottai ésvagy az osztállyal egy assemblyben lévő objektumok érik el

Paraméterek kulcsszavai • Metódusparaméterek fontos kulcsszavai – ref • Használata esetén a metódus nemcsak egy másolatot kap az adatból, hanem egy referenciát • „Pointerátadás”

– out • Akárcsak a ref, de itt a kapott referenciát nem kell előre inicializálni • Akkor érdemes használni, ha a metódusnak több kimeneti értéke kell, hogy legyen

Konstansok kulcsszavai • Konstansok kulcsszavai – const • Fordítási idejű konstans • Deklarációnál kell, hogy értéket kapjon

– readonly • Futásidejű konstans • A konstruktorban adhatunk neki értéket

Példányosítás • Deklaráció – Osztály esetén: hely foglalása a stacken – Értéktípus esetén: hely foglalása és inicializálása

• A new operátor feladata – Osztály esetén: hely foglalása és kinullázása a heapen…

• Azonnali értékadás: értéktípusoknál – Plusz a Stringnél – (Plusz, ahol megírjuk…)

Példányosítás: a konstruktor • A konstruktor feladatai és felépítése – Láthatóság, visszatérési érték – Default konstruktor – Statikus konstruktor

• Konstruktorláncolás – A this kulcsszóval

• A közvetlen ős konstruktorának hívása – A base kulcsszóval – Kötelező, ha az ősnek nincs default konstruktora

Destruktor? • A lefoglalt memóriát felszabadítják, nem? – Elvileg „nem nagyon”  • A stack automatikusan felszabadul • A heapről a GC gondoskodik

– Ha írunk destruktort, felszabadításkor hívódik • Kézzel nem hívható, a Finalize metódus hívja

• A destruktor – Nincs visszatérési típusa, paramétermentes – Neve az osztály nevével egyezik, előtte ~ – Ha egy mód van rá, inkább ne írjunk • Inkább az IDisposable interfészt valósítsuk meg

Konstruktor- és destruktor-hívási lánc • Konstruktorok – Az objektumokat belülről kifelé készítik el • Az inicializálás alulról felfelé történik – Csak így oldható meg a base()-paraméterátadás!

• A futtatás fentről lefelé

• Destruktorok – Az objektumokat kívülről befelé bontják le • Az inicializálás és a futtatás is alulról felfelé történik

Tulajdonságok • Mi a baj a mezőkkel? – Nem szabályozható a hozzáférés • Legfeljebb readonly-vá tehető, de az se sokat segít

– Mindig egy adott értéket tárol, nem számolhat

• A tulajdonság megoldja ezeket a gondokat – get és set accessorok – két metódus, elrejtve • Itt még öröklik a property láthatóságát

– Nem feltétlenül kell egy mezőhöz kapcsolni – Megoldható velük a lazy initialization

FELADAT

Önálló feladat – Tulok, konstruktor • Fejleszd tovább az előző feladatot – Írj egy konstruktort a Celebnek, mely fogadja és beállítja a név és iq adatokat – A két mezőt írd át tulajdonságra. A Név csak olvasható legyen kívülről.

Beágyazott típusok • Osztály az osztályban – Láthatja az őt tartalmazó osztály privát tagjait is – Ha public, akkor kívülről létrehozható – Elbonyolíthatja a kódot – és a tesztelhetőséget –, jól gondoljuk meg, hogy szükség van-e rá

Struktúrák • A struct kulcsszó vezeti be – Csak a System.ValueType lehet a szülője – Automatikusan lezártak

• Adataik helyben helyezkednek el – Thread stack, a szállal együtt semmisül meg – Ref. objektum tagjaként a heapen van

• Kis típusok esetén érdemes használni • Másoláskor az adat másolódik

Struktúrák létrehozása és törlése • Konstruktor – Deklarációkor hívható a default konstruktor • Ezt nem lehet felüldefiniálni • Nem mindig kell kézzel meghívni

– Egyéb konstruktoruk lehet, de minden mezőt inícializálnia kell • Egy paraméterezett konstruktor megléte nem törli a defaultot!

– A deklarációkor csak a const mezők kaphatnak értéket

• Nem lehet destruktoruk

Típusok csoportosítása Referenciatípusok

Értéktípusok

Osztály, interfész, delegált, esemény

Struktúra, enumeráció

Jellemzően nagyok

Kicsik, gyorsan elérhetők A stacken helyezkednek el

Az adatok a heapen helyezkednek el

A GC nem felügyeli őket

A GC kezeli őket

Nincs köztük leszármazás!

Mi a különbség? class Alma { public int X = 5; public int Y = 3; } struct Alma { public int X = 5; public int Y = 3; } Alma a1 = new Alma(); Alma a2 = new Alma(); a2.X = 8; a2.Y = 1; a2 = a1; a1.X = 11; Console.WriteLine(a2.X);

//mit ír ki?

Bónusz kérdés: mi a hiba? 

Értékek és referenciák

Itt mi történik? • • • •

Object o = new Object(); int a = 42; o = a; int b = (int)o;

Dobozolás, kidobozolás • Boxing: értéktípus -> referenciatípus – Ha egy értéktípusú változót ref. típusúként használunk, dobozolásra kerül sor

• Unboxing: referenciatípus -> értéktípus • Az un/boxing lassít, kerülendő!

Enumerációk • Az enum kulcsszó vezeti be • Átláthatóbbá teszik a kódot – Tulajdonképpen csak egy szám, aminek egyes értékeihez nevet rendelünk • Alapesetben egy int van mögötte

– Szűkíthető vele a felhasználható értékek halmaza

• A System.Enum típus könnyít használatukon public enum Colors { Red, Green, Blue }

Az öröklés szerepe • Kiterjeszthető egy típus funkcionalitása – Adott esetben akár teljesen megváltoztatható – Csak a referenciatípusokra alkalmazható

• Cross-language inheritance • A System.Object mindennek az őse – Minden objektum rendelkezik egy alaptudással • Equals, Finalize, GetHashCode, GetType, MemberwiseClone, ReferenceEquals, ToString

Az öröklés megvalósítása • A típusnév után :, és az őslista – Egyetlen ősosztály lehet, ez az első • Sok gondtól megkíméltek minket... 

– Ez után bármennyi interfész következhet • Itt azért előjöhetnek bizonyos problémák...

• Láthatóságok – Az őstípusnak azonos vagy nagyobb láthatósággal kell rendelkeznie

• Tagok láthatóságai – Használjuk a protected láthatóságokat

FELADAT

Önálló feladat – Öröklés • Fejleszd tovább az előző feladatot! – Származtass egy OkosCeleb osztályt a Celebből • Rendelkezzen egy Iskola – string tulajdonsággal

– Származtass egy ButaCeleb osztályt a Celebből • Rendelkezzen egy HetiBulizásokSzáma – int tulajdonsággal

– Oldd meg, hogy a Celeb mezői elérhetők legyenek a leszármazottakban – Oldd meg, hogy a kód leforduljon  • A probléma, hogy a Celebnek nincs paramétermentes konstruktora

Öröklési kulcsszavak • Öröklésnél fontos kulcsszavak – virtual • Metódus: a közvetlen leszármazottakban felüldefiniálható a metódus.

– override • Metódus: a szülő virtuális metódusának felüldefiniálása.

– new • Metódus: azonos szignatúrájú ősmetódus elrejtése. – Nem kötelező használni.

FELADAT

Önálló feladat – Virtuális metódusok • Fejleszd tovább az előző feladatot! – Készíts egy tulajdonságot a Celeb osztályba(/n) • SzerepIndex, int, 0 kezdőértékkel

– Írj egy új metódust a Celeb osztályba(/n) • SzerepelABlikkben, nincs visszatérési értéke, nincs paramétere. Írja ki a képernyőre, hogy a Celeb szerepel a Blikkben, és megnöveli eggyel a SzerepIndex értékét.

– Írd felül a SzerepelABlikkben metódust a leszármazottakban. Más szöveget jelenítsen meg, az indexet növelje.

Öröklési módosítók • Amivel osztályokat is megjelölhetünk – abstract • Osztály: nem példányosítható. • Metódus: nem rendelkezik kóddal. – Egyben virtual is!

– sealed • Osztály: nem származtatható belőle más osztály. • Metódus: nem definiálható felül. – A newval továbbra is elrejthető.

• Nemvirtuálissá teszi a metódushívásokat!

FELADAT

Önálló feladat – Abstract • Fejleszd tovább az előző feladatot! – Tedd absztrakttá a Celeb Tanít metódusát (legalább az egyiket) – Írd felül a Tanít metódust a leszármazottakban

Interfészek • Az interface kulcsszó vezeti be – Saját öröklési fájuk van – Nem-beágyazott esetben csak public vagy internal lehet

• Nem példányosíthatók – De egy interfészt megvalósító objektumra lehet interfészként hivatkozni

• Csak metódus-szignatúrákat és tulajdonságokat tartalmazhatnak – Minden tagjuk implicit módon public abstract

Interfész vagy absztrakt osztály? • Az absztrakt osztály többre képes – Lehet bennük kód is – Származhatnak más osztályból, megvalósíthatnak interfészeket • Az interfészek csak más interfészekből származhatnak

– Lehetnek mezőik – Lehet (van) konstruktoruk és destruktoruk

• Az interfésszel kevesebb a kötöttség – Struktúrák is megvalósíthatnak interfészeket

Interfészek megvalósítása • Explicit interfész-kifejtés – Egy osztály megvalósíthat bármennyi interfészt – A láthatóság eltűnik – nem érhető el a tag – Kasztolás után újra elérhető – Az interfészt megvalósító osztály leszármazottainál dupla kasztolásra lehet szükség

FELADAT

Önálló feladat – Interarc • Fejleszd tovább az előző feladatot! – Készíts egy ILégzőképes interfészt • Tartalmazzon egy void Lélegzik paramétermentes metódust

– Fejtsd ki ezt az interfészt a Celeb osztályon – Készíts egy Egysejtű osztályt • Rendelkezzen egy Méret – int: 1 tulajdonsággal • Valósítsd meg rajta is az interfészt

– A Main metódusban készíts egy olyan tömböt, ami képes eltárolni Celebeket és Egysejtűeket • Tegyél róla, hogy minden elem vegyen levegőt

Típuskonverziók • Őssé kasztolás – Leszármazott biztonságosan alakítható őssé • Átalakítás után csak az ős tagjait érjük el

• Értéktípusoknál nem ennyire egyszerű... – Mivel az interfész referenciatípus, dobozolni kell • Memóriafoglalás, elveszett idő, „kiszámíthatatlan” működés

• Leszármazottá kasztolás – Nem biztonságos

A típuskonverzió fajtái • Implicit konverzió – Nem kell jelölni • Bővítő konverzióknál automatikus

– Nem dobhat kivételt

• Explicit konverzió (kasztolás) – Jelölni kell – InvalidCastExceptiont dobhat

• Az as operátor – Átalakítja az objektumot, ha nem tudja, nullt ad vissza – nincs kivétel

Operátorok Operátorfajta

Példa

Egyenlőség

== !=

Reláció

< > <= >= is

Feltételes

&& || ?:

Értéknövelő/csökkentő

++ --

Aritmetikai

+-*/%

Hozzárendelő

= += -= *= /= %= <<= >>= &= ^= |=

int i = 0; i++; --i; i = i + 42; i -= 42;

// // // // //

0 1 0 42 0

Saját operátor készítése • Az operator kulcsszó vezeti be • Meg kell adni, hogy mely operátort definiáljuk felül, vagy hogy milyen típusok között szeretnénk konverziót megvalósítani • public, static metódusnak kell lennie • Konverziónál több típusa van – Implicit – Explicit

Néhány szabály az operátorfelülíráshoz • Nem definiálhatók felül a következők – – – – –

Tagoperátor (.) Hívásoperátor (()) Értékadás és összetett értékadás (=, +=, -=,...) Feltételes operátorok (&&, ||, ?:) A checked és unchecked, a new, a typeof, az as, az is, a tömb (*+) és a pointer operátorok

• Ajánlott párban felüldefiniálni őket • Ajánlott metódust írni helyettük 

FELADAT

Önálló feladat – Operátorfelülírás • Fejleszd tovább az előző feladatot! – Írd felül a + operátort az Egysejtű osztályban • Adjon vissza egy új Celeb objektumot • Ha régimódi vagy…  …akkor visszaadhat egy olyan Egysejtűt, melynek mérete a két összeadott Egysejtű méretének összege

– Írj egy konverziós operátort az Egysejtű osztályba, ami képes egy Egysejtűt Celebbé alakítani – A Main metódusban próbáld ki az operátorokat, hogy rendben működnek-e

Mi a szép ebben a kódban? int ret = myobject.DoSomething(); if (ret == -1) CleanUpMess5(); else if (ret == -2) CleanUpMess2(); else if (ret == -3) CleanUpMess7(); else if (ret == -4) CleanUpMess8(); else if (ret == -5) CleanUpMess1(); else if (ret == -6) CleanUpMess666(); ret = myotherobject.DoSomethingUToo(); if (ret == -1) CleanUpMessInfinity(); ...

Kivételkezelés: miért? • Biztonság – A kivételt nem lehet figyelmen kívül hagyni! – Garantált a cleanup-kód futása

• Átláthatóság – Jól elválik a BL és a hibakezelés – Az adott kivételt kezelő blokk akár szintekkel a kivétel keletkezésének helye felett is lehet – Építhetünk a kivételek hierarchiájára

• Gazdagabb információ a hibáról – Teljes stacktrace, belső kivétel

Kivételkezelés: try, catch • A try kulcsszó nyitja a logika blokkját • A catch kulcsszó nyitja a hibakezelő blokkot – A kulcsszó után adhatjuk meg a kezelendő kivétel típusát és nevét try { Console.Write("Enter a number: "); int i = int.Parse(Console.ReadLine()); } catch (OverflowException oex) { Console.WriteLine(oex); }

Kivételkezelés: catch, catch • Több catch blokkunk is lehet – Minden blokk egy típust és az abból származókat kapja csak el – A kiértékelés felülről-lefelé halad, az első nyer • A legspecifikusabbtól a legáltalánosabbig haladjunk try { /* kivételeket kiváltó kód */ } catch (ArgumentNullException anex) { /**/ } catch (ArgumentException aex) { /**/ } catch (Exception) { /*névtelen blokk*/ } catch { /*üres blokk*/ } //???

Kivételkezelés: finally • A finally kulcsszó nyitja a cleanup blokkot – A finally blokk mindenképpen lefut – Csak egy lehet belőle, a catchek után • Ha van finally, nem kötelező a catch

– Jellemzően a fájlok lezárását stb. tesszük ide Monitor.Enter(x); try { … } finally { Monitor.Exit(x); }

Kivételkezelés: throw • A throw kulcsszóval dobhatunk saját kivételt – Példányosítanunk kell egy System.Exceptionből származó objektumot – Egy catch blokkban az üres throw továbbdobja az elkapott kivételt • Akkor is, ha nincs rá referencia if (minute < 1 || minute >= 60) { throw new InvalidTimeException( minute + " is not a valid minute"); }

Kivételkezelés: irányelvek • Kivételdobás – Normális futásnál, várható eseményeknél sose használjuk! – System.Exception típust sose dobjunk! – Mindig adjunk érthető leírást a Message tulajdonságban. – Mindig a lehető legspecifikusabb osztályt dobjuk.

• Kivételkezelés – Ügyeljünk a catch blokkok sorrendjére. – Ha egy mód van rá – vagy nem ez a cél –, ne engedjünk egy kivételt a Main metódusig.

FELADAT

Önálló feladat – Kivételkezelés • Fejleszd tovább az előző feladatot! – Ellenőrizd minden paraméterezett metódus paramétereit híváskor, ha probléma van, dobd a megfelelő kivételt. • Null-referencia, értelmetlen érték…

– Teszteld a metódusokat, és híváskor kapd el a keletkező kivételt.

Tömbök – mélyebben, mert az jó • A tömbök fajtái – Vektorok, mátrixok (...), fűrészfogas tömbök – A stack, queue stb. fajták nem részei a nyelvnek

• A tömbök tulajdonságai – System.Array-leszármazottak – a heapen vannak • Az elemek elhelyezkedése típusfüggő

– Immutable – nem változtatható meg a struktúra

• Alapesetben nem szinkronizáltak – IsSynchronized: mindig false (hasznos ^^) – SyncRoot

A System.Array tudása • A tömbök használatát könnyítő metódusok Normál metódusok

Generikus metódusok (C#2)

• BinarySearch, Clear, Constrained/Copy, CopyTo, CreateInstance, Clone, GetEnumerator, GetLength, GetLongLength, GetUpplerBound, GetLowerBound, GetValue, IndexOf, Initialize, LastIndexOf, Resize, Reverse, SetValue, Sort

• AsReadOnly, BinarySearch, ConvertAll, Exists, Find, FindAll, FindIndex, FindLast, FindLastIndex, ForEach, IndexOf, LastIndexOf, Resize, Sort, TrueForAll

Delegáltak • A delegate kulcsszó vezeti be • A delegált egy típus biztos függvénymutató – A delegált és a hivatkozott metódus visszatérési értékének és paramétereinek egyezniük kell class Piano { public void StartMozart() { ... } } ... public delegate void PlayCallback(); PlayCallback callback; Piano piano = new Piano() callback = new PlayCallback(piano.StartMozart); callback();

FELADAT

Önálló feladat – Képviselők ^^ • Fejleszd tovább az előző feladatot! – Írj két metódust az Egysejtű osztályba Méretnövelés és Méretcsökkentés néven. • Eggyel növelik/csökkentik az állat méretét. • Ha penge vagy (igen, Wesley Snipes), akkor erre a feladatra felülírhatod a ++ és -- operátorokat is.

– Írj egy metódust (ÁtméretezésInit), ami egy boolt fogad: true, ha növelni akarjuk a méretet. • Egy osztályszintű delegáltat beállítja valamelyik metódusra.

– Írj egy metódust (Átméretezés) • Egy integert fogad, és ennyiszer futtatja a delegáltat.

Események • Az event kulcsszó vezeti be • Egy objektum/osztály eseményeken keresztül értesít másokat az állapotáról – Publisher és subscriber: sok-sok kapcsolat

• Az esemény egy delegáltra épül • A paramétereket ajánlott EventArgsleszármazott formájában átadni

Események használata • Definiálás public delegate void PlayCallback(); private event PlayCallback MozartStarted;

• Feliratkozás Listener lis = new Listener(); MozartStarted += new PlayCallback(lis.Listen);

• Feliratkozottak értesítése public void StartMozart() { if (MozartStarted != null) { MozartStarted(); } }

FELADAT

Önálló feladat – Események • Fejleszd tovább az előző feladatot! – Az Egysejtű dobjon fel egy eseményt, amikor beállítjuk a delegáltat valamelyik metódusra – A Celeb dobjon fel egy eseményt, amikor megváltozik egy tulajdonságának értéke – Iratkozz fel ezekre az eseményekre, és teszteld őket

Példafeladat

AZ ÁLLATORVOSI LÓ 1.2

Az állatorvosi ló megszületése • Az eddig tanultak alapján, a C# 1.2 eszközeivel… – …készítsük el a Ló osztályt, mely rendelkezik egy névvel, egy születési idővel, egy árral és egy listával az állat eddig begyűjtött díjairól. Legyen továbbá egy eseménye (Verseny), melyre más objektumok feliratkozhatnak, és legyen egy Versenyez metódusa, mely feldobja ezt az eseményt. – …készítsük el az erre feliratkozó Függő osztályt. – …készítsünk egy listát a lovakból, és jelenítsük meg őket ábécérendben, valamint listázzuk ki a 10000 kreditnél drágább lovakat. – …gondoljuk meg, hogyan tudjuk a még ár nélküli lovakat kezelni.

RECAP

Összefoglalás • A C# első verziója lerakta a nyelv alapjait – Menedzselt, letisztult, 21. századi OOP nyelv

• A most megtanultak a nyelv alapjai – szinte kivétel nélkül így működnek a későbbiekben • Rengeteg fejlesztenivaló van... – Erősen típusos, dinamikus gyűjtemények – A delegate-ek kiterjedtebb használata – Null értékkel rendelkező értéktípusok – Kovariancia engedélyezése az eseményekre való feliratkozásnál

A ma megismert snippetek • Használjuk őket, különben egy búúús panda leszek! – – – – – –

class, struct, enum, interface for, while, do, foreach if, else, switch ctor propfull try, tryf

• Aki ezek nélkül kódol holnap, az… – …hős. – …nem kap csokit!!!

Q&A

Overview of .NET and introducing Visual C# 1.2

KÖSZÖNÖM A FIGYELMET!