Programozas Csharp Nyelven Konyv

ILLS ZOLTN

Programozs C# nyelven

JEDLIK OKTATSI STDI Budapest, 2005

I. Alapismeretek

Minden jog fenntartva. Ezt a knyvet vagy annak rszleteit a kiad engedlye nlkl brmilyen formban vagy eszkzzel reproduklni, trolni s kzlni tilos. A knyv ksztse sorn a kiad s a szerz a legnagyobb gondossggal jrt el. Az esetleges hibkat s szrevteleket a [email protected] e-mail cmen szvesen fogadjuk. Szakmailag ellenrizte: Heizlern Bakonyi Viktria, ELTE Anyanyelvi lektor: Gulysn Felkai gnes Bort: Sarkadi Csaba, 2004 Kiad: Jedlik Oktatsi Stdi Bt. 1212 Budapest, Tncsics M. u. 92. Internet: http://www.jos.hu E-mail: [email protected] Felels kiad: a Jedlik Oktatsi Stdi Bt. cgvezetje Nyomta: LAGrade Kft. Felels vezet: Szutter Lnrd ISBN: 963 86514 1 5 Raktri szm: JO 0331

Bevezet ...................................................................................................11 I. Alapismeretek .......................................................................................13

I.1. A nyelv trtnete............................................................................ 13 I.2. A nyelv jellemzi ...........................................................................13 I.3. A .NET krnyezet ttekintse ........................................................15 I.4. A program szerkezete ....................................................................16 I.5. Parancssori krnyezet hasznlata...................................................20 I.6. A krnyezet hasznlata ..................................................................21 I.7. Windows alkalmazsok ksztse ..................................................25 I.8. Feladatok........................................................................................27

II. A C# nyelv alaptpusai ........................................................................ 28 II.1. Vltozk definilsa .....................................................................28 II.2. llandk definilsa .....................................................................29 II.3. Vltozk inicializlsa..................................................................29 II.4. Elemi tpusok................................................................................30 II.5. Felsorols tpus .............................................................................35 II.6. Feladatok ......................................................................................37

III. Kifejezsek, mveletek ......................................................................38 III.1. Egyoperandus opertorok.......................................................... 38 III.2. Ktoperandus opertorok ..........................................................39 III.3. Hromoperandus opertor .........................................................42 III.4. Ktoperandus rtkad opertorok............................................43 III.5. Feladatok .....................................................................................46

IV. sszetett adattpusok..........................................................................47 IV.1. Tmbk ....................................................................................... 47 IV.2. Struktra......................................................................................51 IV.3. Feladatok.....................................................................................54

V. Utastsok ............................................................................................56 V.1. sszetett utasts ..........................................................................56 V.2. Kifejezs utasts..........................................................................56 V.3. Elgazs utasts...........................................................................57 V.4. Ciklus utasts...............................................................................59 V.5. Ugr utastsok............................................................................. 63 V.6. Feladatok ......................................................................................67

VI. Fggvnyek........................................................................................68 VI.1. A fggvnyek paramtertadsa ................................................. 68 VI.2. A Main fggvny paramterei ....................................................72 VI.3. Fggvnyek vltoz szm paramterrel....................................74

I. Alapismeretek

VI.4. Fggvnynevek tdefinilsa......................................................75 VI.5. Delegltak, esemnyek................................................................77 VI.6. Feladatok.....................................................................................80

VII. Osztlyok ..........................................................................................81 VII.1. Osztlyok definilsa.................................................................82 VII.2. Konstruktor- s destruktor fggvnyek .....................................84 VII.3. Konstans, csak olvashat mezk ...............................................92 VII.4. Tulajdonsg, index fggvny.....................................................94 VII.5. Osztlyok fggvnyparamterknt ............................................97 VII.6. Opertorok jradefinilsa.........................................................98 VII.7. Interface definilsa.................................................................104 VII.8. Osztlyok rkldse...............................................................107 VII.9. Vgleges s absztrakt osztlyok ..............................................110 VII.10. Virtulis tagfggvnyek, fggvnyelfeds ............................112 VII.11. Feladatok................................................................................117

VIII. Kivtelkezels ...............................................................................118 VIII.1. Kivtelkezels hasznlata.......................................................118 VIII.2. Sajt hibatpus definilsa ......................................................121 VIII.3. Feladatok ................................................................................125

IX. Input-Output.....................................................................................126 IX.1. Standard input-output................................................................126 IX.2. Fjl input output .....................................................................129 IX.3. Feladatok...................................................................................133

X. Prhuzamos programvgrehajts.......................................................134 X.1. Szlak definilsa .......................................................................134 X.2. Szlak vezrlse .........................................................................135 X.3. Szlak szinkronizlsa................................................................138 X.4. Feladatok ....................................................................................143

XI. Attribtumok....................................................................................144 XI.1. Attribtumok definilsa........................................................... 145 XI.2. Attribtumok hasznlata ...........................................................146 XI.3. Knyvtri attribtumok.............................................................151 XI.4. Feladatok...................................................................................152

XII. Szabvnyos adatments ..................................................................153 XII.1. Knyvtri tpusok szabvnyos mentse...................................153 XII.2. Sajt tpusok szabvnyos mentse ...........................................155 XII.3. Feladatok..................................................................................158

XIII. Knyvtrak, tvoli s web knyvtrak ..........................................159 XIII.1. Helyi knyvtrak hasznlata ..................................................159

XIII.2. Tvoli knyvtrhvs..............................................................162 XIII.3. Webknyvtrak hasznlata..................................................... 168 XIII.4. Feladatok ................................................................................173

XIV. Az elfeldolgoz ........................................................................... 174 XIV.1. Szimblumdefinci hasznlata .............................................174 XIV.2. Terleti jells........................................................................175 XIV.3. Feltteles fordts ...................................................................176 XIV.4. Hibazenet..............................................................................176 XIV.5. Feladatok ................................................................................ 176

XV. Nem felgyelt kd hasznlata ........................................................177 XV.1. Nem felgyelt knyvtr elrse...............................................177 XV.2. Mutatk hasznlata..................................................................178 XV.3. Feladatok .................................................................................179

XVI. Grafikus alkalmazsok alapjai ......................................................180 XVI.1. Windows alkalmazsok alapjai ..............................................180 XVI.2. Webes alkalmazsok alapjai ..................................................185 XVI.3. Feladatok ................................................................................ 189

Irodalomjegyzk.....................................................................................190

11

Bevezet

Valamilyen programot megrni nem nehz, de j programot rni bizony nem egyszer feladat.

Nehz lenne megmondani, hogy melyik az aranyt, amely a j program-kszts iskoljnak tekinthet, de az bizonyosan llthat, hogy j s hatkony programot csakis megfelel fejlesztsi krnyezetben tudunk kszteni.

Mai rohan vilgunkban a gyors gazdasgi, trsadalmi vltozsok mellett is szembetl, mennyire gyors, milyen dinamikus a vltozs az informatikban.

Nem telik el gy hnap, hogy az informatika valamelyik terletn be ne jelentennek valamilyen jdonsgot, legyen az hardver, vagy szoftver.

A szoftver fejlesztsi krnyezeteket tekintve az utbbi idk egyik leg-nagyobb s legtbb jdonsgot hoz egysgcsomagjt kaptk meg a fejlesztk az j Microsoft .NET rendszerrel. Ebben a krnyezetben, brmilyen terletre gondolunk, j technolgik, j lehetsgek segtik a fejlesztk munkjt (Common Language Runtime (clr), ASP.NET, stb.).

Ismerjk mr: j msorhoz j frfi kell. Ezt az elvet alkalmazva a mr klasszikusnak tekinthet Basic s C++ nyel-

vek mellett megjelent az j C# (ejtsd: angolosan sz srp, magyarosan C kettskereszt, Cisz) programozsi nyelv a .NET rendszer rszeknt.

A nyelv mottjnak taln a kvetkez kpletet tekinthetjk:

A Basic egyszersge + a C++ hatkonysga = C#!

Ebben a knyvben a fejlesztsi eszkztrnak ezt az alapjt, a C# programo-zsi nyelvet, annak lehetsgeit ismerhetik meg.

Terveim szerint egy kvetkez knyvben a nyelv legfontosabb krnyezetbeli alkalmazsi lehetsgeit rszletesen trgyalni fogjuk.

Remlem, hogy ez a knyv szles olvastbornak fog hasznos informcikat nyjtani. A programozssal most ismerkedknek egy j vilg j eszkzt mu-tatja meg, mg a programozsban jrtas Olvask taln ennek a knyvnek a segtsgvel megrzik azt, hogy ez az a nyelv, amit kerestek.

Befejezsl remlem, hogy a magyarzatokhoz mellkelt pldaprogramok jl szolgljk a tanulsi folyamatot, s az anyag szerkesztse folytn nem kerl-tek bele nemkvnatos elemek.

Vgl, de nem utolssorban meg kell ksznnm felesgemnek e knyv olvashatsgt segt munkjt.

Ills Zoltn

I. Alapismeretek

13

I. Alapismeretek

I.1. A nyelv trtnete

A C# programozsi nyelv a Microsoft j fejlesztsi krnyezetvel, a 2002-ben megjelent Visual Studio.NET programcsomaggal, annak rszeknt jelent meg.

Br a nyelv hossz mlttal nem rendelkezik, mindenkppen eldjnek tekinthetjk a C++ nyelvet, a nyelv szintaktikjt, szerkezeti felptst.

A C, C++ nyelvekben kszlt alkalmazsok elksztshez gyakran hosz-szabb fejlesztsi idre volt szksg, mint ms nyelvekben, pldul a MS Visual Basic esetn. A C, C++ nyelv komplexitsa, a fejlesztsek hosszabb idciklusa azt eredmnyezte, hogy a C, C++ programozk olyan nyelvet keressenek, ame-lyik jobb produktivitst eredmnyez, ugyanakkor megtartja a C, C++ hatkony-sgt.

Erre a problmra az idelis megolds a C# programozsi nyelv. A C# egy modern objektumorientlt nyelv, knyelmes s gyors lehetsget biztostva ahhoz, hogy .NET keretrendszer al alkalmazsokat ksztsnk, legyen az akr szmols, akr kommunikcis alkalmazs. A C# s a .NET keretrendszer alapja a Common Language Infrastructure(CLI).

I.2. A nyelv jellemzi

A C# az j .NET keretrendszer bzisnyelve. Tipikusan ehhez a keretrend-szerhez terveztk, nem vletlen, hogy a szabvnyostsi azonostjuk is csak egy szmmal tr el egymstl. A nyelv teljesen komponens orientlt. A fejlesztk szmra a C++ hatkonysgt, s a Visual Basic fejleszts gyorsasgt, egysze-rsgt tvztk ebben az eszkzben.

A C# nyelv legfontosabb elemei a kvetkezk: Professzionlis, Neumann-elv. Nagy programok, akr rendszerprogra-

mok rsra alkalmas. A program tbb fordtsi egysgbl modulbl vagy fjlbl ll. Minden

egyes modulnak vagy fjlnak azonos a szerkezete. Egy sorba tbb utasts is rhat. Az utastsok lezr jele a pontosvessz

(;). Minden vltozt deklarlni kell. Vltozk, fggvnyek elnevez-sben az kezetes karakterek hasznlhatak, a kis- s nagybetk kln-bzek.

I. Alapismeretek

A keretrendszer fordtsi parancsa parancssorbl is egyszeren hasznl-hat. (pl. csc /out:alma.exe alma.cs).

Minden utasts helyre sszetett utasts (blokk) rhat. Az sszetett utastst a kapcsos zrjelek kz {} rt utastsok definiljk.

rtk (alaptpusok, enum, struct, value) illetve referencia (class) tpus vltozk.

Nincs mutathasznlat; biztonsgos a vektorhasznlat. Boxing, unboxing. Minden tpus se az object, gy pldul egy egsz t-

pust (int) csomagolhatunk objektumba (boxing) illetve vissza (unboxing).

Fggvnyek defincii nem gyazhatk egymsba, nmagt meghvhatja (rekurzi). Teht fggvnydefinci esetn nincs blokkstruktra. Blok-kon bell statikus vagy dinamikus lettartam vltozk deklarlhatk. Fggvnypolimorfizmus megengedett.

rtk, referencia (ref) s output (out) fggvnyparamterek. Kezd paramter-rtkads, vltoz paramterszm fggvny deklar-

lsa. Delegltak, esemnyek hasznlata. Hierarchikus nvterekben hasznlt osztlyok. Mivel minden osztly, ezrt

a program, a Main fggvny public static hozzfrs. Tbb osztly is tartalmazhat Main fggvnyt, de ilyen esetben a fordtskor meg kell mondani, hogy melyik osztlybeli Main fggvny legyen az aktulis in-dul (/main:osztlynv).

j opertorok: is opertor egy objektum tpust ellenrzi (x is Labda), as opertor a bal oldali operandust jobb oldali tpuss konvertlja (Labda l = x as Labda;). A hagyomnyos konverzis opertortl abban kln-bzik, hogy nem generl kivtelt!

Privt konstruktor (nem akarunk egy pldnyt se), statikus konstruktor (statikus mezk inicializlsa, mindig pldny konstruktor eltt hvdik meg, futsi idben az osztlybetlt hvja meg) hasznlata.

Nincs destruktor, helyette a keretrendszer szemtgyjtsi algoritmusa van. Szksg esetn az osztly Dispose metdusa jradefinilhat.

Egyszeres rkls, interface-ek hasznlata. Opertorok definilsnak lehetsge, property, indexer definils. Kivtelkezels megvalstsa. Prhuzamos vgrehajts szlak definilhatsga.

I. Alapismeretek

I.3. A .NET krnyezet ttekintse

A Visual Studio 6.0 fejlesztrendszer tdolgozsaknt 2002-ben jelent meg a Microsoft legfrissebb fejleszteszkze. Utalva a lnyeges vltoztatsokra, a hlzati munka integrlsra, a fejleszteszkz a Visual Studio.NET nevet kapta. Jelenleg az eszkz 2003-as frisstse a legutols verzi. A knyv szempontjbl nincs lnyeges klnbsg a kt verzi kztt, gy nem is trnk ki a klnbsgek bemutatsra.

Az j eszkz a korbbi fejlesztrendszerekkel ellenttben nem a hagyom-nyosnak tekinthet n. Win32 alap, hanem a .NET krnyezet alatt futtathat alkalmazsokat kszt. Ez azt jelenti, hogy az j eszkzzel kszlt alkalmazsok csak olyan opercis rendszer alatt futtathatk, melyek tmogatjk a .NET keretrendszert (.NET Framework). Alaprtelmezsknt a jelenlegi opercis rendszerek egyike sem tmogatja ezt, viszont Windows 98 opercis rendszertl felfel utlag feltelepthet. A fordt a forrskdot nem natv, hanem egy kz-tes kdra fordtja le. Ezt a kztes kdot MSIL (Microsoft Intermediate Language) nven szoktk emlteni.

A Visual Studio.NET teleptse teht a keretrendszer teleptsvel kezddik. A .NET keretrendszer legfontosabb ernyei: Webszabvnyokon alapul (XML, HTML, SOAP). Univerzlis alkalmazsi modellt hasznl, azaz egy .NET osztly, szolgl-

tats tetszleges .NET kompatibilis nyelvbl hasznlhat. A .NET kom-patibilitst a Common Language Specification (CLS) definilja.

Minden nyelvbl ugyanazok a tpusok hasznlhatk (Common Type System)

Minden .NET osztly a fejlesztk rendelkezsre ll. A keretrendszer a fejleszteszkz szmra fordtsi idej szolgltatsokat

vgez, mg az gy lefordtott alkalmazsoknak futsi idej krnyezetet biztost (Common Language Runtime). A keretrendszer biztostja a fentiek mellett az alkalmazsok szmra a mr nem hasznlt objektumok memriabeli felszabad-tst (Garbage Collection).

A keretrendszer osztlyknyvtra az alkalmazsok tpusa alapjn tbb cso-

portba oszthat: ADO.NET, adatbzis alkalmazsok j genercis knyvtra. ASP.NET, webes alkalmazsok (Web Forms) ksztsnek knytra. XML Web Service, interneten keresztl elrhet knyvtr. Windows alap felhasznli (Windows Forms, Console Application),

alkalmazi knyvtr.

I. Alapismeretek

Az osztlyknyvtrak hasznlathoz egy fejleszt nyelvre van szksg. A Visual Studio.NET alaprtelmezsben hrom nyelvet biztost a fejlesztk sz-mra. A Visual Basic s a Visual C++ nyelveket, mint az eld keretrendszerbl megmaradt bzisnyelveket, s egy j nyelvet, amit a .NET keretrendszerhez fejlesztettek ki, a Visual C#-ot. Ma mr a Java utdnyelv, a J# is a Visual Studio.NET 2003 fejlesztrendszer rsze. Az j C# nyelvet szabvnyostottk, ami a szleskr elterjedsnek fontos felttele. A C# nyelv szabvnyostott dokumentcijhoz ECMA-334 kd alatt frhetnk hozz.

A .NET keretrendszer lnyege, hogy a kzs nyelvi defincik mr szabv-

nyostottak. Ebben a szabvnyostsban a Microsoft mellett az informatikban rdekelt legnagyobb szervezetek is (HP, Intel, IBM, Sun, Fujitsu, Netscape) rszt vettek. Ez ECMA-335-s azonostval, mint a kzs nyelvi infrastruktra vagy eredeti nevn Common Language Infrastucture (CLI) nemzetkzi szabvnyv vlt.

I.4. A program szerkezete

Egy C# program tetszleges szm fordtsi egysgbl (modulbl) llhat. Szoks ezen modulok vagy fjlok sszessgt projektnek nevezni.

A program ezen modulokban definilt osztlyok sszessge. Egy fjl tartalmazza az egyes modulok kzti hivatkozsokat (using), osz-

tlytpus-, vltoz- s fggvnydeklarcikat. Egy modul egy tetszleges nvtr rsze lehet. A nvtr (namespace) az a

logikai egysg, amiben az azonostnknak egyedinek kell lennie. Nem ktelez a nvtr definilsa, ebben az esetben az n. nv nlkli nvtr rsze lesz az adott kd.

Nvtr szerkezete:

namespace j_nvtrnv {

class j_osztlynv { Tpusdefinci; Fggvnydefinci; }

}

I. Alapismeretek

Fggvnyek defincijnak formja:

visszaadott_tpus nv(argumentumlista, ha van) { vltoz defincik, deklarcik s utastsok }

Az osztlyok egyikben kell egy Main nev fggvnynek szerepelnie, amely

futtatskor az opercis rendszertl a vezrlst megkapja. A nyelv megengedi, hogy tbb tpusban (osztlyban) is definiljunk ilyen fggvnyt. Ebben az eset-ben fordtskor kell megmondani, hogy melyik tpus Main fggvnye legyen a fprogram.

A programban hasznlt neveknek betvel vagy _ jellel kell kezddnik, majd a msodik karaktertl tetszleges bet s szm kombincija llhat. A nyelvben a kis- s nagybetk klnbzek, gy pldul a kvetkez kt nv sem azonos:

alma aLma Az azonostnevek hossza ltalban 32 karakter lehet, de sok rendszerben az

ignyeknek megfelelen lehet ezen vltoztatni. A .NET keretrendszer 16 bites unikd karakterbrzolst hasznl, amiben a

magyar kezetes karakterek is benne vannak. A nyelvi fordt ezeket az kezetes betket is megengedi, gy az albbi nv is megengedett:

krte

Azonostk hasznlatra nem megengedettek a C#-ban a kvetkez kulcs-

szavak vagy vdett azonostk: abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public

I. Alapismeretek

readonly ref return sbyte sealed short stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void while

Egy forrsllomny szerkesztse sorn magyarzatokat is elhelyezhetnk a

/* s */ jelek kztt. Az ilyen megjegyzs tbb soron t is tarthat. Egy soron bell a // jel utn rhatunk magyarzatot.

A mai fejlesztkrnyezetekben egyltaln nem ritka, hogy valamilyen specilis megjegyzst arra hasznljanak fel, hogy ennek a programszvegbl trtn kigyjtsvel a forrsllomnynak vagy magnak a programnak egy dokumentcijt kapjk. Ezt a kigyjtst a fordt vgzi el.

A C# fordtnak ha a /doc:fjlnv formban adunk egy fordtsi paramtert, akkor /// karakterek utni informcikat XML fjlba (a megadott nvvel) ki-gyjti. Ha nem parancssori fordtt hasznlunk, ami a Visual Studio.NET krnyezet hasznlatakor gyakran (majdnem mindig) elfordul, akkor ezt a belltst a projekt Tulajdonsgok dialgusablakban az XML Documentation File paramter rtkeknt llthatjuk be.

1. bra

Ha a keretrendszerben egy vltoz vagy fggvny defincija el beszrjuk a /// karaktereket, akkor azt a szvegszerkeszt automatikusan kiegszti a k-vetkez formban:

I. Alapismeretek

Plda: /// /// ez egy vltoz /// int i; /// /// ez meg egy fggvny /// /// public void szamol(int i) { }

A /** .*/ forma is megengedett, szintn dokumentcis clokra. Mivel az elz mdszer nem gyjti ki az ilyen formj megjegyzst, nem is hasznljk gyakran.

Ezek alapjn nzzk meg a szoksosnak nevezhet bevezet programunk

forrskdjt.

Plda: using System; class foci { static void Main() { Console.WriteLine("Hajr Fradi!"); } }

Programunk rvid magyarzataknt annyit mondhatunk, hogy a forrsk-

dunk a legegyszerbb esetben egyetlen llomnybl ll, amiben nem definilunk nvteret, hanem csak egy foci osztlyt. (Valamilyen tpust kell definilnunk!) Ebben az osztlyban egyetlen fggvnyt definilunk, a programot jelent Main fggvnyt. Mivel egyetlen osztlytpus egyetlen pldnya sem ltezik a ltre-hozsig (a definci mg nem ltrehozs!), ezrt ahhoz, hogy a fggvnynk pl-dny nlkl is ltezzen, a static jelzvel kell a hozzfrsi szintet meghatrozni. A C stlus nyelvek hagyomnyaknt a C# nyelvnek sem rszei a beolvas s kir utastsok, gy knyvtri szolgltatsokra kell hagyatkoznunk, ami a System nvtr rsze, s ennek a nvtrnek a Console osztlya biztostja a klasszi-kus kpernyre rs, Console.WriteLine() s billentyzetolvass, Console.ReadLine() feladatt.

I. Alapismeretek

I.5. Parancssori krnyezet hasznlata

A tetszleges szvegszerkesztvel megrt forrskdot egy alma.cs (a nyelv

a cs kiterjesztst szereti) fjlba menthetjk, majd az albbi utastssal for-dthatjuk le:

csc alma.cs

A fordts eredmnye egy alma.exe llomny lesz, amit futtatva a kperny

kvetkez sorban lthatjuk kedvenc buzdt mondatunkat. Termszetesen akkor kapunk hibamentes fordtsi eredmnyt, ha a fordtnk s a knyvtrak hasznlathoz szksges tvonali, krnyezeti vltoz belltsok helyesek. Ezt a vcvars32.bat llomny elvgzi. Ilyen parancssori krnyezetet legknnyebben a Visual Studio.NET programcsoportbeli segdeszkzk kzl tudunk elindtani. (Ekkor lefut a vcvars32.bat, nem kell neknk kzzel indtani!)

2. bra

A parancssori fordtnak a /? paramterrel trtn futtatsa, mint egy segt-

sg funkci, megadja a fordt fontosabb kapcsolit. Ezek kzl a legfontosabbak a kvetkezk: /t:exe alaprtelmezs, exe llomnyt fordt. /t:library a fordtand llomny knyvtr (dll) lesz. /out:nv a fordts eredmnynek nevt hatrozhatjuk meg,

alaprtelmezsben ez a nv megegyezik a fordtott fjl nevvel. /r:valami.dll egy knyvtr felhasznlsa fordtskor, ha tbb knyv-

tri llomnyt kell hozzfordtani, akkor az llomnynevek kz vesszt kell tenni.

/main:osztlynv a nyelv megengedi, hogy tbb osztly is tartalmazzon Main fggvnyt, ekkor ezzel a kapcsolval mondhatjuk meg, hogy a sok Main fggvny kzl melyik legyen a fprogram.

I. Alapismeretek

A keletkezett exe llomnyrl el kell mondani, hogy annak futtatshoz nem elegend egy hagyomnyos 32 bites Microsoft opercis rendszer, gyakran ezt gy fogalmazzk meg, hogy a keletkezett program nem natv kdot tartalmaz, hanem szksges az opercis rendszerhez hozztelepteni a .NET keretrend-szert! Ezt termszetesen a Visual Studio.NET installlsa elvgzi, gy a sajt gpnkn nem tnik fel annak hinya sem. Az irodalom ezt az exe kdot gyak-ran menedzselt (managed) kdnak nevezi.

ltalban elmondhat, hogy az j fejlesztkrnyezet minden egyes nyelvi eszkze olyan kdot fordt, aminek szksge van erre a keretrendszerre. Termszetesen mint az let minden terletn, gy itt is van-nak kivtelek. Ilyen kivtel pldul a C++ nyelv, ahol alaprtelmezs szerint meg kell mondani, hogy a programunkat menedzselt vagy natv kdra fordtsa-e a fordtnk. Natv kd alatt rtjk azt a fordtott eredmnyt, ami processzor szint utastsokat tartalmaz. Ebben a fejlesztkrnyezetben ezt a kdot a menedzselt ellentteknt, nem menedzselt (unmanaged) kdnak is nevezik.

I.6. A krnyezet hasznlata

Mieltt a kvetkez rszben a nyelv rszletes jellemzinek ismertetst

kezdennk, nzzk, hogy a felinstalllt Visual Studio.NET krnyezet segt-sgvel mikppen tudjuk az eddigi egy, illetve a ksbbi pldaprogramokat kiprblni.

Termszetesen nincs szksgnk egy tetszleges szvegszerkeszt (pl: emacs ) hasznlatra, hiszen a fejlesztkrnyezet ad egy jl hasznlhat bels szvegszerkesztt, s nincs szksg a parancssori fordts parancs kiad-sra sem, hiszen ez a parancs egy menpontra van rdefinilva.

A fejlesztkrnyezet installcija utn a Start \ Programok menponton keresztl indthatjuk el a Visual Studio.NET krnyezetet, ami a 3. brn lthat jellemz ablakkal jelenik meg.

A jelenlegi fejlesztkrnyezetekben minden program valjban egy projekt-fednv alatt kszl el. Egy vagy tbb projekt felgyelete a Solution Explorer ablakban vgezhet. A f munkaterleten egy indul Start Page lthat, amiben a legutbbi projektek szerepelnek, illetve j vagy korbbi ltez projektet nyithatunk meg. Termszetesen a File menponton keresztl is elvgezhetk ezek a feladatok.

I. Alapismeretek

3. bra

A New Project menpont kivlasztsa utn, ahogy az az albbi ablakban is ltszik, hrom f krdsre kell vlaszolnunk:

4. bra

I. Alapismeretek

1. Ki kell vlasztani a programozsi nyelvet. 2. Az adott nyelvhez meg kell mondani, hogy milyen jelleg alkalmazst

szeretnnk kszteni. 3. Meg kell adni a munkaknyvtrat s a projekt nevt. Ebben a knyvben a nyelvet illeten mindig a Visual C# Project lehetsget

vlasztjuk, amit a nyitott mappajel is mutat. A Templates ablakban vlaszthatjuk ki az alkalmazs jellegt. Jelen esetben,

illetve a kvetkez rsz pldiban az n. Console Application lehetsget vlasztjuk, ami egy hagyomnyos karakteres fellet programkrnyezetet jelent. Ezek az alkalmazsok parancssori ablakban futnak.

A munkaknyvtr s a projekt nevnek megadsa azt jelenti, hogy ltre-hozza a munkaknyvtron bell a projekt nvvel megadott knyvtrat, esetnk-ben a c:\programok\hajra knyvtrat, s ezen bell egy nknyes class1.cs llo-mnyt, aminek tartalma a kvetkez:

5. bra

Ahogy lthat, a keretrendszer a class1.cs llomnyba mindent elkszt, hogy csak a valdi feladatra kelljen koncentrlnunk. Az llomny tartalma lnyegben megegyezik a korbbi els programkddal. Ahogy mr emltettem, nem ktelez nvteret (namespace) definilni, illetve nem ktelez a Main fgg-vny paramtert jellni, s a vgrehajtsi szl attribtum jellse is opcionlis.

I. Alapismeretek

Ezeket, illetve a dokumentcis megjegyzseket figyelembe vve lthat, hogy a kt kdrszlet azonos.

Amint a 3. brrl lthat, a fejlesztkrnyezet rendelkezik a mr szoksos-nak nevezhet berskori rtelmezssel (IntelliSense), s ha ltala ismert tpust fedez fel, akkor egy helyi ablakban megmutatja az aktulis objektum elrhet jellemzit.

A projekt a 3. brn lthat forrskd mellett mg egy assemblyinfo.cs llo-mnyt is tartalmaz, amiben hrom jellemz attribtum belltst vgezhetjk el. Bellthatjuk programunk jellemz adatait, verziszmt, illetve a digitlis al-rs kulcsllomnyra vonatkoz informcit is. Ezek a tulajdonsgok a .NET keretrendszer szolgltatsain alapulnak, aminek rszletezse meghaladja ennek a knyvnek a kereteit.

A programot a Debug menpont Start (F5) vagy Start without debugging (CTRL-F5) menpontjval fordthatjuk le, illetve futtathatjuk. Ez utbbi men-pontot hasznlva a parancssori ablak nem tnik el a program futsa utn, lehetsget biztostva a program eredmnynek megnzsre.

6. bra

A fordts hatsra ltrejn a c:\programok\hajra knyvtrban egy bin s egy obj knyvtr. Ez utbbiban a lefordtott llomnyok, mg a bin knyvtrban egy Debug vagy Release knyvtrban ltrejn a kvnt exe program is. A kt vltozat kzti klnbsg a nevbl addik, nevezetesen a Debug vltozatban a nyomkvets elsegtst biztostva kszl el a futtathat llomny. Ez a lehet-sg a programfejlesztsek sorn nagyon hasznos, hiszen logikai vagy egyb hibk keressben a lpsenknti, nyomkvet mdszerrel trtn vgrehajts nlklzhetetlen. A Release, kiadsi vgleges vltozatot a program befejezse-knt az 5. bra fejlcben lthat Debug-Release vlasztmez lltsval kszt-hetjk el.

Tbbfelhasznls krnyezetben, pldul Windows XP opercis rendszer alatt, a Debugger Users csoportba minden fejlesztt bele kell rakni.

A knyv msodik rszben a C# nyelv elemeinek megismersekor jellemz

projekttpusknt konzolalkalmazst (6. bra) hasznlunk.

I. Alapismeretek

I.7. Windows alkalmazsok ksztse

Az alkalmazsok msik, s taln ma mr szlesebb krben hasznlt csoportja a grafikus alkalmazs ksztse. Ezeket a programokat Windows alkalmazsnak is szoktk nevezni.

Ahogy a karakteres alkalmazsoknl mr lttuk, j feladatot (projektet) k-sztve a Windows Application (Windows alkalmazs) lehetsget vlasztjuk s megadjuk a nevet, ahogy az a kvetkez kpen lthat.

7. bra

Miutn a fenti dialgusablakban befejezzk az adatok megadst, azt lthat-

juk, hogy a karakteres alkalmazsokhoz kpest a munkafellet megvltozik, hiszen ebben a rendszerben az az alapelkpzels, hogy egy res ablak (form) az indul program.

Ez valjban azt jelenti, hogy egy grafikus tervezablakot kapunk (Form1), amibe az eszkztrbl (Toolbox) a szksges vezrlelemeket a grafikus fel-letre visszk, s ekzben a forrskdot (form1.cs) a keretrendszer a fellet-alaktsnak megfelelen automatikusan mdostja.

I. Alapismeretek

Az els grafikus programunkhoz hrom lpst vgezznk el! 1. rjuk t az ablak fejlcszvegt. Ehhez kattintsunk egyet a form-ra, majd

a jobb als Properties (Tulajdonsgok) ablakban rjuk t a Text tulaj-donsgot. (Els program!)

2. A Toolbox ablakbl helyezznk fel egy Button, nyomgomb objektu-mot. A Tulajdonsg ablakban lltsuk t a Text mezt a Vge szvegre.

3. Kattintsunk kettt a nyomgomb objektumra, ezzel a nyomgomb alap-rtelmezett kattints esemny fggvnyt definiltuk. Ebbe rjuk be a Close(), ablakbezrs utastst. Ekkor a form1.cs forrskd rszlete a kvetkezkppen nz ki:

[STAThread] static void Main() { Application.Run(new Form1()); } private void button1_Click(object sender, System.EventArgs e) { Close(); }

Ezen hrom lps utn fordtsuk le, majd futtassuk a programot. Ezt, ahogy a

korbbi karakteres program esetben is a Debug men Start menpontjval tehetjk meg.

Ahhoz, hogy tovbbi grafikus alkalmazsokat tudjunk kszteni, elenged-hetetlenl szksges, hogy ismerjk egyrszt a vlasztott nyelv lehetsgeit, msrszt a rendszer knyvtri szolgltatsait.

Az elbbi, a nyelvi lehetsgek megismerse ltalban a legknnyebb s

leggyorsabb feladat. Ez remnyeim szerint a kvetkez rsz ttanulmnyozsa utn a kedves Olvasnak is sikerl. Viszont az utbbi, a rendszer knyvtri szolgltatsainak megismerse hosszabb, tbb idt, sok egyni munkt jelent feladat. Azt remlem, hogy a befejez, a grafikus alkalmazsok alapjaival fog-lalkoz rsz utn mindenki elg btorsgot rez magban a tovbbi nll munka folytatshoz.

I. Alapismeretek

I.8. Feladatok

1. Milyen kd programot fordt a Visual Studio.NET fejlesztkrnyezet? 2. Mit csinl a Garbage Collection (szemtgyjt) algoritmus? 3. Lehet-e kezetes karaktereket hasznlni a C# programban? 4. Mik a Main fggvny jellemzi? 5. Egy program hny Main fggvnyt tartalmazhat, hogy tudjuk

lefordtani?

28

II. A C# nyelv alaptpusai

Egy programozsi nyelvben az egyik legfontosabb tulajdonsg az, hogy programkszts sorn hogyan s milyen tpus adatokat hasznlhatunk. Meg kell jegyezni, hogy van nhny olyan programozsi nyelv is (pl. PhP), ahol ez a terlet nem igazn fontos, tpusok gyakorlatilag nincsenek, adatot szksg szerinti tpusban a programoz rendelkezsre bocst.

A C# szigoran tpusos nyelv, ebben a nyelvben csak ennek figyelembe-vtelvel hasznlhatunk sajt vltozkat.

II.1. Vltozk definilsa

A nyelvben a vltozk definilsnak alakja:

tpus vltoznv ;

Azonos tpus vltozkat egymstl vesszvel elvlasztva definilhatunk. A

tpusok ismerete nlkl nzznk nhny pldt vltozk definilsra.

Plda: char ch; // ch vltoz karakter tpus int egy, tizenegy; // az egy s tizenegy egsz tpus

Vltozk lehetnek klsk, azaz fggvnyen kvliek, vagy belsk, azaz

fggvnyen belliek. A fggvnyen kvli vltozk is termszetesen csak oszt-lyon belliek lehetnek. Gyakran hvjk ezeket a vltozkat adatmezknek is.

Bels vltozk, az adott blokkon (fggvnyen) belli loklis vltozk lehet-nek dinamikus vagy statikus lettartamak. Mdost jelz nlkli definils esetn dinamikusnak vagy automatikusnak nevezzk, s ezek lettartama a blokk-ban val tartzkods idejre korltozdik. Ha a blokk vgrehajtsa befejezdtt, a dinamikus vltozk megsznnek.

Statikus lettartam bels vltozt a static sz hasznlatval (ahogy kls vltoz esetn igen) nem definilhatunk. Lttuk, a fggvnyek lehetnek stati-kusak (lsd Main fggvny), melyekre ugyanaz igaz, mint az osztlyvltozkra, ezen fggvnyek lettartama is a programval egyezik meg, ms szval ezen fggvnyek a program indulsakor jnnek ltre.


A vltozkat kt kategriba sorolhatjuk, az osztlytpus vltozk referen-cia tpusak, melyek mindig a dinamikus memriban helyezkednek el (az irodalomban ezt gyakran heap-nek nevezik), mg minden ms nem osztly-tpus, az gynevezett rtktpus (value type) vltoz. Az rtktpus vl-tozkat szoktk stack vltozknak is nevezni.

Az rtktpus vltozk kezdrtkt, az inicializls hinyban, 0, false, null rtkre lltja be a fordt.

A vltozk definilsakor rgtn elvgezhet azok direkt inicializlsa is.

II.2. llandk definilsa

llandk definilst a tpusnv el rt const tpusmdost szcska segts-gvel tehetjk meg. A definci alakja:

const tpus nv = rtk;

Plda:

const float g=9.81; // vals konstans g=2.3; // !!! HIBA const int min=0; // egsz konstans

II.3. Vltozk inicializlsa

Vltozk kezd rtkadsa, inicializlsa azok definilsakor is elvgezhet a kvetkez formban:

tpus vltoz = rtk;

Plda:

char s='a'; int []a={1,2,3}; char[] b="Egy";

A vltozk, konstansok s fggvnyek hasznlatra nzzk a kvetkez pldt.


Plda: // A valtozo.cs fjl tartalma: using System; // A kirshoz szksges deklarcit tartalmazza. class vltoz { static int alma=5; //alma vltoz defincija //s inicializlsa static float r=5.6F //statikus vals tpus vltoz //vals konstanst zrhat az //F (float) bet const float pi=3.1415; //konstans definci static void Main() { Console.WriteLine( "Teszt"); //eredmny Test Console.WriteLine( alma ); //eredmny 5 int alma=6; //helyi vltoz Console.WriteLine( alma ) ; //eredmny 6 Console.WriteLine( vltoz.alma ); //a kls takart (5) //vltozra hivatkozs Console.WriteLine( terlet(r)); //a terlet fggvny // meghvsa } static float terlet(float sugr) // fggvnydefinci { return(pi*sugr*sugr); } }

Br mg nem definiltunk fggvnyeket, gy taln korainak tnhet ez a plda, de inkbb felhvnm mg egyszer a figyelmet az kezetes karakterek hasznlatra. A ksbbi mintafeladatokban, ha elfordul kezet nlkli vltoz, fggvnydefinci, akkor az csak a korbbi krnyezetek rossz uthatsnak ksznhet. Egy osztlyon bell a fggvnyek definilsi sorrendje nem lnyeges. Sok krnyezetben furcsa lehet amit a fenti pldban ltunk, hogy elbb hasznljuk, s csak ezutn definiljuk a fggvnynket. (terlet fggvny)

II.4. Elemi tpusok

char karakter tpus (2 byte hossz)


A karakter tpus 16 bites karakterbrzolst (unikd) hasznl. ltalban igaz, hogy minden alaptpus mrete rgztett.

A karakter tpus vltoz rtkt aposztrf (') jelek kztt tudjuk megadni. Plda:

char c; c='a';

A backslash (\) karakter specilis jelentssel br. Az utna kvetkez karak-ter(eke)t, mint egy escape szekvencit dolgozza fl a fordt. Az gy hasznlhat escape szekvencik a kvetkezk:

\a - a 7-es kd csipogs \b - backspace, elz karakter trlse \f - formfeed, soremels karakter \r - kocsi vissza karakter \n - j sor karakter (soremels+kocsi vissza)

Az j sor karakter hatsa azonos a formfeed s a kocsi vissza karakterek

hatsval.

\t - tabultor karakter \v - fggleges tabultor \\ - backslash karakter \' - aposztrf \" - idzjel \? - krdjel \uxxyy xx s yy unikd karakter

string karaktersorozat A System.String osztlynak megfelel tpus. Szvegek kztt a + s a +=

szvegsszefzst vgz opertorok ismertek. A [] opertor a szveg adott index karaktert adja meg. Az indexels 0-val kezddik. A @ karakter kik-szbli a szvegen belli rzkeny karakterek hatst. Ilyen pldul a backslash (\) karakter.

Plda:

char c='\u001b'; // c= a 27-es kd (Esc) karakterrel string s="alma"; string n="alma"+"barack"; s+="fa"; //s= almafa

II. A C# nyelv alaptpusai char c1=s[2]; // c1= m char c2="szia"[1]; // c2=z string f="c:\\programok\\alma.txt"; string file=@"c:\programok\alma.txt";

A String osztly a fenti lehetsgeken kvl egy sor fggvnnyel teszi hasznlhatbb ezt a tpust. Ezen fggvnyek kzl a legfontosabbak:

Length Csak olvashat tulajdonsg, megadja a szveg karaktereinek a szmt:

string s="alma"; int i=s.Length; //i=4

CompareTo(string) Kt szveg sszehasonltst vgzi. Ha az eredmny 0, akkor azonos a kt szveg:

string str1="egyik", str2="msik"; int cmpVal = str1.CompareTo(str2); if (cmpVal == 0) // az rtkek azonosak {} else if (cmpVal > 0) // str1 nagyobb mint str2 {} else // str2 nagyobb mint str1

Equals(string) Megadja, hogy a paramterl kapott szveg azonos-e az eredeti szveggel:

string str1="egyik", str2="msik"; if (str1.Equals(str2){} // azonos else{} // nem azonos

IndexOf(string) Tbb alakja van, megadja, hogy az eredetiben melyik indexnl tallhat a paramterl kapott szveg. A visszaadott rtk 1 lesz, ha nincs benn a keresett szveg:

int i="almafa".IndexOf("fa"); //4 Insert(int,string) A msodik paramterl kapott szveget, az els paramterrel megadott indextl beszrja az eredeti szvegbe:


string s="almafa alatt"; string ujs=s.Insert(4," a "); // alma a fa alatt

A szvegtpus tovbbi szolgltatsait, fggvnyeit a szvegosztly

(System.String) online dokumentcijban rdemes megnzni. Meg kell emlteni mg azt, hogy a szvegosztly fggvnyei nem mdostjk az eredeti szveget, szvegobjektumot, pldaknt az elz s szveges vltoz rtke vltozatlan marad.

Szveges feldolgozsi feladatok sorn a regulris kifejezsekkel megadhat szvegmintk segtsgt is ignybe vehetjk. A .NET Framework a Perl5 kompa-tibilis regulris kifejezshasznlatot tmogatja. A Regex osztly szolgltatja a regulris kifejezst, mg a Match a tallati eredmnyt. Az osztlyokat a System.Text.RegularExpressions nvtrben talljuk.

Plda: using System; using System.Text.RegularExpressions; class regulris { public static void Main() { Regex reg_kif = new Regex("fradi"); // a fradi keresse Match tallat = reg_kif.Match("A Fradi j csapat?"); if (tallat.Success) { // (hol talltuk meg Console.WriteLine("A tallat helye: " + tallat.Index); } } }

A fenti plda nem ad eredmnyt, hiszen alaprtelmezsben a kis- s nagy-

bet klnbzik, mg ha a regulris kifejezst egy kicsit mdostjuk, az albbiak szerint: Regex reg_kif = new Regex("adi"); akkor a futsi eredmny az albbi lesz:


8. bra

Ha azt szeretnnk elrni, hogy az eredeti szvegnk is vltozzon, akkor ehhez a System.Text nvtr StringBuilder osztlyt tudjuk ignybe venni.

Plda:

using System.Text; StringBuilder s1 = new StringBuilder("almafa alatt"); s1.Insert(4," a "); Console.WriteLine(s1); // "alma a fa alatt"

int egsz tpus(4 byte) Az egsz tpus rtkek ngy bjtot foglalnak a ma leggyakrabban hasznlt

nyelvi krnyezetben , gy rtelmezsi tartomnyuk -231, 231- 1 kztt van. long hossz egsz (8 byte) short rvid egsz (2 byte) sbyte eljeles (signed) byte float vals (4 byte) double dupla pontossg vals (8 byte) decimal pnzgybeli tpus (16 byte), 28 helyirtk Mindkt egsz tpus eljeles, ha erre nincs szksgnk, hasznlhatjuk az el-

jel nlkli vltozatukat, melyek: uint, ushort, byte, ulong. Vals szmok definilsakor a 10-es kitevt jell e konstans hasznlhat. Plda:

float a=1.6e-3; // 1.6 * 10-3

void tpus nlkli tpus Az olyan fggvnynek (eljrsnak) a tpusa, amelyik nem ad vissza rtket.


Plda: void nvel(ref int mit) { mit++; }

Az imnti fggvny paramternek jellse referencia szerinti paramter-

tadst jelent, amirl a Fggvnyek c. fejezetben rszletesen szlunk.

bool logikai tpus (1 byte) A logikai tpus rtke a true (igaz) vagy false (hamis) rtket veheti fel.

Ahogy a nyelv foglalt alapszavainl lthattuk, ezeket az rtkeket a true s false nyelvi kulcssz adja meg.

ltalban elmondhat, hogy mg a nyelv nem definil sok alaptpust, addig az egyes implementcik, fleg azok grafikus fellet alatti knyvtrai ezt bs-gesen ptoljk, s gyakran tbb idt kell az 'j tpusok' megfejtsnek szentelni, mint a fggvnyek tanulmnyozsnak.

II.5. Felsorols tpus

A felsorols tpus gyakorlatilag nem ms, mint egsz konstans(ok), szinoni-mk definilsa. Felsorols tpust nvtren vagy osztlyon bell definilhatunk.

Ennek a kulcsszava az enum. A kulcssz utn a felsorols tpus azonostjt meg kell adni. A System.Enum osztly szinonimjt adja az ezen kulcssz segtsgvel definilt tpus.

Plda: enum szinek {piros,kk,zld,srga}; enum betuk {a='a', b='b'}; betuk sajtbet=betuk.a; // vltoz kezdrtke a enum valami { x="alma"}; // hiba

Ekkor a 0,1, rtkek rendeldnek hozz a felsorolt nevekhez, s a nevek

kirsakor ezen szmokat is ltjuk. A kezdrtkads lehetsgvel lve nem kell ezeket felttlenl elfogadnunk, hanem mi is megadhatjuk az rtkket.

Plda: class Szinek { enum jszinek {piros=4, kk=7, zld=8, srga=12}; public static void Main()

II. A C# nyelv alaptpusai { Console.WriteLine(jszinek.zld); // kirja a sznt //ciklus a szneken trtn vgighaladsra for(jszinek i=jszinek.kk; i


s/vagy mveletekkel a felsorolsadatok kombincijt hatrozhatjuk meg. Ebben az esetben a [Flags] attribtumot kell az enum szcska el szrni.

Plda: [Flags] enum alma {piros=1,jonatn=2,zld=4,golden=8}; alma a=alma.piros | alma.jonatn; Console.WriteLine(a); // piros, jonatn a=(alma) System.Enum.Parse(typeof(alma),"zld,golden"); // a felsorols tpus egyszer rtkadsa helyett // a knyvtri hvs lehetsgt is hasznlhatjuk // Console.WriteLine(a.GetHashCode()); // eredmny 12 lesz

Bithez kttt rtkek esetn ktelez minden egyes konstans nvhez meg-

adni a neki megfelel bites brzolst! Az alaptpusokat a .NET keretrendszer biztostja, gy ennek a fejlesztsi

krnyezetnek egy msik nyelvben pontosan ezek a tpusok llnak rendelke-zsre. Az termszetesen elfordulhat, hogy nem ezekkel a nevekkel kell rjuk hivatkozni, de a nyelvi fordt biztosan ezen rtelmezs szerinti kdot (kztes kd) fordtja le a keretrendszer, mint futtat krnyezet szmra.

Az alaptpusok zrsaknt meg kell jegyezni, hogy a mutat tpus is rtelme-zett, ahogy a C++ vilgban, de ennek a hasznlata csak olyan C# programrsz-ben megengedett, amely nem biztonsgos krnyezetben helyezkedik el (unsafe context). Errl rviden a knyv XIV. fejezetben olvashat.

II.6. Feladatok

1. Milyen alaptpusokat ismer a C# nyelv? 2. Mi a vltoz s az lland kztt a klnbsg? 3. Mi a klnbsg egy statikus s egy dinamikus lettartam

vltoz kztt?

4. Definiljon kt szveg tpus vltozt, adja meg a hosszukat! 5. brzolja felsorols tpussal az NB 1 bajnoksg csapatait!

38

III. Kifejezsek, mveletek

A nyelv jellemzje a korbban (pldul C++ nyelvben) megismert, megszokott kifejezsfogalom, amit tmren gy is fogalmazhatunk, hogy a vezrlsi szerkezeteken kvl a nyelvben minden kifejezs.

Egy kifejezs vagy elsdleges kifejezs, vagy opertorokkal kapcsolt kifejezs.

Elsdleges kifejezsek: azonost (kifejezs) elsdleges kifejezs[] fggvnyhvs elsdleges kifejezs.azonost A kifejezseket egy-, kt- vagy hromoperandus opertorokkal kapcsol-

hatjuk ssze. Egy kifejezsen bell elszr az elsdleges kifejezsek, majd utna az

opertorokkal kapcsolt kifejezsek kerlnek kirtkelsre. A nyelvben hasznlhat opertorok prioritsi sorrendben a kvetkezk.

III.1. Egyoperandus opertorok

new A dinamikus helyfoglals opertora. A helyfoglals opertornak egyetlen operandusa az, hogy milyen tpus objektumnak foglalunk helyet. Sikeres helyfoglals esetn a mvelet eredmnye a lefoglalt memria cme. Sikertelen helyfoglals esetn a null mutat a visszatrsi eredmny.

Plda: int[]a; a = new int; //egy egsz trolshoz //elegend hely foglalsa a = new int[5] //t egsz szmra foglal helyet

A new utasts gyakran szerepel a vektorokkal sszefggsben, amirl

ksbb rszletesen szlunk.


A .NET keretrendszer egyik legfontosabb tulajdonsga az, hogy a dinamikusan foglalt memriaterleteket automatikusan visszacsatolja a fel-hasznlhat memriatartomnyba, ha arra a memrira a programnak mr nincs szksge. Sok nyelvi krnyezetben erre a delete opertor szolgl.

- aritmetikai negls ! logikai negls (not) ~ bitenknti negls, ++,-- inc, dec. (tpus) kifejezs tpusknyszerts

Plda: double d=2.3; int i=(int) d; // i=2

A ++ s -- opertor szerepelhet mind pre-, mind postfix formban. Prefix esetben a vltoz az opertorral vltoztatott rtkt adja egy kifejezs kirtkelsekor, mg postfix esetben az eredetit.

Plda: a= ++b; // hatsa: b=b+1; a=b; a= b++; // hatsa: a=b; b=b+1;

Az egyoperandus opertorok s az rtkads opertora esetn a vgrehajts

jobbrl balra haladva trtnik, minden ms opertor esetn azonos precedencinl balrl jobbra.

III.2. Ktoperandus opertorok

* szorzs / oszts % maradkkpzs

E hrom opertorral mindig igaz: az (a/b)*b+a%b kifejezs az a rtkt

adja. (% opertor esetn az operandusok nem lehetnek valsak, s a prioritsuk

azonos.)


+ sszeads, string esetn azok sszefzse kivons > bitenknti jobbra lptets

A jobbra lptets opertorhoz pldnak tekintsk az a >> b; utastst.

Ekkor ha az a unsigned, akkor balrl nullval, klnben pedig az eljelbittel tlt a bitenknti jobbra lptets opertora.

Plda:

int a= 1, b; b= a >> 2; // b rtke -1 marad

kisebb, nagyobb relcis opertorok = kisebb vagy egyenl, ill. a nagyobb vagy egyenl opertorok ==, != egyenl, nem egyenl relcis opertorok & bitenknti s ^ bitenknti kizr vagy | bitenknti vagy && logikai s || logikai vagy is Logikai opertor, egy objektumrl megmondja, hogy a bal oldali operandus a jobb oldali tpusnak egy vltozja-e.

Plda: int i=3; if (i is int) Console.WriteLine("Bizony az i egsz!"); else Console.WriteLine("Bizony az i nem egsz!");

as Ktoperandus tpusknyszerts. A bal oldali vltozt a jobb oldali referencia tpusra alaktja, ha tudja. Ha sikertelen az talakts, akkor eredmnyl a null rtket adja.

Plda: double d=2.5; Object o= d as Object; Console.WriteLine(o); // eredmny: 2.5 // Object-re mindent lehet alaktani, aminek van toString kir //fggvnye. Errl bvebben ksbb esik sz.


typeof Egy System.Type tpus objektumot kszt. Ennek az objektumnak a mezfggvnyeivel, tulajdonsgaival (FullName, GetType()) tudunk tpus-informcihoz jutni.

Plda: using System; class Teszt { static void Main(){ Type[] t = { typeof(int), typeof(string), typeof(double), typeof(void) }; for (int i = 0; i < t.Length; i++) { Console.WriteLine(t[i].FullName); } } }

A program futsa a kvetkez eredmnyt produklja:

System.Int32 System.String System.Double System.Void

A tpuskonverzival kapcsolatban elmondhat, hogy minden rtktpusbl

ltrehozhatunk egy neki megfelel Object tpus objektumot. Ezt gyakran boxing-nak, csomagolsnak, mg az ellenkez kicsomagol mveletet, amihez a zrjeles tpuskonverzi opertort kell hasznlni, unboxing-nak nevezi a szakirodalom.

Plda: int i=5; Object o=i; // boxing, becsomagols int j=(int) o; // unboxing, kicsomagols

Az Object tpus, ami a System.Object tpusnak felel meg, minden tpus

seknt tekinthet. Ennek a tpusnak a fggvnyei ily mdon minden ltalunk hasznlt tpushoz rendelkezsre llnak.


Az Object tpus tagfggvnyei a kvetkezk:

ToString() Megadja az objektum szveges reprezentcijt. Ha erre van szksg, pldul kirsnl, akkor ezt automatikusan meghvja. Ha ezt egy j tpushoz jradefiniljuk, akkor ez hvdik meg kirs esetn.

Console.WriteLine(o); // indirekt ToString hvs Console.WriteLine(o.ToString());

GetType() Megadja az objektum tpust, hasonl eredmnyt ad, mint a korbban ltott typeof opertor. Equals(object) Megadja, hogy kt objektum egyenl-e, logikai rtket ad eredmnyl.

int i=5; object o=i; Console.WriteLine(o.Equals(5));

Az Equals fggvnynek ltezik egy statikus vltozata is, aminek a formja: Object.Equals(object, object) GetHashCode() Megadja az objektum hash kdjt, ami egy egsz szm. Tetszleges sajt utdtpusban jradefinilhatjuk, amivel a sajt tpusunk hash kdjt tudjuk szmolni.

III.3. Hromoperandus opertor

Az opertorral kpezhet kifejezs alakja a kvetkez: e1 ? e2 : e3 , ahol a ?

s a : az opertor jelei, mg e1,e2,e3 kifejezsek. A kifejezs rtke e2 ha e1 igaz (nem 0), klnben e3.

Plda: char c; int a; a=((c>='0' && c


Az a vltoz vagy a 0-9 vagy 1 rtket kapja. A hromoperandus opertor valjban egy logikai elgazs utasts. A

hatkony kifejezskszts, tmrebb rsmd kivl eszkze.

III.4. Ktoperandus rtkad opertorok

= rtkads opertora

A nyelvben az rtkads sajtos, nmaga is kifejezs. Az egyenlsgjel bal

oldaln olyan kifejezs, vltoz llhat, amely ltal kpviselt adat j rtket vehet fel. Gyakran hvja a szakirodalom ezt balrtknek is (lvalue). Az egyenlsgjel jobb oldaln egy rtket ad kifejezs kell, hogy lljon (jobb-rtk, rvalue). Ez gyakorlatilag azt jelenti, hogy a jobbrtkre semmilyen korltozs nincs.

Az rtkads sorn a bal oldal megkapja a jobb oldali kifejezs rtkt, s egyben ez lesz a kifejezs rtke is.

Plda: char []d=new char[80]; // msoljuk az s forrsszveget d-be while (i>=,


Plda: int a=2; a *= 3; // a= a*3, azaz a rtke 6 lesz string b="alma"; b+="fa"; // b=almafa

A tpusok egyms kzti konverzijval kapcsolatban azt lehet mondani, hogy a C vagy C++-ban ismert automatikus konverzik nem lteznek. Egy egsz tpus vltozt egy valsba gond nlkl berhatunk, mg fordtva mr hibt jelez a fordt. A konverzis lehetsgek szles skljt nyjtja a fejleszteszkznk.

Konverzikkal kapcsolatban kt esetet szoktak megklnbztetni. Ezek kzl az els szm szvegg alaktsa. Ez gyakorlatilag nem ignyel semmilyen segtsget, a szmtpushoz tartoz osztly ToString fggvnyt hvja meg a fordt. Ehhez nem kell semmit sem tenni.

Plda: int a=2; string s="Az eredmny:" + a;

A msik eset, mikor szvegbl szeretnnk szmot kapni, mr nem ilyen

automatikus, de semmikppen nem lehet bonyolultnak nevezni. Tbbfle mdszer lehet az alaktsra, de a legltalnosabb taln a Convert osztly hasznlata. Az osztly konvertl fggvnyei azonos nvkonvencival az albbi formjak:

Convert.ToCTStpusnv

ahol a CTS (Common Type System) tpusnv az albbi lehet: Boolean, Int16

(short int), Int32 (rendes int), Int64 (hossz int), Float, Double, String, Decimal, Byte, Char.

Plda: string s="25"; int i=Convert.ToInt32(s); // i=25 lesz

rdekessgknt megemltem, hogy ltezik a Convert.ToDateTime(object)

fggvny is, ami egy knyvtri dtumtpust kszt a paramterl kapott objek-tumbl.

Ha brmelyik konvertl fggvny hibs paramtert kap, nem tud eredmnyt

produklni, akkor InvalidCastException kivtelt vagy ms, a hiba okra utal kivtelt generl. A kivtelkezelsrl ksbb rszletesen is fogunk beszlni.


ltalban igaz, hogy grafikus alkalmazsok sorn a bert adataink szve-gesek, gy minden esetben az azokkal trtn szmols eltt konvertlnunk kell, ezrt a konvertl fggvnyek hasznlata elg gyakori.

Hasonl konvertl szolgltatsokat kapunk, ha az alaptpusok Parse fgg-vnyt hasznljuk (int.Parse(szveg), double.Parse(szveg)).

Gyakran elfordul, hogy az alapmveletek nem elgtik ki a szmolsi

ignyeinket. A System nvtr Math osztlya a leggyakrabban hasznlt szmolsi mveleteket biztostja. A leggyakrabban hasznlt fggvnyek a kvetkezk:

Math.Sin(x) sin(x), ahol az x szg rtkt radinban kell megadni Math.Cos(x) cos(x) Math.Tan(x) tg(x) Math.Exp(x) ex Math.Log(x) ln(x) Math.Sqrt(x) x ngyzetgyke Math.Abs(x) x abszolt rtke Math.Round(x) kerekts a matematikai szablyok szerint Math.Ceiling(x) felfel kerekts Math.Floor(x) lefel kerekts Math.Pow(x,y) hatvnyozs, xy Math.PI a PI konstans (3.14159265358979323846) Math.E az e konstans (2.7182818284590452354)

Plda: double dd=Math.Sin(Math.PI/2); Console.WriteLine(dd); // rtke 1. dd=Math.Pow(2,3); Console.WriteLine(dd); // 8

Matematikai, statisztikai feladatoknl a vletlenszmok hasznlata gyakori

igny. A System nvtr Random osztlya nyjtja a pszeudo-vletlenszmok generlsnak lehetsgt. Egy vletlenszm-objektum ltrehozst a rendszer-idhz (paramter nlkli konstruktor) vagy egy adott egsz szmhoz kthetjk. A vletlenobjektum Next fggvnye a kvetkez vletlen egsz szmot, a NextDouble a kvetkez vals vletlenszmot adja. A Next fggvnynek hrom, mg a NextDouble fggvnynek egy vltozata van, amit a kvetkez plda is bemutat.


Plda: Random r=new Random(); //r vletlenszm objektum rendszerid alap ltrehozsa Random r1=new Random(10); // r1 vletlenobjektum genertor a 10 rtkbl indul ki // int v= r.Next(); // vletlen egsz szm 0 s MaxInt (legnagyobb egsz) kztt //0 lehet az rtk, MaxInt nem // int v1=r.Next(10); // vletlen egsz szm 0 s 10 kztt, 0

47

IV. sszetett adattpusok

IV.1. Tmbk

A feladataink sorn gyakori igny az, hogy valamilyen tpus elembl tbbet

szeretnnk hasznlni. Amg ez a tbb kett vagy hrom, addig megolds lehet, hogy kt vagy hrom vltozt hasznlunk. Amikor viszont tz, hsz adatra van szksgnk, akkor ez a fajta megolds nem igazn knyelmes, s sok esetben nem is kivitelezhet. Lehetsg van azonos tpus adatok egy kzs nvvel val sszekapcsolsra, s az egyes elemekre index segtsgvel hivatkozhatunk. Ezt az adatszerkezetet tmbnek nevezzk. A tmbk elemeinek elhelyezkedse a memriban sorfolytonos. A tmb helyett gyakran hasznljuk a vektor szt, annak szinonmjaknt.

A C# nyelv minden tmb- vagy vektortpus defincit a System.Array osz-tlybl szrmaztat, gy annak tulajdonsgai a meghatrozak.

A tmbk defincijnak formja a kvetkez:

tpus[] nv;

Az egyes tmbelemekre val hivatkozs, a tmbk indexelse mindig 0-val

kezddik. Az index egsz tpus kifejezs lehet, a tpus pedig tetszleges. Egy tmb ltalnos defincija nem tartalmazza az elemszm rtkt. Br a

nyelv krnyezetben nem lehet mutatkat definilni, de ez gyakorlatilag azt jelenti. A vektor defincija egy referencia tpus ltrehozsa, s a nyelv minden referencia tpust a new opertorral kell konkrt rtkekkel inicializlni (pldnyostani). Ekkor kell megmondani, hogy az adott vektor hny elem lesz. Minden vektornak, ellenttben a C++ nyelvvel, a ltrehozsa utn lekrdezhet az elemszma a Length tulajdonsggal.

Plda: int[] numbers; // egsz vektordefinci numbers = new int[10]; // 10 elem lesz az egsz vektorunk numbers = new int[20]; // most meg 20 elem lett int db = 15; numbers = new int[db]; // egy vltoz adja a hosszt


Mivel a nyelv minden dinamikus referencia tpusnak memriabeli fel-szabadtst a rendszer automatikusan vgzi ezt az irodalom gyakran szemt-gyjtsi algoritmusnak (garbage collection) nevezi , ezrt a pldabeli 10 elem vektor memriahelyt automatikusan visszakapja az opercis rendszer.

A vektorelemek a fenti dinamikus ltrehozs utn 0 kezdrtket kapnak. Ha egyb elemekkel szeretnnk az inicializcit elvgezni, kapcsos zrjelek kz rva adhatjuk meg azokat.

tpus[] nv={rtk, rtk,};

Plda:

int[] n={3,4,5,6}; int hossz= n.Length; // vektorhossz meghatrozs

Ha logikai vektort definilunk, akkor a vektorelemek kezdrtkads hi-

nyban logikai hamis (false), mg ha referencia vektort definilunk, akkor a referenciaelemek a null kezdrtket kapjk meg.

Plda: int[] numbers = {1, 2, 3, 4, 5}; int[] numbers = new int[5] {1, 2, 3, 4, 5}; string[] nevek = new string[3] {"Ali", "Pali", "Robi"}; int[] numbers = new int[] {1, 2, 3, 4, 5}; string[] nevek = new string[] {"Ali", "Pali", "Robi"};

A C# nyelvben nem csak a fenti egydimenzis vektor definilhat. Ezen-

kvl mg definilhat kt- vagy tbbindex, multidimenzis vektor, illetve vek-torok vektora.

Multidimenzis vektor: Plda:

string[,] nevek; nevek= new string[2,4];

A vektor dimenzijt a Rank tulajdonsggal krdezhetjk le.

Console.WriteLine(nevek.Rank); // 2 // az egyes dimenzikbeli mretet a GetLength adja Console.WriteLine(nevek.GetLength(0)); // 2


Console.WriteLine(nevek.GetLength(1)); // 4 Termszetesen a norml vektornak (int[] v) is lekrdezhetjk a dimenzi

rtkt. Plda:

int[,] numbers = new int[3, 2] { {1, 2}, {3, 4}, {5, 6} }; string[,] kapocs = new string[2, 2] { {"Miki","Ani"}, {"Mari","Albert"} }; int[,] numbers = new int[,] { {1, 2}, {3, 4}, {5, 6} }; string[,] kapocs = new string[,] { {"Miki","Ani"}, {"Mari","Albert"} }; int[,] szmok = { {1, 2}, {3, 4}, {5, 6} }; string[,] kapocs = { {"Miki", "Ani"}, {"Mari", "Albert"} };

Hasznlat: numbers[1,1] = 667;

Vektorok vektora: A ms nyelvekbeli analgit tekintve, a multidimenzis vektorban minden

sorban azonos darabszm elem van, ez teht a szablyos, ngyzetes mtrix stb. defincinak felel meg. A vektorok vektora pedig valjban egy mutat vektordefinci, ahol elszr megmondjuk, hogy hny elem a mutat vektor, majd ezutn egyenknt meghatrozzuk, hogy az egyes elemek milyen vektorokat jelentenek.

Plda: byte[][] meres = new byte[5][]; for (int x = 0; x < meres.Length; x++) { meres[x] = new byte[4]; } int[][] szamok= new int[2][] { new int[] {3,2,4}, // ez a hrom elem vektor lesz a szamok els vektora new int[] {5,6} // ez a kt elem vektor lesz a szamok msodik vektora }; int[][] numbers = new int[][] { new int[] {2,3,4}, new int[] {5,6,7,8,9} }; int[][] numbers = { new int[] {2,3,4}, new int[] {5,6,7,8,9} };


Hasznlat: numbers[1][1] = 5;

Termszetesen mindkt esetben multidimenzis, vektorok vektora nemcsak ktdimenzis esetrl beszlhetnk, hanem tetszleges mret vektorrl.

Plda: int[,,] harom = new int[4,5,3];

Lehetsgnk van a ktfle vektordefinci kevert hasznlatra is. A kvetkez plda egy olyan egyszer vektort definil, aminek minden eleme 32 dimenzis szablyos mtrix.

Plda: int[][,,][,] mix;

Ezek utn rjunk egy pldaprogramot, amely bemutatja a korbban megbe-

szlt vektorjellemzk hasznlatt:

Plda: //vektor.cs using System; class vektorpelda { public static void Main() { // Sima vektordefinci, a definci pillanatban // 5 elem vektor lesz // A vektorelemeknek kln nem adtunk kezdrtket, // ezrt azok 0 rtket kapnak. int[] numbers = new int[5]; // Ktdimenzis vektor, sima 5x4-es szveges, //ezen elemek inicializls hinyban null rtket kapnak. string[,] names = new string[5,4]; // Vektorok vektora, ezt az irodalom gyakran //"jagged array", (csipks, szaggatott vektor) nven emlti byte[][] scores = new byte[5][]; // Az egyes vektorok definilsa for (int i = 0; i < scores.Length; i++) { scores[i] = new byte[i+3]; // elemrl elemre n az elemszm. } // Egyes sorok hossznak kirsa


for (int i = 0; i < scores.Length; i++) { Console.WriteLine("Az {0} sor hossza: {1}", i, scores[i].Length); // A {} jelek kztti szmmal hivatkozhatunk az els paramter // utni tovbbi rtkekre. {0} jelenti az i vltozt. // Hasznlata nagyon hasonlt a C printf hasznlathoz. } } }

A program futsa utn a kvetkez eredmnyt kapjuk:

Az 0 sor hossza: 3 Az 1 sor hossza: 4 Az 2 sor hossza: 5 Az 3 sor hossza: 6 Az 4 sor hossza: 7

Plda: string honapnev(int n) { string[]nv={"Nem ltezik","Janur", "Februr","Mrcius", "prilis","Mjus","Jnius", "Jlius","Augusztus", "Szeptember","Oktber", "November","December"}; return(((n12)) ? nv[0] : nv[n]); }

Az imnti plda meghatrozza egy tetszleges sorszm hnaphoz annak

nevt.

IV.2. Struktra

Gyakran szksgnk van az eddigiektl eltr adatszerkezetekre, amikor a lerni kvnt adatunkat nem tudjuk egy egyszer vltozval jellemezni. Elg, ha a taln legkzenfekvbb feladatot tekintjk: hogyan tudjuk a sk egy pontjt megadni? Egy lehetsges megadsi md, ha a pontot mint a sk egy derk-szg koordintarendszernek pontjt tekintem, s megadom az X s Y koor-dintkat.

A struktradefinils az ilyen feladatok megoldsa esetn lehetv teszi, hogy az sszetartoz adatokat egy egysgknt tudjuk kezelni.

A struktradefinci formja a kvetkez:


struct nv { hozzfrs tpus meznevek; hozzfrs fggvnydefinci ; };

Hivatkozs egy mezre: vltoznv.meznv A struktrkon azonos tpus esetn az rtkads elvgezhet, gy ha pldul

a s b azonos tpus struktra, akkor az a=b rtkads szablyos, s az a minden mezje felveszi b megfelel mezrtkeit.

Plda: struct pont { int x; int y; }; pont a; struct egy { string name; int kor; }; egy[] c=new egy[10]; // 10 elem struktra vektor

A fenti definci teljesen j, csak a hozzfrsi szint megadsnak hinyban

minden mez privt, azaz a struktra mindkt adata csak bellrl lthat. A struktra alaprtelmezett mezhozzfrse privt (private). Minden taghoz kln meg kell adni a hozzfrsi szintet.

Struktra esetn a megengedett hozzfrsi szintek: private csak struktrn bellrl rhet el public brki elrheti ezt a mezt internal programon bellrl (assembly) elrhet Plda:

struct szemly { public string nv;


public int kor; };

Az egyes mezkre hivatkozs formja: Plda:

szemly st=new szemly(); System.WriteLine( st.kor); // kor kirsa

Struktradefinci esetn a nyelv nem csak adatmez, hanem fggvnymez definilst is megenged. Azt a fggvnymezt, aminek ugyanaz a neve, mint a struktrnak, konstruktornak nevezzk. Paramter nlkli konstruktor nem definilhat, azt mindig a krnyezet biztostja. A struktra rtktpus adat, gy a vermen s nem a dinamikus memriban jn ltre. ltalban elmondhat, hogy a struktra majdnem gy viselkedik, mint egy osztly, de funkcionalitst tekintve megmarad a klnbz tpus adatok trolsnl.

A struktrkkal kapcsolatosan rdemes megjegyezni hrom alapvet tulaj-donsgot:

Egy struktra adatmezt a definils pillanatban nem inicializlhatunk. Plda:

struct alma { string nev="jonatn"; // fordtsi hiba }

Struktra adatmezket a default konstruktor nem inicializl. A kezdrtk

belltsrl, ha szksges, sajt konstruktorral vagy egyb belltsi mddal kell gondoskodni.

Plda: struct pont { public int x,y; } pont p=new pont(); p.x=2; p.y=4;

Br a struktra rtk tpus, azrt a new opertorral kell biztostani a sajt konstruktorral trtn inicializcit. Ez ebben az esetben a vermen fog elhelyezkedni.


Befejezsl a struktra definilsra, hasznlatra, struktra vektorra nz-znk egy teljesebb pldt:

Plda: using System; struct struktra_plda { public int kor; public string nv; } class struktra_hasznl { public static void Main() { struktra_plda sp=new struktra_plda(); sp.kor=5; sp.nv="va"; // struktra_plda vektor struktra_plda [] spv=new struktra_plda[5]; int i=0; // beolvass while(i


2. Milyen tmbk ltrehozst tmogatja a C# nyelv? 3. Mi a klnbsg a tmb s a struktra kztt? 4. Hatrozzuk meg egy tmb legnagyobb elemt! 5. brzoljuk struktra tpussal az alma legjellemzbb adatait (nv, szn,

mret)! Ksztsnk 5 elem alma vektort!

56

V. Utastsok

A programvezrls menett az utastsok szekvencija szabja meg. Ahogy korbban is lttuk, az opercis rendszer a Main fggvnynek adja t a vezrlst, majd a fggvnytrzs egyms utn kvetkez utastsait (szekvencia) hajtja vgre, ezutn tr vissza a vezrls az opercis rendszerhez.

Az utastsok fajti:

sszetett utasts kifejezs utasts elgazs utasts ciklus utasts ugr utasts

V.1. sszetett utasts

Ahol utasts elhelyezhet, ott szerepelhet sszetett utasts is. Az sszetett utasts vagy blokk a {} zrjelek kztt felsorolt utastsok

listja. Blokkon bell vltozk is deklarlhatk, amelyek a blokkban loklisak lesznek. Blokkok tetszlegesen egymsba gyazhatk.

V.2. Kifejezs utasts

Az utasts formja:

kifejezs ;

Az utasts specilis formja az, amikor a kifejezs elmarad. Az ilyen utas-

tst (;) res vagy nulla utastsnak nevezzk. Ennek termszetesen ltalban nagyon sok rtelme nincs. Az albbi plda egy vltoz rtkt nveli egyesvel egy ciklusban.

Plda: int k=5; for(i=0; i

V. Utastsok

V.3. Elgazs utasts

Az elgazsok kt tpusa hasznlhat, a ktfel s a sokfel elgaz utasts. A ktfel elgaz utasts formja:

if (kifejezs) utasts; if (kifejezs) utasts; else utasts;

Elszr a kifejezs kirtkeldik, majd annak igaz rtke esetn a kifejezs

utni utasts, hamis rtke esetn az else ha van utni utasts hajtdik vgre.

Egymsba gyazs esetn az else gat a legutbbi else nlkli ifhez tartoz-nak tekintjk.

Plda: if (c=='a') Console.WriteLine("Ez az a bet"); else Console.WriteLine("Nem az a bet");

Ha az igaz gon sszetett utastst hasznlunk, akkor utna pontosvessz

nem kell, illetve ha mgis van, az az if lezrst jelenten, s hibs lenne az utastsunk az if nlkli else hasznlata miatt.

Plda: if (c=='a') { Console.WriteLine("Ez az a bet");} else Console.WriteLine("Nem az a bet");

A tbbirny elgazs utastsa, a switch utasts formja:

switch (kifejezs) { case rtk1: utasts1 ; case rtk2: utasts2 ; default: utasts ; };

V. Utastsok

A switch utni kifejezs nem csak egsz rtk lehet, hanem szveg (string) is. Ha a kifejezs rtke a case utn megadott rtkkel nem egyezik meg, akkor a kvetkez case utni rtk vizsglata kvetkezik. Ha egy case utni rtk azonos a kifejezs rtkvel, akkor az ez utni utasts vgrehajtdik. Ha egy case g-ban nincs egyrtelm utasts arra vonatkozan, hogy hol folytatdjon a vezr-ls, akkor fordtsi hibt kapunk.

A C++ nyelvet ismerk tudhatjk, hogy abban a nyelvben egy case g vgt nem kellett vezrlstadssal befejezni, s ebbl gyakran addtak hibk.

Minden elgazsgat, mg a default gat is, ktelez valamilyen vezrls-tadssal befejezni! (break, goto, return)

Plda: switch (parancs) { case "run": Run(); break; case "save": Save(); break; case "quit": Quit(); break; default: Rossz(parancs); break; }

A case belpsi pont utn csak egy rtk adhat meg, intervallum vagy tbb rtk megadsa nem megengedett, hiszen ezek az 'rtkek' gyakorlatilag egy cmke szerept tltik be. Ha kt rtkhez rendeljk ugyanazt a tevkenysget, akkor kt cmkt kell definilni.

Plda: switch (a) { case 1: case 2: Console.WriteLine("Egy s kett esetn"); break; default:Console.WriteLine("Egybknt"); break; };

V. Utastsok

V.4. Ciklus utasts

A ciklus utastsnak ngy formja alkalmazhat a C# nyelvben, ezek a while, a do, a for s a foreach ciklus utastsok.

V.4.1. while utasts A while ciklus utasts formja:

while (kifejezs) utasts;

Elszr a zrjelben lv kifejezs kirtkeldik, ha rtke igaz, akkor a

zrjeles kifejezst kvet utasts amit szoks ciklusmagnak nevezni , vgrehajtdik. Ezutn jbl a kifejezs kirtkelse kvetkezik, igaz rtk esetn pedig a ciklusmag vgrehajtsa. Ez az ismtls addig folytatdik, amg a kifejezs hamis rtket nem ad.

Mivel az utasts elszr kirtkeli a kifejezst s csak utna hajtja vgre a ciklusmagot (ha a kifejezs igaz rtket adott), ezrt a while ciklus utastst elltesztel ciklusnak is szoks nevezni.

Plda: while(true) { Console.Writeline("Vgtelen ciklus!"); Console.WriteLine("Ilyet ne nagyon hasznlj!"); } static void Main() // betnknti kirs { string szveg[]="Szveg!"; int i=0; while(i

V. Utastsok

V.4.2. do utasts Az utasts formja:

do utasts; while (kifejezs) ;

A ciklusmag a do s a while kztti rsz vgrehajtsa utn kirtkeli a

kifejezst, s amg a kifejezs igaz rtket ad, megismtli a ciklusmag vgre-hajtst. A do ciklust szoks htultesztel ciklusnak is nevezni.

Plda: string nv; do { Console.WriteLine("Ki vagy?"); nv=Console.ReadLine(); } while (nv!="Zoli"); Console.WriteLine("Szia {0}!",nv); do Console.WriteLine("Biztos egyszer lefut!"); while(false);

V.4.3. for utasts Az utasts formja:

for (kifejezs1; kifejezs2; kifejezs3) utasts;

Ez az utasts egyenrtk a kvetkez alakkal:

kifejezs1; while (kifejezs2) { utasts; kifejezs3; };

Mindegyik kifejezs elmaradhat. Ha kifejezs2 is elmarad, akkor while (true)-knt tekinti a ciklust. A kifejezsek kztti pontosvessz nem maradhat el.

A kifejezs1 tpusdefincs kifejezs utasts is lehet. Nagyon gyakran lt-hat forrskdban az albbi forma:

V. Utastsok

Plda: for (int i=0; i

V. Utastsok

Plda: using System; public class adatsor { int[] elemek; public adatsor() { elemek = new int[5] {12, 44, 33, 2, 50}; } public vektor GetEnumerator() { return new vektor(this); } // Az "enumerator", class definils: public class vektor { int Index; adatsor a; public vektor(adatsor ad) { a = ad; Index = -1; } public bool MoveNext() { Index++; return(Index < a.elemek.GetLength(0)); } public int Current { get { return(a.elemek[Index]); } } } } public class MainClass { public static void Main() { adatsor adatok = new adatsor();

V. Utastsok

Console.WriteLine("Az adatsor elemei:"); // elemek kirsa foreach (int i in adatok) { Console.WriteLine(i); } } } /*Eredmny: 12 44 33 2 50*/

V.5. Ugr utastsok

V.5.1. break utasts Az utasts formja:

break;

Hatsra befejezdik a legbels while, do, for vagy switch utasts vgrehaj-

tsa. A vezrls a kvetkez utastsra addik.

Plda: int i=1; while(true) // ltszlag vgtelen ciklus { i++; if (i==11) break; // Ciklus vge Console.WriteLine( i); }

A break a tbbirny elgazs (switch) utastsban is gyakran hasznlt, gy kerlhetjk el, hogy a nem kvnt case gak vgrehajtdjanak.

V.5.2. continue utasts Az utasts formja:

continue;

V. Utastsok

Hatsra a legbels while, for, do ciklus utastsokat vezrl kifejezsek kerlnek kirtkelsre. (A ciklus a kvetkez ciklusmag vgrehajtshoz kszl.)

Plda: int i=1; while(true) // 10 elem ciklus { i++; if (i

V. Utastsok

goto case 1; case 1: egy(); goto default; default: valami(); break; }

A goto utastsrl zrskppen meg kell jegyezni, hogy a strukturlt

programksztsnek nem felttlenl rsze ez az utasts, gy hasznlata sem java-solt. A knyv ksbbi pldaprogramjaiban sem fordul el egyszer sem ez az utasts.

V.5.5. using utasts A using kulcssz ktfle nyelvi krnyezetben szerepelhet. Egyrszt n.

direktva, knyvtri elemek, adott nvtr, osztly hasznlataknt. Ennek formja:

using nvtr_vagy_osztly; Plda:

using System; // a keretrendszer f nvternek hasznlata // a C++ #include-hoz hasonlan megmondja a // fordtnak, hogy ennek a nvtrnek a tpusait is // hasznlja. Ezen tpusokat azrt enlkl is teljes // nvvel (System.Console) hasznlhatjuk

A msik eset a using utasts. Egy ideiglenesen hasznlt objektum esetn a

using utasts utn a keretrendszer automatikusan meghvja az objektum Dispose metdust. A using utasts alakja a kvetkez:

using (objektum) { utastsok;} Plda:

using (Objektumom o = new Objektumom()) { o.ezt_csinald(); }

V. Utastsok

Ez a hasznlat az albbi kdrszletnek felel meg, a nem ismert nyelvi eleme-ket ksbb ismertetjk:

Objektumom o = new Objektumom(); try {o.ezt_csinald();} finally { if (o != null) ((IDisposable)o).Dispose(); }

A Dispose utastst s krnyezett bvebben a destruktorokkal kapcsolatban

rszletezzk.

V.5.6. lock utasts Ha egy kritikus utasts blokk vgrehajtsakor egy referencia blokkolsra

van szksg a biztonsgos vgrehajtshoz, akkor ezt a lock utastssal megtehet-jk.

A lock kulcssz egy referencit vr, ez jellemzen a this, majd utna kvetkezik a kritikus blokk. Ennek formja:

lock(ref) utasts; Plda:

lock(this) { a=5; // biztonsgos }

A lock utastsnak, ahogy lttuk, a leggyakrabban hasznlt paramtere a this,

ha a vdett vltoz vagy fggvnyutasts nem statikus. (Osztlypldnyok.) Ha statikus vltozkat vagy fggvnyutastsokat szeretnnk biztostani

(lockolni), hogy egyszerre csak egy vgrehajtsi szl tudjon hozzfrni, akkor a lock referencinak az osztly tpust kell megadni.

Plda: class adatok { static int szamlalo=0; public void mentes(string s)

V. Utastsok

{ lock(typeof(adatok)) { szamlalo++; Console.WriteLine("Adatments elindul!"); for(int i=0;i

68

VI. Fggvnyek

VI.1. A fggvnyek paramtertadsa

Ha egy fggvnynek adatot adunk t paramterknt, akkor alapveten kt klnbz esetrl beszlhetnk. Egy adat rtk szerint s hivatkozs szerint kerlhet tadsra. Az els esetben valjban az eredeti adatunk rtknek egy msolata kerl a fggvnyhez, mg a msodik esetben az adat cme kerl t-adsra.

VI.1.1 rtk szerinti paramtertads ltalnosan elmondhatjuk, hogyha nem jellnk semmilyen paramtert-

adsi mdszert, akkor rtk szerinti paramtertadssal dolgozunk. Ekkor a fggvny paramterben, mint formlis paramterben, a fggvny meghvsakor a hvrtk msolata helyezkedik el.

Tekintsk meg a kvetkez maximum nev fggvnyt, aminek az a feladata, hogy a kapott kt paramtere kzl a nagyobbat adja vissza eredmnyknt.

Plda: class maxfv { static int maximum(int x,int y) { return (x>y?x:y); } static void Main() { Console.WriteLine(maximum(4,3)); } }

Az gy megvalstott paramtertadst rtk szerinti paramtertadsnak

nevezzk, a maximum fggvny kt (x s y) paramtere a hvskor megadott kt paramtert kapja rtkl. rtk szerinti paramtertadsnl, hvskor konstans rtk is megadhat.

A fggvny hvsnak egy sajtos esete az, mikor egy fggvnyt sajt maga hv meg. Szoks ezt rekurzv fggvnyhvsnak is nevezni. Erre pldaknt nz-zk meg a klasszikus faktorilisszmol fggvnyt.

VI. Fggvnyek

Plda: class faktor { static int faktorialis(int x) { return (x

VI. Fggvnyek

VI.1.3. Fggvnyeredmny paramtere A referencia szerinti paramtertadshoz hasonlan, a fggvnybeli vltoz

rtke kerl ki a hv vltozba. A klnbsg csak az, hogy ebben a vltozban a fggvny nem kap rtket.

Az eredmny paramtert az out kulcsszval definilhatjuk. A hvskor is a paramter el ki kell rni az out jelzt. A hasznlata akkor lehet hasznos, amikor egy fggvnynek egynl tbb eredmnyt kell adnia.

Plda: using System; public class MyClass { public static int TestOut(out char i) { i = 'b'; return -1; } public static void Main() { char i; // nem kell inicializlni a vltozt Console.WriteLine(TestOut(out i)); Console.WriteLine(i); } } Kperny eredmny: -1 B

VI.1.4. Tmbk paramtertadsa A nyelv a tmbt annak nevvel, mint referencival azonostja, ezrt egy

tmb paramtertadsa nem jelent mst, mint a tmb referencijnak tadst. Egy fggvny termszetesen tmbt is adhat eredmnyl, ami azt jelenti, hogy az eredmny egy tmbreferencia lesz. Egy tmb esetben sincs msrl sz, mint egyszer vltozk esetben, a tmbreferencia egy referenciavltoz , rtk szerinti paramtertadsrl.

Az elmondottak illusztrlsra lssuk a kvetkez sematikus pldt.

VI. Fggvnyek

Plda: void mdost(int[] vektor) { // a vektort, mint egy referencit kapjuk paramterl // ez rtk szerint kerl tadsra, azaz ez a referencia //nem vltozik, vltozik viszont a 0. tmbelem, s ez a // vltozs a hv oldalon is ltszik vektor[0]=5; }

Ahogy a fenti pldn is lthat, a vektor paramterknt a referencijval ke-

rl tadsra. Ez rtk szerinti paramtertadst jelent. Ha egy fggvnyben a mutatott rtket (vektorelemet) megvltoztatom, akkor a vltozs a kls, para-mterknt tadott vektorban is lthat lesz!

A nyelvben a vektor tudja magrl, hogy hny eleme van (Length), ezrt ellenttben a C++ nyelvvel , az elemszmot nem kell tadni.

Tmb esetben is alkalmazhatjuk a referencia vagy out paramter tads-nak lehetsgt. Ennek illusztrlsra nzzk a kvetkez pldkat:

1. plda:

using System; class teszt { static public void feltlt(out int[] vektor) { // a vektor ltrehozsa, s inicializlsa vektor = new int[5] {1, 2, 3, 4, 5}; } static public void Main() { int[] vektor; // nem inicializltuk // meghvjuk a feltlt fggvnyt: feltlt(out vektor); // A vektorelemek kirsa: Console.WriteLine("Az elemek:"); for (int i=0; i < vektor.Length; i++) Console.WriteLine(vektor[i]); } }

VI. Fggvnyek

2. plda: using System; class Refteszt { public static void feltlt(ref int[] arr) { // Ha hv fl mg mg nem ksztette el, //akkor megtesszk itt. if (arr == null) arr = new int[10]; // nhny elem mdosts arr[0] = 123; arr[4] = 1024; // a tbbi elem rtke marad az eredeti } static public void Main () { // Vektor inicializlsa int[] vektor = {1,2,3,4,5}; // Vektor tadsa ref, paramterknt: feltlt(ref vektor); // Kirs: Console.WriteLine("Az elemek:"); for (int i = 0; i < vektor.Length; i++) Console.WriteLine(vektor[i]); } }

VI.2. A Main fggvny paramterei

A parancsok, programok indtsakor gyakori, hogy a parancsot valamilyen

paramter(ek)rel indtjuk. Ilyen parancs pldul a DOS echo parancsa, amely paramtereit a kpernyre visszhangozza, vagy a type parancs, mely a para-mterl kapott fjl tartalmt rja a kpernyre.

Ezeket a paramtereket parancssor-argumentumoknak is szoks nevezni. Amikor elindtunk egy programot (a Main fggvny az opercis rendszertl tveszi a vezrlst), akkor hvskor a Main fggvnynek egy paramtere van. Ez a paramter egy szveges (string) tmb, amelynek elemei az egyes paramterek. A paramtertmbt gyakran args nvre keresztelik.

VI. Fggvnyek

A parancssor-argumentumok hasznlatra nzzk az imnt mr emltett echo parancs egy lehetsges megvalstst.

Plda: static void Main(string[] args) { int i=0; while (i

VI. Fggvnyek

A Main fggvnyt, abban az esetben, ha a parancssori paramtereket nem akarjuk feldolgozni, a paramterei nlkl is deklarlhatjuk:

static void Main() {}

VI.3. Fggvnyek vltoz szm paramterrel

A feladatmegoldsok sorn gyakran elfordulhat, hogy elre nem tudjuk

eldnteni, hny elemet kell a fggvnynek feldolgoznia. Teht nem tudjuk, hogy hny paramterrel ksztsk el a kvnt fggvnynket. A params kulcssz segtsgvel egy vektorparamtert definilhatunk a fggvnynek, ami ezeket a paramtereket tartalmazza majd.

Nzznk nhny pldt ilyen fggvny definilsra, majd a hasznlatra.

Plda: using System; public class vltparamter { public static void intParamterek(params int[] list) { for ( int i = 0 ; i < list.Length ; i++ ) Console.WriteLine(list[i]); Console.WriteLine(); } public static void objParamterek(params object[] list) { for ( int i = 0 ; i < list.Length ; i++ ) Console.WriteLine(list[i]); Console.WriteLine(); } public static void Main() { intParamterek(1, 2, 3); objParamterek(1, "fradi", "teszt", 3.5); int[] myarray = new int[3] {10,11,12}; intParamterek(myarray); } }

VI. Fggvnyek

Az eredmny a kvetkez lesz: 1 2 3 1 fradi teszt 3.5 10 11 12

Egy vltoz paramterszm fggvnynek lehetnek fixen megadott

paramterei is. A fixen megadott paramtereknek ktelezen meg kell elznik a vltoz paramtereket. A kvetkez plda egy ilyen fggvnydefincit mutat.

Plda: using System class parameters { public static void valtozo(int x, params object[] list) { Console.WriteLine(x); foreach (object o in list) Console.WriteLine(o); } public static void Main() { valtozo(25, "alma", "barack","szilva"); } }

Eredmnyl kapjuk a fggvny paramtereinek kirst egyms al.

VI.4. Fggvnynevek tdefinilsa

Egy-egy feladat esetn gyakorta elfordul, hogy a megoldst ad fggvnyt klnbz tpus vagy klnbz szm paramterrel jellemezhetjk. Termszetesen az ezt megold fggvnyt azonos nvvel szeretnnk elkszteni minden esetben, hisz ez lenne a legkifejezbb. A lehetsget gyakran fggvny overloading nvvel is megtalljuk az irodalomban, vagy a polimorfizmus kapcsn kerl megemltsre.

VI. Fggvnyek

Hatrozzuk meg kt szm maximumt! Ha el szeretnnk kerlni a tpus-konvertlst mondjuk egsz tpusrl valsba s fordtva, akkor kln az egsz s kln a vals szmok esetre is meg kell rnunk a maximum fgg-vnyt.

Knyelmetlen dolog lenne, ha mondjuk egszmax s valsmax nven kel-lene megrni a kt fggvnyt. Mindkt esetben szeretnnk a maximum fggvnynevet hasznlni, hogy ne neknk kelljen eldnteni azt, hogy az egszek vagy valsak maximumt akarjuk-e meghatrozni, hanem dntse el a fordt a paramterlista alapjn automatikusan, hogy melyik fggvnyt is kell az adott esetben meghvni.

Plda: // vals maximum fggvny double maximum(double x,double y) { if (x>y) return x; else return y; } // egsz maximum fggvny int maximum(int x,int y) { if (x>y) return x; else return y; } int a=2,b=4; double c=3.123, d=2; Console.WriteLine(maximum(4.1,2)); // vals hvs Console.WriteLine(maximum(4,2)); // egsz hvs Console.WriteLine(maximum(a,b)); // egsz hvs Console.WriteLine(maximum(c,d));

Meg kell jegyezni, hogy ezt a tulajdonsgot sok nyelvben fggvnysablon

(template) tulajdonsg segtsgvel elegnsabban oldhatnnk meg, de a jelenlegi C# ezt nem tmogatja.

VI. Fggvnyek

VI.5. Delegltak, esemnyek Ahogy korbban is sz volt rla, a biztonsgosabb programkd ksztsnek

rdekben a mutat aritmetika a C# nyelvben nem engedlyezett. Ebbe beletartozik az is, hogy a fggvnymutatk sem lehetnek kivtelek.

Ez utbbi esetben viszont olyan nyelvi tulajdonsgok nem implementl-hatk, mint pldul egy menponthoz hozzrendelt fggvny, amit a menpont vlasztsa esetn kell vgrehajtani. Ezen utbbi lehetsget hivatott a deleglt tpus biztostani. Ez mr csak azrt is fontos, mert tbbek kztt a Windows programozs callback jellemz paramtere is ezt hasznlja.

A C++ krnyezetben ezt a lehetsget a fggvnymutat biztostja. A deleglt valjban egy fggvnytpus-definci, aminek alakja a kvet-

kez:

delegate tpus delegltnv(tpus paramternv,); A deleglt referencia tpus. Ha paramtert is megadunk, akkor a paramter

nevt is meg kell adni.

Plda: delegate int pelda(int x, string s);

Az elbbi pldban teht a pelda deleglt tpust definiltuk. Ez olyan fgg-

vnytpus, amelyiknek egy egsz s egy szveg paramtere van, s eredmnyl egy egsz szmot ad.

Egy deleglt objektumnak vagy egy osztly statikus fggvnyt, vagy egy osztly pldnyfggvnyt adjuk rtkl. Deleglt meghvsnl a hagyo-mnyos fggvnyhvsi formt hasznljuk. Ezek utn nzznk egy konkrt pldt:

Plda: using System; class proba { public static int negyzet(int i) { return i*i; } public int dupla(int i) { return 2*i; } }

VI. Fggvnyek class foprogram { delegate int emel(int k); // az emel deleglt definilsa public static void Main() { emel f=new emel(proba.negyzet); // statikus fggvny lesz a deleglt Console.WriteLine(f(5)); // eredmny: 25 proba p=new proba(); emel g=new emel(p.dupla); // norml fggvny lesz a deleglt Console.WriteLine(g(5)); // eredmny: 10 } }

A delegltakat a krnyezet kt csoportba sorolja. Ha a deleglt visszatrsi tpusa void, akkor egy deleglt tbb vgrehajtand fggvnyt tartalmazhat (multicast, sszetett deleglt), ha nem void a visszatrsi tpus, mint a fenti pldban, akkor egy deleglt csak egy vgrehajtand fggvnyt tud meghvni (single cast, egyszer deleglt).

Az egyszer s sszetett delegltakra nzzk a kvetkez pldt:

Plda: using System; class proba { public static int negyzet(int i) { return i*i; } public int dupla(int i) { return 2*i; } public int tripla(int i) { return 3*i; } public void egy(int i) { Console.WriteLine(i); } public void ketto(int i) { Console.WriteLine(2*i); } }

VI. Fggvnyek

class foprogram { delegate int emel(int k); delegate void meghiv(int j); public static void Main() { emel f=new emel(proba.negyzet); Console.WriteLine(f(5)); proba p=new proba(); emel g=new emel(p.dupla); Console.WriteLine(g(5)); emel h=new emel(p.tripla); g+=h; //g single cast, g a tripla lesz Console.WriteLine(g(5)); // eredmny: 15 meghiv m=new meghiv(p.egy); // multicast deleglt m+=new meghiv(p.ketto); m(5); // deleglt hvs, eredmny 5,10 } }

Ha fggvnymutat tpust (deleglt) deklarlunk, akkor rtkads esetn a

mutat tpusa hatrozza meg, hogy a fordtnak melyik aktulis fggvnyt is kell az azonos nevek kzl vlasztania.

delegate double vmut(double,double); // vmut olyan deleglt amelyik egy vals rtket visszaad, // s kt vals paramtert vr fggvnyt jelent delegate int emut(int,int); // emut olyan deleglt, amelyik egy egsz rtket visszaad // , s kt egsz paramtert vr fggvnyt jelent vmut mut=new vmut(maximum); // vals hvs Console.WriteLine(mut(3,5));

A multicast deleglt (tpus) definilsi lehetsget, igaztva az ignyeket az

esemnyvezrelt programozsi krnyezethez (mind a Windows, mind az X11 ilyen), az egyes objektumokhoz, tpushoz gy kapcsolhatjuk, hogy esemny tpus mezt adunk hozzjuk. Ezt az albbi formban tehetjk meg:

public event meghiv esemeny;

ahol a meghiv sszetett deleglt. Az esemny objektum kezd rtke null lesz, gy az automatikus meghvs (esemeny()) nem ajnlott!

VI. Fggvnyek

Az esemnyhez zrskppen meg kell jegyezni, hogy az egsz keretrendszer a felhasznli tevkenysget ehhez a lehetsghez rendeli akkor, amikor klasszi-kus Windows alkalmazst akarunk ks

Documents

Programozas Csharp Nyelven Konyv