C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.

info)

A C# programozási nyelv
a felsőoktatásban Programozás tankönyv

Dr. Kovács Emőd Hernyák Zoltán Radványi Tibor Király Roland

Ez a 1. oldal a 242-ből www.kuruc.info

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.info)

Tartalom
TARTALOM .............................................................................................. 2 TÖRTÉNETI ÁTTEKINTŐ ............................................................................. 7
Egy jó programozási nyelv .................................................................................................................................................................................................... 8

ELSŐ GENERÁCIÓS PROGRAMOZÁSI NYELVEK: GÉPI KÓD.............................................. 8 MÁSODIK GENERÁCIÓS PROGRAMOZÁSI NYELVEK: ASSEMBLY..................................... 9
Változók az assembly nyelvben ........................................................................................................................... 10 Vezérlési szerkezetek az assembly nyelvben ..................................................................................................... 11
Forráskód ............................................................................................................................................................................................................................. 9 Fordítás ................................................................................................................................................................................................................................ 9

Eljáráshívás az assembly nyelvben ..................................................................................................................... 12 Több modulból álló programok az assembly nyelvben ..................................................................................... 12 HARMADIK GENERÁCIÓS PROGRAMOZÁSI NYELVEK: PROCEDURÁLIS NYELVEK ......... 13 Az első nagyon fontos változás - az eljárás fogalmának bevezetése. ............................................................. 13 A másik fontos változás a VÁLTOZÓ fogalmának finomodása: ........................................................................... 13 A harmadik fontos változás - a típusrendszer bővíthetősége ........................................................................... 14 A negyedik fontos változás - a vezérlési szerkezetek bevezetése ................................................................... 14
A változó élettartama ........................................................................................................................................................................................................ 14 A változó hatásköre ............................................................................................................................................................................................................ 14

Szekvencia ....................................................................................................................................................................................................................... 11 Feltétlen vezérlésátadás................................................................................................................................................................................................. 11 Feltételes vezérlésátadás............................................................................................................................................................................................... 11 Visszatérés ....................................................................................................................................................................................................................... 11

Az ötödik fontos változás - a hardwarefüggetlenség. ........................................................................................ 14

Szekvencia .......................................................................................................................................................................................................................... 14 Szelekció ............................................................................................................................................................................................................................. 14 Iteráció ............................................................................................................................................................................................................................... 14

HÁROM ÉS FÉL GENERÁCIÓS PROGRAMOZÁSI NYELVEK: OBJEKTUMORIENTÁLT NYELVEK .......................................................................................................... 15 NEGYEDIK GENERÁCIÓS PROGRAMOZÁSI NYELVEK: SPECIALIZÁLT NYELVEK .............. 15 ÖTÖDIK GENERÁCIÓS PROGRAMOZÁSI NYELVEK: MESTERSÉGES INTELLIGENCIA NYELVEK .......................................................................................................... 15 A PROGRAMOZÁSI NYELVEK CSOPORTOSÍTÁSA ........................................................... 15
Imperatív (procedurális) nyelvek: ......................................................................................................................... 15 Applikatív (funkcionális) nyelvek: ........................................................................................................................ 16 Logikai nyelvek: ..................................................................................................................................................... 16 Objektum-orientált nyelvek: .................................................................................................................................. 16 Futtatórendszerek .................................................................................................................................................. 16

Direkt futtatás .................................................................................................................................................................................................................... 16 Interpreterrel való futtatás................................................................................................................................................................................................. 17 Virtuális futtatás ................................................................................................................................................................................................................ 17

BEVEZETÉS - A MICROSOFT®.NET ........................................................... 18 „HELLÓ VILÁG!”..................................................................................... 23
Első lépés ............................................................................................................................................................................................................................ 24

FELADATOK: ........................................................................................................ 28
Programozási feladat:............................................................................................................................................ 28

„ALAP I/O”............................................................................................ 30
AZ ALAPVETŐ INPUT/OUTPUT ................................................................................ 31
Az értékadásnak jól meghatározott szintaktikája van ........................................................................................................................................................ 34 A feladat ............................................................................................................................................................................................................................. 39

PROGRAMOZÁSI FELADATOK .................................................................................. 42

„SZELEKCIÓ ALAPSZINT” ......................................................................... 43
A LOGIKAI TÍPUSÚ VÁLTOZÓ .................................................................................... 44 A FELTÉTELES UTASÍTÁS .......................................................................................... 45 AZ ELÁGAZÁS ....................................................................................................... 46 NÉHÁNY EGYSZERŰ PÉLDÁCSKA A SZELEKCIÓ ALKALMAZÁSÁRA ...................................... 47
Ez a 2. oldal a 242-ből www.kuruc.info

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.info)
Döntsük el egy számról, hogy páros-e! ............................................................................................................... 47

MEGOLDÁSRA AJÁNLOTT FELADATOK....................................................................... 47

ELŐÍRT LÉPÉSSZÁMÚ CIKLUSOK ................................................................ 49
Programozási feladat: ............................................................................................................................................ 53

FELADATOK: ........................................................................................................ 54

„VEKTOROK!” ........................................................................................ 56
VEKTOROK KEZELÉSE ............................................................................................. 57
Tömb deklarálása ................................................................................................................................................... 57 A tömb elemeinek elérése ..................................................................................................................................... 57 A tömb elemeinek rendezése, keresés a tömbben ............................................................................................. 58 Vektor feltöltése billentyűzetről ............................................................................................................................ 60 Vektor feltöltése véletlenszám-generátorral ....................................................................................................... 62 N ELEMŰ VEKTOROK KEZELÉSE ................................................................................ 63 Összegzés ............................................................................................................................................................... 63 Maximum és minimum kiválasztása .................................................................................................................... 64 Eldöntés .................................................................................................................................................................. 65 Kiválogatás ............................................................................................................................................................. 65 DINAMIKUS MÉRETŰ VEKTOROK ............................................................................. 66 Az ArrayList főbb jellemzői: .................................................................................................................................. 66 Az ArrayList főbb metódusai: ............................................................................................................................... 66 Feladatok dinamikus tömbre ................................................................................................................................ 67
Kérjünk be számokat a nulla végjelig ................................................................................................................................................................................. 67

TÖBBDIMENZIÓS TÖMBÖK ..................................................................................... 70 TOVÁBBI MEGOLDÁSRA AJÁNLOTT FELADATOK .......................................................... 73

„LOGIKAI CIKLUSOK” .............................................................................. 75
A CIKLUSOK ......................................................................................................... 76
A WHILE ciklus ....................................................................................................................................................... 76 A break .................................................................................................................................................................... 79 A continue ............................................................................................................................................................... 79 A DO WHILE CIKLUS ............................................................................................... 80 A foreach ................................................................................................................................................................. 81 PROGRAMOZÁSI FELADATOK .................................................................................. 81

„SZELEKCIÓ EMELT SZINT!” ..................................................................... 83
SZELEKCIÓ HALADÓKNAK ....................................................................................... 84
Feladat:.................................................................................................................................................................... 84

TOVÁBBI MEGOLDÁSRA AJÁNLOTT FELADATOK .......................................................... 88

STRINGEK KEZELÉSE............................................................................... 89
A STRING TÍPUSÚ VÁLTOZÓ ..................................................................................... 90 A STRING-EK MINT VEKTOROK................................................................................. 93 PROGRAMOZÁSI FELADATOK .................................................................................. 95

ELJÁRÁSOK ALAPFOKON .......................................................................... 97
Hová írjuk az eljárásainkat? .................................................................................................................................. 99 Hogyan kell megosztani változókat eljárások között? ..................................................................................... 100 FELADATOK: ......................................................................................................101
Az eljárás ........................................................................................................................................................................................................................... 98

FÜGGVÉNYEK ÍRÁSA ............................................................................. 103
FELADATOK: ......................................................................................................106

ELJÁRÁSOK ÉS FÜGGVÉNYEK KÖZÉPFOKON .............................................. 108
FELADATOK: ......................................................................................................111

ELJÁRÁSOK ÉS FÜGGVÉNYEK FELSŐFOKON ............................................... 112
Ez a 3. oldal a 242-ből www.kuruc.info

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.info)

„WINFORM” ........................................................................................ 118
A WINDOWS FORMOK .......................................................................................119
Hibakezelés ........................................................................................................................................................... 119 A try és a catch ..................................................................................................................................................... 119 A finally blokk ....................................................................................................................................................... 121 Kivételek feldobása .............................................................................................................................................. 122 Checked és unchecked ....................................................................................................................................... 122 PROGRAMOZÁSI FELADATOK ................................................................................123 ÚJ PROJEKT KÉSZÍTÉSE .........................................................................................123
A program sorai ................................................................................................................................................................................................................125

Feladatok............................................................................................................................................................... 127 A LÁTHATÓ KOMPONENSEK, A KONTROLLOK ...........................................................127 Button (Gomb) ...................................................................................................................................................... 127 Label, Linklabel .................................................................................................................................................... 128 Textbox.................................................................................................................................................................. 129 CheckBox .............................................................................................................................................................. 130
Példakód: ..........................................................................................................................................................................................................................130

GroupBox .............................................................................................................................................................. 130 MainMenu .............................................................................................................................................................. 131 RadioButton .......................................................................................................................................................... 133 ComboBox ............................................................................................................................................................ 134 ListView ................................................................................................................................................................. 136 TreeView................................................................................................................................................................ 138 TabControl ............................................................................................................................................................ 140 DateTimePicker komponens ............................................................................................................................... 141
Érték beírása és kiolvasása ................................................................................................................................................................................................143

MonthCalendar komponens ................................................................................................................................ 144
Kiemelt dátumok kezelése .................................................................................................................................................................................................146 Dátum hozzáadás: .............................................................................................................................................................................................................146 LargeChange .....................................................................................................................................................................................................................147 SmallChange .....................................................................................................................................................................................................................147

Listbox................................................................................................................................................................... 148 Panel ...................................................................................................................................................................... 148 PictureBox ............................................................................................................................................................ 149
Image: ...............................................................................................................................................................................................................................149 Sizemode: ..........................................................................................................................................................................................................................150 SizeModeChanged: ............................................................................................................................................................................................................150 Timer komponens ..............................................................................................................................................................................................................150 Timer kezelése ...................................................................................................................................................................................................................151 Az Interval határai: ............................................................................................................................................................................................................151

NumericUpDown .................................................................................................................................................. 151 ProgressBar .......................................................................................................................................................... 152
A ProgressBar értékének közvetlen beállítása ...................................................................................................................................................................153

TrackBar-ellenőrzés ............................................................................................................................................. 154
LargeChange tulajdonság..................................................................................................................................................................................................154

HelpProvider ......................................................................................................................................................... 154
Mintapélda ........................................................................................................................................................................................................................155

ImageList............................................................................................................................................................... 158
Példa .................................................................................................................................................................................................................................158 Paraméterezés ..................................................................................................................................................................................................................162

RichTextBox ......................................................................................................................................................... 162
Példa: ................................................................................................................................................................................................................................163

ToolTip .................................................................................................................................................................. 164
Példa: ................................................................................................................................................................................................................................165

ContextMenu ........................................................................................................................................................ 165 NotifyIcon .............................................................................................................................................................. 167 StatusBar .............................................................................................................................................................. 167 ToolBar .................................................................................................................................................................. 168 FORMOK HASZNÁLATA, FORMOK TÍPUSAI ............................................................... 170 Formok jellemzői: ................................................................................................................................................. 170 A rendszer által biztosított üzenetablakok használata ..................................................................................... 171 Modális és nem modális formok ........................................................................................................................ 173 DIALÓGUSOK .....................................................................................................175 A fontDialog .......................................................................................................................................................... 175 ColorDialog ........................................................................................................................................................... 176 PrintPreviewDialog .............................................................................................................................................. 177 Fájl megnyitása és mentése ............................................................................................................................... 178 MessageBox ......................................................................................................................................................... 178 FELADATOK .......................................................................................................179 TÖBBSZÁLÚ PROGRAMOZÁS .................................................................................179
Ez a 4. oldal a 242-ből www.kuruc.info

.................................................................................................................................................................................................................................................................................................224 Kapcsolat létrehozása SQL Server-hez .....181 „GRAFIKAI ALAPOK!” ................................................................................222 Tranzakciók ................................................................................................info) FELADATOK ...........................................................................................................................................................................................................183 GDI+ ................222 Kapcsolatok tervezéskor a Server Explorer-ben ................................................................................................................... 216 MS SQL szerver elérése C#-ból ..............................................................................................................................185 Néhány változás a GDI+ porgramozásban ...................................................223 Kapcsolat bontása .......................198 Harmadfokú Bézier-görbék .................................................................AZ ADO................................223 Lehetőségeink: .. 187 Cardinal Spline-ok .....................................................................................................................................................................................................................................................................................206 Ponttranszformációk .............................info A tábla létrehozása ...................................................................................190 Vonalrajzolás GDI+ használatával ..............................................................224 Kapcsolódás létrehozása VIZUÁLIS ESZKÖZÖKKEL ....................................................................................................210 Nyírás: ..... 205 Hermit-görbe...............................................................................................................................................................216 Új elemek létrehozása...............................206 Áttérés hagyományos Descartes koordinátákról homogén koordinátákra: ............... 186 A GDI+ újdonságai ..................................................... 194 Interpoláció és approximáció ..........................................................................................235 Ez a 5.......................................................................221 ADO.......................................................................................NET-ADATKEZELÉS C#-BAN .........................................................................C#-programozás a felsőoktatásban (ezt is nézd azért meg: www....197 Bézier-görbe ....................................................................................................................................234 While ciklusok ......kuruc........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................... 212 „ADATOK KEZELÉSE!” ......................................................................207 Eltolás: ..............................................................................................................................................................................................................210 Grafikus konténerek .............................................................................................. 221 Kapcsolat létrehozása és megszüntetése ....................................................................................225 Szűrés és rendezés a DataView objektum segítségével .........................................................................................................................................................................................................................227 A RowFilter tulajdonság .....227 Rendezés a DataViewban .............................................................................................235 A CONTINUE utasítás .....................................................................................................................................................................................234 CASE utasítások .....................................NET ..........................................................................................................................................................................................................................................184 GDI+ osztály és interfész a ......................198 A Bézier-görbe előállítása Bernstein-polinommal.......................................................................................................... 197 Ponttranszformációk .................................................................................................................................... 233 ................... 191 Mátrix transzformációk ..............................................................................................................210 Skálázás: .....................NET-ben ................................................................................................................................................................................................................................................................................................227 Az alapértelmezett nézet ................................................................................................................................................................................................................. 185 A Graphics osztály ........................................ oldal a 242-ből www........................................................223 Kapcsolattervezési eszközök Visual Studio-ban .........................................................................................................................................................................................................202 Homogén koordináták...............................................................207 Második példa: ..................................................................................................................................................................................................................... 223 Kapcsolódás SQL Server-hez az alkalmazásunkból .................227 Mi is az a Transact-SQL? ..............................................................................................................................................................................................................................................................191 Metódusok felülbírálása (Method Overloading)..........................................218 Bevezetés az ADO..........................................................................................................................................................................233 Feltételes szerkezetek használata ............................................................................................................................................................................... 187 Névterek...................................................................................................................................................................................................................................................................................................................................................................................198 Bézier-görbe néhány tulajdonsága ....................................................................................................................................................NET kapcsolat objektumok létrehozása ....................................................................................................................... 224 Szűrés és rendezés az ADO.........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................209 Elforgatás az origó körül alfa szöggel pozitív irányba: ................................................................................................................................................................................................ 208 A koordináta rendszer transzformálása és a Path használata ..............................................................................................................................................................................................................................................................................................................................................................................................................200 Cardinal spline ..............................................................................................................................189 A következő formátumokat támogatja ...............................................................................................................................223 Kapcsolat létrehozása SQL Server-hez ADO................................................................................ 221 Connection String .............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................NET kapcsolódási eszközeihez ..................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................212 GDI+ transzformációs metódusai .....................................................................222 Beállítható kapcsolattulajdonságok ....................................................................................................................................................................................................................................................................224 A DataTable osztály................................................................................................................................................................................................................................................................................. 182 A GRAFIKUS SZOFTVER....................................................................................................................................................... 215 AZ ADO..........................................................................................NET használatával...............................................217 Kapcsolatok ....................192 Szétválasztott metódus a rajzolásra ..........................................................................................................................................................................................................................................................209 Tükrözés: .................188 Alpha Blending ..................................................................................................................................................................................................................................................206 Első példa: .........................................................................................................................................................................................................................................................................................................233 Változók ...........................kuruc............................................................................. 222 Összetett kapcsolatok (Pooling Connections) ................................................................................................ 225 Tárolt eljárások . namespaces ................................192 Regiók létrehozása ........................................................206 Visszatérés homogén koordinátákról Descartes koordinátákra: ..............................................................................................................................................................................................................................................................................................................................................NET-ben ...................................................................................................223 Kapcsolat létrehozása .224 SQL Server kapcsolat Server Explorer-ben ............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................

................235 RAISERROR utasítások használata........................239 Többutasításos táblaértékű függvények..................................................................................................................................................................................................................................... oldal a 242-ből www....kuruc...........................................................................................................................................................................236 KURZOROK használata ....................................................................................235 RETURN utasítások használata ......................................................................................................................................................................................................................................................................................................info ...............................................................................................kuruc.239 Lokális ideiglenes........................................................................................................238 Helyben kifejtett táblaértékű függvények .....................C#-programozás a felsőoktatásban (ezt is nézd azért meg: www..........................................241 Ez a 6................................................................................................................................................................................................................................................................................................................................................................................................................235 WAITFOR utasítások használata ............................................................................................. 240 Függvénykategóriák: ...........................................................................................................................240 Tárolt eljárások végrehajtása: ................................................................................................................................241 Kioldók ......................................................................................238 Felhasználói függvények létrehozása ....................................................................................................................................................................................................................................................................................................236 FÜGGVÉNYEK HASZNÁLATA .......................................................................................................................................................info) A BREAK utasítás .................................................................................................. 238 Tárolt eljárások létrehozása:..............................................................................................................................................................................241 Összefog(lal)ás ...................

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info) Programozás tankönyv I. Fejezet Történeti áttekintő Hernyák Zoltán Ez a 7. oldal a 242-ből www.info .kuruc.kuruc.

egyszerű programokat kéEz a 8. A programozó szemszögéből a gépi kódban történő programozás nagyon lassú folyamat. A kész program nehezen megérthető. Az eredményt (az EAX regiszter új értékét) tároljuk a memória egy másik pontján. először még el kellett sajátítania a különbségeket. hogy a gépi kódú programozási nyelv nehézkes.info) A számítástechnika történetének egyik fontos fejezete a programozási nyelvek kialakulása. elősegítve a programozási hibák minél korábban (lehetőleg fordítási időben) történő felfedezését. Emeljünk ki néhányat ezek közül: könnyen elsajátítható alapelvekkel rendelkezik. könnyen módosítható. AX. Ha egy gépi kódban programozó számára egy másik processzorra kellett programot írni.255 közötti egész számok. Két szám összeadását az alábbi módon kell végrehajtani: Olvassuk be az első számot az EAX regiszterbe a memóriából. Az utasítások nagyon alacsony szintűek voltak. oldal a 242-ből www. A fejlődés során a programozási nyelvek szintaktikája változott meg. A programozási nyelveket generációkba lehet sorolni a fejlődés bizonyos szakaszait figyelembe véve: Első generációs programozási nyelvek: GÉPI KÓD A számítógépek a NEUMANN elveknek megfelelően a végrehajtandó programutasításokat a memóriában tárolják. A gépi kódban létező fogalom a regiszter. Vagyis más processzor esetén az utasításkódok is mások. Aránylag kevés regiszter áll rendelkezésre (kevesebb.három utasításból állt. Ezek a számok 0. hanem esetleg kevesebb vagy több utasítás van. úgy azokat is számként kell megadni. pl. Az EAX regiszterhez adjuk hozzá a második számot.info . A gépi kódú utasítások a második oszlopban vannak (a 8B45F4 számsorozat egyetlen gépi kódú utasítást (8B). nehezen tanulható. de az utasítások különbözősége sok nehézséget okozott. Aprólékosan lehet csak a programot felépíteni. hogy inkább csak rövidebb. ezért nem lehetett akármilyen célra felhasználni. Nyilván az alapelvek maradtak.. mások könnyen elkerülhetőek.. hogy a mikroprocesszor alapvetően az utasításokat is számoknak tekinti. Egy nagyobb rendszer elkészítése olyan időigényes feladat lenne. A memória ma már alapvetően byte szervezésű. Ebből az következik. A 32 bites processzorokon a regiszterek nevei felvették az ’E’ előtagot (Extended AX regiszter . A bal oldali oszlopban a memóriacímeket adjuk meg (0044F02B.EAX). könnyen dokumentálható a kód. egy egyszerű összeadás művelet is . amely a mikroprocesszoron belüli tárlórekeszt jelöl. és többnek speciális feladata volt. egyetlen nagyméretű byte-sorozatnak tekinthető. Egy ilyen rekesz tartalma egy egész szám lehet.mint láttuk a fenti példán . könnyen áttekinthető forráskód. Sok más hátránya mellett külön kiemelendő. 0…255 értéktartományból. A fentieken is látszik.. A regisztereknek kötött nevük van. A számkódokat leggyakrabban hexadecimális formában adják meg. bővíthető a forráskód.. fejlődése.kuruc. BX.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.) ahol az adott gépi kódú utasítást tároljuk.kuruc. A gépi kódú programozási nyelvben az utasításokat számkódok jelölik.F4)). hogy a gépi kódú programokat alkotó utasítások csak az adott mikroprocesszor számára érthetőek. Egy igazán jó programozási nyelven nagyon sok hibafajta eleve el sem követhető. Az utasításokat számkódok jelölik. története. illetve más-más a paraméterezése a hasonló feladatú utasításoknak. valamint a paramétereit jelöli: honnan kell beolvasni az értéket az EAX regiszterbe (45. mint 20 darab). DX. CX. nem áttekinthető. Amennyiben az utasításnak vannak paraméterei. Nemcsak számkódjukban különböznek. nehéz hibát elkövetni kódolás közben. Egy jó programozási nyelv sokféle jellemzővel rendelkezik. Minden byte egy egész számot jelölhet.

Ennek megfelelően az assembly nyelv egy adott mikroprocesszor adott gépi kódjához készült el. majd LE KELL FORDÍTANI gépi kódú. mert az eredeti forráskód elveszett. Fordítás: az a folyamat.info . Az ASSEMBLY nyelv első közelítésben a ’megérthető gépi kód’ nyelve. A „két szám összeadása” az angol ADD=összeadni mnemonikot kapta. e közben generálta a gépi kódú utasítássorozatot . és szabadon használhatjuk a memóriát is. Előnyei persze akadnak ennek a nyelvnek is: a gépi kódú utasítások segítségével maximalizálhatjuk a programunk futási sebességét. emiatt az első eszköznek is tekinthetjük.a fordítóprogramok megjelenésével megjelent az igény ezek intelligenciájának fejlődésére! Ez a 9. MNEMONIKokkal helyettesítették. Az assembler nem bonyolult program. Az ittlévő. tárgyprogramra (OBJECT CODE). FORDÍTÁSI IDŐBEN TÖRTÉNŐ HIBÁnak nevezzük. ezért visszaállítani sem lehet őket. amelyet a programozók munkájának segítésére (is) alkottak. Ezért az assembly nyelv is processzor-függő. ún. hiszen megkötések nélkül felhasználhatjuk a mikroprocesszor minden lehetőségét.<memcím>”. Ezek a megjegyzések a gépi kódú változatba nem kerültek bele. hogy az assembly-programozók már nem voltak hajlandók közvetlenül a gépi kódot módosítani. mint a gépi kód. Például a „memória-tartalom beolvasása egy regiszterbe” (bemozgatás) az angol MOVE=mozgatni szó alapján a MOV mnemonikot kapta. olyan jellegű hibákat. A MOV utasítás önmagában nem lefordítható gépi kódra. Ennek oka általában a nyelv szabályai (szintaktikája) elleni vétség. Ez a művelet persze némi veszteséggel járt . Az 1. inkább helyreállították az assembly forráskódot. A fordítás ellenkező művelete a de-compiling. abban elvégezték a módosításokat. Az ASSEMBLER a forráskód feldolgozása közben egyszerű ellenőrzéseket is elvégez.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. ezért ezt SZINTAKTIKAI HIBÁnak is nevezzük.a mnemonikok alapján előállította a megfelelő gépi kódú utasítás számkódját. amely közben a forráskódot egy fordítóprogram (COMPILER) gépi kódú utasítások sorozatára transzformálja. ábrán a harmadik oszlopban szerepelnek a gépi kódú utasítások assembly nyelvű megfelelői. Második generációs programozási nyelvek: ASSEMBLY A gépi kódú programozási nyelv hátrányai miatt új nyelvet kellett kifejleszteni. hogy melyik memória-cím tartalmát kell betölteni melyik regiszterbe. oldal a 242-ből www. a memóriacímet pedig a további számkódok írják le. A gépi kódú programok módosíthatóságának nehézségét jelzi. vagy memória-kihasználtságát (vagy mindkettőt egyszerre). Ennek során a gépi kódú programváltozatból a programozó megpróbálta visszaállítani annak assembly nyelvű eredetijét. Az utasítás egyik lehetséges formája „MOV EAX.kuruc.hiszen a tényleges eredeti assembly forráskódban többek között megjegyzések is lehettek. Az assembler végigolvasta a forráskódot sorról-sorra.info) szítettek benne a programozók. majd újra lefordították (generálták) a gépi kódú programot. a programozó elgépelte). de ezen a szinten újabb fogalmak jelentek meg: Forráskód: az assembly nyelvű programot a CPU nem képes közvetlenül megérteni és végrehajtani. de a programon mégis módosítani kellett. Az assembly nyelv esetén ezt a fordítóprogramot ASSEMBLER-nek nevezték. akkor a fordítási folyamat leáll. melyek súlyossága folytán a fordítás nem fejezhető be. Egy ilyen mnemonik (emlékeztető szócska) a gépi kódú utasítás jelentéstartalmára utalt. Az utasítások számkódjait néhány betűs (2-3-4 betűs) ún. az assembler hibaüzenettel jelzi a hiba okát és helyét a forráskódban. Ami viszont nagyon fontos lépés . Amennyiben valamely mnemonikot nem ismeri fel (pl. illetve könnyebben módosítható. Az assembly nyelvű programot egy szöveges file-ban kell megírni (FORRÁSKÓD). Az assembler a program szintaktikai helyességét ellenőrzi le. Az assembly nyelvű programok forráskódja olvashatóbb. hiszen a fordítás egyszerű szabályok szerint működik. Ennek már egyértelműen megfelel egy gépi kódú utasításkód (mov eax = 8B). Erre sokszor azért volt szükség. hiszen azt is meg kell adni.kuruc.

[1034] helyett (ami azt jelentette. A memória-beolvasást ugyanis a fogadó regiszEz a 10.helyet a memóriában. másrészt amennyiben a fizetés értékét mégsem az 1034-es memóriacímen kellett tárolni (változás). Az első esetben a megadott memóriacímről 4 byte-nyi adat kerül be az EAX nevű regiszterbe. Ez sok szempontból nem volt elég rugalmas: A számok nem hordozzák a jelentésüket. A példában ezek a sorszámok a [0 . Ennek persze a programozó az oka..kuruc. A fenti problémákon túl az assembler azt sem tudta ellenőrizni. A memóriacím alapján nem dönthető el. oldal a 242-ből www. aki rosszul írta fel a táblázatot. ugyanis a memóriacím csak a memóriabeli kezdőcímet jelöli.kuruc. Egy 128Mb memóriával szerelt számítógépben 128*1024*1024 db sorszámot lehet használni.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. harmadik esetben csak 1 byte. mi az ott lévő érték jelentése. melyhez a programozó konstans formájában rendelt hozzá memóriacímet . Az assembly programok sokszor tényleges memóriacímeket (sorszámokat) tartalmaztak számkonstansok formájában. Ezért a memóriacímek nem voltak könnyen módosíthatóak. Ez az egyszerű és logikus meggondolás indította el a ’változó’ fogalmának fejlődését. hogy a FIZETES névvel jelölt memóriaterület 4 byte-os tároló hely volt. hogy a 1034-es memóriacímen milyen adat van. Második esetben csak 2 byte. akkor egyetlen helyen kellett csak átírni . hogy ADD EAX. hogy add hozzá az [1034] memóriacímen található értéket az EAX regiszterben éppen benne levő értékhez) azt írhatták. hogy az ott tárolt adat hány byte-ot foglal el.info . hiszen ekkora memória-szakasz fenntartása után a következő memóriaterület (’ELETKOR’ elnevezéssel) 4 byte-tal távolabbi ponton kezdődik. Megakadályozni nem tudja. A programban e memóriacímek sokszor előfordultak. akkor 2 byte-nyi felhasználatlan terület keletkezne a memóriában (ami szintén nem szerencsés). Ezeket a programok elejére összefoglaló jelleggel. hogy elkerüljük két tárolóterület átfedését a memóriában (átlapolás). mert segíti. hiszen amennyiben a fizetés tárolási igénye 8 byte lenne. A fenti esetben a FIZETES volt az azonosító. A helyzet javítása érdekében a programozók elkezdtek konstansokat használni a programjaikban. Ha azonban a fizetés tárolására 2 byte is elég lenne. Ez sokkal olvashatóbb forma. hogy a tárlórekeszt megfelelően kezeli-e a programozó a későbbiekben: A fenti utasítások mindegyike elfogadható az assembly nyelv szintaktikai szabályai szerint.[FIZETES]. mivel a memória ennyi db byte-ot tartalmaz. akkor a fenti esetben az életkor még átlógna a fizetés tárlóhelyének utolsó 4 byte-jára.727] intervallumból kerülnek ki. nehezen volt kiolvasható a programból. Ez a változat azért is jobb.a program eleji táblázatban. Még fejlettebb assembler fordítók esetén a fenti táblázat az alábbi formában is felírható volt: Ebben az esetben már kiolvasható volt a táblázatból. táblázat-szerű módon írták le: Ezek után az assembly programokban az ADD EAX.info) Változók az assembly nyelvben Az assembly programokban a memória-címekre azok sorszámával lehetett hivatkozni. 134.217.

Ezekből kellett összerakni a programot. A NYUgDiJAS egy byte.kuruc. A változó más komponenseinek (élettartam. A típus sok mindent meghatároz. ’short int’. aminek helyigénye 4 byte. Ezt a plusz információt hívják a programozási nyelvben TÍPUSnak. Feltételes vezérlésátadás (feltételes ugró utasítás): mint az egyszerű ugró utasítás. majd attól a ponttól kezdve a végrehajtás újra szekvenciális. hatáskör) kezelése is hiányzott az assembly nyelvből. Az első azonosító címéhez képest a primitív típusnevek (dword. vagyis egy 4 byte-os helyigényű értéknek még mindig szabad volt az egyik felét beolvasni. csak egy olyan típusnév volt. Mivel a jelentést a fordító még nem kezelte. Nem volt ’char’. Vezérlési szerkezetek az assembly nyelvben Az assembly nyelv másik szegényes tulajdonsága a vezérlési szerkezetek hiánya. Amikor az ASSEMBLER-ek már a fenti táblázatot is kezelték. és adtak értéket az azonosítóknak. aminek helyigénye (mint a neve is mutatja) 1 byte. ’bool’. Visszatérés az ugró utasítást követő utasításra (azon helyre. hiszen miért olvasnánk be a fizetést tartalmazó számsorozatnak csak az egyik felét? Az ilyen jellegű hibákra azonban az assembler nem tudott figyelmeztetni.. ha az előírt feltétel teljesül. 2 byte helyigényű. A fenti primitív típusnevek még nem jelölték az azonosítók tényleges típusát. és dolgozni vele. byte. Egy egyszerű elágazást ennek megfelelően az alábbi módon kellett kódolni: Ez a 11. ’unsigned short int’ típusok. hiszen nem volt információja arról. de az ugrást csak akkor kell végrehajtani.kuruc. Amennyiben a fizetés 4 byte-on kerül tárolásra. hogy mit is ért a programozó fizetés alatt.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Többek között meghatározza az adott érték tárolási méretét a memóriában. A helyes kezelésre a programozónak kellett ügyelnie. mivel számára a FIZETES csak egy memóriacím volt. Ennek megfelelően ezt még nem tekinthetjük tényleges típusnévnek. akkor már képesek voltak a tárterületcímeket automatikusan kiosztani.) tárolási igényét ismervén automatikusan növelték a memóriacímeket.info . word. A típus ismeretében a fenti táblázat felírható az alábbi formában: A fenti táblázat szerint a FIZETES egy dupla-szó (DWORD). Az assembler nem is tudta volna ellenőrizni a kódot ebből a szempontból. A fordító mindössze a tárigény-szükséglet kiszámítására használta fel. Ezek az értékek továbbra is memóriacímek voltak. csak ezen 1 byte-on hordozott információ jelentésében térnek el. mindössze tárolási-igény névnek. ahonnan az ugrás történt). és az assembler programokból. Feltétlen vezérlésátadás (ugró utasítás): a program folytatása egy másik memóriabeli pontra tevődik át. Nem voltak ’finom’ típusnevek. A hibás kezelés lehetőségét még mindig megengedte. Lényegében csak az alábbi vezérlési szerkezetek találhatóak meg: Szekvencia: a program utasításainak végrehajtása a memóriabeli sorrend alapján történik. úgy a második és harmadik utasítás nagy valószínűséggel hibás.. amelynek 1 byte volt a tárolási igénye.info) ter mérete befolyásolja. Az ELETKOR egy szimpla szó (WOrD). de az automatikus kiosztás miatt a memóriaterületek átlapolásának esélye még kisebbre zsugorodott. oldal a 242-ből www. . Ezek mindegyike 1 byte tárolási igényű.

mert az assembly programok általában nagyon hoszszúak voltak.mivel a program már másik pontján járt a fejlesztés. oldal a 242-ből www. Paraméterek átadására például több mód is van . melyek segítségével a programok fejlesztési ideje.info . akkor hol kapjuk meg a visszatérési értéket? Illetve honnan tudjuk.csakúgy mint a függvények visszatérési értékének visszaadására. nagyon sokat könnyítenek a programkód olvashatóságán. Eljáráshívás az assembly nyelvben Az assembly nyelv elvileg ad lehetőséget eljáráshívásra is az alábbi formában: A ’kiiras’ itt valójában címke (programsort jelölő név).kuruc. Egy másik programozó által fejlesztett. Ugyanakkor a program jelentős része a fejlesztés közben már elkészült.kuruc. ha ez nem eljárás. hogy itt valójában feltételes elágazás történt . és az assembly nyelv értelemszerűen átvette. Ezért bevezették a több modulból történő fordítást.és energiapocsékolás volt. hogy az assembly nyelvű programból kibogozni. Ekkor az assembler a fordításhoz egy listát kaEz a 12. Ezeket a lehetőségeket maga a gépi kód tartalmazza. azt a programozó nem módosította .különösen az egymásba ágyazott ciklusok esete. és a tesztelési ideje is alaposan lerövidült. Egy hosszú forráskód fordítása nagyon sok időbe került. újra felhasználható eljárásokat és függvényeket. milyen típusú adattal. mint újra megírni a szóban forgó eljárást. De ezek egymással való megosztása a fenti akadályok miatt nehézkes volt. de megfelel az eljárásnév primitív fogalmának. nem megfelelően dokumentált eljárás felhasználása a kódban néha több energia felemésztésével járt. Több modulból álló programok az assembly nyelvben A több modulra tagolás azért volt fontos. A probléma nem is itt rejtőzik.nem egyszerű. hanem függvény. A programozók szívesen fejlesztettek általános.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. másrészt az akkori számítógépek még nagyon lassúak voltak. Ezt a szakaszt újra és újra lefordítani az assemblerrel felesleges idő. Hasonló problémákkal jár a ciklusok megtervezése és kódolása is .info) A fentiből talán sejthető. A nevesített címkék egy jó névválasztással. hanem hogy az eljárásnak hogyan adunk át paramétereket? Illetve. értékkel tér vissza az adott függvény? A fenti kérdésekre a válaszokat maga az assembly nyelv nem tartalmazza.

. és tárolási (kódolási) módját). Sőt.. általános eljárásaikat külön kis kód-gyűjteményben tárolták. vagy. A fentiek bizonyítják. Ez tovább erősítette a vágyat az általános célú eljárások írására. szemléletbeli váltást követeltek meg az assemblyprogramozóktól. Ezzel is nagyon sok tipikus programozóhiba kiszűrhetővé vált. míg logikai típusúval a logikai műveletek (és. úgy azt az assembler egy gyors ellenőrzéssel észrevette.NEVE (azonosítója). A frissen felnövekvő programozó nemzedék.kuruc. A deklaráció helye további információkat jelent a fordítóprogram számára . hasonló jelentős lépésként a fordítóprogram az eljárás hívásakor ellenőrizte. értékeket kell az eljárás számára átadni. akik nem hordoztak magukban rossz szokásokat és hibás beidegződéseket .C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. ezzel lehet a kódban hivatkozni rá. . módosítása). Ez leírta. hogy az assembly nyelv sok olyan lehetőséget rejtett magában. Miután az assembler végzett a forráskódok fordításával. speciális feladatot végző program következett.az eljárás fogalmának bevezetése. A linker a sok apró kis tárgykód alapján készítette el a működőképes programot. .A változókat általában kötelezően deklarálni kellett. és rögzített paraméterezése (FORMÁLIS PARAMÉTERLISTA). . xor. a programozók így az újra felhasználható. . Ez a 13. .A típus ezen túl meghatározza az adott nevű változóval elvégezhető műveletek körét is (numerikus típusú változóval végezhető az osztás.. Ez jelentősen meggyorsította a fordítást egyéb hátrányok nélkül.A kifejezésekben szereplő adatok és változók típusait a fordítóprogram elemzi. Az eljárásoknak neve volt. hogy a megadott összes adatot átadjuk-e az eljárásnak (aktuális paraméterlista). Ez újabb fontos mérföldkő a fordítóprogram intelligenciájának fejlődésében. szorzás. kivonás. a szerkesztő program (linker).). Ugyanakkor a nyelvi korlátok gátolták a programozási stílus fejlődését. Az első nagyon fontos változás . . A másik fontos változás a VÁLTOZÓ fogalmának finomodása: A változónak van: . Ugyanakkor. Harmadik generációs programozási nyelvek: PROCEDURÁLIS NYELVEK Az assembly nyelv hiányosságainak kiküszöbölésére születtek a harmadik generációs nyelvek. hogy az eljárás meghívása során milyen adatokat.meghatározza a változó élettartamát és hatáskörét is. De az assembly nyelv ez irányú képességeinek hiánya ebben továbbra is komoly gátat jelentett. Az assembler a forráskód-modulokat egyenként fordította le egy-egy TÁRGYKÓD( object)-állományba.info .info) pott. Amennyiben a forráskódon nem történt módosítás. Az ELJÁRÁSORIENTÁLT (procedurális) nyelvek sok szempontból elvi. összeveti.TÍPUSA (mely meghatározza a memóriabeli helyigényét. Ezen túl a nyelv rögzítette az átadás módját is. egy másik..)). oldal a 242-ből www. Ennek során a programozó bejelentette a fordítóprogram számára érthető formában. és nem generálta újra a hozzá tartozó object kódot. összeadás. Ezzel elhárult az általános célú eljárások írásának legjelentősebb akadálya.A programban lehetetlenné vált a változó tárhelyének részleges kezelése (a változó értékét reprezentáló byte-ok csak egy részének kiolvasása. melyek változtak az utolsó fordítás óta. és egymás közötti megosztásra. hogy az adott azonosító (változónév) alatt mit ért (milyen típust). és ellenőrzi a kifejezés típushelyességét. hogy mely forráskód-fileokból tevődik össze a PROJECT. . amely miatt megérdemli a külön generációs sorszámot. és újabb project kezdése esetén eleve hozzácsatolták a project forráskódlistájához. Így csak azon forráskódok fordítása történt meg.azonnal és gyorsan átvették ezeket a szemléletbeli előírásokat.kuruc. Az ELJÁRÁS (és függvény) nyelvi elemmé vált.

úgy a magas szintű forráskódot az adott számítógépre írt fordítóprogrammal újra kell fordítani . akkor a változó automatikusan létrejön. felhasználható.a hardwarefüggetlenség.). A program egy adott pontján mindig egyértelműen megadható a változó hatáskörök figyelembevételével. struktúrák.a forráskód bármilyen változtatása nélkül. Ez a 14. A GLOBÁLIS VÁLTOZÓK minden esetben STATIKUSAK is. A változó hatásköre: Globális: a program szövegében több helyen (több eljárásban is) elérhető. Ezen típusok a meglévő típusok szűkítései (felsorolás típus..).kuruc. halmaz alapú ciklusok. és melyek nem. iteráció: adott programrész ismétlése (előírt lépésszámú ciklus. logikai feltételhez kötött ciklusok. Az ötödik fontos változás . A vezérlési szerkezetek e formája áttekinthető. könnyen olvasható kódot eredményez.info) A változó élettartama: Statikus: a változó a program indulásának pillanatától a futás végéig a változó folyamatosan létezik. A dinamikus változók létrehozását és megszüntetését a fordítóprogram által generált kód automatikusan végzi. Amint feleslegessé vált . így az ugró utasítások szükségtelenné váltak.. Dinamikus: a változó a program futása közben jön létre és szűnik meg (akár többször is). A dinamikus változó létrehozása és megszűnése eme lokális területhez kötődik . vektorok. különben . amíg fontos. kizárt a memória-átlapolás és nem keletkeznek fel nem használt memóriaterületek. hogy mely változók érhetők el.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. ... egyszerű. Mills bizonyította. amikor a fordítóprogram a gépi kódú változatot generálja. sokáig szükséges adatokat statikus változókban tároljuk. Amennyiben a programot más platformon is szeretnénk futtatni. A negyedik fontos változás .. akkor a változó automatikusan megszűnik. akkor a fenti szerkezeteket ugró utasítások formájában valósítja meg .és a procedurális nyelven megírt magas szintű kódot az adott gépi kódra fordítja. vagy összetett algebrai adatszerkezetek is lehetnek (pl. A procedurális nyelvek már nem processzorfüggőek. hogy minden algoritmus kódolható a fenti három vezérlési szerkezet használatával. A típusokhoz tartozó tárhely-igényt a fordítóprogram kezeli.. A DINAMIKUS változók a memóriaterület gazdaságos felhasználása szempontjából fontosak ...info . és rögzítették azokat: szekvencia: az utasításokat a forráskódban rögzített sorrendben kell végrehajtani..megszűnik. .. akkor . résztartomány-típus). Természetesen. A fordítóprogram ismeri az adott számítógép processzorának gépi kódját . A memóriaterület kiosztását a fordítóprogam végzi a változó-deklarációk alapján. A nyelvi alaptípusokból további (felhasználó által definiált) típusokat lehet készíteni. A fontos.a változó csak addig legyen a memóriában..hiszen a gépi kódban csak ezek szerepelnek.a típusrendszer bővíthetősége A magas szintű programozási nyelvek eleve adott típusokkal készültek. Amikor a program végrehajtása elhagyja ezt a területet.-szerkezetek). helye felszabadul a memóriában. és változatlan helyen lesz a memóriában.amikor a program végrehajtása eléri ezt a pontot. belép erre a területre.. a ha . Lokális: a program szövegében a változó felhasználása helyhez kötött.a vezérlési szerkezetek bevezetése Az assembly nyelv ugróutasításaiból megszervezhető vezérlési szerkezetek körét csökkentették. A STATIKUS változók fontosak az adatok megőrzése szempontjából.kuruc. oldal a 242-ből www. A harmadik fontos változás . és a helyére később más változó kerülhet. szelekció: feltételes elágazás (pl. csak egy meghatározott programrészben (körülhatárolt szegmensben) használható fel. A dinamikus változók pedig általában lokálisak. Emiatt nagyon sok lehetséges programozási hiba egyszerűen megszűnt létezni. listák.

és nagyon egyszerű. eleve létező elemi típus. A saját típusokhoz nem csak operátorokat rendelhet. mint kódolási technikákban.info) Fennmaradt azonban egy nagyon fontos probléma: a felhasználó által definiált típusokhoz nem lehet operátorokat definiálni. Ezen nyelvek jellemzője. emiatt kifejezésekben nem lehet az új típusokat felhasználni.kuruc. A vezérlési szerkezetek is a megszokott három formára épülnek (szekvencia. Három és fél generációs programozási nyelvek: OBJEKTUMORIENTÁLT NYELVEK Az objektumorientált programozási nyelvek (OOP nyelv) ezen a ponton jelentenek fejlődést. szinte mondatszerűen olvasható utasítások fogalmazhatók meg. amely elsősorban adatbáziskezelésre van felkészítve. Az értékadó utasítások során részeredményeket számolunk ki . Vagyis a felhasználói adattípus kevesebbet ér. Az értékadó utasítás bal oldalán egy VÁLTOZÓ áll. hogy az értékadó utasításokat TÖBBSZÖR is végrehajthassunk. hogy a program fejlesztése értékadó utasítások megfelelő sorrendben történő kiadására koncentrálódik. iteráció). Az egy típusba sorolt adattároló változók (mezők). a jobb oldalán pedig egy megfelelő típusú KIFEJEZÉS. a hozzájuk tartozó műveletek és operátorok csoportját (halmazát) OSZTÁLYnak nevezzük. hogy nagyon kevés nyelvi elemmel dolgoznak. gyakorlatilag e nyelvek kutatása. A szelekció (elágazás) csak azt a célt szolgálja. hanem megadhat függvényeket és eljárásokat is. Negyedik generációs programozási nyelvek: SPECIALIZÁLT NYELVEK A negyedik generációs nyelvek speciális feladatkörre készült nyelvek. hogy bizonyos értékadó utasításokat csak ADOTT ESETBEN kell végrehajtani. Meglévő típusok továbbfejlesztésével (öröklődés) kevés munkával készíthet új típusokat. Egy OOP nyelvben tehát szintén megtalálhatóak az eljárások és függvények. változók. A programozási nyelvek csoportosítása A programozási nyelveket más szempontból vizsgálva egy másik csoportosítás fedezhető fel: Imperatív (procedurális) nyelvek: Ezen nyelvek közös jellemzője. Ez a 15. Ezek után a saját típus szinte minden szempontból egyenrangúvá válik a nyelvi alaptípusokkal. oldal a 242-ből www. A felhasználó sokkal egyszerűbben és szabadabban készítheti el a saját típusait. a típus részeinek tekintendők. amelyek az adott típusú adatokkal végeznek valamilyen műveletet. illetve a paraméterek.kuruc. Ezért az OOP nyelveket nem tekintik külön generációnak. fejlesztése még folyamatban van. A saját típusaihoz (általában) készíthet operátorokat is (melyeknek jelentését természetesen le kell programozni). Mivel e függvények és operátorok az adott típushoz tartoznak.info . Ötödik generációs programozási nyelvek: MESTERSÉGES INTELLIGENCIA NYELVEK A mesterséges intelligencia programozási nyelvekkel elvileg az emberi gondolkodás leírása történne meg. Ezen a szinten a nyelv fejlődése nem haladhatja meg ezt a pontot. mint a ’gyári’. A CIKLUSOK pedig azért vannak. szelekció.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Erre jó példa az SQL nyelv.végül megkapjuk a keresett végeredményt. Ezért az OOP nyelvek inkább csak szemléletmódban mások (melyik eljárást és függvényt hova írjuk meg).

Logikai nyelvek: Az ilyen jellegű nyelveken tényeket fogalmazunk meg. melyeket interface-ek írnak le. A programozó munkája a kifejezés kiszámításának leírására szolgál. hogy az adott utasítás a program feladata szempontjából helyes-e. melyek egy művelet eredményeképpen kapott értéket egy olyan memóriaterületre írná be. hogy a mai programok elszeparált területeken tárolják a programkódot és az adatokat. vita nélkül engedelmeskedik és végrehajtja a soron következő utasítást. A funkcionális nyelvek tipikus felhasználási területének a természettudományos alkalmazások tekinthetőek. A futtatás háromféleképpen történhet: Direkt futtatás: a generált kód az adott mikroprocesszor gépi kódú utasításait tartalmazza. A hiba bekövetkezése ellen védelmet jelent. melynek értékét a programozási nyelv a beépített kiértékelő algoritmusa segítségével. hibás-e. A processzor e pillanattól kezdve önállóan végrehajtja a következő utasítást. Az objektumok egymás műveleteit aktiválják. és futtatja. hogy a gépi kód szintjén nincs típusfogalom.kuruc. és az adatokat gépi kódú utasításokként próbálja értelmezni. és áttér a hibakezelő állapotra. írja és olvassa a memória hivatkozott területeit anélkül. hiszen egy adatterület belsejébe irányul. A logikai nyelvek tipikus felhasználási területe a szakértői rendszerek létrehozásához kapcsolódik. Ekkor a processzor hibás működés állapotára tér át. ahol utasításkódok vannak. szükséges-e. vagy egy olyan kódot fog találni a processzor. oldal a 242-ből www. A mai processzorok már védekeznek ez ellen. Az elkészült futtatható programot ezen időpont után az operációs rendszer kezeli. Ennek megfelelően az utasítássorozatot az operációs rendszer egyszerűen átadja a mikroproceszszornak és megadja a program kezdőpontját. A hibás ugróutasítás emiatt felfedezhető. Értékadó utasítás sincs.info . csak adott függvény visszatérési értékének megadása létezik. Futtatórendszerek A fordítóprogramok által generált tárgykódokat a szerkesztőprogram önti végleges formába. általában nincs ciklus (helyette rekurzió van). Másik védelmi mechanizmus szerint a kód-terület nem írható. követi az ugrási pontokat. Mivel a memóriában (a nagy byte-halmazban) az adatok területén is byte-ok találhatók.info) Applikatív (funkcionális) nyelvek: A funkcionális nyelveken a kiszámolandó kifejezést adjuk meg. Ugyanakkor jegyezzük meg. Vagy valamely utasítás paraméterezése lesz értelmezhetetlen. ezért elvileg elképzelhető. hogy a program vezérlése egy hibás ugró utasításnak köszönhetően áttér egy ilyen területre. Így a processzor képes felfedezni a hibás értékadó utasításokat. a tények és szabályok figyelembevételével meghatároz. Ez meggátolja a programkód futás Ez a 16. megfelelő mennyiségű bemenő adattal. akkor az adott objektum a hívó félnek szabványos módon (kivételkezelés) jelzi a probléma pontos okát. és szinte lehetetlen eldönteni. amely nem értelmezhető utasításkódnak. hogy tudná. Egy funkcionális nyelvben nincs változó. A program ezen kívül egyetlen logikai kifejezést is tartalmaz. Ezen módszer ELŐNYE a MAXIMÁLIS VÉGREHAJTÁSI SEBESSÉG. és logikai állításokat írunk le. A processzor feltétlenül megbízik a programkódban.kuruc. valójában mit csinál a program az adott ponton. és ilyen esemény detektálásakor speciális hibakezelő rutinok futtatására térnek át. Ha egy művelet nem végrehajtható. A processzor már ekkor leállítja a program futását. amely a számítógép leállásához (lefagyás) is vezethet. csak olvasható. Ez persze valószínűleg nem fog menni.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Objektum-orientált nyelvek: Az OOP nyelveken a program működése EGYMÁSSAL KÖLCSÖNHATÁSBAN ÁLLÓ OBJEKTUMOK MŰKÖDÉSÉt jelenti. A program futása közben egyszerűen kiszámítja a szóban forgó kifejezést.

Az interpreteres rendszerekben a futtató rendszer a lefordított kódot még végrehajtás előtt elemzi. mint a gépi kódból). mint általában az interpreteres rendszerekben. Egy ilyen ’tárgykód’-ból az eredeti forráskód általában szinte veszteség nélkül helyreállítható.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. hogy milyen változókra van szüksége. Ilyen rendszerekben az is megoldható. Ezen ’gépi kód’ eltérhet a jelenlegi gépi kódtól. amennyiben az adott processzorra is létezik a futtató rendszer. A generált kód már nem feltétlenül hasonlít. másrészt a generált ’tárgykód’ az adott programozási nyelv szintaktikai lenyomatát hordozza. hogy amennyiben egy programozási nyelv fordítóprogramja képes e virtuális gépi kódú program generálására. még a változónevek és az eljárásnevek is visszaállíthatóak. nem feltétlenül hordozza az eredeti programozási nyelv szintaktikai lenyomatát. Ezt a ’tárgykódot’ egy futtatórendszer (az INTERPRETER) futás közben utasításonként elemzi. a paraméterei is már feldolgozott. és sokkal több típust ismer. Ma már e módszert inkább csak a vírusok és egyéb kártékony programok használják. úgy a futtatáshoz már felhasználható a kész futtatórendszer. A futtatórendszer ’kitalálja’ az adott programsorhoz érve.info) közbeni módosítását (önmódosító kód) amely egy időben igen elterjedt volt. Egy adott nyelv interpretere (pl. akár korrigálhatja is a feltételeket. oldal a 242-ből www. virtuális gép) sokkal egyszerűbb. Az interpreteres rendszerek sokkal rugalmasabbak. változóhivatkozások). a BASIC interpreter) nem képes futtatni más interpreteres nyelv fordítóprogramja által generált ’tárgykódot’.info . Ez a 17. hiszen a generált kód alacsonyabb szintű utasításokat tartalmaz. A legismertebb ilyen nyelv a JAVA.kuruc. és hajtja végre az előírt szabályok szerint. hogy a változókat nem kell deklarálni explicit módon a program szövegében. ahol az eredeti programozási nyelv utasításai vannak számkódokká átfordítva. A felügyelő interpreter időben leállíthatja a futó programot. A virtuális futtatás előnye. Interpreterrel való futtatás: a fordítóprogram EKKOR NEM GENERÁL KÖZVETLENÜL VÉGREHAJTHATÓ GÉPI KÓDÚ UTASÍTÁSOKAT. Egy adott utasítás végrehajtása előtt ellenőrizheti a szükséges feltételek teljesülését. Ha nem megfelelő. pontosítja azt (pl. A futtató rendszer az adott utasításhoz érve ellenőrzi hogy ott éppen milyen változók szükségesek. Valamint ezen a virtuális nyelven generált kód MÁS-MÁS PROCESSZORON IS FUTTATHATÓ lesz. nem univerzális. hogy a változó típusa futás közben derüljön csak ki. egyszerűsített formában kódoltak. sokkal magasabb szintű utasításokat tartalmaz. ellenőrzi hogy azok pillanatnyi típusa megfelelő-e. hanem egy KÖZTES KÓDOT. hogy megfeleljenek az utasításnak. akkor vagy leáll hibaüzenettel. amennyiben azt nem találja megfelelőnek. sőt. vagy törli a nem megfelelő típusú változót és létrehoz egy megfelelő típusút helyette. Virtuális futtatás: ez az interpreteres elv módosítását jelenti. A fordító nem direktben futtatható gépi kódú programot generál. szükség esetén az utolsó pillanatban korrigálja.kuruc. Ezen nyelv interpreteres futtató rendszere (processzor-szimulátor. Az interpreteres rendszerek vitathatatlan hátránya. és pontosan e pillanatban hozza csak létre. vagy akár menet közben többször meg is változzon. hanem egy nem létező (VIRTUÁLIS) processzor virtuális gépi kódjára generál programot. belőle az eredeti forráskód csak veszteségesen állítható helyre (bár sokkal kevesebb veszteség árán. ahol a futtató rendszert Java Virtual Machine-nak (JVM-nek) hívják. hogy egyrészt lassú a futtatás. Ezen rendszerek futtatása sokkal biztonságosabb. Ezen kívül az is megoldható.

a Microsoft®.kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc. oldal a 242-ből www. Fejezet Bevezetés .info .NET Hernyák Zoltán Ez a 18.info) Programozás tankönyv II.

info) A Microsoft. a Windows a rendszerkönyvtáraiban megtalálható DLL (Dynamic Link Library) file-okban tárolja. mik a paraméterei. alkönyvtárakat és file-okat kezel. sok más dolog mellett ismernie kell. A felhasználó számára az operációs rendszer az.kuruc. parancsokat lehet rajta keresztül kiadni akár karakteres felületen. Ez az új generációs technológia a Web szolgáltatásokon alapul .” (->http://www. Ez már nem csak a grafikus felület miatt tartalmazott több felhasználható szolgáltatást. hogy egy dotNet környezetben a programozónak semmilyen más API-t (elvileg) nem kell ismernie. A dotNet (elvileg) ma már több különböző operációs rendszeren is képes működni . amelyek képesek kapcsolatba lépni egymással csakúgy.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.asp) Másik lehetséges meghatározás szerint A DOTNET EGY PROGRAMFEJLESZTÉSI KÖRNYEZET. Minden DLL több függvényt és eljárást tartalmaz.de a programozónak ezt nem kell feltétlenül tudnia .com/net/basics/whatis.APPLICATION PROGRAMMING INTERFACE . általuk előállított operációs rendszer tartalmazta. A Microsoft honlapján például az alábbi meghatározás szerepel: „ez egy software technológiák halmaza.info . A dotNet egyféle szemszögből nézve az operációs rendszert helyettesíti. lévén. hogy az már grafikus operációs rendszerrel. amelyben az alkalmazása futni fog. E függvények és eljárások összességét nevezzük API-nak. eltakarván a tényleges operációs rendszert a fejlesztő elől. elrejtvén. embereket. DOS-API => Win16-API => Win32-API => DOTNET-API A Win16-API sokkal több szolgáltatást tartalmazott. mik a lehetséges visszatérési értékek. mint egy felhasználó.NET felépítését: Ez a 19. Ezzel szemben a programozó az operációs rendszert elsősorban az API szempontjából nézi: melyek azok a FUNKCIÓK. és figyelembe kell vennie azt a környezetet.teljesen új területeket is megcélzott. és bevezettek bizonyos jogosultsági módszerek kezelését is (és még számtalan mást is). rendszereket és eszközöket kapcsol össze. Az API . Amikor egy programozó egy alkalmazás fejlesztésébe kezd. amibe be kell jelentkezni. Az operációs rendszert egy programozó teljesen más szempontból nézi. hogy melyek azok a szolgáltatások.írja le egy adott operációs rendszer esetén. Egy operációs rendszer API-leírásában szerepelnek a következő információk: a függvény melyik DLL-ben van benne. AMELYEKET az operációs rendszer elvégez a program feladatai közül. a függvénynek mi a feladata (mit csinál).NET-et (továbbiakban dotNet) sokféleképpen lehet definiálni. E szolgáltatásokat pl.kis alkalmazásokon. melyekre hivatkozhatunk a programjainkban is. amelyeket az operációs rendszer eleve tartalmaz.lévén a DOS egy egyfelhasználós. A DOTNET ezen szempontból egy új API-nak tekinthető. és amelyeket a programozó a fejlesztői munka során felhasználhat. mely számtalan hasznos szolgáltatással segíti a programozók mindennapi munkáját. mi a függvény neve.hiszen ő már nem használja az adott operációs rendszer API-ját. A Win32-API a fejlettebb Windows operációs rendszerekben jelent meg. a Windows ’95. FELADATOK. mint pl. csak a dotNet-et által definiált függvényeket és eljárásokat. A környezet egyik legfontosabb jellemzője az operációs rendszer. hanem mivel ez egy többfeladatos operációs rendszer . akár egér segítségével. Ez olyannyira igaz. mint nagyobb méretű alkalmazásokkal az Internet-en keresztül. Ebben javítottak a többszálú programok kezelésén. amely információkat.microsoft. milyen módon jelzi a függvény a hibákat stb… A Microsoft-os világban az első ilyen API-t az első. és melyek azok. Ez volt a DOS. egyfeladatos operációs rendszer.kuruc. Ez nem tartalmazott túl sok elérhető szolgáltatást . oldal a 242-ből www. Tekintsük át a Microsoft. a Windows 3. amelyeket nem.1-gyel került be a köztudatba.

aszerint hogy az alkalmazás felhasználói felületét web-es. hogy egy JIT Compiler (JIT=Just In Time) gondoskodik arról. onnan induláskor azokat visszaolvasni. A következő réteg. A következő réteg kétfelé válik . mint a natív kódú programoké. az ADO.NET és XML a 21. ezért a programok CSAKIS az operációs rendszeren keresztül kommunikálhatnak egymással. Ez az egyik legérdekesebb réteg. Másrészt az utasítások végrehajtása előtt ellenőrizni lehet a jogosultságot is vagyis hogy az adott felhasználó és adott program esetén szabad-e végrehajtani az adott utasítást pl. Az első ilyen előny. . futási sebessége elhanyagolhatóan kisebb. vagy file-ba írni. oldal a 242-ből www. A futtatás maga interpreter módban történik. Lényeges különbség a megelőző API-kal szemben. Ez nem csak áttekinthetőbb. névterekbe és osztályokba szervezett a sok ezer hívható szolgáltatás. Mivel egy jól megírt. elérésére. használhatják fel az erőforrásokat (hálózat.info .vagyis az operációsrendszer-API-n keresztül. hogy a felügyelete alatt futó programok önállóan kezeljék a számítógép hardware-elemeit. vagy Ez a 20. mivel a mai alkalmazások egyre gyakrabban használják fel e professzionális és szabványos technikákat adatok tárolására. A BASE CLASS LIBRARY tartalmazza azokat a szolgáltatásokat.kuruc. ezért a programkód futtatása közben a memória-hozzáféréseket ellenőrizni lehet . Ezért egy dotNet-es program hatékonysága. file-rendszer. A rétegek segítségével a programok a háttértárolókon képesek adatokat tárolni. hogy a végrehajtás megfelelő hatékonysággal történjen. Ez a réteg egy jól megírt operációs rendszer esetén nem kerülhető meg.így meggátolható a helytelen. Ugyanakkor meg kell jegyezni.a KÖZÖS NYELVI FUTTATÓRENDSZER. A következő szinten van A COMMON LANGUAGE RUNTIME . A második réteg tartalmazza a dotNet API nagyobb részét. amelyeket egy dotNet-es programozó felhasználhat a fejlesztés közben. biztonságos operációs rendszer nem engedi meg. ugyanis a dotNet-es programok egy virtuális mikroprocesszor virtuális gépi kódú utasításkészletére vanak fordítva. hibás viselkedés. hogy a szóban forgó virtuális gépi kódú nyelv típusos. ugyanakkor a dotNet fejlett futtató rendszere a virtuális gépi kódú utasításokat futás közben az aktuális számítógép aktuális mikroproceszszorának utasításkészletére fordítja le. hogy ez már nem csak eljárások és függvények halmaza. de hatékonyabb felhasználhatóságot jelent egy. és hajtja végre.info) Legalsó szinten az OPERÁCIÓS RENDSZER található. Ezen technikák ma már egyre hangsúlyosabbak. századi ADATELÉRÉSI TECHNOLÓGIÁKat tartalmazza. hanem itt struktúrált.. hálózati kapcsolatot létesíteni. memória..kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.) . módosítására. A CLR lényegében egy processzoremulátor. az objektum orientált programozásban jártas programozó számára. Ennek futtatását végzi a CLR.

Ami nem ingyenes. A réteg nem kevés vita után elsimította eme különbségeket. nem kifejezetten interaktív program írása. Elvileg bármilyen programozási nyelven lehet dotNet-es programokat fejleszteni. míg más nyelvekben ez nem ennyire kötött. A másik lehetséges választás a WEB-es felületű. akik most ismerkednek a dotNet világával. melyek segítségével grafikus felületű ablakos. a másik felét pedig egy másikon.a COMMON LANGUAGE SPECIFICATION . Az IDE nem csak a forráskód gyors áttekintésében segít a színekkel történő kiemeléssel Ez a 21. Ennek megfelelően a dotNet programozási környezet ingyenesen hozzáférhető minden programozást tanulni vágyó számára.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. A memória felszabadításáról nem kell intézkednie.így a fordítás során az eredeti forráskód nyelvi különbségei eltűnnek. A dotNet nem épül egyetlen nyelvre sem rá. hogy egy nagyobb projekt esetén a projekt egyik felét egyik programozási nyelven írjuk meg. illetve a Basic nyelvekhez készítette el a dotNet-es fordítóprogramot. A keretrendszer részét képezi a BCL. Internet Explorer vagy Mozilla. az automatikusan bekövetkezik. Ha megpróbálnánk összegezni. nemrégiben csatlakozott nyelv a Delphi. Az új nyelv sok más nyelv jó tulajdonságait ötvözi.NET Framework) jelenleg ingyenesen letölthető a Microsoft honlapjáról. és a különböző nyelven megírt részek zökkenőmentesen tudnak egymással kommunikálni. ami radikálisan csökkenti a fejlesztési időt A dotNet keretrendszer (Microsoft. A fentieken túl van még egy olyan szolgáltatása a dotNet rendszernek. Tiszta szintaktikájával nagyon jól használható eszköz azok számára. amely ismeri a CLS követelményeit. és képes a CLR virtuális gépi kódjára fordítani a forráskódot. Ezek futtatásához szükséges valamilyen web szerver. A CLS réteg fölött helyezkednek el a különböző programozási nyelvek és a fordítóprogramjaik. Ezt egy Garbage Collector nevű programrész végzi. de már nem használt memória felszabadítását végzi.info) hagyományos interaktív grafikus felületen valósítjuk meg. Ugyanakkor nemcsak a Microsoft készít fordítóprogramokat erre a környezetre. melyeket a különböző programozási nyelvek a fejlődésük során történelmi okokból különböző módon értelmeztek. Egyik legismertebb. melyet C#-nak (ejtsd szí-sharp) nevezett el.NET-nek nevezik.kuruc. és nem hordozza magával a kompatibilitás megőrzésének terhét.NET-ben programozni) kihasználhatjuk az automatikus memória-menedzselés szolgáltatásait (Garbage Collector) felhasználhatjuk a programfejlesztéshez az eleve adott Base Class Library rendkívül széles szolgáltatás-rendszerét.a tömböket.Integrált Fejlesztői Környezet). hogy memóriát igényeljen. melynek jelentőségét nem lehet eléggé hangsúlyozni: AUTOMATIKUS SZEMÉTGYŰJTÉS. gondolván itt elsősorban a mikroprocesszorra nem kell új programozási nyelvet megtanulnunk.info . a kliens oldalon pedig valamilyen internetes tallózó program. az alábbi főbb szempontokat hozhatjuk fel: az alkalmazás operációs rendszertől független lesz független lesz az adott számítógép hardware-étől is. A dotNet-ben a Microsoft által fejlesztett ilyen környezetet Microsoft Visual Studio. Mivel mindkét nyelv fordítóprogramja a közös rendszerre fordítja le a saját forráskódját . A dotNet igazából nem kötött egyetlen programozási nyelvhez sem. A fenti két követelmény betartásának van egy nagyon érdekes következménye: elvileg lehetőség van arra. így NYELVFÜGGETLEN. Részét képezi egy 3 CD-t megtöltő súgó. ha arra szüksége van. valamint egy parancssori C# fordító. hogy a C alapú nyelvekben a vektorok indexelése mindig 0-val kezdődik. A következő réteg . pl. oldal a 242-ből www. mely tartalmazza a BCL leírását. A Windows Forms tartalmazza azon API készletet. ha már ismerünk valamilyen nyelvet (valószínűleg olyan nyelven is lehet . az a programozási felület (IDE = Integrated Development Environment . tárolási módját .beleértve a string-eket . A Microsoft a C++.kuruc. amelyekhez létezik olyan fordítóprogram.definiálja azokat a jellemzőket. valamint tervezett egy új nyelvet is. interaktív alkalmazásokat készíthetünk. Ez a réteg írja le az alaptípusok méretét. valamilyen browserban futó. amely folyamatosan felügyeli a futó programokat. Fontos eltérés például. Ez a szolgáltatás a memória-kezeléssel kapcsolatos. hogy miért jó dotNet-ben programozni. és a program által lefoglalt. Ennek tudatában a programozónak csak arra kell ügyelni. Ez nem csak egy színes szövegszerkesztő. példákkal illusztrálva. és a CLR réteg.

javítja az éppen begépelés alatt álló kulcsszót. oldal a 242-ből www.kuruc. Ezen túl a felületből kilépés nélkül lehet a forráskódot lefordítani. hanem a program írás közben már folyamatosan elemzi a forráskódot.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. és a generált programot elindítani. A Studio kényelmes módon kezeli a több file-ból álló programokat (PROJECT). illetve a több project-ből álló programokat is (SOLUTION). Környezetérzékeny módon reagál a billentyűk leütésére. és azonnal megjelöli a hibás sorokat benne.info . Ez a 22. ill. és kiegészíti.kuruc.info) (syntax highlight).

Fejezet „Helló Világ!” Hernyák Zoltán Ez a 23.info) Programozás tankönyv III.kuruc.info .C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc. oldal a 242-ből www.

1.parancssor)ból fordítsuk le a kis programunkat: csc HelloVilag. úgy vagy írjuk ki a teljes nevet. néha kissé misztikus világgal.4322). majd a File/New/Project menüpontot válasszuk ki: A felbukkanó párbeszédablak arra kíváncsi.info . ahol a <version> helyében a dotNET Framework verziószámát kell behelyettesíteni (például: v1. Első lépésként indítsuk el a MICROSOFT VISUAL STUDIO. hogy „helló világ” (angolul: Hello World). az kiírja a képernyőre a kívánt üdvözlő szöveget. Nézzük. milyen nyelven kívánunk programozni (ez C#). elkészül egy HelloVilag.exe . e módja a programkészítésnek nagyon ’kőkorszaki’. a C:\WINDOWS\Microsoft.cs parancs kiadása segítségével. Nos.ezzel kezdjük hát mi is ismerkedésünket ezzel a különös. A fenti parancs kiadása után ugyanazon alkönyvtárban. ahova a program szövegét is lementettük.. Amennyiben a számítógép nem ismeri fel a csc programnevet. században. A fenti példaprogramot készítsük el egy tetszőleges editor programmal (akár a jegyzettömb is megfelel) HelloVilag.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info) Majd minden programozó ezzel a kedves kis programmal kezdi a programozástanulást: írjunk olyan számítógépes programot. A csc.a C-SHARP COMPILER . Ez a 24. oldal a 242-ből www.. majd command prompt( .kuruc.CS néven.kuruc. amely kiírja a képernyőre. milyen típusú program írását kívánjuk elkezdeni: A fenti párbeszédablak minden pontja roppant fontos! Első lépésként a bal felső részen határozzuk meg. vagy vegyük fel a PATH-ba a fenti alkönyvtárat.exe futtatható program is. Elindítva e kis programot.NET fejlesztői környezetet.a merevlemezen a Windows rendszerkönyvtárában.NET\Framework\<version> alkönyvtárban található. milyen módon kell ezt csinálni a 21. Ezen program elhíresült példaprogram .

Mivel e program több forrásszövegből fog majd állni. és akit zavarnak a programban lévő felesleges programsorok..) gépeljük be.info . és a „Project will be created. Ez a 25.” részben ki is van írva.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info) Második lépésként adjuk meg. Mire figyeljünk? A programunk utasításokból áll.WriteLine("Hello Világ"). Negyedik lépésben válasszuk ki a készülő program nevét a Name részben.. Egyelőre jegyezzük meg a következő fontos szabályt: MINDEN PROGRAMUTASÍTÁST A MAIN FÜGGVÉNY BELSEJÉBE KELL ÍRNI! Sehova máshova! A Main függvény belsejét a Main utáni kezdő kapcsos zárójel és a záró kapcsos zárójel jelzi! Koncentráljunk most a valódi problémára: a programnak ki kell írnia a képernyőre a Helló Világ szöveget! Vigyük a kurzort a Main függvény belsejébe.Console. Harmadik lépésként a Location részben adjuk meg egy (már létező) alkönyvtár nevét. jelen példában ez a C:\Programjaim\HelloVilag alkönyvtár lesz! Az OK nyomógombra kattintva rövid időn belül nagyon sok minden történik a háttérben. oldal a 242-ből www.kuruc. De térjünk vissza a Studio-hoz! A generált program nagyon sok sorát kitörölhetnénk. ha megtekintjük a fenti alkönyvtár tartalmát. Itt a sok lehetőség közül egyelőre a Console Application-t.kuruc. Több file is generálódott ebben az alkönyvtárban. Ezen alkönyvtár neve a Location és a Name részből tevődik össze. azok tegyék is meg bátran (csak ne végezzenek félmunkát!). ezért a Studio külön alkönyvtárat fog neki készíteni. a legegyszerűbb működési rendszerű programtípust választjuk ki. milyen típusú programot akarunk fejleszteni ezen a nyelven. Ezt egy Windows Intéző indításával azonnal tapasztalhatjuk. és a hiányzó sort (System.

info . Az első: Debug/Start menüpont. mert az ablak azonnal be is csukódik! Miért? A válasz: a program egyetlen utasítást tartalmaz: a szöveg kiírását. hogy jegyezzük meg az F5-ös billentyűt! Máris van egy problémánk: a program elindul. e közben nem történik semmi (még csak nem is álmodik). Az utasítás végét pontosvesszővel kell lezárni (mint a ’pont’ a mondat végén). Második: üssük le az F5 billentyűt. A megadott érték (1000) éppen 1 másodpercnyi várakozást jelent. ezért a parancs teljes neve System. hogy hova írjuk ezt a sort! A szabály értelmében a Main függvény belsejébe kell írni.Console. Az elkészült programot a File/Save All menüponttal mentsük le. de csak ha elég gyorsak vagyunk. Ennek több módja is van. és gondolkozzunk el a látottakon: a kis ablak előbukkan. És ha a program már nem fut. A szóban forgó utasítás: Ezen utasításnak zárójelben (paraméterként) ezredmásodpercben kell megadni a várakozás idejét. De milyen sorrendben? A programozás tanulás legjobb módszere a próbálkozás! Próbáljuk meg a kiírás elé beírni! Indítsuk el a programot. oldal a 242-ből www. és sűrűn használt funkció.kuruc. ezért javasoljuk. a rendszer (angol: System=rendszer) által eleve tartalmazott utasítás. hogy várjon valamennyi idő elteltére. ezért így a futása be is fejeződik. más dolga nincsen. Mivel a program ezt már megtette.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. esetleg elolvashatjuk a kiírást. hogy ne fejeződjön be azonnal! Első módszer: utasítsuk arra. A Sleep=aludni jelentése konkrétan annyi.info) A kiíró utasítás neve WriteLine. de a következő utasítást majd csak egy másodperc letelte után fogja végrehajtani a számítógép! Lényeges. Ez egy. rövid időre felvillan egy fekete színű kis ablak. majd indítsuk el. A harmadik: kattintsunk az indítás gombra. A szöveget a konzolra kell írni (Console=karakteres képernyő). hogy a program jelen esetben 1 másodpercre ’elalszik’. amelyet egy kis háromszög szimbolizál: Mivel a programindítás igen fontos. Line=sor szavakból tevődik össze. és dupla idézőjelek közé kell tenni.kuruc. mely az angol Write=írni. kis ideig nem törEz a 26. A kiírandó szöveget a parancs után gömbölyű zárójelbe kell írni. akkor bezáródik az ablak! A megoldás is erre fog épülni: adjunk még dolgot a programnak.WriteLine.

elég-e? Növelhetjük az időt. hogy 1 mp. De egyelőre ez a módszer lesz az. Próbáljuk elindítani a programot. mert bár a ReadLine ellátja a feladatát. amíg le nem ütjük az Enter-t.kuruc. Ezt az elvet később pontosítjuk. és azonnal bezáródik az ablak. de sajnos az Enter leütése előtt lehetőségünk van bármilyen szöveget begépelni. Próbáljuk meg fordított sorrendben: A kiírt szöveg megjelenik. s ez elrontja a dolog szépségét.és ekkor az ablak bezáródik. De mennyire? Ez a megoldás nem elég rugalmas. néha kevesebbet. Közben láthatjuk. persze az érték átállításával.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Nos. mert a szöveg már kiíródott a képernyőre. Van egy nagyon fontos szabály: az UTASÍTÁSOKAT UGYANABBAN A SORRENDBEN KELL VÉGREHAJTANI. majd bezáródik az ablak. Néha több időt kellene várni. és a programozással! Figyeljük meg lépésről lépésre a működést! Ehhez ne az F5 billentyűvel indítsuk el a programot. melyik utasítás miatt nem fejeződött be a program? Az nem lehet a WriteLine. hanem az F11 billentyűvel (vagy a Debug/Step into menüponttal): A sárga (szürke) kiemelés a következő végrehajtandó utasítást jelöli. ez az utasítás végrehajtása tehát már befejeződött! Ekkor csak a ReadLine utasítás maradt. Miért? A számítógép a program sorait nem akármilyen sorrendben hajtja végre. hogy a progEz a 27. Mit tapasztalunk? Hogy az ablak nem akar bezáródni! Üssük le az Enter billentyűt . amikor a program futása befejeződik. majd felvillan a kiírás. AMILYEN SORRENDBEN A PROGRAMOZÓ LEÍRTA AZOKAT. azért nem záródott be! Mivel most összesen két utasításunk van (a WriteLine. és a ReadLine).kuruc. Kerüljünk közelebbi kapcsolatba a programmal.info . Keressünk más megoldást: A Sleep-es sort cseréljük le a fenti sorra. amit használni fogunk. Persze felmerül a kérdés. Ezek szerint a program még futott. Megjegyzés: a megoldás azért nem tökéletes. oldal a 242-ből www. eltelik egy kis idő (1 másodperc). Mi történt? Az ablak akkor záródik be. ha adatot kérünk be a billentyűzetről.info) ténik semmi. a ReadLine utasítást alapvetően akkor használjuk majd. ezért a ReadLine mindaddig nem fejeződik be. Az adatbevitelt az Enter leütésével jelezzük. és elnevezzük SZEKVENCIA-ELVnek.

az alábbi . amikor még ellenőrizhetjük a program kiírásait a fekete hátterű ablakban. az ablak bezáródik. vagy csak nem értjük annak működését teljes mértékben. akkor ne módosítsuk a program szövegét (ez főként akkor fordul elő. Ha ez mégis előfordulna. a Studio nem fogja tudni. Üssük le újra az F11 billentyűt! A sárga kiemelő csík átlépett a Sleep sorára. mert mi a forráskódban a már megváltozott szöveget látjuk. majd újra felbukkan a sárga kiemelés a Main függvény blokkjának záró kapcsos zárójelén.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. akkor is még az eredeti „Helló Világ” fog kiíródni. hogy ha pl. hogy a változás ellenére folytatjuk az eredeti program futtatását. Egy másodpercig nem történik semmi (a program ’elalszik’). és rövid leírásukat. hogy ha már elkezdtük a programot futtatni lépésenként. ha véletlenül leütünk valamilyen billentyűt). Ezt azt jelenti. pl.kuruc. és a közben bekövetkezett változásokat nem fogja figyelembe venni. és esetleg nem értjük. Ez azért nagy gond. a forráskód és a futó program nem fog megegyezni. Ez az utolsó pillanat. Ennek oka az. E módszert nyomkövetésnek hívjuk (angolul debugging). A fenti módszert főként akkor használjuk. Feladatok: 1) formában: Kis Pál (felesége: Nagy Borbála) Kis József Kis Aladár (felesége: Piros Éva) Kis István Kis Pál 2) Programozási feladat: Írassuk ki a képernyőre az eddig megismert C# parancsokat. a Studio rögzítette az állapotot (a forráskód akkori tartalmát).info) ram ablaka létrejött. Újabb F11 leütésére a program végképp befejeződik. átírjuk a szöveget „Helló Világ!”-ról „Helló Mindenki”-re. amit látunk.” Ez azt jelenti. pl. Üssük le újra az F11 billentyűt. hogy kiíródott a szöveg a képernyőre. vagy a Continue lenyomásával dönthetünk úgy is. ha a program nem úgy működik.info Programozási feladat: Írassuk ki a képernyőre a családfánk egy részét. hogy amikor elkezdtük a programot futtatni (az első F11 leütésével). oldal a 242-ből www. *** ReadLine *** Ez a 28. A program futtatását egyébként bármikor megszakíthatjuk a Debug/Stop debugging menüponttal. Nagyon ügyeljünk. és folytatjuk a program futtatását. ha végrehajtjuk a következő lépést! A Restart lenyomásával leállíthatjuk a program futtatását. amíg azt újra nem indítja. ahogyan azt szeretnénk.kuruc. de még egyelőre üres. Később újabb módszerekkel és technikákkal bővíthetjük ez irányú tudásunkat. jelen esetben lépésenkénti programvégrehajtást végzünk. Ha folytatja a futtatást. hogy miért nem az történik. mit is akarunk tőle: A szöveg fordítása: „A forráskód megváltozása nem fog jelentkezni a program futásában. az alábbi formában: *** WriteLine *** Kiír egy szöveget a képernyőre. hogy a WriteLine végrehajtásra került? Ellenőrizzük! A programablakra kattintva láthatjuk. vagy a Shift-F5 leütésével.

kuruc.kuruc. oldal a 242-ből www.info .info) Vár egy ENTER leütésére.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Ez a 29. *** Sleep *** Várakozik a megadott időig.

kuruc. oldal a 242-ből www.info .C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info) Programozás tankönyv IV. Fejezet „Alap I/O” Király Roland Ez a 30.kuruc.

Az ÉLETTARTAM azt jelenti. Ezt a folyamatot DEKLARÁCIÓNAK nevezzük. hogy az adott változó a program futása során mikor és meddig. Az alábbiakban megvizsgálunk néhány példát a helyes és helytelen névadásokra: Valtozo valtozo Valtozónév szemely_2_neve int alma#fa 10szemely Az első négy névadás helyes. mivel az int foglalt kulcsszó. értéktartományait. mivel A PROGRAMBAN HASZNÁLT ADATOKAT VÁLTOZÓKBAN ÉS KONSTANSOKBAN TUDJUK TÁROLNI. hogy a program mely részeiben használható. ami nem használható. Vegyük észre. Az utolsó elnevezés számmal kezdődik. Inkompatibilitás esetén a . mint a pointerek.NET rendszerben nem kell törődnünk a memória kezelésével. mikor az egyik változót értékül akarjuk adni egy másiknak. Az hatodik névben a # karakter szerepel. vagyis AKTUÁLIS ÉRTÉKE. lefoglalja és felszabadítja a memóriát. illetve azt. A változókat a programban BEVEZETJÜK. vagyis minden azonosítóhoz hozzárendeljük a memória egy szeletét. hogy a valtozo és a Valtozo azonosítók két külön változót jelölnek. Az ötödik elnevezés helytelen. de a .kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. vagyis közöljük a fordítórendszerrel. bármely programozási nyelvet szeretnénk elsajátítani.NET-fordító hibát jelez. hogy adatokat olvasunk be a billentyűzetről.és bemenetének tárgyalásához elsőként meg kell ismernünk néhány C#-ban használatos változótípust.) Vizsgáljunk meg néhány. mivel a C# nyelv ÉRZÉKENY a kis-nagybetűk különbségére. Az angol terminológia ezt CASE-SENSITIVE NYELVnek nevezi.info) Az alapvető Input/Output Az alapvető input-output. valamivel bonyolultabb a helyzet. Minden változónak van neve. A változók a memóriában tárolódnak. mely szintén hibás. hogy milyen műveleteket lehet értelmezni rajta. A program ezekkel számol. (Néhány változó típus esetén. egyszerü típust! Ez a 31.NET felügyeli. A kompatibilitás akkor fontos. melyet a rendszer lefoglalva tart a változó teljes életciklusa alatt. s a munka végeztével a kapott eredményt kiírjuk a képernyőre. a változótípusok ismerete nagyon fontos. a C# nyelvben használatos. és segítségükkel kommunikál a felhasználóval. vagy más néven AZONOSÍTÓJA. mivel a . A TÍPUS határozza meg a VÁLTOZÓ lehetséges értékeit.kuruc. oldal a 242-ből www. A kommunikáció a programozási nyelvek esetében körülbelül azt jelenti. A VÁLTOZÓK.info . A változók névének kiválasztása során ügyelnünk kell a nyelv szintaktikai szabályainak betartására. a HATÓKÖR azt adja. TÍPUSA és tartalma. hogy milyen névvel milyen típusú változót kívánunk használni a programban. Ezeken kívül rendelkezik élettartammal és hatáskörrel. a névvel pedig a változóra hivatkozhatunk. Más nyelvektől eltérően a C#-BAN AZ ÉKEZETES BETŰKET is használhatjuk névadásra. vagyis a KONZOLALKALMAZÁSOK ki. és milyen más típusokkal kompatibilis.

A képernyőn nem jelenik meg semmi. A következő program bemutatja. mivel kiíró és beolvasó utasításokat nem használunk.kuruc. Az alábbi példa bemutatja a deklaráció pontos szintaktikáját. és kezdőértékkel ellátni. Ezeket a fejezet későbbi részeiben tárgyaljuk. hogyan lehet a változókat deklarálni.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. A kezdőérték adása azért is fontos. Ez a 32. mert az érték nélkül használt változók kifejezésekben való szerepeltetése esetén a fordító hibát jelez.info) A táblázatban felsorolt típusokkal deklarálhatunk változókat. A változóinkat kezdőértékkel is elláthatjuk. oldal a 242-ből www.kuruc.info .

hogy a programozás során ne kövessünk el hasonló hibákat. ha egy változót deklarálunk. vagy egyáltalán nem deklaráljuk. Ebben az esetben a következő hibaüzenetek jelenhetnek meg a képernyőn: Cannot implicitly convert type 'string' to 'int' Cannot implicitly convert type 'int' to 'string' Azonos változónevek esetén is hibaüzenetet kapunk. esetleg lefoglalt kulcsszót akarunk alkalmazni a névadásnál. oldal a 242-ből www. Előfordul. de a programban próbálunk hivatkozni rá. A következő példában láthatunk néhány rossz deklarációt.kuruc. Ekkor a . de nem használunk fel. Gyakori hiba az is. hogy az osztály.NET fordító a futtatáskor hibát jelez.kuruc. de hatékonyságát csökkenti. a fordító olyan hibát talál a programunkban. hogy a deklaráció során nem adunk nevet vagy típust a változónak.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Bizonyos esetekben.info .) Ez a 33. Ilyen hiba lehet. (. hogy nem megfelelő típusú kezdőértékkel látjuk el a változókat. amikor nem Error.info) Gyakran előforduló hiba. hanem Warning típusú hibaüzenetet kapunk. vagyis a class neve megegyezik valamely változó nevével. amitől az még működőképes.

Ez egy ún.: A literálok alapértelmezés szerint int típusúak. d. Az értékadó utasítás bal oldalán a változó AZONOSÍTÓJA áll.0 típuskényszerítéssel nem okozunk hibát. és double.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. a jobb oldalon pedig az ÉRTÉK. A példában az y változónak egy valós típust adunk értékül. t. Ahhoz. Amennyiben ezt tesszük.kuruc. nekünk kell a megfelelő utasításokat beépíteni a forráskódba. ügyelnünk kell a programkód helyességére. Amennyiben float Ez a 34. c. ha valósak. vagy a változóra vonatkozó következő értékadásig meg is tartanak. A felhasználó még mindig nem láthatja őket. A változók egy érdekes típusa a literál.info . melyet a program futása alatt.: explicit konverzió.info) A fenti változók (a. értékkel rendelkeznek. hogy lehetővé tegyük a program használójának a változók értékének manipulálását. és az értéküket nem tudja módosítani. f) a programunk futása közben használhatóak. az értékadások után tartalommal. b. melynek az aktuális értékét a változóban tárolni szeretnénk. Akkor használjuk. oldal a 242-ből www. vagy kifejezés. pl.kuruc. mikor a programban egy konkrét értéket szeretnénk szerepeltetni. középen EGYENLŐSÉGJEL. de ebben az esetben az (int)3. ha egészek. Az értékadásnak jól meghatározott szintaktikája van.

Console. hogy az adatokat. vagy meg tudjuk jeleníteni a képernyőn. Amennyiben a Read() beolvasó utasítást használjuk.: System.).kuruc. ha megnézzük a két metódus prototípusát. Threadpool.Write() és a Console. Ez nem csak a System -re. A programjainknak fontos része a felhasználóval való kommunikáció. QueueUserWorkltem().C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Ez kiderül.NET rendszerben igénybe vehetjük a C# alapvető I/O szolgáltatásait.Read() és a Console. melyekre később bővebben kitérünk. A következő program bemutatja a beolvasás és a kiírás mechanizmusát. Pl.. Mikor eltekintünk a névtérimportálástól. Más nyelvektől eltérően. Adat beolvasásakor természetesen nem csak erre a két típusra van szükségünk. illetve ulong esetén az ul karakterpárt stb. a . Ez a minősítő előtag (pl. Thread. minősített. ezért az input adatokat konvertálnunk kell a megfelelő konverziós eljárásokkal.: standard input stream-ről várunk adatokat. az érték után kell írni az „f” karaktert. s nem lehet felüldefiniálni őket. A konstansok a program futása alatt megőrzik értéküket. vagyis a változók tartalmát be tudjuk olvasni. így a program bármely részéből meghívhatjuk az adott függvényt.ReadLine() a beolvasásra használható. hanem valamennyi névtérre igaz. vagy eljárást.. illetve értékadó utasítással megváltoztatni értéküket. míg a Console. a System névtérben található Console osztály ide tartozó metódusait (függvények és eljárások). hogy az ún. hogy használni tudjuk a Consol metódusait. long típus esetén az l. amelyeket a fordító nem biztos. A C# programokban állandókat. Ez a 35. Erre szükség is lehet.WriteLine() a kiírásra. oldal a 242-ből www. mi volt a program futásának eredménye. a ReadLine() viszont string. A beolvasás azt jelenti. ami a függvény névtérben elfoglalt helyével kezdődik. hogy megtalál a hivatkozás nélkül. a using bejegyzés után felvesszük a következő módon: Ezt a műveletet NÉVTÉRIMPORTÁLÁSNAK nevezzük. a ReadLine() metódus esetében viszont stringet. meg kell vizsgálnunk néhány példát. A Console. hogy a Read() int típusú. és a könyv későbbi fejezeteiben bővebben olvashatunk a témáról. mivel a System névtér is több fájlból (DLL) ál. később még visszatérünk rá) Ahhoz. vagy más néven KONSTANSOKAT is definiálhatunk. Jól látszik.info) típust szeretnénk készíteni. int típusú adatot kapunk. vagy q NEVÉRŐL beszélünk. amennyiben azt a program elején. vagy közölnünk kell. A System hivatkozás elhagyható a metódusok hívásakor. akkor az adott metódus teljes.kuruc.info .: System. Adatokat kell kérni tőle. (a többszálú programok készítésénél van jelentősége. itt a konstansnak is van típusa. Ahhoz.

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc. utasítást.. hogy a formátum string megfelelő pontjaira behelyettesítsük a paraméterlistában felsorolt változók értékeit: a {0} jelenti a nulladik. A helyes hivatkozás tehát: Ezek a bejegyzések nem hagyhatóak el. Amennyiben a {} zárójelek között olyan értéket adunk meg.Console.WriteLine(”{{0}} = {0}”. {1}. A metódusban ún. vagyis a sorban az első változó helyét. pontosabban a képernyőn megjelenő Consol alkalmazás ablakába. b=. de ilyenek nem léteznek. mely a nulladik helyen áll. mivel csak így tudjuk a változók tartalmát a képernyőre írni. mivel az egyetlen változó a kiíró utasításban az i.info .kuruc. nem megfelelő. {0} karaktereket hogyan írjuk a képernyőre. mivel a formátum definiálja.WriteLine() metódussal a standard output-ra. vagyis a számunkra megfelelő alakban tudjuk megjeleníteni.info) A System. A kedves olvasó kipróbálhatja a Console. a változók helyét a kiírt szövegben. A példában az első és a harmadik változóra hivatkoztunk (sorrendben a második és a negyedik).a). A formátum string tartalmaz konstans részeket (a=. a+b=) ami változatlan formában kerül a képernyőre. A {0}. mely nem létező változóra hivatkozik.WriteLine(”{} {0} = {0}”.WriteLine() paraméter listájában a változók fel vannak cserélve. oldal a 242-ből www.. és így tovább.a). a program leáll. {2} bejegyzéseket arra használjuk. (Érdekes kérdés lehet. }. a {1} a második változó helyét. formátum string-et. hogy a példaprogramban a második Console. hogy a változók értékeit formázottan. vagy más néven MASZKOT alkalmaztunk. A Console.) A formátum maszkjába a következő vezérlő karaktereket helyezhetjük el: Ez a 36. hogy a {. A sorrendjük sem mindegy. a kiírási sorrend mégis megfelelő. Vegyük észre. vagyis a képernyőre tudunk írni.

hogy a változók milyen módon kaphatnak értéket! Ez a 37. hanem szám típusú. Így a felhasználó nem lát szinte semmit az egészből. miután a program lefutott. A példaprogramban a Convert. Az ilyen jellegű hibákra megoldás lehet a kivételek kezelése. de nem ad lehetőséget felhasználónak a változók értékének a megváltoztatására.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. vagyis a billentyűzetről.ReadLine() utasítást arra használjuk. A program végén a Console. A felhasználói input kezelésére lehetőséget biztosítanak a Console. Nézzünk meg a példát a beolvasásra és a konverzióra! Ebben az alkalmazásban a változók a felhasználói inputról nyernek értéket. Ha a beolvasás során az input stream -ről hibás adatot kapunk.info) Vegyük észre.ReadLine() metódusok. Ez fontos a Consol alkalmazások esetén. Ahhoz. hogy a programunk megjeleníti a tárolt értékeket. hogy a Consol ablak ne tűnjön el a képernyőről. A fentiek ismeretében vegyük sorra. oldal a 242-ből www. vagyis a billentyűzetről bevitt adatokat. hogyan kezelhetjük le a felhasználótól érkező inputot.kuruc. hogy tovább tudjunk lépni. és a kimeneti képernyőt is bezárják.kuruc. majd leállnak. el kell sajátítanunk.és a Console. így a beolvasott adatok változtatásával minden lefutásnál más-más eredményt kapunk. mely nem konvertálható. mivel ezek nem esemény vezérelt működésűek. Mindkettő esetében adatokat olvashatunk be a standard inputról. A programok elindulnak. s azok összegét is. melyről a későbbi fejezetekben szót ejtünk majd.Toint32() metódust használjuk az input 32-bites int típussá konvertálására. vagy logikai értékeket is beolvashatunk a felhasználótól. s ha megtámogatjuk a két metódust a Convert osztály konverziós függvényeivel. nemcsak int és string típusú adatokat. a programunk leáll.info .Read() . végrehajtják a programozó által definiált utasításokat.

és jól bemutatja a billentyűzetről nyert adatok egész számmá konvertálását.kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. hogy melyik a nagyobb. ha nem kezdünk velük semmit? A következő program két változó értékéről eldönti. majd az eredményt kiírjuk a képernyőre. Nézzük meg a forráskódot! Ez a 38. hogy melyik változó értéke a nagyobb. A Convert osztály TOINT32() metódusával alakítjuk a beolvasott. A beolvasást követően megvizsgáljuk. hogy a számok egyenlők-e. megnézzük. Ez a program viszonylag egyszerű.info) A változókba beolvasott értékeket fel is tudjuk használni. ha ez a feltétel nem teljesül. itt még String típusként szereplő számot.info . és legtöbbször ez is a célunk. majd azt konvertáljuk egész számmá (int).kuruc. A b változóval ugyanígy járunk el. s adjuk értékül az a változónak. oldal a 242-ből www. Miért is olvasnánk be értékeket.

hogy egy változóba beolvassuk az adott kör sugarát. A műveleteket csoportosíthatjuk a következő módon: Értékadás: a = 2. Mindenképpen jobb. ha kerek mondatokat használunk. vagy r 2 *Π. mind a programok világában. Az elnevezések arra utalnak. Az elsőben már egész jól megtanultuk a társas érintkezés formáit.kuruc. A program használhatóságát növeli. összehasonlítások: a = = b. így foglalva mondatba a program futásának eredményét. A programhoz szükséges ismeretek: a kör kerülete: 2r*Π. ha összefüggő szöveg formájában beszélgetünk. és azt. Használjuk inkább a C# math osztályban definiált PI konstanst! Ekkor a program a következő módon írható le: A feladat az. A következő táblázat bemutatja a rövidítések használatát. Mi harminc? Mi mennyi? Az ilyen és hasonló párbeszédek érthetetlenné teszik a kommunikációt mind a valós életben.kuruc. Ez gyakori megoldás a felhasználóval történő kommunikáció megvalósítására. bináris és ternáris műveletek. A kifejezések kiszámítását elvégezhetjük a kiíró utasításban is. majd a képernyőre írjuk a körhöz Ez a 39. és a területe: r*r*Π.info . hogy a kiírt string konstanst KONKATENÁLJUK (SZÖVEGEKET ÖSSZEVONJUK) a változók értékével. mely a felhasználótól bekéri egy tetszőleges kör sugarát. hogy elegendő tudással rendelkezünk a Consol I/O parancsairól és a műveletek használatáról. csak a megfelelő formátum string-et kell elkészítenünk.info) Az alkalmazás kimenetére kerek mondat formájában írjuk ki az eredményt úgy. hogy 3. hogy a műveletben hány operandus szerepel. Az aritmetikai értékadásokat rövid formában is írhatjuk. feltételes műveletek. vagyis felhasználóbarát programokat készíthetünk. Most. tartozó kerületet és a területet. Biztosan sokan emlékeznek a következő párbeszédre: Mennyi? Harminc. A műveleti jelek alapján három kategóriát hozhatunk létre. készítsünk programot. majd kiszámítja annak kerületét és területét. oldal a 242-ből www. hogy a rövidített formulák mivel egyenértékűek.14. de ebben az esetben nem lenne elég pontos a számításunk eredménye. matematikai műveletek: z = a + b. A hétköznapi kommunikáció során is jobb. Unáris. hogy jobban megértsenek minket.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Honnan vegyük a pí-t? Írhatnánk egyszerűen azt. tanuljuk meg a másodikban is! A kiíratás és beolvasás mellett a műveletvégzés is fontos része a programoknak. és a pí értékét behelyettesítenünk a képletekbe. a < c.

és a CONVERT osztályról. viszont az értéktartomány megváltozik. de sajnos az élet nem ilyen egyszerű. Az átváltáskor.info . Logikai true értéket kapunk eredményül. ha az adott számjegy nagyobb. a kör sugarát. de ez a fenti kiíró utasításban nem követhető nyomon.kuruc.info) Vizsgáljuk meg.kuruc.WriteLine()-metódusban kiszámoljuk a megadott kifejezés alapján a kör kerületét és területét. A ToByte() metódus byte típust ad vissza. mivel a kiírt érték byte típusban is 1. A ToChar() metódus a karakter ASCII kódjával tér vissza. Az eredmény kiíródik a képernyőre. Nullánál false visszatérési értéket kapnánk. hogyan működik a program! Az r változóban tároljuk a billentyűzetről beolvasott értéket. mivel a kilences számrendszertől fölfelé történő konvertáláskor a 9-nél nagyobb számok esetén az ABC nagy betűit használjuk.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Ez a metódus jól használható a számrendszerek közti átváltások programozására. s a program az enter leütése után befejezi futását. mint 9. oldal a 242-ből www. A fejezetben már szóltunk a típusok konverziójáról. átalakíthatjuk a következő módon: Ez a 40. Nagyobb szám konvertálása hibához vezet. Egy bájtnál nagyobb érték nem fér el a byte típusban. Az egész típusú számokkal már jól boldogulunk. de a teljesség kedvéért vegyük sorra a fontosabb metódusait! Az alábbi felsorolás tartalmazza azokat a konvertáló metódusokat. melyeket az alapvető I/O alkalmazása során használni fogunk: ToBoolean() ToByte() ToChar() ToString() ToInt32() ToDateTime() A ToBoolean() metódus logikai értékkel tér vissza. majd a Console. A legtöbb alkalmazásban szükség van a típusok közti konverzióra.

A kódrészletben az int típusú változóba a billentyűzetről olvasunk be értéket. de a programjaink megírásához a felsoroltak elegendőek. (Amennyiben a többire is kíváncsiak vagyunk. így a beolvasott érték egész típusú számként (int) kerül a memóriába.ReadLine() metódust ’’paraméterként” átadjuk a Convert. ami alapértelmezésként 0:00:00.ToInt32() függvénynek. A kódot ezután karakterré konvertáltuk. A ToInt32() metódust már használtuk az előző programokban. nincs szükség konverzióra. hogy az megegyezzen a megfelelő tizenhatos számrendszerbeli számjegy ASCII kódjával. ahol a felhasználótól a születési dátumát. Ez a 41. vagy éppen az aktuális dátumot szeretnénk megkérdezni. Eredménye az 1. vagy adatbázisban tárolni. Látható.Parse(Console.info) A példában a számjegy ASCII kódját toltuk el annyival. Amennyiben a ToChar() bemenő paramétere a 11+55 lenne. oldal a 242-ből www.23 szám string-ként. mivel string típust készítettünk belőle.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. akkor használnunk kell a ToDateTime() függvényt. Konvertálás után 1. hogy az eredmény megjelenjen a képernyőn. hogy ToDateTime() paraméterében megadott string-ben az aktuális időt is fel tudjuk venni a következő módon: Ennek a kódrészletnek az eredményeként a dátum mellett az idő is kiíródik a képernyőre. használjuk a .ReadLine()). Ebből következik. de alkalmas string-ekhez való hozzáfűzésre. vagy típus konverzió esetén is használhatjuk. forma használata. de álljon itt is egy példa a használatára.kuruc.23-al nem végezhetünk aritmetikai műveletet. A felsorolás végére hagytuk a ToDateTime() metódust.kuruc. A Console.NET dinamikus HELP rendszerét!) A példákban a konvertálást a kiíró utasítással kombináltuk. de ha dátum típusként tárolt adattal szeretnénk összehasonlítani azt. A következő programrészlet a fent említett eljárás használatával a 10 szám helyett egy a betűt ír a képernyőre. Előfordulnak programok. a b betű jelene meg a képernyőn. A két megoldás azonos eredményt szolgáltat. Természetesen a C# -ban sokkal több konverziós metódus létezik. hogy a dátum mellett az aktuális idő is megjelenik. Másik lehetőség a konverzióra az i=Int32. A ToString() string-et konvertál a bemenő paraméterből.info . de a metódusokat változók értékének a beállításakor. mivel a dátum típussal még nem foglalkoztunk. Amennyiben ki akarjuk íratni a képernyőre amit beolvastunk.

Programozási feladatok Írjon programot. majd kiírja a két szám számtani közepét! Ez a 42. A megfelelően átgondolt. A standard Input/Output kezelésének alapjait elsajátítottuk. A szelekció. hogy az ne egy kör. A tervek leírása sok esetben már a program vázlatát adja. ha az (a+b>c) és (a+c>b) és (b+c>a) feltétel teljesül.) Írjon programot.) Olvasson be a billentyűzetről egy számot és mondjuk meg. mivel az int típust olvas be.) A tervezés. mely megkérdezi a felhasználó nevét. területét is ki tudja számítani! (Szükség lesz újabb változó bevezetésére. (Egyszerűbb programok esetén elég. előkészítés lépésekeit soha nem szabad kihagyni. különbségét. értékadástól. vagyis a feltételes elágazások témakörét ez a fejezet is érintette. de nem merítette ki. A következő fejezetben a szelekcióval ismerkedünk meg. hogy téglalapok kerületét. majd köszön neki. tervezni kell. majd írja ki azok összegét. hogy a háromszög szerkeszthető-e! (A háromszög szerkeszthető. A szintaktika mellett fontos megemlíteni. megtervezett programok elkészítése a későbbiekben felgyorsítja a programozási folyamatot. meg kell keresni a lehetséges matematikai megoldásokat (persze. Ez kicsit eltér a fent bemutatott bool b=Convert. ha a felhasználói igényeket papírra vetjük ©. Elsőként fel kell vázolni a születendő programok működését. hanem egy négyzet kerületét és területét számítsa ki! Az előző programot módosítsa úgy. mely logikai true/false értékeket olvas be a billentyűzetről! True esetén a képernyőre az IGAZ szót írja ki a program! Írjon programot. a kör kerületét és területét kiszámító programunkat úgy. javítását. hogy a nevén szólítja! (Pl. mely beolvas egy számpárt a billentyűzetről.info) Logikai érték esetén a beolvasás a következő módon oldható meg: Ennél a programrészletnél a true szót kell begépelni a billentyűzeten. A beolvasásnál az 1 érték nem megfelelő.kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.: Hello Kiss Attila!) Próbálja meg átalakítani a fejezetben tárgyalt. majd megmondja. de úgy.info . egyszerűbbé teszi a hibák keresését. csak ha erre szükség van). hogy a szám negatív. vagy pozitív! Kérjen be a billentyűzetről két számot. A teljes körű megismeréshez mindenképpen fontos a következő fejezet tanulmányozása. mely egy háromszög oldalainak hosszát olvassa be a billentyűzetről. hogy a programozás folyamata nem a fejlesztői eszköz kód editorában kezdődik. oldal a 242-ből www. Nem szerencsés a logikai értékek beolvasásakor a Read() metódust használni.kuruc. szorzatát és hányadosát a képernyőre! Készítsen programot.ToBoolean(1).

oldal a 242-ből www.info .kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Fejezet „Szelekció alapszint” Radványi Tibor Ez a 43.info) Programozás tankönyv V.kuruc.

kuruc. vagyis igaz. Ezek a tagadás. vagy hamis. a logikai és. ÉS A B A && B TRUE TRUE TRUE FALSE TRUE FALSE TRUE FALSE FALSE FALSE FALSE FALSE Azaz kizárólag akkor lesz a művelet eredménye igaz. Ez a 44. akkor az Sz < 4 kifejezés értéke lehet igaz is és hamis is.kuruc. attól függően. illetve a logikai vagy operátorok. oldal a 242-ből www. Például ha Sz változó int típusú. VAGY A B A || B TRUE TRUE TRUE FALSE TRUE TRUE TRUE FALSE TRUE FALSE FALSE FALSE Látható. Logikai kifejezéseket logikai operátorokkal köthetünk össze. ha mindkét paraméter értéke igaz. Ezek az értékek konstansként is megadhatók: Két kompatibilis érték összehasonlításának eredménye vagy igaz (true) vagy hamis (false) lesz.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. a bemenő paraméterek különböző értékei mellett az operációk milyen eredményt szolgáltatnak? Tagadás: A !A TRUE FALSE FALSE TRUE Tehát minden értéket az ellentettjére fordít.info . Az összehasonlítás eredményét tudjuk tárolni egy logikai típusú változóban. hogy mi a változó pillanatnyi értéke. a TRUE és a FALSE.info) A logikai típusú változó A logikai típusú változónak két lehetséges értéke van. A C#-ban a műveleteket a következőképpen jelöljük: Tagadás (negáció) ! ÉS (konjunkció) && VAGY (diszjunkció) || Nézzük az operátorok igazságtáblázatát. ha mindkét paraméter értéke hamis. hogy akkor hamis a művelet eredménye.

vagy operatorok segítségével. A fenti kódrészlet csak akkor írja ki a szöveget. Ez a 45. akkor a második if feltételében vizsgáljuk.kuruc. VAGY.kuruc. akkor a sorrend: TAGADÁS. ha ez teljesül. ÉS. akkor a kapcsos zárójelek elhagyhatóak. hogy x > 10 és ugyanakkor y > 20 is. Két vizsgálatot csinálunk. Ezt leírhatjuk az és operátor alkalmazásával is: Tekintsük az alábbi programrészletet: A billentyűzetről bekérünk egy karaktert. hogy ha mindössze egy utasítást szeretnénk végrehajtani.info . A feltételes utasítás if (logikai kifejezés) { igaz érték esetén végrehajtandó utasítások } Látható. akkor jelenik meg a szöveg a képernyőn. ha ez nem dönt. Bármely feltétel hamis állapota esetén a szöveg kiírása elmarad. Előírhatunk összetett logikai feltételeket az if többszörözésével. Egyenrangú műveletek esetén a balról-jobbra szabály lép életbe.info) Egy kifejezés kiértékelésében a zárójelek határozzák meg a kiértékelés sorrendjét. ha egyszerre teljesül. Amennyiben mindkettő feltétel teljesül. hogy a karakter kisbetű-e. az első if feltételében megvizsgáljuk hogy a kapott karakter betű-e.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. oldal a 242-ből www.

kuruc. akkor a "A karakter nagybetűs. hanem valami más karakter jelenik meg. Míg ha a külső if logikai kifejezése hamis.info .C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. akkor a beírt karakter már nem is betű. Ha a belső if utasítás logikai kifejezése hamis. hogy több utasítás megadása esetén használni kell a kapcsos zárójeleket." szöveg jelenik meg. Itt is érvényes. Ekkor a "a karakter nem betű" szöveg fog megjelenni. Ebben az esetben nem használhatunk a 2 db if utasítás helyett logikai operátorral összekapcsolt kifejezést.info) Az elágazás if (logikai kifejezés) { igaz érték esetén végrehajtandó utasítások } else { Hamis érték esetén végehajtandó utasítások } Amennyiben a logikai kifejezés értéke hamis. Ez a 46. MERT A HAMIS ESETET KÜLÖN KEZELJÜK LE. oldal a 242-ből www. pl.kuruc. akkor az else utáni utasítások kerülnek végrehajásra.: számjegy.

info) Néhány egyszerű példácska a szelekció alkalmazására Döntsük el egy számról. hogy hány jegyű! Adott egy tetszőleges pont koordinátáival. számról döntse el a program hogy számtani sorozatot alkotnak e! Ez a 47. így ezt vizsgáljuk.kuruc. Megoldásra ajánlott feladatok 1) 2) 3) 4) 5) 6) 7) Egy beolvasott számról döntse el a program hogy -30 és 40 között van-e! Két beolvasott szám közül írassuk ki a nagyobbikat! Vizsgáljuk meg hogy osztható-e egy A egész szám egy B egész számmal! Tetszőleges 0 és egymillió közötti egész számról mondja meg a program. Mivel ez karaktersorozat. így egész számmá kell konvertálni. Határozzuk meg melyik síknegyedben van! Rendeztessünk sorba 3 egész számot! Három tetszőleges. Ne próbáljuk meg az értékadás = jelével helyettesíteni. A logikai egyenlőség reláció operátora a == karakterekkel jelöljük. a szam % 2 megadja a szam nevű változó értékének kettes maradékát.info . Ez páros szám esetén 0.kuruc. A % jel a maradékképzés operátora. Az if utasítás egyszerű logikai feltételt tartalmaz.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. hogy páros-e! A deklarálás után bekérünk egy számot. oldal a 242-ből www.

9) Olvassunk be négy számot és határozzuk meg a páronkénti minimumok maximumát! 10) Írjunk programot. téglalap. oldal a 242-ből www. mely kibarkochbázza.info .kuruc. hogy milyen négyszögre gondoltam (négyzet. rombusz.info) 8) Három adott számról döntse el a program. hogy lehetnek-e egy háromszög oldalainak mérőszámai.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. stb)! Ez a 48.kuruc.

Hernyák Zoltán Ez a 49.info) Programozás tankönyv VI.info .kuruc. oldal a 242-ből www.kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Fejezet Előírt lépésszámú ciklusok "Ismétlés a tudás anyja”.

.info) Az eddig megírt programok szekvenciális működésűek voltak. hogy ez a ciklus VÉGTELEN CIKLUS lesz. hiszen minden egyes alkalommal a 4. Vegyük észre. harmadikra stb. négyzetszám = ”. sorba egy feltétel került. Ezt a szakaszt CIKLUSMAGNAK nevezzük..kuruc. I := I+1 // az I változó értéke növelve 1 -el 4.. A fenti példaprogramban ez a szakasz (a ciklusmag) a 2. stb. akkor ugorj a 6. mivel ’kilépünk’ a ciklusból a ciklus utáni első utasításra ugorva.”. sorból áll. ugorj újra a 2. az algoritmusok és a programok egyik fontos viselkedési jellemzője. így a program a végtelenségig fut. I := I+1 // az I változó értéke növelve 1 -el 5. akkor befejezzük a ciklusmag végrehajtását. ha teljesül. leggyakrabban nem írható fel a megoldás ilyen egyszerű lépésekből. négyzetszám = 4”. A program végrehajtása elkezdődött a Main függvény első utasításán. A fenti kódot nevezhetjük kezdetleges ciklusnak is. I*I 4.info . négyzetszám = 9”. Hogy e feltétel legelső alkalommal is kiértékelhető legyen. amelyek valamely más szám négyzeteként előállíthatóak . négyzetszám = ”.ilyen pl. mint 5. A 2.az mindig 1-gyel nagyobb az előző értéktől. oldal a 242-ből www.kuruc.”. Ez jellemzően helytelen viselkedés. I*I 3.. de első 50 négyzetszámot kell kiírni a képernyőre! Vegyük észre.. az 1. I := 1 // az I változó értéke legyen ’1’ 2. a 25). Vegyük az alábbi programozási feladatot: írjuk ki az első 5 négyzetszámot a képernyőre (négyzetszámnak nevezzük azokat a számokat.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. sorra 3. sorra 6. Módosítsunk a kódon: 1. négyzetszám= 1”. A CIKLUSOK olyan PROGRAMVEZÉRLÉSI SZERKEZETEK. I := 1 // az I változó legyen ’1’ 2. ha nem az első 5. hogy visszaugrik a ciklusmag első utasítására. amikor is a program működése leállt. és annak mennyi az értéke. hogy a program sorai nagyjából egyformák. A 4. ezzel kényszerítve a számítógépet a ciklusmag újbóli végrehajtására. Nézzük az alábbi pszeudó-utasítássorozatot: 1. Írd ki: I. sorra. Ha az I értéke nagyobb. Írd ki: I. ugorj újra a 2. Sőt. sorban beállítjuk az I változó érEz a 50. sor lényege. De képzeljük el ugyanezt a programot. ahol a program bizonyos szakaszát (sorait) TÖBBSZÖR is végrehajthatjuk. sor elérésekor visszaugrunk a 2. „3. hogy véges sok lépés végrehajtása után leállnak. majd haladtunk a másodikra. A fenti program még a hagyományos szekvenciális működés betartásával íródott. amíg el nem értük az utolsó utasítást. és a 3. Az hogy hányadik négyzetszámról van szó . két ponton különböznek egymástól: hogy hányadik négyzetszámról van szó. majd a „2. Nem minden probléma oldható meg ilyen egyszerűen. sorra Ennek során kiíródik a képernyőre az „1. mely.

amelyet akár többször is végrehajtanak (ciklusmag). A ciklusoknak tehát az alábbi fontos jellemzőjük van: Tartalmaznak egy utasításblokkot. végrehajtja a léptetőutasítást. Ennek megfelelően egy hibás kezdőértékadás eredményezheti azt is. hogy a ciklusmag egyetlen egyszer sem hajtódik végre. hogy kell-e még ismételni a ciklusmagot. végrehajtja a ciklusmagot. amelynek segítségével előbb-utóbb elérjük azt az állapotot. léptetőutasítás ( i=i+1 ). Másik dolog. visszaugrik a 2. sort. A C#-ban a legnépszerűbb ciklus a FOR ciklus: A fenti példában a for kulcsszóval jelöljük. amely biztosítja. hogy kiléphessünk a ciklusból. Formailag a három részt pontosvesszővel kell elválasztani. A ciklusmag tartalmaz olyan utasítást. A ciklusmagot pedig kapcsos zárójelek közé kell tenni (UTASÍTÁSBLOKK). amely meghatározza.kuruc. kiértékeli a vezérlő feltételt.info . Valamint szintén figyeljük meg a 4. hiszen az I értéke e nélkül nem érhetné el a kilépéshez szükséges 6 értéket. A for kulcsszó után zárójelben HÁROM dolgot kell megadni: kezdőérték beállítása ( i=1 ). ismétlési feltétel ( i<=5 ). ezért ebben az esetben a vezérlőfeltételt a ciklusban maradás feltételének is nevezhetjük. akkor kilép a ciklusból. és ha HAMIS. Tartalmaznak egy kezdőértékadást (a ciklus előtt). Tartalmaznak egy feltételt (vezérlő feltétel). amit megfigyelhetünk: a vezérlő feltétel kiértékelése már legelső alkalommal is a ciklusmag előtt hajtódik végre. Például: Ez a 51. Ha a vezérlőfeltétel igaz. oldal a 242-ből www. lépésre. hogy ciklust szeretnénk írni.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. hogy a ciklus feltétele már legelső alkalommal is egyértelműen kiértékelhető legyen.kuruc.info) tékét (értékadás). A C# az alábbi módon értelmezi a for ciklust: 1) 2) 3) 4) 5) végrehajtja a kezdőértékadást. Ezen sor is nagyon fontos. akkor végrehajtja a ciklusmag utasításait.

. és alakítsuk át ciklusos szerkezetűvé. majd i=2. akkor már célszerűtlen lenne a program ezen formája.kuruc. cv <= végérték. Ez a 52. amíg túl nem lépjük a végértéket.. Az első megoldás még nem tartalmaz ciklust: Ugyanakkor. hogy egy már meglévő szekvenciális szerkezetű programban találjuk meg az ismételhető lépéseket.. Kicsit alakítsuk át a fenti programot: A fenti program ugyanazt teszi. hogy a ciklusmag hányszor hajtódik végre: Ezen ciklus magja legelső alkalommal az i=1. mint az előző. elsősorban hagyománytiszteletből. ha nem 3. összesen 10 alkalommal. cv = cv+1) . oldal a 242-ből www. hanem 30 számról lenne szó. i=10 értékekre hajtódik végre.kuruc. és írjuk ki a képernyőre a 3 szám összegét. melyet az esetek többségében ’i’vel jelölünk. A for ciklus egy nagyon gyakori alakja tehát felírható az alábbi módon (’cv’ jelöli a ciklusváltozót): for (cv = kezdőérték. . majd szintén az esetek többségében ezt az értéket minden ciklusmag lefutása után 1-gyel növeli.info) A ’for’ ciklusra jellemző. de már látszik..info . Ebből már könnyű ciklust írni: Sokszor ez a legnehezebb lépés. Vegyük az alábbi programozási feladatot: kérjünk be 3 számot.. hogy tartozik hozzá egy ciklusváltozó. melyik az utasításcsoport. Ezen i változó felveszi a kezdőértékét. amelyet 3szor meg kell ismételni.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Ennek megfelelően előre kiszámítható.

A ++ egy operátor. Ekkor a C# megengedi. jelentése ’növeld meg 1-gyel az értékét’.kuruc.info) Programozási feladat: Készítsük el az első 100 egész szám összegét. . Ezért a fenti kis program az alábbi módon is felírható: Magyarázat: a program minden lépésben hozzáad egy számot az ’ossz’ változóhoz. Ugyanakkor a probléma megoldása az első N négyzetszám összegképletének ismeretében egyetlen értékadással is megoldható: Programozási feladat: Határozzuk meg egy szám faktoriálisának értékét. 15-ig) tesztelhetjük csak a fenti programot. Jegyezzük meg. hogy aránylag gyakori.kuruc. mint léptető utasítás. végül magával a számmal... Magyarázat: pl. majd 3-t. így számolva ki lépésről lépésre a végeredményt. és az alkalmazott módszer érdekes tanulságokat tartalmaz.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. A párja a -. Első lépésben 1-et.. amelynek induláskor 0 a kezdőértéke. hogy 1*2*3*4*5*6. és a kitevőt kérjük be billentyűzetről! Ez a 53. hogy a ciklusokban az i=i+1 utasítás nagyon gyakori. oldal a 242-ből www... Másik észrevételünk. hogy a ciklusmag egyetlen utasításból áll csak. Megjegyzés: a ’szam’ növelésével a faktoriális értéke gyorsan nő. Ezt gyakran i++ alakban írják a programozók. így állítván elő az első 100 szám összegét. .operátor. majd 2-vel. majd 3-al.. amelynek jelentése: ’csökkentsd 1-gyel az értékét’. Megjegyzés: a fenti feladat ezen megoldása. A számot kérjük be billentyűzetről.info . ezért csak kis számokra (kb. majd 100-t ad az ossz változó aktuális értékéhez. A program a ’fakt’ változó értékét megszorozza először 1-el. hogy ne tegyük ki a blokk kezdet és blokk vége jeleket. majd 2-t. a 6 faktoriális úgy számolható ki. Programozási feladat: Határozzuk meg egy szám pozitív egész kitevőjű hatványát! A számot.

Amennyiben az osztási maradék 0. A program a ’ertek’ változó értékét megszorozza annyiszor a ’szam’-al. Minden osztó-találat esetén növeljük 1-gyel a ’db’ változó értékét. Programozási feladat: Írassuk ki a képernyőre egy szám összes többszörösét. Ez akkor teljesül. Valahányszor találunk ilyen ’i’ értéket. Ha a ’szam’ értéke pl. akkor megkapjuk a legnagyobb olyan értéket. A további többszörösöket úgy kapjuk. hogy ezen számok egymástól ’szam’ távolságra vannak: Magyarázat: a ’100/szam’ osztási művelet. hogy 4*4*4. ezért az ’i’ változóban lévő érték egy osztó. ha a szám maradék nélkül osztja az ’i’-t. vagy sem. amelyek nem nagyobbak. mert 14 osztva 4-gyel 2 osztási maradékot ad). Programozási feladat: Határozzuk meg egy szám osztóinak számát! A számot kérjük be billentyűzetről! Magyarázat: a 10 lehetséges osztói az 1. hogy sorba próbálkozunk a szóba jöhető számokkal. a 14%4 értéke 2 lesz. hogy mi a legnaEz a 54. minden lépésben csökkentve a ciklusváltozónk értékét (i--). hogy a kiinduló értéket minden cikluslépésben csökkentjük ’szam’-al. mint 100 (’max’). mindannyiszor kiírjuk azt a képernyőre. 2) Programozási feladat: Állapítsuk meg két billentyűzetről bekért számról.kuruc. akkor a ’100/szam’ eredménye 14. hogy az osztója-e a számnak. Feladatok: 1) Programozási feladat: Állapítsuk meg egy billentyűzetről bekért számról.. mivel két egész szám típusú érték között kerül végrehajtásra automatikusan egész osztásnak minősül. mindegyiket ellenőrizve. Minden lépésben megvizsgáljuk.kuruc.info .info) Magyarázat: pl. ha figyelembe vesszük. Az oszthatóságot a ’%’ operátorral ellenőrizzük. 4 harmadik hatványa kiszámolható úgy. csökkenő sorrendben! A számot kérjük be billentyűzetről! Magyarázat: elindulunk 100-tól. hogy a szóban forgó ’i’ többszöröse-e az eredeti számnak. oldal a 242-ből www.10 tartományba esnek. 7. és a legnagyobb ilyen többszöröse a ’szam’-nak. amely nem nagyobb. visszafele haladunk. mint 100. A módszer lényege. Ha ezt visszaszorozzuk a ’szam’-al. mint 100. hogy prímszám-e! A prímszámoknak nincs 1 és önmagán kívül más osztója. úgy az ’i’ maradék nélkül osztja a ’szam’ változó értékét. A % operátor meghatározza a két operandusának osztási maradékát (pl. Ez lesz a kiinduló értéke a ciklusváltozónak. és nem nagyobb.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Ugyanezen feladat megoldható hatékonyabban. amely biztosan többszöröse a ’szam’-nak. ahányszor azt a kitevő előírja.

9. hogy egy adott intervallumba eső számok közül melyik a legnagyobb prímszám! Az intervallum alsó és felső határának értékét kérjük be billentyűzetről! Próbáljunk keresni idő-hatékony megoldásokat! 6) Programozási feladat: Írjunk olyan programot. amely kiszámolja és kiírja az alábbi változó növekményű számtani sorozat első 20 elemének összegét: 3.kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. vagy az Euklideszi algoritmussal is.2.. amíg a sorozat következő elemének értéke meg nem haladja az 1000-t! A sorozat első eleme: a1=1! 13) Programozási feladat: Határozzuk meg az első n négyzetszám összegét! N értékét kérjük be billentyűzetről! 14) Programozási feladat: Határozzuk meg egy [a. Ezen értéket meghatározhatjuk kereséssel (ciklus).5. amely egy összegző ciklussal kiszámolja és kiírja az alábbi számtani sorozat első 20 elemének összegét: 3. és a kvócienst! Ezek után kiírja a képernyőre a mértani sorozat első 20 elemét.. és azok összegét! Az a és b értékét kérjük be billentyűzetről! 15) Programozási feladat: Számoljuk ki és írjuk ki a képernyőre a Fibonacci sorozat első 10 elemét! A sorozat az alábbi módon számítható ki: a1 = 1 a2 = 1 an = an-1 + an-2 ha n>2 Ez a 55. 4) Programozási feladat: Állítsuk elő egy szám prímtényezős felbontását! Pl: 360=2*2*2*3*3*5! 5) Programozási feladat: Állapítsuk meg.kuruc.! Ellenőrizzük le az eredményt a számtani sorozat összegképlete segítségével! 7) Programozási feladat: Írjunk olyan programot. amely mindkét számot osztja.5.17.stb. és a differenciát! Ezek után kiírja a képernyőre a számtani sorozat első 20 elemét. hogy relatív prímeke! Akkor relatív prímek.23. és az elemek összegét! 10) Programozási feladat: Számoljuk ki és írjuk ki a képernyőre a 2n értékeit n=1.11. az elemeket egymástól vesszővel elválasztva.. egy sorban! 9) Programozási feladat: Írjunk olyan programot.info .10-re! 11) Programozási feladat: Számoljuk ki és írjuk ki a képernyőre az an=an-i+2n sorozat első 10 elemét.12. amely bekéri egy tetszőleges mértani sorozat első elemét.30. amely addig írja ki a képernyőre a an=2n2n-1 sorozat elemeit a képernyőre.! 8) Programozási feladat: Írjunk olyan programot.8.7. ha a1=1! 12) Programozási feladat: Írjunk olyan programot. amely bekéri egy tetszőleges számtani sorozat első elemét.. 3) Programozási feladat: Állapítsuk meg két billentyűzetről bekért számról.stb. oldal a 242-ből www.b] intervallum belsejébe eső négyzetszámokat (írjuk ki a képernyőre).info) gyobb közös osztójuk! A legnagyobb olyan szám. ha a legnagyobb közös osztójuk az 1.

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info .kuruc. Fejezet „Vektorok!” Radványi Tibor Ez a 56.kuruc.info) Programozás tankönyv VII. oldal a 242-ből www.

int típusú tömböt. melynek tetszőleges. A tömb lehet egy. akkor a new operátor elhagyható: A tömb elemeinek elérése A tömb elemein végiglépkedhetünk egy egyszerű for ciklus alkalmazásával. Használhatjuk.kuruc. valós stb tömböt deklarálni: A tömb elemeire INDEXEIK segítségével hivatkozhatunk. ha van rá lehetőségünk és ismeretünk: Ha az előbbi módon használjuk a tömb deklarációt. azaz rögtön megadjuk a kezdőértékeket is. Fejezetünkben az EGYDIMENZIÓS TÖMBÖK kezelésével foglalkozunk.(ezek a vektorok) vagy többdimenziós. hogy a tömb deklarációjakor megadjuk az elemeit. ELEME Tömb deklarálása Hasonlóan történik.info) Vektorok kezelése A TÖMB egy összetett homogén adatstruktúra. a dimenzió száma nem korlátozott. mint egy hagyományos változóé. Az elemek típusa azonos.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. oldal a 242-ből www. Ezzel létrehoztunk egy 5 elemű. csak a [] jellel kell jelezni. hiszen a memóriában még nem történt meg a helyfoglalás. hogy tömb következik: Ilyenkor a tömbünk még nem használható. A fentiekhez hasonlóan tudunk string. ha általános függvényt szeretnénk írni. Ez a 57. vagy használhatjuk a foreach ciklust. melynek alapján a többdimenziós tömbök kezelése is elsajátítható.info . Megtehetjük. feltölthetjük. Ezt a NEW operátor használatával tehetjük meg. műveleteket végezhetünk vele. Ez mindig 0-tól indul és egyesével növekszik. de előre meghatározott számú van.kuruc.

keresés a tömbben A tömb kiíratásához használhatunk egy egyszerű metódust: Ennek a segítségével vizsgáljuk meg az Array osztály lehetőségeit. A tömb elemeinek rendezése. akkor a tömb egy résztömbjét rendezhetjük.info) A length tulajdonság segítségével megkapjuk a tömb méretét. melynek egy paramétere van.info .kuruc. Ez a 58. Deklarációja: Használata: Eredmény: Az első kiíratáskor: 1 2 17 90 4 A második kiíratáskor: 1 2 4 17 90 Ebben az esetben a teljes tömb rendezésre kerül.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. oldal a 242-ből www. helyben rendezi a paraméterként kapott tömböt. melyet akár ciklusban is használhatunk paraméterként. A Sort metódus.kuruc. Ha a Sort metódus háromparaméteres változatát használjuk.

kuruc. Használata: A string tömb elemeinek kiíratásához használt metódus: Eredmény az első kiíratás után: 1 34 17 90 4 első második harmadik negyedik ötödik Ez a 59. A metódus rendezi a keys tömb elemeit. A rendezés következő esete. és ennek megfelelően az items tömb elemeinek sorrendje is változik. és ez kerül rendezésre.info) Deklarációja: Ekkor az index paramétertől kezdve a length paraméterben megadott hosszban képződik egy részhalmaza a tömb elemeinek. Eredmény: Az első kiíratáskor: 1 2 17 90 4 A második kiíratáskor: 1 2 17 4 90 Tehát csak a 90 és a 4 cserélt helyet. mert csak az utolsó két elem rendezését írják elő a paraméterek (3.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.info . melyek a Keys tömb elemeinek felelnek meg. mely tartalmazza a kulcsokat a rendezéshez Items: elemek.2). Deklarációja: Keys: egy egydimenziós tömb. amikor két tömbparamétert használunk. oldal a 242-ből www.

kuruc.info) Eredmény a második kiíratás után: 1 4 17 34 90 első ötödik harmadik második negyedik Az előző kulcsos rendezéshez hasonlóan.ReadLine() függvény visszatérési értéke string.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. ezért ezt át kell alakítani a megfelelő formátumra a Convert osztály ToInt32 metódusának a segítségével. melynek megoldásához tömböket használunk Vektor feltöltése billentyűzetről Ebben az egyszerű példában bekérünk 5 db egész számot a billentyűzetről. Ha szám helyett szöveget. a kulcsokhoz tartozó elemeket tartalmazó tömb index: a rendezendő terület kezdőpozíciója length: a rendezendő terület hossza Eredmény az első kiíratás után: 1 34 17 90 4 első második harmadik negyedik ötödik Eredmény a második kiíratás után: 1 34 17 4 90 első második harmadik ötödik negyedik Következzen néhány alapfeladat. de csak részhalmazrendezésre használható az alábbi metódus: Deklaráció: keys: egy egydimenziós kulcsokat tartalmazó tömb items: egy egydimenziós.info . oldal a 242-ből www.kuruc. akkor a program hibaüzenettel leáll. Semmiféle ellenőrzést nem tartalmaz a kód. Mivel a Console. Ez a 60. így csak egész számok esetén működik jól. például „almafa” írunk az adatbekérés helyére.

hogy csak olyan értékeket fogadjon el.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Ez a 61.info) Módosítsuk úgy a programot. Azaz kérjünk be a billentyűzetről 5 db különböző egész számot.info .kuruc.kuruc. melyek még eddig nem szerepeltek. oldal a 242-ből www.

Oldjuk meg ezt a feladatot is úgy. Használatkor az rnd példány paramétereként adjuk meg a felső határát a generálandó számnak.info . Készítsünk egy rnd nevű példányt belőle. A véletlenszám-generátort a Random osztályból érjük el.kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. oldal a 242-ből www. hogy az értékek típushelyesek legyenek.kuruc. hogy ne engedjük meg az ismétlődést a generált számok között. Ebben az esetben biztosítjuk. Ez a 62.info) Vektor feltöltése véletlenszám-generátorral Nézzük meg az előző feladatot. de most használjuk a tömb feltöltéséhez a véletlenszám-generátort.

info) N elemű vektorok kezelése Egyszerű programozási tételek alkalmazása vektorokra. Töltsük fel véletlen számokkal.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Megoldás: Ez a 63.kuruc.kuruc.info . Összegzés Feladat: Adott egy 10 elemű. egész típusú tömb. oldal a 242-ből www. majd határozzuk meg a számok összegét.

Megoldás: Magyarázat: A program eleje hasonló az összegzésnél látottakkal.info . Ennek a segítségével fogjuk előállítani a véletlen számokat. a sum a gyűjtőváltozó lesz.kuruc. Az első for ciklusban feltöltjük a tömböt a véletlen számokkal. Itt fogjuk megjegyezni az aktuális legnagyobb és legkisebb elemet. Majd kiíratjuk a végeredményt. Rögtön le is foglaljuk a memóriában 10 elem helyét. Létrehozunk a Random osztályból egy rnd nevű példányt. majd határozzuk meg a legnagyobb illetve legkisebb elem értékét. melyben a tömb elemeinek az összegét generáljuk. oldal a 242-ből www. melynek a neve tm. Töltsük fel véletlen számokkal. végiglépkedve az elemeken.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc. egész számokat tartalmazó tömb. Ezért ennek 0 kezdőértéket kell adni. és azok értékével növeli a sum változó pillanatnyi értékét.info) Magyarázat: Az első sorban deklarálunk egy int típusú elemeket tartalmazó tömböt. Az összegzést a második FOR ciklus végzi. Az i ciklusváltozó. A példában az Ez a 64. Egy max és egy min változót is deklarálunk. Maximum és minimum kiválasztása Feladat: Adott egy 10 elemű.

mert ha nincs ilyen tömbelem. Az első feltétel azt ellenőrzi. Megoldás: Ez a 65.info) elem értékét jegyezzük meg. Figyeljünk oda. Ha bármelyik feltétel hamissá válik. Töltsük fel véletlen számokkal. ha mindkét feltétel igaz. hogy a feladat mit követel meg tőlünk. A ciklusmagban az i ciklusváltozó értékét növeljük. akkor onnan kezdve az lesz a max. a második. Az értékek feltöltése után a következő for ciklussal végignézzük az elemeket. előltesztelő ciklust használunk összetett logikai feltétellel. hogy benne vagyunk-e még a tömbben. akkor a vizsgálatkor már i = 11 lenne. majd írassuk ki a páros számokat közülük. ügyelve a konverzió szükségességére. Mivel logikai ÉS kapcsolat van a két feltétel között. vagy elfogyott a tömb.kuruc.Parse függvényt használtuk. attól függően. hogy az if feltételben nem alkalmazhatjuk a while feltétel második részét. oldal a 242-ből www. Az eldöntéshez egy while.info . egész számokat tartalmazó tömb. Eldöntés Feladat: Adott egy 10 elemű. Ehhez itt a Int32.kuruc. Ennek megfelelően írjuk ki üzenetünket. és ha találunk az aktuális szélsőértéknél nagyobb illetve kisebb tömbértéket. Döntsük el hogy a bekért szám szerepel e a 10 elemű tömbben. Kiválogatás Feladat: Adott egy 10 elemű. Megoldás: Magyarázat: A tömb feltöltése után kérjünk be egy számot a billentyűzetről.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. majd kérjünk be egy egész számot a billentyűzetről. Így utána az if feltétellel döntjük el a kilépés okát. hogy a tömbindexet tároljuk el. hogy még nem találtuk meg a keresett értéket. azaz hogy megtaláltuk a szám első előfordulását. akkor kilépünk a ciklusból. de van rá lehetőség. így nem létező tömbelemre hivatkoznánk. így a ciklusmag akkor hajtódik végre. vagy a min értéke. egész számokat tartalmazó tömb. Töltsük fel véletlen számokkal.

Deklarálás: Az ArrayList főbb jellemzői: Capacity: az elemek számát olvashatjuk. Dinamikus méretű vektorok Dinamikus elemszámú tömbök kezelését valósítja meg az ARRAYLIST osztály. IndexOf: A megadott elem első előfordulásának indexét adja vissza.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Ez a 66. Count: az elemek számát olvashatjuk ki. Csak olvasható tulajdonság. Ha a tömbelem 2-vel osztva 0 maradékot ad. Sort: Rendezi az elemeket az ArrayListben. A feltétel.kuruc. a párosság vizsgálata. akkor a szám páros. Az ArrayList főbb metódusai: Add: Hozzáad egy objektumot a lista végéhez.info) Magyarázat: A tömb feltöltése után a második cikluson belül írjuk a megfelelő feltételt az if szerkezetbe. Item: A megadott indexű elemet lehet írni vagy olvasni. CopyTo: Átmásolja az ArrayList-át egy egydimenziós tömbbe. Ennek teljesülése esetén kiírjuk a tömbelemet. oldal a 242-ből www. illetve írhatjuk elő. Ebben az esetben kerül kiíratásra. A lista első elemének az indexe a 0.kuruc. Ezt a maradékképzés % operátorával vizsgáljuk. Insert: Beszúr egy elemet az ArrayListbe a megadott indexhez.info . BinarySearch: Rendezett listában a bináris keresés algoritmusával megkeresi az elemet Clear: Minden elemet töröl a listából.

info) Feladatok dinamikus tömbre Kérjünk be számokat a nulla végjelig Deklaráljunk egy dtm nevű ArrayList objektumot. hozzáadjuk az ArrayListánkhoz az add metódus meghívásával. oldal a 242-ből www. és példányosítsuk is.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Határozzuk meg azt a minimális sugarú kört. és a konverzió eredményét tároljuk az elem nevű változóba.info .kuruc.kuruc. Amennyiben ez nem nullaértékű. Az adatbekérést mindaddig folytatjuk. mely magába foglalja az összes pontot. adjuk meg a középpontját és a sugarát! A feladat első felét nézzük most. A 0 beírása után az ellenőrzés miatt visszaírattuk az ArrayList tartalmát az alábbi függvény meghívásával: Feladat: Adott a síkon koordinátáival néhány pont. míg nullát nem írunk be. Az adatbekéréskor a ReadLine() függvény által visszaadott karakterláncot konvertáljuk Int32 típussá. Ez a 67. Hogyan kezeljük a pontokat és adatait.

mint átmérő fölé rajzolt kör adatait meghatározni.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info) Ezzel létrehoztunk egy TPont osztályt. Ehhez használjuk a következő osztályt. A kozeppont változó a TKor osztályban lett deklarálva. mint adatmezőt tartalmazza. Ehhez a kör középpontjának koordinátáira és a sugarának hosszára lesz szükségünk. oldal a 242-ből www.kuruc. Használjuk fel a már meglévő TPont osztályt. az öröklés miatt ez az osztály is látja.kuruc. Ezen az osztályon fog alapulni a feladat megoldása. ahol egy végpontjainak koordinátáival adott szakasz fölé rajzolt kör adatait tudjuk meghatározni. Ezek után minden eszközünk megvan ahhoz. Tekintsük az alábbi deklarációt. A feladatunk megkeresni azt a két pontot. Ez a 68. melyek távolsága a legnagyobb.info . és a public láthatósága miatt használhatja is. mely lehetővé teszi tetszőleges számú pont felvételt a síkon. Itt használjuk ki a dinamikus ArrayList adta lehetőségeket. és az általuk meghatározott szakasz. hogy megoldjuk a feladatot. mely a síkbeli pont két koordinátáját. Hozzunk létre egy kört leíró osztályt is.

Ezeket feltölthetjük billentyűzetről: Keressük meg a maximális távolságra lévő pontokat a ponthalmazból.kuruc. akkor a megoldást mindössze két metódus meghívása szolgáltatja: Ez a 69. Ehhez lehet ezt az egyszerű metódust használni: Ha a fenti metódusokat egy olyan osztályban hozzuk létre.info .kuruc.info) A pontok nevű ArrayListbe fogjuk tárolni a pontok adatait.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. oldal a 242-ből www. melyet a TSzakasz_kore osztályból származtattunk.

Többdimenziós tömbök Sok feladat megoldásához az egydimenziós tömb struktúra már nem elegendő.info) Ekkor a Main függvény tartalma a következő lehet: Ezzel a feladatot megoldottuk. akkor egy újabb index bevezetésére van szükségünk.kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc. de a napokhoz rendelt indexek nehézkesek lennének. mert február 1-hez a 32-es. Egyszerűbb. június 1-hez már a 152-es index tartozna. Ez a 70. a másik a napot. Nézzük meg egy egyszerű példán keresztül a deklarációt. vagy túl bonyolulttá tenné a kezelést. Az egyik jelentheti a hónapot. Ha például gyűjteni szeretnénk hónaponként és azon belül naponként a kiadásainkat. Töltsünk fel egy 3x3 mátrixot véletlen számokkal és írassuk ki őket mátrix fromában a képernyőre.info . Ha már az évet is szeretnénk tárolni. A kiadások számok. ha a kiadásainkat két indexszel azonosítjuk. oldal a 242-ből www.

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.info)

Látható, hogy a deklarációkor a két indexet úgy jelezzük, hogy egy vesszőt teszünk a zárójelbe, majd a példányosításkor megadjuk az egyes indexekhez tartozó elemszámot. A kétdimenziós tömböt feltölteni elemekkel, illetve kiíratni azokat elég két ciklus, ahol az egyik ciklusváltozó az egyik indextartományt futja végig, míg a másik ciklusváltozó a másik tartományt. Ha nem két, hanem többdimenziós tömböt használunk, akkor a ciklusok száma ennek megfelelően fog nőni. A példában látható, hogy a mátrixforma-megtartás érdekében egyszerűen a sorok elemeit egymás mellé Write utasítás alkalmazásával írattuk ki. A belső ciklus minden sor kiírásáért felelős, így a sorok végén a soremelésről gondoskodtunk a WriteLine utasítással, melynek nem volt paramétere. A kétdimenziós tömböt feltölthetjük kezdőértékkel, hasonlóan az egydimenziós esethez:

Tekintsük a következő feladatot: Töltsünk fel egy 3x3-as mátrixot (többdimenziós (ábra v.) táblázat) a billentyűzetről egész számokkal. Írassuk ki a szokásos formátumban, majd generáljuk a transzponáltját, és ezt is írassuk ki. A szükséges tömb és ciklusváltozók deklarálása:

Töltsük fel a mátrixot billentyűzetről egész számokkal:

Ez a 71. oldal a 242-ből www.kuruc.info

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.info)

Deklaráljunk egy tr tömböt a transzponált mátrix elemeinek. Majd generáljuk le az eredeti tm tömbből. A TRANSZPONÁLT mátrixot az eredeti mátrix sorainak és oszlopainak felcserélésével kapjuk.

Ez a 72. oldal a 242-ből www.kuruc.info

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.info)

A program futtatását bemutató képernyő:

Vegyük észre, hogy a két kiíratásban csak a tömb neve a különböző. Feleslegesen írjuk le kétszer ugyanazt a kódot. Erre jobb megoldást ad az eljárásokról és függvényekről szóló fejezet.

További megoldásra ajánlott feladatok
1) Határozzuk meg N db pozitív egész szám harmonikus közepét! 2) Határozzuk meg két N dimenziós vektor skaláris szorzatát, ha adottak a két vektor koordinátái. 3) 5 km-enként megmértük a felszín tengerszint feletti magasságát. (összesen N mérést végeztünk) A méréseket szárazföld felett kezdtük és fejeztük be. Ott van tenger, ahol a mérés eredménye 0, másutt >0. Határozzuk meg, van-e ezen a tengerszakaszon sziget! 4) Az előző feladatból mondjuk meg Hány szigeten jártunk? Adjuk meg azt a szigetet, ahol a legmagasabb csúcs van! Határozzuk meg a tengerszakaszok hosszát! Állapítsuk meg hogy van-e két egyforma szélességű sziget!
Ez a 73. oldal a 242-ből www.kuruc.info

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.info) 5) Egy nyilvántartásban a személyekről négy adatot tartanak nyilván: magasság, szemszín, hajszín, életkor. Döntsük el, hogy van-e két olyan személy, akiket ez a nyilvántartás nem különböztet meg. 6) Határozzuk meg N (N>1) természetes számnál nem nagyobb, legnagyobb négyzetszámot! 7) Állítsunk elő 50 véletlen számot 1 és 500 között. Válogassuk ki a 100-nál nagyobb páratlan számokat! Válogassuk ki a hárommal nem osztható páros számokat! Válogassuk ki a 200-nál nem nagyobb és 300-nál nem kisebb számok közül azokat, melyek a számjegyeinek összege öttel osztható! Válogassuk ki a 100 és 300 közé eső, 3-as számjegyet tartalmazó számokat! Keressük meg a legnagyobb 3-mal nem osztható, de 7-el osztható számot! Keressük azt a legkisebb számot, mely tartalmaz 3-as számjegyet! 8) Készítsünk egy totótipp-sort, vegyük figyelembe, hogy az 1-es 50%, x 30%, 2-es 20% valószínűséggel következik be. 9) Az X N-elemű vektor elemein végezzük el a következő transzformációt: mindegyik elemet helyettesítsük saját magának és szomszédainak súlyozott átlagával. A súly legyen az elem indexe a vektorban. 10) Egy mennyiség pontos mérését 9 azonos célműszeren egyenként 100 alkalommal végezték el. Mindegyik műszer az i. adatát azonos pillanatban mérte. Az eredményeket egy sorozatban helyezték el úgy, hogy az első 100 szám az első műszeren mért adatot jelenti, ezt a második műszeren mért adatok követik, és így tovább. Határozzuk meg az összes mérés átlagát, és számítsuk ki minden egyes mérésnél a 9 műszeren mért értékek átlagát! 11) Határozzuk meg A(N,N) mátrix felső háromszöge elemeinek összegét! 12) Adott A(N,N) mátrix. A mátrix fődiagonálisába írjunk olyan értékeket, hogy a mátrix minden sorában az elemek összege 0 legyen! 13) Egy osztály tesztlapokat töltött ki. Minden kérdésre 4 lehetséges válasz volt, és csak 1 jó. A válaszokat egy mátrixban tároljuk. Készítsünk programot, amely összehasonlítja a válaszokat a helyessel, majd megmondja, melyik tanuló hány jó választ adott. A helyes válaszokat tároljuk egy vektorban. 14) Egy színház pénztárának nyilvántartása tartalmazza, hogy egy adott előadásra mely helyekre keltek már el jegyek. B(i,j) tömbelem az i. sor j. helyét jelenti a baloldalon, J(i,,j) ugyanezt a jobboldalon. A tömbelem értéke 1, ha az adott helyre szóló jegy már elkelt, 0 ha még szabad. Írjunk programot mely keres két szomszédos szabad helyet az adott előadásra. 15) Az A(N,2) mátrixban egy gráfot ábrázoltunk: a mátrix egy sora a gráf éleit írja le úgy, hogy megadja azoknak a csúcsoknak a sorszámát, amelyekre az él illeszkedik. Határozzuk meg a csúcsok fokszámát! 16) Írj programot, mely kiírja két, számokat tartalmazó tömb közös elemeit!

Ez a 74. oldal a 242-ből www.kuruc.info

kuruc.info) Programozás tankönyv VIII.info .C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Fejezet „Logikai ciklusok” Király Roland Ez a 75.kuruc. oldal a 242-ből www.

Elöl tesztelő a while ciklus Hátul tesztelő a do while ciklus A WHILE ciklus A while ciklus általános formája a következőképpen írható le: while (feltétel) { utasítás1.info . és sokszor még az sem ismert. hogy az utasításokat hányszor kell ismételni. vagy utasítások sorozatát többször kell végrehajtanunk. A logikai ciklusoknak két alapvető formája létezik a C# nyelvben. Ebben a fejezetben a LOGIKAI CIKLUSOKAT nézzük át. vagyis TRUE értékű.info) A ciklusok A programozás során sokszor kerülünk szembe olyan problémával. A ciklus magját kapcsos zárójelek { } közé kell tenni. hogy hol végződik az aktuális. Az első feldolgozást szimbolizáló téglalap csak akEz a 76. mikor egy lépést ezerszer kell végrehajtani. A kapcsos zárójelek közti utasításblokkot ismétli a rendszer mindaddig. A ciklus magjában lévő utasításokat. amikor valamely utasítást. Folyamatábrával szemléltetve a while ciklus a következő formában írható le: A folyamatábra a while ciklus logikai modellje. melyek tetszőleges számban fordulhatnak elő. utasításn. melynek több formája létezik. Kevés számú ismétlésnél megoldhatjuk a problémát olyan módon is (és ez a rossz megoldás). de javasolt a használatuk a programok jobb áttekinthetősége érdekében). jelezve ezzel a ciklus utasításainak a kezdetét és végét (egy utasítás esetén a zárójelek elhagyhatóak. } A fenti ciklus a WHILE kulcsszóval kezdődik. amíg a feltétel igaz. utasítás2.kuruc. hogy az utasításokat többször egymás után leírjuk. de gondoljunk arra az esetre. Innen tudja a fordító. oldal a 242-ből www. Az ismétlések megvalósításának az eszköze a CIKLUS-UTASÍTÁS.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. pontosvesszővel választjuk el egymástól. majd a zárójelek közti részben a ciklusban maradás feltételét kell megadni.kuruc. Ilyen és ehhez hasonló helyzetekben célszerű az ITERÁCIÓ használata. és hol kezdődik a következő utasítás.

) Ügyeljünk arra is. ha a ciklusban használunk ciklusváltozót. vagyis az értékét minden lefutáskor növeljük meg eggyel. és az i+=1. oldal a 242-ből www. (Emlékezzünk vissza a for ciklusra! Ott a ciklusváltozó növelése automatikus és nem is célszerű azt külön utasítással növelni). ekvivalens az i=i+1. ellenkező esetben az ismétlések száma nem lesz megfelelő. hogy a ciklusváltozójának mindig adjunk kezdő értéket. utasítással. Az előző fejezetekben már láthattunk néhány példát a logikai ciklusokra. (Természetesen a fenti ismétlést megvalósíthattuk volna egyszerűen for ciklussal is. esetleg azt a ciklus bennmaradási feltételeként alkalmazzuk. Ha megértjük a folyamatábra és az általános forma működési elvét. de ott nem részleteztük a működésüket. hogyan lehet tízes számrendszerbeli számokat átváltani kettes számrendszerbe. így a C#-ban is. hogy a ciklusváltozóját léptetni kell. ha van ciklusváltozó. természetesen csak abban az esetben.) A while-t használó megoldásnál ügyeljünk arra.info) kor szükséges. A következő példa bemutatja. fejezetben az aritmetikai műveletekről és azok rövidítéséről bővebben olvashattunk.kuruc. A ciklus feltételrésze tartalmazza a ciklusban maradás feltételét. akkor azok alapján bármilyen while ciklust el tudunk készíteni. Természetesen a while ciklust leginkább a logikai értékek vizsgálatakor használjuk. A második feldolgozásblokk tartalmazza a ciklus utasításait. s nem számlálóciklusként (arra ott van a for ©). A C típusú nyelvekben.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. (A IV.info . mert a for ciklussal ellentétben itt a rendszer erről nem gondoskodik.kuruc. Ez a 77. Nézzünk meg egy konkrét példát a while ciklus használatára! A következő ciklus kiírja a 0-10 közötti egész számokat a konzol képernyőre. ez a rövidített forma megengedett. valamint a ciklusváltozójának léptetését. A változó léptetésére a következő formulát használtuk: i++.

hogy ne csak a 8-as számra működjön. Megfigyelhetjük. mivel az mindig a futás közben végrehajtott műveletek eredményétől függ (annyi lefutás van. akkor az egész kifejezés értéke Ez a 78. amelyik a kettes számrendszerbeli számjegyeket írja a képernyőre. oldal a 242-ből www. hogy az utolsó értékes számjegy a negyedik indexen. vagy a feltételek mindegyike hamissá válik. vagy más néven feltételes ciklusokat alkalmazni. Több feltétel használatakor az egyes kifejezéseket. mivel azok a feladat szempontjából nem értékes számjegyek. de csak azokat. hogy ebben a ciklusban nem tudjuk előre megmondani a lefutások számát. hanem csökkentjük.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. így az első ciklusunkban négy osztás történt. melyek az osztás során jöttek létre.info . ahány osztással elérjük a nulla értéket). hanem a felhasználótól beolvasott tetszőleges értékekre!) Vegyük sorra. Nulla érték esetén a ciklus befejezi futását. Az átváltás után a k változó értéke 5. így a tömbben lévő számjegyeket visszafelé írjuk ki a képernyőre.kuruc. vagyis a k-1 helyen van. és az utolsó lefutáskor még növeltük a k értékét eggyel. Az előző három pont együttes fennállása esetén. (Próbáljuk meg átírni a fenti programot úgy. Ha a leállás valamilyen logikai értéket szolgáltató kifejezés eredményétől függ. Ha bármelyik rész-feltétel. A második ciklusban. A tömb többi értékét nem vizsgáljuk. a ciklusváltozó kezdőértéke a k-1. Amennyiben nem tudjuk meghatározni a ciklus ismétléseinek a számát (futás közben dől el). illetve VAGY kapcsolatba hozni egymással. Az értékét nem növeljük. hogy mikor célszerű logikai. hogy az ismétléseket addig kell végezni. A while ciklus ekkor addig fut. mert az átváltandó számjegy a 8. logikai értékeket célszerű ÉS.kuruc. a ciklus szempontjából azt jelenti. Ebből az következik. míg a feltétel minden része igaz.info) Az első while ciklus feltétele a (szam!=0). míg a szam változó értéke nullától nagyobb. Több leállási feltétel együttes használatakor.

A feltételes elágazásban a d=5 feltétel teljesülése esetén a break utasítás állítja meg a while ciklust. A continue A CONTINUE utasítással visszaadjuk a vezérlést a while ciklus feltételére. a második viszont hibásat. ahol mindkettőt használnunk kell egy kifejezésen belül. hogy a feltételek összekapcsolására && vagy || operátort használunk. a futása akkor áll meg. vagy rossz helyen történő alkalmazása nehezen észrevehető hibákat eredményez. s ez hibához vezet. vagyis a ciklus soha nem áll meg. Ügyeljünk a megfelelő zárójelezésre. Az alábbi ciklus feltétel részébe a true értéket írtuk. Ritkán használjuk. amit általában egy feltétel teljesüléséhez kötünk.info) hamis lesz. Ez a 79. vagy ha megtaláljuk a nulla elemet.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Ekkor a continue utáni rész teljesen kimarad az aktuális lefutáskor. Mindig gondoljuk végig. ha az i értéke eléri a tömb elemszámát. ami azt jelenti. A break A C# nyelvben a while ciklusból ki lehet ugrani a BREAK utasítással. Az első jó eredményt fog szolgáltatni. oldal a 242-ből www. Vizsgáljuk meg az alábbi két ciklust. A zárójelek elhagyása. A rosszul felírt zárójelek miatt a fordító először a (10 && a) részt értékeli ki. de mindenképpen meg kell ismerkednünk vele. Az ÉS kapcsolat. hogy megáll.kuruc. Az alábbi két formula közül az első helyes eredményt produkál. vagyis az && operátor használatakor ügyeljünk a megfelelő zárójelezésre és a precedencia szabályra. és az ismétlés befejeződik. mivel abban szándékosan elrontottuk a zárójelezést. hogy a feltétel mindig igaz. A második ciklus nem biztos.kuruc.info . Vannak olyan problémák.

Amíg a feltétel igaz. A folyamatábrán jól látszik. Az ismétlés akkor áll meg. hogy jobban megértsük a működését. Ennek érdekessége az. ha hamissá válik. ha a c karakter típusú változóba a ”v” értéket adja meg a felhasználó. megáll. Amennyiben negatív szám érkezik az inputról.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. oldal a 242-ből www.info) A programrészlet egy tömb elemeinek billentyűzetről való feltöltését valósítja meg úgy. így egyszer mindenképpen végrehajtódnak a ciklus magjában definiált utasítások. de egyszer mindenképpen lefut. A következő példa egy lehetséges megvalósítását mutatja meg a hátul tesztelő do while ciklusnak. mivel a feltétel vizsgálata a ciklus végén van. hogy a ciklus magja egyszer mindenképpen lefut. a ciklus fut. Ez a 80.info .kuruc. A do while ciklus A ciklusutasítás következő típusa a hátul tesztelő változat. hogy negatív számokat nem fogad el.kuruc. hogy a ciklusbanmaradás feltétele a ciklus utasításai után szerepel. A do while ciklust is érdemes felírni folyamatábrával. a continue visszadobja a vezérlést a ciklus elejére.

s minden olyan probléma megoldásánál. Ez a program-részlet több utasításból áll. vagy alulindexeljük a gyűjteményt. mellyel a tömböt.info) Ahogy a fenti példa is mutatja. Fontosak a szöveges információk kezelésénél. és az összetett adat szerkezetekkel még nem foglalkoztunk. szükség van egy ciklusváltozóra. mely képes a gyűjtemények. de a foreach-et pontosan arra találták ki. hogy ez nem logikai ciklus. melynek az értékét növelnünk kell. Természetesen a fenti program részletet for. a do while ciklust jól használható ellenőrzött. vagy gyűjteményt indexelnénk. Ez azt jelenti. hogy az prímszám-e! (Prímszámok azok a 1) 2) 3) 4) 5) Ez a 81. és nincs szükség ciklusváltozóra sem. Ráadásul a foreach használatakor nem fordulhat elő. Igaz. Programozási feladatok Írjon programot. A foreach Van egy speciális ismétlés. oldal a 242-ből www. és a kezdőértékről is gondoskodnunk kell. majd kiírja a képernyőre az intervallumba eső egész számok közül azokat. Az aktuális tömb elem a c változóból olvasható ki. A feltétel vezérelt ciklusokat a programozás számos területén használjuk. amikor az iterációt for ciklussal nem lehet.info . hogy ne kelljen figyelni a tömb elemszámát és a tömb elemeit se kelljen a programozónak indexelnie. mely beolvassa a billentyűzetről egy intervallum kezdő és végértékét.kuruc.kuruc. hogy túl-. vagyis mikor végigjárta a tömböt. A következő példában a while ciklussal felírt változatot láthatjuk. vagy while ciklussal is megvalósíthattuk volna. hogy az csak a páros számokat írja a képernyőre! Írassa ki a képernyőre az első n egész szám összegét! Írassa ki a képernyőre az első n egész négyzetszámot! Írjon programot. vagy nem célszerű megvalósítani. a foreach. melyek 3-mal és 5-tel is oszthatóak! 6) Állapítsa meg a felhasználótól beolvasott számról. hogy nem szükséges ciklusutasítást szerveznünk. Az ismétlés az utolsó elem kiírása után áll le. a fájlkezelésnél. de a teljesség kedvéért vizsgáljuk meg ezt a típust is! A foreach általános formája a következő: A példában a foreach sorra veszi a t tömb elemeit. mely kiírja a képernyőre az első tíz egész számot visszafelé! Alakítsa át az előző programot úgy. vagy végjelig történő beolvasásra. vagy a tömbök végigjárására.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.

info .) 7) Keresse meg az első n darab prímszámot! 8) Készítsen programot.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. oldal a 242-ből www. Az éppen beolvasott számnak írja ki a négyzetét. Ez a 82. 9) A felhasználótól beolvasott számot a program váltsa át kettes számrendszerbe! 10) Programja olvasson be a billentyűzetről egész számokat egy meghatározott végjelig (legyen a végjel -999999). majd meghatározza a számok átlagát. mely beolvassa a billentyűzetről az egész számokat egy meghatározott végjelig. mely beolvas n db számot a billentyűzetről. 11) Írjon programot.kuruc.info) számok. melyek csak önmagukkal és eggyel oszthatóak. mely kiírja az első n db páros szám összegét a képernyőre! 12) Készítsen programot. majd a végjel beolvasása után írja ki a legnagyobbat és a legkisebbet a kapott értékek közül.kuruc.

Fejezet „Szelekció emelt szint!” Radványi Tibor Ez a 83.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. oldal a 242-ből www.info .kuruc.kuruc.info) Programozás tankönyv IX.

kuruc. Az utolsó else ág elhagyható. Ha az első feltétel nem teljesül. ha egyik feltétel sem teljesült. A többágú szelekció folyamatábrája: Egymásba ágyazott if utasítások sorozatával tudjuk megvalósítani a fenti szerkezetet. valakinek az életkorát. klasszikus példát. Feladat: Olvassunk be egy nemnegatív egész számot. akkor a második feltétel kiérétkelése következik. Hogyan valósítjuk ezt meg C#-ban? Ehhez nézzünk egy egyszerű. A végrehajtás legfeljebb egy igaz ágon fog futni. oldal a 242-ből www.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. és kortól függően írjuk ki a megfelelő szöveget: 0 .59 évig: felnőtt 60 -: idős Ez a 84.info) Szelekció haladóknak A szelekciónak több ága is lehet.info . vagyis ha az egyik feltétel teljesül.23 évig: ifjú 24 . Az ábra szerint az Utasítás-4 akkor kerül végrehajtásra. akkor a többit már nem kell vizsgálni sem.kuruc. És így tovább.13 évig: gyerek 14 . Ilyenkor a feltételek közül legfeljebb EGY teljesülhet.17 évig: fiatalkorú 18 .

oldal a 242-ből www. akkor a default ág kerül végrehajtásra.info . Egy egyszerű felhasználás: Ez a 85.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Default: Ha egyetlen case feltétel sem teljesül.info) A többágú szelekció másik megoldása a SWITCH utasítás.kuruc. akkor a belépési ponttól számítva a további case-eket is feldolgozza.kuruc. Ha elhagyjuk. Kifejezés: egész típusú. vagy string kifejezés. Ugrás: Kilép a vezérlés a case-szerkezetből.

stringek felhasználásával is: Feladat: Olvassunk be egy hónap és egy nap sorszámát! Írjuk ki. oldal a 242-ből www.kuruc.info) Ugyanez feladat megoldható konvertálás nélkül.kuruc.info . ha a beolvasott számok nem jó intervalEz a 86.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.

A február legyen 28 napos. oldal a 242-ből www. Első. amikor a hónap megfelelő. és a harmadik lehetőség.kuruc. de a nap nem helyes.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Ez a 87.info .info) lumba esnek. Megoldás: Nézzük a lehetséges futási eredményeket. második. amikor minden rendben.kuruc. amikor a hónap száma nem jó.

9 Jó reggelt. 8.kuruc.info) További megoldásra ajánlott feladatok 1. Kati.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Köszönjön a program a napszaknak megfelelően. Először az idősebbeket. Adjon meghárom diszjunkt intervallumot. illetve a párosak közül mennyit követett közvetlenül páratlan szám. Olvassunk be egy számsorozatot. és írja ki hogy melyik intervallumba esik. 22 . Olvassa be Zsófi. amelyek indexe prímszám. oldal a 242-ből www. 5. Elemei közül válogassuk ki azokat. 4 . 10 . Határozzuk meg az A(N) vektor elemeinek összegét úgy hogy a páratlan értékű elemek a (-1) szeresükkel szerepeljenek az összegben. Adott egy természetes számokat tartalmazó vektor. Adott N ember neve. Eztán olvasson be egy számot. Olvasson be egy egész óra értéket.kuruc. 18 . 6.21 Jó estét.17 Jó napot. hány pozitív érték van a vektor azon elemei között. Adott egy A(N) vektor. személyi száma. Juli születési évét. nulla. 9. hogy ezek közül hány darab volt páros. 2. Válogassuk ki a halak csillagképben született férfiak neveit (február 21 .március 20). Ez a 88. Írja ki a neveket udvariassági sorrendben. 4. majd számoljuk meg hogy ezekből mennyi a negatív. Számoljuk meg. A negatívokat és a pozitívokat rakjuk át egy másik sorozatba. 3. 7. Egy dobókockával 100-szor dobunk. pozitív.3 Jó éjszakát. melyek relatív prímek a 15-höz.info . Adjuk meg.

Fejezet Stringek kezelése Király Roland Ez a 89.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info) Programozás tankönyv X. oldal a 242-ből www.info .kuruc.kuruc.

kuruc. mivel vannak metódusaik. így nem értelmezhetőek rá a numerikus típusoknál használt operátorok. tulajdonságaik. oldal a 242-ből www. escape-szekvencia (VÉDŐKARAKTER).-formában. viszont a rendszer megpróbálja értelmezni. hogy a C alapú nyelvekben a \ (backslash) karakter ún. (A fejezet későbbi témáinál kitérünk a + operátor működésére. A relációk használata kisebb megkötésekkel a string-eknél is megengedett. hogy a fent szereplő értékadásban (s="1234567890") számok sorozatát adtuk értékül az s string típusnak. hanem ún. mivel a \h-nak nincs jelentése.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Az összehasonlításokat elvégezhetjük logikai kifejezésekben.: karakterlánc. Az s változóban szereplő értékkel ebben az esetben nem számolhatunk. Az s="C:\hello" karakter sorozat hibás eredményt szolgáltat. akkor induláskor ’null’ értéke van. Ilyen esetekben vagy s="C:\\hello" vagy s=@"C:\hello" formulát használjuk! Az első megoldásban az első \ jel elnyomja a második \ jel hatását. a következő megoldást használhatjuk: Ezzel a metódussal össze tudjuk hasonlítani két string értékét.info) A string típusú változó A C#-ban. vagy > relációba hozni egymással (s[1]<s[2]). Ha egy string-nek nem adunk értéket. Hasonlóan a többi változóhoz. vagy a kiíró utasításokban. a teljes stringre viszont csak a != és a == relációkat alkalmazhatjuk. ha elérési útként szeretnénk felhasználni. Adhatunk nekik értéket: Kiolvashatjuk. vagy s=String. Az OOP nyelvekben a stringekre osztályként tekinthetünk.kuruc. A második megoldásnál a @ jel gondoskodik arról. hogy az utána írt string a "C:\hello" formában megmaradjon az értékadásnál.literálként. Igaz. Az üres string-et vagy s="". de dolgozni úgy tudunk velük. a string-eket is deklarálni kell.Empty-formában jelezhetjük. elágazások és logikai ciklusok feltételrészében. Ha mégis szeretnénk összehasonlítani két string-et. mely a többi osztálynak. hogy a + művelet értelmezhető a string-ekre is. mint minden magas szintű nyelvben. vagy éppen a képernyőre írhatjuk a bennük tárolt adatokat: Figyeljük meg. A következő példa ezt be is mutatja: Ez a 90. mint az összes többi programozási nyelv string típusával.info . létezik a STRING típus. de működése eltér a számoknál megszokottól. mert az nem numerikus értékként tárolódik. és minden olyan paraméterük. A string-ek egyes elemeit tudjuk <.) Fontos megemlíteni.

oldal a 242-ből www.kuruc. mint 0. mint a Pascal nyelv pos(). Az Objektumorientált megközelítés előnyei jól nyomon követhetőek a string típus esetében. A string-eket is használhatjuk konstansként.: a szóközök eltávolításáról. Ahogy azt már említettük. Ha a kapott érték kisseb. akkor az str1 ABC sorrendben előbb van az str2-nél. mert nem a programozónak kell gondoskodnia pl. A program futása a következő: Ez a 91. vagy copy() eljárásainál.info . Ugyanúgy definiáljuk őket.kuruc. mint 0. akkor str2 van előbb. A következő példaprogram bemutatja a string-ek használatának néhány lehetőségét. és nem kell külső rutinokhoz folyamodnia. Ez némiképp megkönnyíti a használatukat. hogy rendelkezzen saját metódusokkal. mint a cde. Az egységbezárás lehetővé teszi.info) A két string egyenlősége esetén a visszatérési érték 0. mint bármely más osztály. ha nagyobb. A példában a második if feltétele teljesül. a kis és nagybetűs átalakításról. mint a többi típus állandóit. C# nyelvben a string-ek is rendelkeznek metódusokkal.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. a keresés metódusainak definiálásáról. mivel az abc karaktersor előbb szerepel a sorrendben.

hogyan használhatjuk az IndexOf() metódust.. A ToUpper() és a ToLower() metódusokkal a kis. oldal a 242-ből www. A keresés művelete is szerepel a metódusok között.’) zárják közre. hogy a tényleges tartalom alapján döntsünk.info .konstanssal.kuruc. hogy az adott string-hez jobbról és balról is hozzáfűzhetünk más string-eket. s=”a fa alatt”+s. Ez azt jelenti. Arra is figyelni kell. vagyis a kezdő indexét jelenti a keresett karakternek. a képernyőre írja a mondatot. Gyakori hiba. míg a TrimStart() és TrimEnd() metódusok paramétereit aposztrófok (’. ezért a vizsgálat előtt a beolvasott adatokat nagybetűssé alakítjuk. Amennyiben a fenti értékadásban szereplő változót és konstanst felcseréljük.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. hogy a kettőt felcseréljük. A string-ből kimásolhatunk részeket a Substring() metódussal. ha a paraméter listájában megadott karakter. Mivel a stringek 0. A következő metódus a TrimEnd(). Az eredmény: ”alma a fa alatt”. A paraméterezéskor ügyeljünk arra. a szót és azt. vagy karakterláncnak. találat esetén 0-tól a string hosszáig kaphatunk visszatérési értéket. TrimEnd() és a Trim() metódusuk paraméterek nélkül a string elejéről és végéről levágják a szóközöket. mivel a karakterek nem kezelhetőek stringként és fordítva.) A TrimStart(). Ez a 92.”) közé tettük.info) Az első WriteLine-ban az s string TrimStart() metódusát használtuk. de ilyenkor öszefűzésről beszélünk. mely eltávolítja a szöveg elejéről a paraméter listájában megadott karakter összes előfordulását. (Az aaalma string-ből az lma stringet állítja elő.. Az IndexOf() függvény -1 értéket ad vissza. eredményül az ” a fa alattalma” karaktersort kapjuk. A program beolvas egy tetszőleges mondatot és az abban keresendő szót. akkor az adott indextől a string végéig az összes karaktert kimásoljuk. és a másolandó karakterek számát. hogy a szó szerepel-e vagy sem a mondatban.és nagybetűs átalakításról gondoskodhatunk. a másodikban karaktert definiáltunk. kiegészül a + jel után írt sring. ahonnan kezdjük a másolást. A stringek-re a + műveletet is értelmezhető. hogy az s=”alma” utasításnál a string-et macskakörmök (”. hogy a string első eleme a 0. mivel az első esetben string-et. Ha a Substring() csak egy paramétert kap és a paraméter értéke belül van a string index tartományán. Ilyenkor a fordító hibát jelez. A C# nyelv kis-nagybetű érzékeny (case-sensitive).. hogy mindig csak akkora indexet adjunk meg.kuruc. az utolsó pedig a karakeszám-1. Ez a string végéről vágja el a megadott karaktereket.tól vannak indexelve. indexű elem. Amennyiben a szó szerepel a mondatban. Vegyük észre. 0. Amennyiben a fenti példában szereplő s stringek közé a + operátort írjuk. ahány eleme van a string-nek. vagy pozitív értéket. A következő példa bemutatja. ami a találat helyét. melynek paraméter listájában meg kell adni a kezdő indexet. ha szerepel. akkor: az s tartalma megváltozik.. vagy karaktersorozat nem szerepel a string-ben. A következő példa megmutatja a Substring() használatát.

A problémára több megoldás is létezik. de az Output-ja nem tökéletes. majd a program végén az eredeti változók tartalmát írjuk ki a képernyőre. azok tartalmát segédváltozókban tároljuk. mint a karaktereket tartalmazó tömbökre. Az egyik. hogy az eredeti változókat megőrizzük.kuruc. majd ezt a formáját írja vissza a képernyőre. műveleteket végezhetünk velük. Hivatkozhatunk rájuk elemenként. mivel az eredeti mondatot nagybetűsre alakítja. és ezekben átmásolni az eredeti változók tartalmát…) A string-ek mint vektorok A stringek kezelhetőek vektorként is.info . Nincs más dolga.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. csak két újabb változót bevezetnie. a felhasználó által begépelt kisnagy betűket vegyesen tartalmazó forma helyett.kuruc. amiket átalakíthatunk nagybetűssé. (Ezen megoldás elkészítése a kedves Olvasó feladata. A hossz tulajdonság a string-ben szereplő karakEz a 93. majd a ciklus magjában mindig az aktuális elemet írattuk ki a képernyőre. oldal a 242-ből www.info) A program futásának eredménye: A programunk megfelelően működik. A fenti példában a string Length tulajdonságával hivatkoztunk a hosszára.

működése megegyezik a matematikai logikából ismert kizáró-vagy operátorral. vagy a karakterláncot. Az értékadás akkor válik helyessé. ahova szeretnénk beszúrni. az utolsó elem indexe. A titkosításhoz a XOR (kizáró-vagy) operátort használjuk fel.info . Ezt a következő példán keresztül be is láthatjuk.) A C# nyelvben a XOR műveletet a(z) ^ karakter jelenti. mivel az s-nek elfogytak az elemei. értékadó utasítás eredménye a következő hibaüzenet jelenik meg: Vagyis a két típus nem kompatibilis.kuruc. Az s=s[1]. Ennél az értékadásnál már nem kapunk hibaüzenetet.Length) a ciklus végén hibaüzenetet kapnánk. eleme. a string egy eleme karakter. Az értékadás eredménye az s 1-es indexszű eleme. (Amennyiben a titkosított szöveget egy változóban tároljuk. vagyis az s[i]. A fenti programrészlet eredményeként az s változó tartalma az alábbi érték lesz: A következő példa megmutatja. Amennyiben a for ciklusban egyenlőség is szerepelne (i<=s.: rész string-eket szúrhatunk be az Insert() metódus segítségével. Ezt túlindexelésnek nevezzük.ne kövessük el!) Az s string i. (A titkosításhoz és a visszafejtéshez érdemes függvényt készíteni. a XOR újbóli alkalmazásával a string eredeti állapotát kapjuk vissza. (Gyakori hiba kezdő programozóknál . az ilyen típusú műveletek kellő körültekintést igényelnek. A string-ekbe ún. vagyis az aktuális indexelt elem karakter típus. Annak ellenére. hogyan tudunk tetszőleges szöveget a felhasználó által megadott kulcs segítségével titkosítani. A következő példa bemutatja az Insert() metódus használatát. A 0. mivel karakterek sorozatából épül fel.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info) terek számát adja vissza. hogy a string-ek elemenként is olvashatóak. ha az s[1] elemet konvertáljuk string-gé. a length-1. oldal a 242-ből www. A paraméter listának tartalmaznia kell az indexet.kuruc.) Ez a 94. Az értékadásoknál inkább használjuk a típus megfelelő beszúró rutinját. és a karaktert. az első.

Természetesen a string-ek használatának még rengeteg finomsága létezik.kuruc. kódfejtő algoritmusok. Ezzel a megoldással értük el. mely megszámolja. és nagyon kevés olyan nyelv van. éljünk vele.info . Használhatjuk őket számrendszerek közti átváltások eredményének tárolására. mert megkönnyíti és meggyorsítja a programozást. típuskényszerítést alkalmaztunk. melyekhez nem találunk megfelelő ”méretű” változókat. de ahol megtaláljuk (ilyen a C# nyelv). A Kiíró utasításban ún. (Természetesen a titkosított szöveg visszafejtése lehetséges. szorzására. Programozási feladatok 1) Írja a képernyőre a következő string konstansokat: ”c:\alma”. oldal a 242-ből www. különösképpen igaz ez a fájlkezelő programokra. olyan nagy számok összeadására. hogy minden karakterét kizáró-vagy kapcsolatba hozzuk a felhasználótól kapott kulccsal. melyben osztályként használhatjuk. mivel a XOR eredményeként kapott érték nem karakter. hogy az inputként érkező mondatban hány darab ”a” Ez a 95. Sajnos nem minden programozási nyelv tartalmazza a string típust. Ez által az eredeti szövegből egy matematikai úton titkosított szöveget kapunk.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.: karakter statisztikák. ”c:\\alma”! 2) Írjon programot. hanem numerikus adat.info) A for ciklus kiíró utasításában a beolvasott szöveget alakítjuk át úgy. matematikus ismerősök ©.) A titkosítás eredményét az egyszerűség kedvéért nem tároltuk. számos módszer létezik rá. hogy a képernyőn nem az adott karakter kódja. csak kiírtuk a képernyőre. A string típus szinte minden komolyabb programban előfordul. pl. melyet az eredeti kulcs ismerete nélkül nem lehet viszszaállítani.kuruc. hanem maga a karakter látható.

a négy alap-műveletet tartalmazó kifejezést (1+2. hogy az input szövegben szerepelnek-e számok! Ez a 96. hogy hány darab van belőle. a nagybetűs karaktereket pedig kisbetűsre! 11) Két mondatról döntse el. hogy az visszafelé is ugyanazt jelenti-e! (Az ”Indul a görög aludni”.info) betű van! 3) Az előző programot alakítsa át úgy. oldal a 242-ből www. és azt. hogy a számlálandó betűt is a felhasználó adja meg! 4) Készítsen karakter statisztikát a felhasználótól beolvasott szöveg karaktereiről! A statisztika tartalmazza az adott karaktert. mivel azok a mondat elején nem szerepelnek.info .1*2. majd a kifejezés értékét írja ki a képernyőre! 10) A beolvasott mondat kisbetűit alakítsa nagybetűsre.6/2.) Ügyeljen a mondatvégi írásjelekre.) a billentyűzetről egy sring típusú változóba.kuruc. majd az így kapott szöveget írja ki a képernyőre! 13) Állapítsa meg. majd alakítsa szám típussá! 9) Olvasson be egy egyszerű.kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. hogy a szó szerepel-e a mondatban! 7) A beolvasott mondatról döntse el. a programnak akkor is megoldást kell adnia! 12) Az inputként beolvasott szövegben cserélje ki az összes szóközt a # karakterre. 5) Az input szövegből távolítsa el a szóközöket! 6) Olvasson be egy mondatot és egy szót! Mondja meg. hogy azonosak-e! Ha a kis és nagybetűk különböznek. stb. 8) Olvasson be egy számot egy string típusú változóba.43. vagy a ”Géza kék az ég” visszafelé olvasva is ugyanazt jelenti.

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. vazze!) Hernyák Zoltán Ez a 97. (Vagyis osszád meg osztá' szággyád szíjjee'. Fejezet Eljárások alapfokon Oszd meg és szedd szét.kuruc.info) Programozás tankönyv XI. oldal a 242-ből www...kuruc.info .

oldal a 242-ből www. A fenti példában az eljárás neve ’Információ’. elkülönített programrészletet ELJÁRÁSNAK nevezzük. és folytatódik tovább a program futása: Természetesen van rá lehetőség. önálló feladattal és névvel ellátott.). Az ilyen.info . van neve (azonosító). Az eljárás (egyelőre) ’static void’ legyen. és saját UTASÍTÁSBLOKKJA van (a ’{’ és ’}’ közötti rész). majd a végrehajtás visszatér a hívást követő utasításra.kuruc. a program áttekinthetetlen lesz. Az eljárásnak a visszatérésiérték-típusa kötelezően void. kiírás. Amennyiben a program adott pontján szeretnénk végre hajtani az eljárásban foglalt utasítássorozatot. úgy egyszerűen hivatkoznunk kell rá a nevével (eljárás indítása. E részfeladatoknak jól hangzó nevet találunk ki (pl. hogy ne csak a Main()-ből hívjunk eljárásokat. amennyiben nincsenek paraméterek.info) Hosszabb programok írása esetén amennyiben a teljes kódot a Main tartalmazza. lehetnek paraméterei. a Main fv-től elkülönítve írjuk meg. bekérés. amelyek önmagában értelmes részfeladatokat látnak el.kuruc. kigyűjtés. feltöltés. van törzse. stb. eljárás meghívása): Ekkor az adott ponton az eljárás végrehajtásra kerül. Mindenképpen javasolt a kód részekre tördelése. maximális elem megkeresése. és a zárójelpár megadása kötelező abban az esetben is.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. hanem az eljárásokból is van lehetőség további eljárásokat hívni: Ez a 98. listázás. Ennek során olyan részeket különítünk el. ezeket a program külön részén.

A szabály az. mindegy. Ez a 99.kuruc. Az OSZTÁLY (CLASS) mintegy csoportba foglalja az egy témakörbe. előtt. A sorrendjük azonban lényegtelen. vagy után írjuk le.kuruc. ezért érvényes az azonosító névképzési szabálya: betűvel vagy aláhúzással kezdődik.info) C#-ban az eljárások neve AZONOSÍTÓ. Az eljárások ’nem látják’ egymás változóit. E miatt a program felépítése a következő lehet: Az egyéb eljárásainkat ugyanabba a csoportba (osztályba) kell megírni. hogy a változók csak az őket tartalmazó blokk-on belül ’láthatók’. hogy közös osztályba (class) kerüljenek. feladatkörbe tartozó eljárásokat. változókat. illetve írhatjuk őket vegyes sorrendben is. aláhúzás karakterekkel folytatódhat (de nem tartalmazhat szóközt)! A C#-ban szabad ékezetes karaktereket is használni az eljárás-nevekben. Az eljárások egymás közötti sorrendje sem lényeges.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Hová írjuk az eljárásainkat? Az Objektumorientált programozás elvei szerint A PROGRAMOK ÉPÍTŐKÖVEI AZ OSZTÁLYOK. Ennek oka a változók hatáskörének problémakörében keresendő. található. A hatáskör megadja. vagyis A VÁLTOZÓK HATÁSKÖRE AZ ŐKET TARTALMAZÓ BLOKKRA TERJED KI. mint ahol a Main() fv. betűvel. oldal a 242-ből www. Ami fontos.info .és kódlapfüggő forráskódot eredményez. hogy a saját eljárásainkat a Main() fv. emiatt másik gépen másik programozó által nehezen elolvashatóvá válik a forráskód. hogy az adott változót a program szövegében mely részeken lehet ’látni’ (lehet rá hivatkozni). számjeggyel. függvényeket. A programok eljárásokra tagolása persze újabb problémákat szül. Minden változónévhez tartozik egy hatáskör. de nem javasolt .karakterkészlet.

A megoldás: ne itt deklaráljuk! Azokat a változókat. Ezt (hibásan) az alábbi módon reagálhatjuk le: Ekkor a ’Feltoltes()’ eljárásban is létrehozunk egy másik. mivel az ’a’ változó hatásköre a ’Main’ függvény belseje. Ezért hiába tesszük bele az ’a’ változóba a ’10’ értéket. A nevek azonossága ellenére ez két különböző változó.kuruc. azokat az eljárásokat összefogó osztály (class) belsejében. oldal a 242-ből www.info) A fenti kód hibás. amíg az ’a’ változót a Main() függvény blokkjában deklaráljuk. nem a Main()-beli ’a’ változóba. Ez a változó sajátja lesz a ’Feltoltes()’-nek. szintén ’a’ nevű változót. Ha mégis megpróbáljuk. kezdetű fordítási hibaüzenettel jelzi ezt nekünk.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. addig e változót más eljárásokban nem érhetjük el. Mivel az eljárásaink static jelzővel vannak ellátva. amelyeket szeretnénk megosztani az eljárásaink között. és nincs kivétel. majd írjuk Ez a 100. akkor a C# fordító a The name 'a' does not exist . de semmilyen kapcsolatban nem áll a ’Main()’ függvény-beli ’a’ változóval. ezen érték a ’Feltoltes()’ eljárásbeli ’a’ változóba kerül bele. Ha ezt elmulasztanánk.. Nézzünk egy összetett feladatot: kérjünk be egy tízelemű vektor elemeit billentyűzetről. két különböző adatterületen helyezkedik el. ezért mindaddig. akkor a static eljárások nem ’látnák’ a nem static változókat.info .kuruc. az ’a’ változóra a ’Feltoltes()’ eljárásban nem hivatkozhatunk.. ezért a közöttük megosztott változókat is ugyanúgy static jelzővel kell ellátni. Hogyan kell megosztani változókat eljárások között? Mivel a hatáskör-szabály szigorú. de az eljárásokon kívül kell deklarálni.

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. és a Main() függvény írja ki a képernyőre.kuruc. amely egy megosztott tömb elemeit generálja 100-900 közötti véletlen számokkal (a véletlen szám generálásához a System. a tényleges műveleteket eljárásokba szerveztük. amely egy megosztott tömb elemeit kéri be billentyűzetről. Figyeljük meg. oldal a 242-ből www.Random osztály példányát kell használni)! 4) Programozási feladat: Készítsünk olyan eljárást. hogy a Main() függvény nem tartalmaz lényegében semmilyen kódot. és ezen értéket berakja egy megosztott ’max’ nevű változóba! Ez a 101.info . amely egy megosztott tömb elemeit kéri be billentyűzetről. mert ezen változó értékét az ’OsszegSzamitas()’ eljárás számolja ki.info) ki a vektor elemeinek értékét a képernyőre egy sorban egymás mellé vesszővel elválasztva. de nem enged meg ismétlődést (két egyenlő értékű elemet nem fogad el)! 3) Programozási feladat: Készítsünk olyan eljárást. Feladatok: 1) Programozási feladat: Készítsünk olyan eljárást. Ezen túl meg kellett osztani egy ’osszeg’ nevű változót is. mert azt minden eljárás használta. de csak pozitív számokat fogad el! 2) Programozási feladat: Készítsünk olyan eljárást. és jól csengő nevet adtunk nekik: A változók között meg kellett osztani magát a tömböt. amely egy megosztott tömb elemei közül meghatározza a legnagyobb elem értékét. majd számoljuk ki és írjuk ki a képernyőre a vektor elemeinek összegét.kuruc.

Az ösvényt egy tömbben írjuk le. akkor is helyesen működjön a program! 19) Programozási feladat: Készítsünk olyan eljárást. amely egy ’a’ tömb elemeit 1-gyel lejjebb csúsztatja! Az ’a’ tömb régi legelső eleme legyen most a legutolsó (ciklikus csúsztatás)! 18) Programozási feladat: Készítsünk olyan eljárást. amely egy.info . feltöltött tömb elemeit mint halmazokat kezeli. amelyek párosak. A polinom együtthatóit egy ’a’ tömb tárolja! A polinom általános alakja a[0]*xn + a[1]*xn-1 + a[2]*xn-2 + . bemásolja egy ’b’ tömbbe. amely egy feltöltött tömb elemeinek ismeretében megadja a leghosszabb olyan szakasz elemszámát. ahol a 0 jelenti a tócsát. megosztott tömb alapján meghatározza. feltöltött tömb elemeit mint halmazokat kezeli. b: csökkenő sorrendbe vannak-e rendezve. hogy hány különböző érték szerepel a tömbben! Az eredményt egy ’kulonbozo_db’ nevű megosztott változóba helyezi el! 7) Programozási feladat: Készítsünk olyan eljárást. és elkészíti a két tömb különbségét egy ’kulonbseg’ nevű szintén megosztott tömbbe! Mekkora legyen ezen ’kulonbseg’ tömb mérete? 10) Programozási feladat: Egy ösvényen tócsák és száraz foltok váltogatják egymást. A maradék helyeket töltsük fel 0-kal! 16) Programozási feladat: Készítsünk olyan eljárást. hogy a sétáló képes-e átjutni az ösvény egyik végéből a másikba anélkül. a maradék elemeket pedig a ’b’ tömb végére! 17) Programozási feladat: Készítsünk olyan eljárást. amely egy megosztott tömb elemei közül meghatározza a legnagyobb elem sorszámát. amely egy ’a’ tömb elemeit fordított sorrendbe bemásolja egy ’b’ tömbbe! 15) Programozási feladat: Készítsünk olyan eljárást. Az x értékét az eljárás az ’x’ változóban találja meg.kuruc.. és elkészíti a két tömb unióját egy ’unio’ nevű szintén megosztott tömbbe! Mekkora legyen ezen ’unio’ tömb mérete? 8) Programozási feladat: Készítsünk olyan eljárást. c: rendezetlenek. feltöltött tömb elemeit mint halmazokat kezeli. amelyből a tömb elemek származnak! 14) Programozási feladat: Készítsünk olyan eljárást. amely egy feltöltött.. 12) Programozási feladat: Készítsünk olyan eljárást. az 1 jelenti a száraz foltot. amely két egyenlő hosszú ’a’ és ’b’ vektor szorzatát számítja ki ( szorzat=a[0]*b[0]+a[1]*b[1 ]+. amely két megosztott. + a[n].kuruc. Készítsünk olyan eljárást. oldal a 242-ből www.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. amely egy polinom helyettesítési értékét számolja ki. Egy arra járó sétáló maximum 4 egymás melletti tócsát képes átugrani egyszerre. egész számokkal feltöltött ’a’ tömb elemei közül azokat. amely egy megosztott tömb elemeit végigolvasva megadja. amely egy ’a’ tömb elemeit n-nel lejjebb csúsztatják ciklikusan! Az ’n’ értékét szintén egy megosztott változóból vegye ki az eljárás (n=0 esetén az elemek helyben maradnak. amely két megosztott. amely két megosztott. hogy a tömb elemei a: növekvő sorrendbe vannak-e rendezve. amely egy ilyen tömbalapján meghatározza. n=1 esetén előző feladat)! Ha az n értéke nagyobb. és ezen értéket berakja egy megosztott ’maxi’ nevű változóba! 6) Programozási feladat: Készítsünk olyan eljárást. A számítás gyorsítására használjuk fel a Horner elrendezés adta előnyöket! Ez a 102.. hogy tócsába kellene lépnie! 11) Programozási feladat: Készítsünk olyan eljárást. amely egy feltöltött tömb elemeinek ismeretében megadja azt a legszűkebb intervallumot. és elkészíti a két tömb metszetét egy ’metszet’ nevű szintén megosztott tömbbe! Mekkora legyen ezen ’metszet’ tömb mérete? 9) Programozási feladat: Készítsünk olyan eljárást. amely egy ’a’ tömb páros elemeit átmásolja egy ’b’ tömb elejére.info) 5) Programozási feladat: Készítsünk olyan eljárást. +a[n]*b[n] )! 20) Programozási feladat: Készítsünk olyan eljárást. ahol a tömb elemek növekvő sorrendben vannak! 13) Programozási feladat: Készítsünk olyan eljárást. mint a tömb elemszáma..

kuruc. oldal a 242-ből www.kuruc..info . Fejezet Függvények írása Számold ki és ide vele..C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Hernyák Zoltán Ez a 103.info) Programozás tankönyv XII.

info . hogy milyen típusú értéket adnak majd vissza. hiszen az ’OsszegSzamitas()’ már nem ilyen módon közli az eredményt a Main() függvénnyel. hogy ezen értéket a függvényt meghívó programrész fogadja. hanem egyszerűen visszaadja azt. feldolgozza. A függvények ezek után kötelesek minden esetben egy ilyen típusú értéket vissza is adni! A függvény visszatérési értékét a ’return’ kulcsszó után írt kifejezésben kell feltüntetni. Ebben a formában a program már nem kell. melyből később ki tudja írni a képernyőre ezen értéket. hogy a sum változóban szereplő értéket (ami int típusú) adja vissza. Amennyiben egy másik programba szeretnénk ezt a függvényt áthelyezni. Amennyiben ezt eljárás segítségével oldjuk meg. oldal a 242-ből www. hogy egy értékekkel már feltöltött tömb elemeinek összegét kell kiszámítani. ezt jelöljük a típusnévvel: int. Ez a 104. melynek PONTOSAN EGY VÉGEREDMÉNYE is VAN . Pl: FÜGGVÉNY rokonfogalom az eljárással .egy apró különbséggel. A függvény saját változót használ fel segédváltozóként (sum) a számítás során. hogy megosszon ’osszeg’ változót. Ezt a függvény neve előtt kell feltüntetni (a ’void’ helyett). ezért gondoskodni kell róla.kuruc. Ez sokszor nem túl szerencsés megoldás. mint az eljárások hívása. úgy vele együtt kell mozgatni a megosztott változót is. A fenti részben e függvény egy egész számot fog visszaadni. A FÜGGVÉNY EGY OLYAN ELJÁRÁS.EGY ÉRTÉK. Amennyiben az a részfeladat. Az ilyen jellegű feladatokat megoldó alprogramokat FÜGGVÉNYEK formájában írjuk meg. Amennyiben függvényt akarunk írni. a végeredmény EGYETLEN SZÁMÉRTÉK. majd a függvény végén a return sum-mal jelöli. KÉT fontos dolgot kell szem előtt tartanunk: A függvényeknél rögzíteni kell.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. A függvények meghívása hasonlóan történik. mert a függvény kötődik ezen megosztott változó nevéhez. Itt a meghívóponton az OsszegSzamitas() függvény által visszaadott értéket a meghívó rögtön eltárolja egy ’osszesen’ nevű változóba. Csak mivel a függvény vissza is ad egy értéket.info) A AMELY OLYAN RÉSZFELADATOT OLD MEG. mint visszatérési értéket. úgy a végeredményt egy megosztott változóba kell elhelyezni.kuruc.

fejezetben felsorolt eljárások legnagyobb részét át lehet írni függvényekre.értékekkel már feltöltött .C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info) A 11. Vegyük például a maximális elem értékének meghatározását. oldal a 242-ből www.tömb elemei között. E függvény a megosztott ’tomb’ elemei közül keresi ki a legnagyobb elem értékét. A ’return false’ utasításra már csak akkor jut el a függvény. ezért a ciklus további futtatása már felesleges .info .kuruc. Ekkor a kérdésre a válasz a false érték. akkor az alábbi függvényt írhatnánk meg: A fenti függvényben kihasználjuk azt. úgy a keresett érték szerepel a tömbben.kuruc. ha az egyenlőség egyszer sem teljesült. hogy egy adott érték szerepel-e egy . A fenti függvény meghívása a következő módon történhet: Ez a 105. hogy a ’return’ kulcsszó hatására a függvény azonnal megszakítja a futását. Amennyiben az egyenlőség teljesül. és visszatér a hívás helyére.megvan a keresett válasz. Meghívása az alábbi módon történhet meg: Amennyiben azt szeretnénk ellenőrizni.

oldal a 242-ből www. amely eldönti egy számról. a megfelelő időpontban meghívjuk a Feltoltes() függvényt.kuruc. amely megszámolja. hogy prímszám-e! 5) Programozási feladat: Készítsünk olyan függvényt. feltölti elemekkel a billentyűzetről. 10 elemű tömböt a memóriában. amely egy téglalap két oldalának ismeretében kiszámítja a téglalap területét! 2) Programozási feladat: Készítsünk olyan függvényt. Feladatok: 1) Programozási feladat: Készítsünk olyan függvényt.info . amely meghatározza két szám legnagyobb közös osztóját! 3) Programozási feladat: Készítsünk olyan függvényt.info) Más módja. Majd a Main() függvény belsejében. hogy egy adott érték hányszor szerepel egy tömbben! Ez a 106. akkor azt az alábbi módon kell megoldani: Ekkor a ’tomb’ változót először csak deklaráltuk. megadtuk a típusát.kuruc. amely eldönti egy számról. majd visszaadja a feltöltött tömböt az őt meghívónak: Amennyiben a feltöltött tömböt egy megosztott változóba szeretnénk tárolni.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. hogy a függvény visszatérési értékét rögtön az ’if’ feltételében használjuk fel: A függvények ennél bonyolultabb értékeket is visszaadhatnak: A fenti függvény létrehoz egy int-ekből álló. és az általa elkészített és feltöltött tömböt betesszük a megosztott változóba. hogy hány osztója van! 4) Programozási feladat: Készítsünk olyan függvényt.

amely meghatározza két megosztott tömb elemeinek ismeretében a különbségük elemszámát (hány olyan elem van a két tömbben összesen. amely meghatározza egy tömbben hány 3-al osztható. oldal a 242-ből www.kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info .info) 6) Programozási feladat: Készítsünk olyan függvényt. amely meghatározza egy tömb elemeinek átlagát! 9) Programozási feladat: Készítsünk olyan függvényt. amelyik csak az egyik tömbben van benne)! 8) Programozási feladat: Készítsünk olyan függvényt. amely meghatározza két megosztott tömb elemeinek ismeretében a metszetük elemszámát! 7) Programozási feladat: Készítsünk olyan függvényt. de 5-el nem osztható szám van! Ez a 107.kuruc.

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.info)

Programozás tankönyv XII. Fejezet

Eljárások és függvények
KÖZÉPFOKON

Hernyák Zoltán

Ez a 108. oldal a 242-ből www.kuruc.info

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.info) Amikor eljárást (vagy függvényt) írunk, az alprogram törzsében sokszor hivatkozunk ilyen megosztott (KÖZÖS) változókra. E változókban az eljárás a program előző részei által előállított adatokat kap meg, vagyis BEMENŐ ADATOKAT fogad. Az eljárás ezen adatok segítségével újabb értékeket állíthat elő, melyeket elhelyezhet megosztott változókban, ahol a többi eljárás megtalálhatja őket. Így állít elő az eljárás KIMENŐ ADATOKAT. Bemenő adatokat az eljárás azonban nemcsak a megosztott változókban vehet át, hanem paraméterekben is. A paramétereket az eljárás fejrészében kell feltüntetni. Fel kell sorolni vesszővel elválasztva a bemenő adatok típusát, és egy azonosítót (nevet) kell adni ezen adatoknak. Ezt a listát FORMÁLIS PARAMÉTERLISTÁNAK hívjuk. Pl:

A fenti példában ezen eljárás két bemenő értéket vár. Mindkettő ’int’ típusú, vagyis egész számok. Az eljárás törzsében a paraméterekre a formális paraméterlistában feltüntetett azonosítókkal (név) hivatkozhatunk. A fenti eljárás kiírja a két számot a képernyőre, majd a két szám összegét is. Amikor ezen eljárást meg akarjuk hívni, akkor ezen eljárásnak a fenti bemenő adatokat át kell adni. A hívás helyén feltüntetett paraméterlistát (mely az aktuális bemenő adatok értékét tartalmazza) aktuális paraméterlistának hívjuk. Aktuális paraméterlistában már sosem írunk típusokat, hanem konkrét értékeket!

A fenti kódrészlet elindítja a Kiiras eljárást, átadván neki a két bemenő adatot. Az eljárás elindulása előtt feltölti a paraméterváltozókat az aktuális értékekkel (a=12, b=15), majd utána kezdődik az eljárástörzs utasításainak végrehajtása.

Bizonyos szempontból nézve a formális paraméterlista egyúttal változódeklarációnak is minősül, hiszen a formális paraméterlistában lényegében típusok és nevek vannak megadva. Az eljárás törzsében ezekre a paraméterekre mint adott típusú változókra hivatkozhatunk. Ezen változók kezdőértékkel rendelkeznek, a kezdőértékeket az aktuális paraméterlistában adjuk meg. Ennek megfelelően az aktuális és a formális paraméterlistára szigorú szabályok vonatkoznak: az aktuális paraméterlistában pontosan annyi értéket kell felsorolni, amennyit a formális paraméterlista alapján az eljárás vár tőlünk, az aktuális paraméterlistában pontosan olyan típusú értékeket kell rendre megadni, mint amilyet a formális paraméterlista szerint az adott helyen fel kell tüntetni.

Ez a 109. oldal a 242-ből www.kuruc.info

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.info)

Megállapíthatjuk, hogy az aktuális paraméterlistában olyan értéket kell írnunk, amelynek a végeredménye jelen esetben ’int’ típusú. A hívás helyére írhatunk számkonstanst (LITERÁL - rögzített, állandó, nem változó értékek), kifejezést - melynek kiszámítása int-et eredményez, illetve változót is (ekkor a változó aktuális értékét adjuk át). A konstans (literál) és a változó is kifejezésnek minősül, csak egyszerű kifejezés. Ezért általánosan azt mondhatjuk, hogy az AKTUÁLIS PARAMÉTERLISTÁBAN olyan kifejezést kell írnunk, melynek típusa megfelel a formális paraméterlistában leírt követelményeknek. Ezt a típus-megfelelőséget a kompatibilis típusok szabályai írják le. Az OO nyelvekben a típuskompatibilitást is az OO szabályai írják le. Egyelőre annyit jegyezzünk meg, hogy az ’int’ kompatibilis a ’double’-lal, az ’int’-ek (sbyte, uint, int, ...) kompatibilisek egymással, csakúgy, mint a double típusok is (double, float), persze ha az aktuális érték a kívánt típusban az adott pillanatban elfér.

Ezen eljárás egy tetszőleges racionális számot vár, majd kiírja az adott szám felét.

Ebben az esetben az aktuális paraméterlistában nem egy tört, hanem egy egész számot adtunk át. Ez ugyan nem pontosan ugyanolyan típusú, mint amit a formális paraméterlistában leírtunk, de az aktuális érték (12) KONVERTÁLHATÓ (kompatibilis) a kért típusra.

Ezen példa szerint is az aktuális érték egy ’int’ típusú érték, de ez elfogadható, ha a fogadó oldalon akár ’double’-t is képesek vagyunk fogadni.

Ez a 110. oldal a 242-ből www.kuruc.info

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.info)

Értelemszerűen a küldő oldal (aktuális paraméterlista) hiába próbálná átadni a 12.5 értéket, a fogadó oldal (formális paraméterlista) csak egész típusú értéket tud átvenni. Ezért ezt a paraméterátadást a C# fordító nem engedi, még akkor sem, ha...

Ekkor hiába van a ’z’ változóban olyan érték, amelyet a fogadó oldal akár át is tudna venni, ez általános esetben nem biztonságos. A hívás helyére olyan típusú kifejezést kell írnunk, amely ennél több garanciát ad. Ezért nem engedi meg a C# fordító, hogy a típusok ennyire eltérjenek egymástól. Ennél persze bonyolultabb típusok is szerepelhetnek a formális paraméterlistában:

A fenti példában a ’Kiiras’ eljárás egy komplett tömböt vár paraméterként. A tömb elemei ’int’ típusú értékek kell hogy legyenek. A hívás helyére ekkor természetesen egy ennek megfelelő értéket kell írni:

Itt az ’x’ változó típusa ’int[]’, ami megfelel a fogadó oldali elvárásoknak, ezért a fenti eljáráshívás típusában megfelelő, így helyes is.

Feladatok:
1) Programozási feladatok: készítsünk olyan függvényt, amely kap paraméterként két számot, és visszaadja a két szám közül a nagyobbik értékét! Amennyiben a két szám egyenlő, úgy az első szám értékét kell visszaadni! 2) Programozási feladatok: készítsünk olyan függvényt, amely kap két int tömböt paraméterként, mindkét tömbben 3-3 szám van! A tömbök egy-egy háromszög oldalainak hosszát írják le! Adjuk vissza a nagyobb kerületű háromszög kerületének értékét! 3) Programozási feladatok: készítsünk olyan függvényt, amely meghatározza egy paraméterben megadott, int típusú tömbben a leghosszabb egyenlő elemekből álló szakasz hosszát! 4) Programozási feladatok: készítsünk olyan eljárást, amely egy megosztott tömböt feltölt véletlen elemekkel egy megadott intervallum elemei közül úgy, hogy két egyenlő érték ne forduljon elő a tömbben! Az intervallum kezdő és végértékeit paraméterként adjuk át!

Ez a 111. oldal a 242-ből www.kuruc.info

oldal a 242-ből www.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info .kuruc.kuruc. Fejezet Eljárások és függvények FELSŐFOKON Hernyák Zoltán Ez a 112.info) Programozás tankönyv XIII.

Az eljárás fogadja a tömböt a ’tomb’ változóban. amikor átadjuk a ’Feltoltes’ eljárásnak. Pl. A helyzet igen bonyolult mindaddig.info) Kérdés: tudunk-e a paraméterváltozókon keresztül értéket visszaadni? Erre sajnos a C#-ban nem egyszerű válaszolni. … …ekkor kiíráskor az ’x’ változó értéke még mindig 12 lesz. majd megváltoztatja a ’tomb’ elemeinek értékét. Mivel a paraméterátadás során a híváskori érték (12) átadódik az eljárás ’a’ változójába mint kezdőérték (a=12).. marad benne a 12. úgy nem tudunk értéket visszaadni a hívás helyére. Az érték egyszerűen ÁTMÁSOLÓDIK a fogadó oldal változóiba. az nem fogja befolyásolni az ’x’ értékét. string. úgy a helyzet megváltozik: A hívás helyén szereplő kis tömb még feltöltetlen.kuruc. ha a paraméter típusa tömb. Mint az ábrán is látszik. és nem zavarja.. nem változtatja meg az ’x’ értékét. akkor a tömbelemeken keresztül azonban igen. Amennyiben azonban a paraméterátadás-átvétel során tömböket adunk át. ezért az eljárás Ez a 113. . oldal a 242-ből www.) közül valamelyik.: Ha a fenti eljárást az alábbi módon hívjuk meg. és a fogadó oldalon szereplő ’a’ változó között minden további kapcsolat megszűnik. double. char. Ezért hiába teszünk az ’a’ változóba az eljáráson belül más értéket (a+b). az ’x’ aktuális értéke (12) átmásolódik a memória külön területén helyet foglaló ’a’ változóba. A fenti technikát ÉRTÉK SZERINTI PARAMÉTERÁTADÁSNAK nevezzük. de utána a hívás helyén szereplő ’x’ változó. Ezen változás azonban beleíródik a ’kisTomb’ által reprezentált tömbbe is.info .kuruc. amíg a referenciatípusú változókkal alaposan meg nem ismerkedünk.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Addig is használjuk az alábbi szabályokat: amennyiben a paraméterváltozók típusa a nyelv alaptípusai (int. hogy a kapcsolatot fenntartaná. E miatt az a=a+b értékadás eredménye is ezen a külön területen kerül tárolásra. Ekkor az aktuális paraméterlistában feltüntetett értéket a fogadó oldal átveszi .anélkül.

Az érték szerinti paraméterátadás során az érték az átadás pillanatában két példányban létezik a memóriában . Ezen másodlagos memóriaterületet a ’new’ hozza létre. . Ekkor a fogadó oldal megkapja a memóriaterület címét...) értékének képzésekor nem kell a ’new’ kulcsszót használni...info . hogy azok a változók lesznek referencia típusúak. Az nyelvi alaptípusok (int. hogy viszonylag nagy memóriaigényük van. double. . Egyelőre fogadjuk el szabályként. míg a fenti tömb tárolása 40 byte. akkor azt a küldő oldal is észlelni fogja majd: Ez a 114. char. Ezen memóriacím a másodlagos memóriaterület helyének kezdőcíme lesz.kuruc.info) lefutása után a kisTomb[0] értéke már 10 lesz. …de a tömböknél igen: Az ilyen jellegű változókat általában az jellemzi. Egy ’int’ típusú érték tárolása csak 4 byte.lemásolódik: A referencia típusú változók esetén azonban nem másolódik le az érték még egyszer a memóriában (ami a tömb esetén a tömbelemek lemásolását jelentené). és ha beleír ebbe a memóriaterületbe.kuruc. string. ezért nehéz felismerni. vagy egyéb jelzés. A referencia-típusú változóknál dupla memóriafelhasználás van. hanem csak a szóban forgó tárterület címe (memóriacíme) adódik át. amelyek esetén a ’new’ kulcsszót kell használni az érték megadásakor (példányosítás). oldal a 242-ből www.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Az elsődleges területen ilyenkor mindig egy memóriacímet tárol a rendszer. Az ilyen jellegű paraméterátadást REFERENCIA-SZERINTI ÁTADÁSNAK nevezzük! A referencia típus nem jelentkezik külön a változó deklarációja során mint külön kulcsszó.

A new foglalja le számára a memóriát.info . ez az. mely mint érték másolódik át a paraméterváltozókba. A bemutatott függvény paraméterként megkapja egy int típusú tömb kezdőcímét. úgy a változtatásokat a ’kisTomb’-ön keresztül is el tudjuk majd érni. Mivel a ’tomb’ változó is ismerni fogja a tömbelemek tényleges helyét a memóriában.amikor az eljárás már befejezte a futását. Mivel az eredeti változó is ugyanezen területre hivatkozik. majd visszaadja a terület kezdőcímét. Ezt a kezdőcímet általában egy megfelelő típusú változóban tároljuk el. és nem ténylegesen a tömb elemei. mint amit megkapott. Mivel a függvény ugyanazt a memóriacímet adja vissza.kuruc. oldal a 242-ből www. Figyeljük meg azonban a hívás helyét: Ez a 115. Az már más kérdés. de amennyiben erre nincs szükség. A tömb elemeit billentyűzetről tölti fel oly módon.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. akkor azt meg is változtathatja. A referencia-szerinti paraméterátadás is érték szerinti paraméterátadás. ami valójában átmásolódik a ’tomb’ váltózóba. A feltöltött tömb címét (referenciáját) visszaadja. hogy a ’kisTomb’ változónk aktuális értéke átmásolódik a ’tomb’ aktuális értékébe. hogy a tömbelemek értékének módosítása a fogadó oldalon maradandó nyomot hagy a memóriában .kuruc. Ez az oka annak. az értékek akkor is hozzáférhetőek. melynek végeredménye egy referencia: Az előzőekben bemutatott kifejezés létrehoz egy 20 elemű int tömböt. ezért a változásokat a küldő oldalon később észlelni. hiszen mindkét esetben ugyanazokra a tömbelemekre hivatkozunk a memóriában. a változó értéke ilyenkor egy memóriacím. Csakhogy a ’kisTomb’ értéke egy memóriacím. hogy csak pozitív számot fogad el. hogyha a fogadó oldal megkapja a terület kezdőcímét. úgy a memóriacímet tárolás nélkül átadhatjuk egy eljárásnak paraméterként. úgy a küldő oldalon csak olyan kifejezés szerepelhet. ezért amenynyiben megváltoztatja azokat.info) A fenti ábrán látszik. Amennyiben a fogadó oldalon referencia típusú paramétert fogadunk. (pl: kiolvasni) lehet. ennek nem sok értelme látszik.

kuruc. úgy azt jelölni kell: A fenti eljárás két értéket is előállít . majd visszaadja az immár feltöltött tömb címét. oldal a 242-ből www. hiszen a függvény db és osszeg paraméterváltozóinak kezdőértéke érdektelen.a páros tömbelemek számát és összegét. hanem rögtön átadjuk a függvények. Mivel ez már kettő darab érték. a függvény feltölti ezt a tömböt elemekkel. Az ÁTMENŐ PARAMÉTEREK egyidőben bemenő és kimenő paraméterek.kuruc. feltöltését. mert egy sorban oldja meg a tömb létrehozását. hanem az ’out’ kulcsszóval kell megjelölni! Ez a 116.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. hogy e paraméterek csak kimenő értékeket hordoznak. Ugyanakkor a ’ref’ kulcsszó ennél többet jelent . bemenő értékük érdektelen. Az eljárásban e paraméter értékét felhasználhatjuk. A tömb a hívás helyén készül el. úgy az alábbi módon kellene meghívni: Amennyiben egy alaptípusú paraméter-változón keresztül szeretnénk értéket visszaadni.a ’ref’ paraméterben értéket is adhatunk át az eljárás számára. Az ilyen paramétereket nem a ’ref’. Ez a fenti függvény esetén egyébként értelmetlen. A probléma forrása az.info) A hívás helyén a frissen elkészített tömb memóriacímét nem tároljuk el. Amennyiben a paraméterként átadott változók nem rendelkeznének értékkel a hívás pillanatában (definiálatlan változó). Az ilyen jellegű paraméterátadást CÍM SZERINTI PARAMÉTERÁTADÁSnak nevezzük. Ez a paraméter klasszikus átmenő paraméter. Ekkor a hívás helyén is jelölni kell. A fenti megoldás azért szép. Amennyiben a Feltoltes() csak egy eljárás lenne. üresen (csupa 0-val inicializálva). ezért nem írhatjuk meg függvényként. hogy az adott paraméterben értéket is vissza szeretnénk adni. úgy a C# fordító szintaktikai hibát jelez. és meg is változtathatjuk. hogy az átadott változóban kimenő adatokat várunk: A ’ref’ kulcsszóval kell jelölni.info . Egy függvény csak egy értéket adhat vissza.

hogy a hívás helyén (aktuális paraméterlistában) szereplő változóknak ’out’ esetén nem kötelező kezdőértéküknek lenniük. A ’ref’ esetén a függvényhívás előtt a változóknak kötelező értéket felvenni. ezért a ’ref’ kulcsszót kell használni.kuruc. és a függvényben kötelező értéket adni ezeknek a paraméterváltozóknak a függvény visszatérési pontja (return) előtt.info . A fenti eljárás kitűnően felhasználható egy rendezőeljárásban: Ez a 117. oldal a 242-ből www. ugyanis a paraméterek alapértelmezésben bemenő adatok. és a függvényben nem kötelező azt megváltoztatni.kuruc.info) A hívás helyén is: A ’ref’ és az ’out’ módosítók között az egyetlen különbség. A fenti eljárás a paramétereként megkapott két változó tartalmát cseréli fel. vagyis az ’in’ módosítót ki sem kell írni. Aki esetleg keresné. Mivel ilyenkor érdekes a paraméterek aktuális értéke is. Valamint egy ’out’-os paraméterváltozót a fordító kezdőérték nélkülinek tekint.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. ’in’ módosító nincs a C#-ban.

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info) Programozás tankönyv XIV.kuruc. oldal a 242-ből www. Fejezet „WinForm” Radványi Tibor Király Roland Ez a 118.kuruc.info .

mely eszköz segítségével a programjainkba hibakezelő (KIVÉTELKEZELŐ) kódrészleteket építhetünk. mivel a try a catch blokkhoz irányítja a vezérlést. A kivételkezelő eljárások lényege. a programunk leáll. de erről majd bővebben szólunk a fejezet későbbi részeiben. megakadályozzák a program leállását. hogy elkerüljük a futás közbeni hibák esetén felbukkanó hibaüzeneteket. A CATCH segítségével azokat a kivételeket kaphatjuk el.NET vagy az operációs rendszer veszi át. és megvédjük programjainkat a váratlan leállástól. melyek a try blokkban keletkeznek. ha nem használjuk a hibakezelő eljárásokat. Abban az esetben. melyek hiba esetén az általunk megírt hibakezelő eljárásokat hajtják végre. Ebből a példából is jól látható milyen nagy szükség lehet a kivételkezelőre. A catch blokkban definiált hibakezelő rész lefut.kuruc. A catch segítségével különböző hibák egyidejű kezelését is megvalósíthatjuk. és a hiba kezelését a . vagyis a képernyőn megjelenik a hibaüzenet. Most nézzünk meg egy példát a try használatára! Amennyiben futtatjuk a fenti programot. a hibakezelő eljárás elindul. és a beolvasásnál 20 karakternél rövidebb mondatot adunk meg. oldal a 242-ből www. A try és a catch A TRY parancs segítségével a programok egyes részeihez hibakezelő rutinokat rendelhetünk. Itt határozhatjuk meg. ha jól működő programokat akarunk írni.kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Fokozottan érvényes ez azokra a prograEz a 119.info . s ami nagyon fontos.info) A Windows Formok Hibakezelés A C# nyelv a futásidejű hibák kiszűrésére alkalmas eszközt is tartalmaz. hogy milyen rutinok fussanak le és hogyan kezeljék a felmerülő hibákat.

Ez azt jelenti. a hiba típusának meghatározására. értelmezhetetlen üzenetekkel terheljük. Talán még elismerően bólint is. A célunk sem az.kuruc. mert így nem teszünk többet. ha megállapítjuk a hiba okát. A catch hibakezelő rutinjait szintén kapcsos zárójelek közé kell írni. oldal a 242-ből www.info .. hogy a programunk használóját hosszú. majd a megfelelő hibakezelés aktivizálásával meg is szüntetjük azt.. melyek a program írásakor rejtve maradnak. amit az e. Sokkal jobb megoldás. működésbe lép a kivétel-kezelés.kuruc. hogy a try blokkban előforduló bármely hiba esetén ugyanaz a hibaüzenet jelenik meg a képernyőn. ahol a felhasználó adatokat visz be. ezzel jelezve a fordítónak. a catch blokkban elkapjuk a hibát és kiírjuk az okát a képernyőre. A következő programban erre láthatunk példát. melyből kiolvashatjuk a hiba okát. A catch parancs a kivételt paraméterként is fogadhatja.Exception típusú. mint az eredeti hiba-ablak.Message rutinnal kapunk meg. A programban látható. és a megfelelő hibakezelőt indíthatjuk el. A képernyőn megjelenő hibaüzenet nem nagyon beszédes. hogy a try után kapcsos zárójelek közt adjuk meg a hibát okozható program részletet.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. illetve gyakran túlságosan sok. hogy kiírjuk a képernyőre a hiba minden paraméterét. Amennyiben az inputról nem megfelelő adatok érkeznek. A paraméterként megadott változó System.. hogy hol kezdődik és végződik a hibakezelés. A fenti példában a túlindexelés és a típuskülönbségek mellett előfordulhatnak más hibák is. és a javított hibáért a felhasználó nem is haragszik annyira. (Ekkor még mindig ráérünk kiírni a képernyőre. mivel nem definiáltuk a lehetséges hibákat.) Ez a 120. ahogy a fenti példában láthattuk. A catch blokkban lehetőségünk van a különböző okok miatt keletkezett hibák szétválasztására.. hogy hiba történt. még annak ellenére sem. Az ilyen jellegű hibákra az előző kód nincs felkészítve. Ráadásul a felhasználó nem is nagyon tudja kezelni a keletkezett hibákat. nehezen érthető információt tartalmaz.info) mokra.

ha az általános hibák elé helyezzük azokat a hibákat.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. ha a program végzetes hibával áll le. Az ilyen típusú problémákra nyújt megoldást a finally kulcsszó. Tipikus példa erre a fájlkezelés. (Nem igaz ez arra az esetre. A finally blokk Sokszor lehet szükség arra is. hogyan alkalmazhatjuk a nyelv finally kulcsszavát: Ez a 121.) A következő példa bemutatja. mint pl.info . függetlenül az előtte keletkezett hibáktól. A FINALLY blokkban elhelyezett kód MINDIG LEFUT.kuruc. oldal a 242-ből www.: a fenti matematikai hiba. hogy egy program részlet hibás és hibátlan működés esetén is lefusson. melyekre már eleve számítani lehet a programban. A fontosabbakat az alábbi táblázatban foglaltuk össze. A System névtérben rengeteg kivételtípust definiáltak. A helyes megközelítés az. melyek egy bizonyos típusú hiba elfogására alkalmasak. A catch blokkok sorrendje sem mindegy. ahol a megnyitott fájlt HIBA ESETÉN IS le kell zárni.kuruc.info) Írhatunk olyan catch blokkokat is.

mivel ilyenkor elmarad a hibaellenőrzés. A példában a verem tetejéről akarunk levenni egy elemet akkor.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. A kivétel feldobását a throw végzi. mivel a definiált kivétel is egy osztály. A következő példa bemutatja. Amennyiben egy értékadáskor egy változóba olyan értéket szeretnénk elhelyezni. bárhol ’’dobhatjuk” a kivételt a throw segítségével. így példányosítani kellett.info) Kivételek feldobása A C# nyelv lehetőséget ad a saját magunk által definiált kivételek használatára is. Az egyik a CHECKED. végül az operációs rendszer lekezeli a saját hibakezelő rutinjával. A kivételek dobása a THROW kulcsszóval történik.) Checked és unchecked A C# nyelv tartalmaz két további kulcsszót a kivételek kezelésére és a hibák javítására. A kivétel dobásakor a new kulcsszót használtuk. Jobb esetben az ilyen hibákat el tudjuk kapni a megfelelő catch{} blokkal. (Ha nem kapjuk el. A konstruktor paramétere egy string. oldal a 242-ből www. hogyan dobhatunk saját kivételt. Amennyiben nincs már elem a veremben. mely nem fér el annak értéktartományában. a másik pedig az UNCHECKED. ha az nem üres. ezt egy kivétel dobásával jelezzük. melynek paramétere egy exception osztály: Exception(”Hibaüzenet”). amit a kivétel elkapásakor kiírhatunk. A program bármely szintjén. Ez a 122. OverflowException hibával leáll a programunk. Amennyiben nem kapjuk el sehol. és egy tetszőleges catch blokkal el is kaphatjuk. ami legtöbbször azt jelenti. de az unchecked kulcsszó használatával megakadályozhatjuk a kivétel keletkezését is.kuruc. az operációs rendszer akkor is kiírja egy hibaablakban a hibaüzenetként megadott stringet.kuruc. az a Main() függvény szintjén is megjelenik. melyben a hibaüzenetet adhatjuk meg. hogy a programunk leáll.info .

Nélküle nehéz lenne elképzelni hibátlanul működő programokat. A checked és unchecked kulcsszavak nem csak blokként használhatóak: checked{}. Az ilyen típusú programoknak rendelkezniük kell egy ablakkal. sem a felhasználó életét. hanem kimondottan egy kifejezés vagy értékadás vizsgálatánál is.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Erre külön hívjuk fel a figyelmét!) Új Projekt készítése A WINDOWS APPLICATION PROJEKtek készítése már a kezdeti lépésekben eltér a Console Application típusétól. A fentiek ismeretében elmondhatjuk.info) Az értékadás megtörténik. hogy a kivételkezelést alkalmazó programok sem tökéletesek. A kivételek nevét egy konstans tömbben tárolja! 7) Írjon programot. mert könnyen okozhatunk végzetes hibákat a programokban. vagy egyéb műveletekre vonatkoznak. Csak nagyon indokolt esetekben használjuk ki az unchecked nyújtotta lehetőségeket. Nem számtípus beolvasásakor kivételekkel kezelje le az előforduló hibákat! 8) Készítsen programot. majd a képernyőre írja a beolvasott számok négyzetét! A program csak számokat fogadjon el inputként. hogy a beolvasásnál csak 3-mal és 5-tel osztható számokat fogadjon el! 6) Készítsen programot.kuruc. a változóba bekerül a csonkított érték. de csak páros számokat fogad el! 5) Módosítsa az előző programot úgy. mely a fejezetben felsorolt kivételek nevét kiírja a képernyőre. melyre a többi komponenst rakhatjuk. Az ellenőrzés mindenképpen megtörténik. és kivétel keletkezik a hiba miatt. Ekkor a következő formában írhatjuk őket: Ebben a formában csak a zárójelek közé írt kifejezésekre. hogy a hibakezelés. A beolvasás és a konverzió során keletkező hibákat kivételekkel kezelje le! (Hiba az is. oldal a 242-ből www. ami definiálja az előbbiek működését. mely számokat olvas be a billentyűzetről egy string típusú változóba. Programozási feladatok 1) Írjon programot.kuruc. Alapértelmezés szerint a checked állapot érvényesül a programokban található minden értékadásra és műveletre. az eredményt pedig kiírja a képernyőre! Nullával való osztás esetén a program jelezze a hibát a felhasználónak! 2) Készítsen programot. Amikor futtatjuk a programot. mely egy meghatározott végjelig szám párokat olvas be a billentyűzetről és a szám párok első elemét elosztja a másodikkal.info . (Amekkora még elfér benne.) A checked alkalmazásával pontosan az előbbi folyamat ellenkezőjét érjük el. ha a felhasználó a string-ben nem számokat ad meg. unchecked{}. mely verem kezelést valósít meg egy n elemű vektorban! A program a Pop() és a Push() műveletek hibája esetén dobjon kivételt! 3) Az előző programot módosítsa úgy. mivel lényegesen több forráskód és erőforrás szükséges a készítésükhöz. nem keserítik sem a programozó. de talán nem állnak le végzetes hibákkal. akkor is ez a Form lesz az. A beolvasott számot alakítsa szám típussá. mely számokat olvas be a billentyűzetről. a kivételek kezelése nagyon fontos és hasznos lehetőség a C# nyelvben. s a forráskóddal. hogy a kivételek dobáskor a hibaüzenetek megjelenjenek a képernyőn! 4) Készítsen programot. majd tárolja egy int típusú változóban. Igaz. mely egy n elemű tömbbe olvas be egész típusú értékeket. az ablakot leíró osztállyal. Az alkalmazás fő része maga a FORM. ami megjeEz a 123.

varázsló. A forráskódot kezdetben nem is láthatjuk. Most ne a megszokott Console Application típust válasszuk. A vezérlők működését más fejezetek mutatják be. hogy a Start Page lapon. A Form-ra helyezhető komponenseket a bal oldali. (A panel a többihez hasonlóan fixálható. melylyel dolgozni szeretnénk. ahol ki kell választanunk azt a programozási nyelvet.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. a kódszerkesztőbe betölti a forráskódot. hogy a fájlok ne keveredjenek össze. hanem a Windows Applicationt! Határozzuk meg a program nevét.kuruc. Az jóváhagyást követően a . előállítja a Form-ot. oldal a 242-ből www. ahova el akarjuk menteni a fájlokat! Érdemes külön könyvtárat készíteni minden programnak.NET dolgozni kezd. Jelöljük ki a C# nyelvet! Az ablak jobb oldali részében meg kell mondanunk. csak a Form felületét a Design ablakban. Itt tudjuk szerkeszteni.NET fejlesztői eszközt! A File menü new menüpontjában található listából válasszuk a new project-et! Ezt megtehetjük úgy is. majd azt a könyvtárat. Toolbox feliratú. de sajnos túl sokat takar a hasznos felületből. hogy milyen típusú alkalmazást szeretnénk készíteni. rákattintunk a new project linkre.kuruc.info) lenik a képernyőn. Generálja a programunkhoz szükséges fájlokat. mint Windows alkalmazás. ami az indításkor megjelenik a szerkesztő részben.info . Készítsük el az első Form-mal rendelkező programunkat! Indítsuk el . és vezérlő elemeket is itt adhatunk hozzá. Ekkor elindul a New Project .) Ez a 124. előugró panelen találjuk meg.

A forráskód tartalmazza a saját névterét is. kozásokkal: A program sorait tanulmányozva rögtön feltűnik az.NET ablakának a jobb oldalán (nem alapértelmezés szerinti beállítások esetén máshol is lehet) találunk egy függőleges panelt. Ez a 125.info .C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. a komponensekhez és a grafikus felület programozásához szükséges hivatkozások. Amennyiben újabb komponenseket adunk a Form-hoz. Ha itt kiválasztjuk a Form1 címkét. oldal a 242-ből www. A panel a projekt elemeit fa struktúrába szervezve tartalmazza. a lista tovább bővülhet.kuruc. hogy mutassa meg a forráskódot.info) A . A panelre kattintva tudjuk megmondani a szerkesztőnek. és duplán kattintunk rá. melyet tetszés szerint átnevezhetünk. a szerkesztőbe betöltődik a Form-hoz tartozó kód. melynek a felirata Class View. hogy a using rész kibővült a következő hivat- Az importált elemek közt helyet kapott a Windows form-okat leíró osztály.kuruc.

Ez a Form külön alkalmazásként fut. különböző szerverek.kuruc. A Main() függvényt a lista végén. destruktora és az inicializálásához szükséges utasítások. de ezt a .Run(). A jobb oldalon találjuk Dinamikus Help rendszert. ezután elindítja a Programot. vagy a ráhelyezett vezérlők valamelyikének a felületén duplát kattintunk.info . rendelkezik saját memória területtel. tallózására..kuruc. konstruktora.listájában.NET kezelői felületén még számos panel található a felsoroltak mellet. ha rákattintunk egérrel a kívánt ablak fejlécére. stb. A Main() függvénynek jelenleg az egyetlen utasítása az Appliaction. vagyis a forráskód ablakai közt válthatunk.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. elindul az előfordítás. visszakerülünk a szerkesztőbe. A Form Designer és a Form1. Amennyiben a Form-on. A projekt futtatása az F5 billentyű leütésekor indul el.NET ellenőrzi a kód helyességét.info) A névtérhez tartozó programrészeket kapcsos zárójelei között helyezhetjük el. megjelenik a Windows Task. de még a Class zárójelein belül definiálhatjuk. melynek a feladata az alkalmazás elindítása.cs. mely lehetőséget nyújt a számítógép erőforrásainak (adatbázisok. (Természetesen a háttérben bonyolult műveletek hajtódnak végre. Ha leállítjuk. de ebben az esetben az adott elem valamely eseményét kapjuk. optimalizálás.) A Form megjelenik a képernyőn a szerkesztő ablaka előtt. oldal a 242-ből www.NET megteszi helyettünk. ami csak abban az esetben működik megfelelőEz a 126. A programozás során a két ablak közt folyamatosan váltogatni kell. A Toolbox felett foglal helyet a Server Explorer. service-ek) megtekintésére. A . DLL fájlok. Itt foglal helyet a Form osztály definíciója. a kódszerkesztőbe ugrik a kurzor. s tovább dolgozhatunk a forráskódon. A . mivel a Windows Application projektek készítése a forráskód és a felület együttes szerkesztését igényli.

jelöljük ki.NET fejlesztői eszközzel! 7) A Help rendszer segítségével keresse meg a form-okról rendelkezésre álló lehető legtöbb információt. és vizsgálja meg. Egy új ablak nyílik. majd nyomjuk le az F1-et. hogy senki nem tudja fejben tartani azokat. Például elindíthat.info . Anchor Form melyik részéhez igazítson BackColor Gomb hátterének a színe BackgroundImage Gomb hátterének a képe Ez a 127. mivel a rendelkezésre álló osztályok és tagfüggvények száma olyan hatalmas. 1) 2) 3) 4) A látható komponensek. Feladatok Hozzon létre egy új.cs állományt majd nyissa meg azt a . Nagyobb programozói tudást igényelnek és feltételezik a magas szintű Objektum Orientált programozási ismereteket.kuruc. Alapbeállításban tiltva van. praktikus dolgok. Properties (Tulajdonságok) AllowDrop Engedélyezi. Végül a képernyő alsó részén kaptak helyet a futtatási információkat és az esetleges hibák okát feltáró Output és Debug ablakok. hogy az Output és a Debug ablakban milyen üzenetek jelennek meg! 5) Próbálja meg értelmezni az üzeneteket! 6) A létrejött állományok közül keresse meg a form1. vagy megszakíthat egy folyamatot.info) en. mivel a következő futtatáskor úgyis újra megjelennek. a kontrollok Button (Gomb) A nyomógomb komponens által a felhasználó műveletet hajthat végre.kuruc. hogyan működik! Gépeljük be a szerkesztőbe az int szót. Windows Application projektet! Mentse el a háttértárra az aktuális alkalmazás minden adatát! Keresse meg az alkalmazás mentett adatait.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. A Help használata elengedhetetlen a Windows programok írásakor. melyben az int típusról megtalálható. Ezeket be is zárhatjuk. vagy tiltja a drag and drop funkciót. A Consol Application projektek készítése bonyolultabb az eddig tanult alkalmazásokénál. leírások. A Help rendszert az F1 billentyűvel is aktivizálhatjuk. melyeket a Consol Application projekteknél is megtalálhattunk. összes információ szerepelni fog: forráskód példák. Próbáljuk ki. oldal a 242-ből www. vagy rendelkezünk internet kapcsolattal. majd töltse vissza azokat! Futtassa az alkalmazást. ha telepítettük a számítógépünkre az MSDN Library minden CD-jét.

vagy tiltja a drag and drop funkciót.y formában Gomb lezárása A gomb hozzáférésének a lehetőségei: public. amíg a gomb fókuszban van Billentyű elengedése. private.kitölti az egész Form-ot Engedélyezett-e A gombon található szöveg betűtípusa A gombon található szöveg színe Összerendelés a gomb és az imagelist között. amíg a gomb fókuszban van Fókuszból kikerülés Mutató a gomb fölött helyezkedik el Mutató elhagyja a gombot Szülő megváltozik Label. internal A gomb mérete Elérhető-e tabulátorral A tabulátoros lépegetés sorrendje Gomb felirata A felirat elhelyezkedése a gombon Látható-e Gombra kattintás Gomb fókuszba kerülése Billentyű lenyomása. Bottom . oldal a 242-ből www. Left .baloldalra Right . Fill . KeyDown KeyUp Leave MouseEnter MouseLeave ParentChanged Jobbgombos előbukkanó menü Beállítja a gomb visszatérési értékét.jobboldalra.kuruc. protected internal.felső részhez.alsó részhez. Közös tulajdonságok: Name AllowDrop Név Engedélyezi. Ez a 128.info) ContextMenu DialogResult Dock IGAZÍTÁS Enabled Font ForeColor ImageList ImageIndex Location Locked Modifiers Size TabStop TabIndex Text TextAlign Visible Események: Click Enter GotFocus Keypress. protected. amihez a felhasználó nem fér hozzá.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Az imagelistben megadott képnek az indexe A gomb a bal felső saroktól való távolsága x. Linklabel A label szöveget jelenít meg.info .kuruc. Beállítja a gomb helyzetét a következő pozíciókba: TOP .

oldal a 242-ből www. Az imagelistben megadott kép indexe A gombnak a bal felső saroktól mért távolsága x.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.nagybetűs. ahol a felhasználó általában egysoros szöveget adhat meg. amikor a mutató fölötte van A link színe Volt-e már megnézve? Megnézett link színe LINKLABEL tulajdonságai: ActiveLinkColor LinkBehavior LinkColor LinkVisibled VisitedLinkColor Textbox A textbox egy olyan területet jelöl ki.info) Anchor BackColor BackgroundImage Enabled Font ForeColor ImageList ImageIndex Location Size Text Visible Form melyik részéhez igazítson A címke hátterének a színe A címke hátterének a képe Engedélyezett-e A címkén található szöveg betűtípusa A szöveg színe Összerendelés a címke és az imagelist között.info .kuruc.kuruc. amíg a gomb fókuszban van Fókuszból kikerülés Mutató a gomb fölött helyezkedik el Mutató elhagyja a gombot Ez a 129. vagy módosíthat. Upper . KeyDown KeyUp Leave MouseEnter MouseLeave Automatikus méret A textbox keretének a stílusa A betű métete . Normal .Lower .y formában A címke mérete A címke felirata Látható-e Az aktivált link színe A link stílusa. amíg a gomb fókuszban van Billentyű elengedése.vegyes Texboxban található sorok sorszámozva A texboxba írható szöveg maximális hossza Többsoros megjelenítés Az textboxban megjelenő karakter (jelszavaknál) Textboxban található szöveg Billentyű lenyomása.kisbetűs. Tulajdonságai: AutoSize Borderstyle CharacterCasing Lines MaxLength Multiline PasswordChar Text Események: Keypress.

amikor egy igaz/hamis. Logikailag egységbe tartozó vezérlő elemek összefogására használjuk a formon.MiddleRight igazítást használja.Systemre van állítva.kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info) CheckBox Akkor használjuk. Ha kettő. különben pedig a ContentAlignment. akkor a felhasználó operációs rendszerének beállításai határozza meg ezt. addig a RadioButtonnál már csak a lista EGY elemét. hogy a CheckBoxnak két vagy három állapota legyen. hogy a CheckBox egy általános kiválasztó négyzet legyen. akkor a CheckBox aktuális értékét lekérdezni és beállítani a Checked tulajdonságnál tudjuk. Az Appearance (megjelenés) tulajdonságnál azt állíthatjuk be.Systemre van állítva. akkor mindezt a CheckState tulajdonságnál tudjuk megtenni. akkor ez a vezérlő elem úgy jelenik meg. De amíg a CheckBoxnál a lista elemeinek kombinációját választhatjuk ki.MiddleRight igazítást figyelembe véve jelenik meg. Ha a CheckAlign tulajdonság az egyik jobb igazításra van állítva. A GroupBox egy konténer. Ha ez FlatStyle. Ez a 130. igen/nem választási lehetőséget szeretnénk adni a felhasználó számára.kuruc. Példakód: GroupBox A GroupBox egy terület keretét határozza meg egy vezérlőelem. -csoport körüli felirattal vagy felirat nélkül. és a ContentAlignment. . A ThreeState tulajdonság azt határozza meg. Ha három. Megjegyzés: Mikor a FlatStyle tulajdonság FlatStyle. Mindkettő lehetővé teszi a felhasználó számára. Megjegyzés: A Checked tulajdonság 3 állapotú CheckBox esetén mindig igaz értéket ad vissza A FlatStyle a CheckBox stílusát és Megjelenését határozza meg. A CheckBoxnak és a RadioButtonnak a funkciója ugyanaz. ami vezérlőcsoportokat tud meghatározni. hogy a ContentAlignment.MiddleLeft vagy ContentAlignment. hogy egy listából válasszon. oldal a 242-ből www. akkor CheckAlign tulajdonság figyelmen kívül van hagyva.info . vagy egy nyomógomb.MiddleLeft igazítás állítja be.

info . akkor mindkettőben ki tudunk választani egyet-egyet.kuruc. Példa kód: MainMenu A MainMenu egy konténer a form menüstruktúrájának számára. A MainMenu MenuItem objektumokból áll össze. össze kell egyeztetni a form Menu tulajdonságával. vagy az ősmenüelemeken. illetve az al-. mindkettőben néhány RadioButton. Ha van két GroupBoxunk. melyek egyedi menüutasítások a menü struktúrában.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info) A GroupBoxot jellemzően RadioButton-csoportok összefogására használjuk. amit végrehajt az alkalmazásunkban. Ahhoz. Minden menüitemhez tartozik egy utasítás. hogy beillesszük a MainMenut a formba és az megjelenjen rajta. oldal a 242-ből www.kuruc. A GroupBoxhoz a Control tulajdonság Add metódusával tudunk hozzáadni vezérlőket. Ez a 131.

akkor használjuk a CloneMenu metódust. mint az arab nyelv írásakor.kuruc. akkor el lehet végezni a megfelelő módosításokat az új menüstruktúrán. Ha újra akarjuk használni a MainMenut egy speciális menüstruktúrában. Ez a 132. oldal a 242-ből www. ami a menüelem szövegét jobbról balra jeleníti meg.kuruc.info .C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Amikor kész van a másolat. ha több menüstruktúrát szeretnénk megvalósítani. Egy formhoz lehet készíteni több MainMenut is.info) Azokhoz az alkalmazásokhoz. lehet használni a RightToLeft tulajdonságot. ami egy másolatot készít. melyek több nyelvet támogatnak.

Amikor a felhasználó kiválaszt egy RadioButtont egy csoportból. addig a RadioButtonnál már csak a lista egy elemét. Ha egy formra több csoportot akarunk rakni. Mindkettő lehetővé teszi a felhasználó számára. egy csoportot alkot. Ez a 133. akkor a többi automatikusan üresre változik. A RadioButton meg tud jeleníteni egy szöveget. GroupBox. akkor minden egyes csoportnak helyezzünk el egy konténert a formon (mint pl. Ezt az Appearance tulajdonság határozza meg.info) RadioButton A CheckBox és a RadioButton a funkciója ugyanaz. Panel).kuruc. vagy úgy. vagy egy képet. mint egy hagyományos RadioButton. A RadioButton úgy nézhet ki. mint egy nyomógomb. ami egy adott konténeren belül van (mint pl.kuruc. hogy egy listából válasszon. vagy mindkettőt. egy form). oldal a 242-ből www. Minden RadioButton.info . A Checked tulajdonsággal tudjuk lekérdezni és beállítani a RadioButton állapotát. De amíg a CheckBoxnál a lista elemeinek kombinációját választhatjuk ki.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.

E problémák megoldására használhatjuk a combobox osztályt. ami a vezérlőn jobb egérgombbal történő kattintásra jelenik meg Ez a 134.info) Példa kód: ComboBox A listák nagy helyet foglalnak a formokon. Első pillantásra egy TextBox-ot láthatunk a jobb oldalán egy nyilacskával.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. ami megjelenik a vezérlő fölött. és az általuk felkínált elemek nem bővíthetőek a felhasználó által. Ez EGYESÍTI a szerkesztő mező (edit) és a lenyíló lista tulajdonságait.info .kuruc. oldal a 242-ből www. amikor az egérkurzort fölé mozgatjuk a megjelenést és a működést vezérli szöveg megjelenítésére használt betűtípus előtérszín (pl.kuruc. betűszín) a vezérlőben látható szöveg meghatározza. Feladata: Adatok legördülő ablakban történő megjelenítése Megjelenés BackColor Cursor DropDownStyle Font ForeColor Text Viselkedés AllowDrop ContextMenu a ComboBox háttérszíne a kurzor típusa. hogy a vezérlő fogadhat-e „Fogd-és-vidd” értesítéseket helyi menü.

hogy a ComboBox menüje legördült jelzi. vagy nem true. a vezérlő mely szélei rögzítettek az őt tartalmazó konténer széleihez képest megmutatja. amikor egy bizonyos elem magasságát ki kell számítani akkor következik be. különben false a ComboBox egy elemének magassága pixelben A legördülő listában egyszerre látható bejegyzések maximális száma a ComboBox beviteli részébe írható karakterek maximális száma Meghatározza. ahonnan a vezérlő az elemeit veszi az adatforrás egy tulajdonsága. átmozgatható-e A vezérlő láthatósági szintjét jelöli Horgony. hogy az elem kiválasztható-e a TAB billentyű használatával a vezérlő látható vagy nem a listát jelöli.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. amit a comboboxban meg kívánunk jeleníteni a ComboBox elemeit tartalmazza Tetszőleges célokra használható egész értékű mező A vezérlő neve megmutatja.kuruc. oldal a 242-ből www. amikor a rendszerszínek megváltoznak háttérszín helyzetérzékeny menü kurzor adatforrás megjelenítendő adattag-forrás igazítás engedélyezettségi állapot betűtípus előtérszín (betűszín) helyzet (Lásd Location) szülő kiválasztott érték Ez a 135. hogy a DropDownStyle tulajdonság megváltozott A felhasználó segítséget kér a vezérlőről akkor következik be. hogy a vezérlő átméretezhető.info) DrawMode DropDownWidth Enabled IntegralHeight ItemHeight MaxDropDownItems MaxLength Sorted TabIndex TabStop Visible Adat DataSource DisplayMember Items Collection Tag Tervezés Name Locked Modifiers Anchor Dock Location SelectedValue Események Click DoubleClick DrawItem DropDown DropDownStyleChanged HelpRequested MeasureItem SelectedIndexChanged StyleChanged SystemColorsChanged BackColorChanged ContextMenuChanged CursorChanged DataSourceChanged DisplayMemberChanged DockChanged EnabledChanged FontChanged ForeColorChanged LocationChanged ParentChanged SelectedValueChanged A ComboBox megrajzolási módját vezérli a legördülő ablak szélessége pixelben azt jelzi. ha a listarészlet csak teljes elemeket tartalmazhat. hogy a ComboBox engedélyezett.info A következő események mindegyike egy tulajdonság megváltozását jelzi: . mezője. hogy a vezérlő tartalma rendezett vagy sem az elem helyét adja meg a TAB sorrendben megmutatja. amikor a ComboBox ’SelectedIndex’ tulajdonsága megváltozik. amikor egy bizonyos elemet vagy területet meg kell rajzolni azt jelzi.kuruc. hogy a vezérlő mely szélei vannak összekapcsolva az őt tartalmazó elem szélével Beállítja vagy lekérdezi a vezérlő bal felső sarkának az őt tartalmazó elem bal felső sarkától mért relatív távolságát Kiválasztott elem értéke kattintáshoz kötődő esemény Dupla kattintáshoz kapcsolódó esemény akkor következik be. ha megváltozott a vezérlő stílusa bekövetkezik. azaz újabb elem kerül kijelölésre jelzi.

Count Add Insert Remove Indexer. a lista lenyitható A kritikus tulajdonság a DropDownStyle lehetséges értékei: A listához hasonlóan a comboboxban is az Items tulajdonság tárolja a lista elemeit. az elemek számát adja vissza Új elem felvétele a listához Új elem beszúrása a listába Elem törlése A felhasználó által kiválasztott elemet a SelectedItem tulajdonságon keresztül érjük el. egész számokkal tölti fel a combobox items tulajdonságát: ListView Ha az előzőeknél is kifinomultabb listát szeretnénk használni. Tekintsünk át néhány alapműveletet a példa segítségével: A ’Törlés’ gomb mind a Items tárolót. oldal a 242-ből www.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Ha az indexére van szükségünk. a lista lenyitható. akkor a SelectedIndex tulajdonságot használjuk.info) SizeChanged TabIndexChanged TabStopChanged TextChanged VisibleChanged Simple DropDown DropDownList méret tab-sorrendbeli hely TAB-bal történő kiválaszthatóság beállítása szöveg vizuális láthatóság Szerkeszthető mező.info . (alapértelmezett) Nem szerkeszthető a mező. ami egy objektumot ad vissza. Ez a tulajdonság egy ObjectCollection típus.kuruc. akkor erre lehetőséget ad a ListView Ez a 136. a lista mindig látszik Szerkeszthető mező. mind a text mezőt törli: Egy egyszerű switch szerkezettel módosíthatjuk a stílusát a comboboxnak: A ’Feltöltés’ gomb eseménykezelője egyszerű. Így kezelése a szokásos metódusok használatával lehetséges.kuruc.

info a ListView háttérszíne A keret stílusa azt mutatja. ami a vezérlőn jobb egérgombbal történő kattintásra jelenik meg A vezérlőben megjelenő oszlopfejlécek(. Feladata: elemek gyűjteményének . hogy milyen típusú műveletre van szükség a felhasználó részéről egy elem aktiválásához Alignment megmutatja az elemek igazítási módját a ListView-n belül jelzi.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. hogy a vezérlő kijelölt elemén megmarad-e a kijelölés.info) osztály. hogy az elemek címkéit megváltoztassák azt jelöli. hogy a felhasználó megváltoztathatja-e az oszlopok sorrendjét jelzi. a vezérlő mely szélei rögzítettek az őt tartalmazó konténer széleihez képest megmutatja. hogy az egérkurzort fölötte hagyjuk A ListView elemei megengedi a felhasználónak. hogy a vezérő átméretezhető. amikor az egérkurzort fölé mozgatjuk Font szöveg megjelenítésére használt betűtípus előtérszín (pl. hogy a combobox engedélyezett. amikor a vezérlő elveszíti a fókuszt megmutatja.megjelenítése Megjelenés BackColor BorderStyle CheckBoxes Cursor ForeColor FullRowSelect View Viselkedés Activation AllowColumnReorder AllowDrop AutoArrange ContextMenu Coulumns Enabled HeaderStyle HideSelection HoverSelection ImeMode Items LabelEdit LabelWrap LargeImageList MultiSelect Scrollable SmallImageList Sorting StateImageList ImageList-je TabIndex TabStop Visible Adat Tag Tervezés Name Locked Modifiers Anchor Dock Location Események Ez a 137..kuruc.) meghatároza. hogy a vezérlő mely szélei vannak összekapcsolva az őt tartalmazó elem szélével Beállítja vagy lekérdezi a vezérlő bal felső sarkának az őt tartalmazó elem bal felső sarkától mért relatív távolságát . hogy a vezérlőben megjelenhetnek-e gördítősávok. átmozgatható-e A vezérlő láthatósági szintjét jelöli Horgony. hogy az elem kiválasztható-e a TAB billentyű használatával a vezérlő látható vagy nem Teszőleges célokra használható egész értékű mező A vezérlő neve megmutatja. részletek.kuruc. hogy kijelölhető-e egy elem azáltal. lista. amenynyiben nincs elég hely az ikonok számára a lista ikonjai Kis ikonok nézetben elemek rendezésének módja a lista alkalmazás által meghatározott állapotokkal kapcsolatos az elem helyét adja meg a TAB sorrendben megmutatja. hogy a címke szövege több sorra törhető-e a lista ikonjai Nagy ikonok nézetben engedélyezi több elem egyszerre történő kijelölését Meghatározza. oldal a 242-ből www. vagy nem Oszlopfejlécek stílusa azt jelöli. hogy a vezérlő fogadhat-e „Fogd-és-vidd” értesítéseket az ikonok automatikus rendezettségét jellemzi helyi menü. Collection) azt jelzi. az elemek megjelenítési módja (ikonok. betűszín) Megmutatja.. hogy egy elemen történő kattintás kijelöli-e az elem összes alelemét is GridLines rácsvonalak jelennek meg az elemek és a részelemek körül. ami megjelenik a vezérlő fölött.különböző nézetekben történő . hogy megjelennek-e CheckBoxok az elemek mellett a kurzor típusa.

amikor a rendszerszínek megváltoznak háttérszín ContextMenuChanged helyzetérzékeny menü kurzor igazítás engedélyezettségi állapot betűtípus előtérszín (betűszín) helyzet (Lásd Location) szülő méret tab-sorrendbeli hely TAB-bal történő kiválaszthatóság vizuális láthatóság A következő események mindegyike egy tulajdonság megváltozását jelzik: TreeView Ez az osztály az elemek hierarchikus rendben történő megjelenését szolgálja.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. hogy megjelennek-e CheckBoxok az elemek mellett a kurzor típusa.info) Click ColumnClick DoubleClick ItemActivate ItemDrag AfterLabelEdit AfterLabelEdit HelpRequested ItemCheck SelectedIndexChanged StyleChanged SystemColorsChanged BackColorChanged CursorChanged DockChanged EnabledChanged FontChanged ForeColorChanged LocationChanged ParentChanged SizeChanged TabIndexChanged TabStopChanged VisibleChanged kattintáshoz kötődő esemény oszlopfejlécre történő kattintáshoz kötődő esemény Dupla kattintáshoz kapcsolódó esemény Elem aktiválása akkor következik be. ami megjelenik a vezérlő fölött. oldal a 242-ből www.info . amikor a ComboBox ’SelectedIndex’ tulajdonsága megváltozik. amikor a felhasználó elkezd „vonszolni” egy elemet elemcímke módosítása után következik be elemcímke módosítása előtt jelentkzik A felhasználó segítséget kér a vezérlőről egy elem „check” állapotának megváltozásához tartozik akkor következik be. azaz újabb elem kerül kijelölésre jelzi.kuruc. amikor az egérkurzort fölé mozgatjuk szöveg megjelenítésére használt betűtípus Ez a 138.kuruc. ha megváltozott a vezérlő stílusa bekövetkezik. Feladata: címkézett elemek hierarchikus gyűjteményének megjelenítése Megjelenés BackColor BorderStyle CheckBoxes Cursor Font a ComboBox háttérszíne A keret stílusa azt mutatja.

amikor a felhasználó elkezd „vonszolni”egy elemet akkor következik be. hogy az elem kiválasztható-e a TAB billentyű használatával a vezérlő látható vagy nem Teszőleges célokra használható egész értékű mező A vezérlő neve megmutatja.kuruc. mielőtt a TreeNode CheckBox kijelölésre Ez a 139. hogy a vezérlőben megjelenhetnek-e gördítősávok. hogy az elemek hyperlink-stílusúvá váljanak-e. oldal a 242-ből www. amikor a vezérlő elveszíti a fókuszt megmutatja. átmozgatható-e A vezérlő láthatósági szintjét jelöli Horgony. amenynyiben nincs elég hely az elemek megjelenítése számára alapértelmezett képindex a kiválasztott csomópontok számára csomópontokat összekötő vonalak megjelenítése plusz/mínusz gombok megjelenítése a szülőcsomópontok mellett vonalak megjelenítése a szülőcsomópontok mellett Meghatározza.info) ForeColor ItemHeight Viselkedés AllowDrop ContextMenu Enabled FullRowSelect HideSelection HotTracking ImageIndex ImageList Indent LabelEdit Nodes PathSeparator Scrollable SelectedImageIndex ShowLines ShowPlusMinus ShowRootLines Sorted TabIndex TabStop Visible Adat Tag Tervezés Name Locked Modifiers Anchor Dock Location Size Események Click DoubleClick ItemDrag AfterCheck AfterCollapse AfterExpand AfterLabelEdit AfterSelect BeforeCheck kerül előtérszín (pl. ami a vezérlőn jobb egérgombbal történő kattintásra jelenik meg azt jelzi. a vezérlő mely szélei rögzítettek az őt tartalmazó konténer széleihez képest megmutatja. vagy nem Megmutatja.kuruc. hogy a vezérlő tartalma rendezett vagy sem az elem helyét adja meg a TAB sorrendben megmutatja. amelyből a csomópontokhoz tartozó képek származnak a gyermekcsomópontok behúzása pixelben megengedi a felhasználónak. hogy egy elemen történő kattintás kijelöli-e az elem összes alelemét is azt jelöli.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. hogy a vezérő átméretezhető. hogy a combobox engedélyezett.info . amikor a TreeNode egy CheckBox-ának értéke megváltozik Lista felgördítése után következik be Lista legördítése után következik be elemcímke módosítása után következik be akkor váltódik ki. hogy a vezérlő kijelölt elemén megmarad-e a kijelölés. hogy a vezérlő mely szélei vannak összekapcsolva az őt tartalmazó elem szélével Beállítja vagy lekérdezi a vezérlő bal felső sarkának az őt tartalmazó elem bal felső sarkától mért relatív távolságát A vezérlő mérete pixelben kattintáshoz kötődő esemény Dupla kattintáshoz kapcsolódó esemény akkor következik be. betűszín) a TreeView egy elemének magassága pixelben meghatározza. hogy az elemek címkéit megváltoztassa Gyökércsomópontok a TreeView-n belül a csomópontok teljes elérési útvonalának megadásához használt elválasztó sztring Meghatározza. amikor a kijelölés megváltozik kiváltódik. hogy a vezérlő fogadhat-e „Fogd-és-vidd” értesítéseket helyi menü. amikor az egérmutató föléjük ér az alapértelmezett képindex a csomópontok számára a vezérlő ImageList-je.

amikor az egérkurzort fölé mozgatjuk szöveg megjelenítésére használt betűtípus a TabControlhoz megmutatja.és-vidd” értesítéseket megjelenési beállítások helyi menü.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info .kuruc. oldal a 242-ből www. a fülek hol helyezkednek el a TabControlon belül jelzi.kuruc. amikor a rendszerszínek megváltoznak háttérszín helyzetérzékeny menü kurzor igazítás engedélyezettségi állapot betűtípus előtérszín (betűszín) helyzet (Lásd Location) szülő méret tab-sorrendbeli hely TAB-bal történő kiválaszthatóság vizuális láthatóság A következő események mindegyike egy tulajdonság megváltozását jelzik: TabControl Feladata: lapok összefüggő halmazát alkotja A megjelenése: Cursor Font ImageList Megjelenés Alignment AllowDrop Appearance ContextMenu DrawMode a kurzor típusa.info) BeforeCollapse BeforeExpand BeforeLabelEdit BeforeSelect HelpRequested StyleChanged SystemColorsChanged BackColorChanged ContextMenuChanged CursorChanged DockChanged EnabledChanged FontChanged ForeColorChanged LocationChanged ParentChanged SizeChanged TabIndexChanged TabStopChanged VisibleChanged Lista felgördítése után következik be Lista legördítése után következik be elemcímke módosítása előtt jelentkzik a TreeNode kijelölse előtt váltódik ki A felhasználó segítséget kér a vezérlőről jelzi. hogy a vezérlő fogadhat-e „Fogd. ami megjelenik a vezérlő fölött. ha megváltozott a vezérlő stílusa bekövetkezik. ami a vezérlőn jobb egérgombbal történő kattintásra jelenik meg A TabControl megrajzolási módját vezérli Ez a 140.

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. oldal a 242-ből www.info) Enabled HotTrack ItemSize MultiLine Padding ShowToolTips SizeMode TabIndex TabStop Visible Adat Tag: Tervezés Name DrawGrid Locked Modifiers SnapToGrid Anchor Dock Location Size TabPages Események Click DoubleClick DrawItem HelpRequested SelectedIndexChanged StyleChanged SystemColorsChanged BackColorChanged CursorChanged DockChanged EnabledChanged FontChanged LocationChanged ParentChanged SizeChanged TabIndexChanged TabStopChanged VisibleChanged azt jelzi. amikor a ComboBox ’SelectedIndex’ tulajdonsága megváltozik.kuruc. az egyes lapok méretezési módját állítja be az elem helyét adja meg a TAB sorrendben megmutatja. hogy a pozícionáló rács kirajzolásra kerüljön-e GridSize meghatározza a pozícionáló rács méretét megmutatja. hogy a vezérlőknek kapcsolódnia kell-e a pozícionáló rácshoz Horgony. hogy mennyi extra hely legyen a vezérlő „fülei” körül Meghatározza. a vezérlő mely szélei rögzítettek az őt tartalmazó konténer széleihez képest megmutatja. vagy írhatunk ki dátumot. hogy látszódnak-e a lapokhoz tartozó ToolTip-ek. átmozgatható-e A vezérlő láthatósági szintjét jelöli Meghatározza.info . Ez a 141. hogy a TabControl engedélyezett vagy nem megmutatja.kuruc. vagy több fül is lehet a vezérlőn belül meghatározza. amikor egy bizonyos elemet vagy területet meg kell rajzolni A felhasználó segítséget kér a vezérlőről akkor következik be. ha megváltozott a vezérlő stílusa bekövetkezik. hogy a fejlécelemek vizuálisan megváltozzanak-e. azaz újabb elem kerül kijelölésre jelzi. hogy az elem kiválasztható-e a TAB billentyű használatával a vezérlő látható vagy nem Teszőleges célokra használható egész értékű mező A vezérlő neve megmutatja. hogy a vezérlő mely szélei vannak összekapcsolva az őt tartalmazó elem szélével Beállítja vagy lekérdezi a vezérlő bal felső sarkának az őt tartalmazó elem bal felső sarkától mért relatív távolságát A vezérlő mérete pixelben A lapok a TabControlban kattintáshoz kötődő esemény Dupla kattintáshoz kapcsolódó esemény akkor következik be. hogy csak egy. amikor az egérmutató föléjük ér Meghatározza a vezérlő al-ablakainak méretét Meghatározza. amikor a rendszerszínek megváltoznak háttérszín ContextMenuChanged helyzetérzékeny menü kurzor igazítás engedélyezettségi állapot betűtípus helyzet (Lásd Location) szülő méret tab-sorrendbeli hely TAB-bal történő kiválaszthatóság vizuális láthatóság A következő események mindegyike egy tulajdonság megváltozását jelzik: DateTimePicker komponens A DateTimePicker komponens segítségével egyszerűen kérhetünk be. hogy a vezérlő átméretezhető.

nap) Rövid dátum (év. A lenyíló naptár helyett használhatjuk a komponenst görgetőkkel is (a lenyitó gomb helyett fel-le gombok jelennek meg) a ShowUpDown tulajdonság igazra állításával. hónap száma.kuruc. hónap neve. mely a dátumot/időt tartalmazza szöveges formában. másodperc) Egyéni (custom) Tulajdonságok: Ez a 142.kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. perc. Két részből áll: egy szövegbeviteli doboz. mely megegyezik a MonthCalendar komponens kinézetével és használatával. melyek határt szabhatnak a bevitelre.info) időt. és egy lenyíló naptár. Beállíthatunk két dátumot (minimum és maximum).info . oldal a 242-ből www. nap) Idő (óra. A kívánt értékeket négyféle formátumban képes a komponens megjeleníteni: Hosszú dátum (év. ezeknél kisebb vagy nagyobb dátumot nem lehet beírni.

Month (hónap). Az érték beállítható szerkesztéskor vagy futásidőben is. 24 órás ábrázolás Kétszámjegyű óra.kuruc.info .. a komponenst tartalmazó form megjelenítésekor. Ha csak egyjegyű..C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Tulajdonságok dátumban: Year (év). Ha csak egyjegyű.info) Érték beírása és kiolvasása A komponensben kiválasztott értéket a Value tulajdonság tartalmazza. . Day (nap) tulajdonságok egész számokat adnak vissza. 24 órás ábrázolás Egy vagy kétszámjegyű perc Kétjegyű perc. kiegészül egy megelőző nullával Ddd Nap neve három betűs rövidítéssel Dddd Nap teljes neve Hh Kétszámjegyű óra. Sunday) Tulajdonságok időben: Hour (óra). 12 órás ábrázolás H HH M Mm M MM MMM MMMM Egy vagy kétszámjegyű óra. A komponens egy DateTime értéket ad vissza. . oldal a 242-ből www. Alapértelmezésben ez az érték az aktuális dátumot/időt tartalmazza. Értékadás: Egyéni formátum-string: Állítsuk a Format tulajdonságot Custom-ra. kiegészül egy megelőző nullával Egy vagy kétszámjegyű hónap Kétszámjegyű hónap. Second (másodperc) és Millisecond (ezredmásodperc) tulajdonságok egész számot adnak vissza. DayOfWeek tulajdonság a hét egy napjának nevét adja vissza (Monday.kuruc. vagy kaphat. pl. Minute (perc). A formátum-stringben az alábbiak használhatók: D Egy vagy kétjegyű nap száma Dd Kétjegyű nap. nullás kiegészítés Hónap neve három betűs rövidítéssel Hónap teljes neve Ez a 143.

Bizonyos dátumokat megjelölhetünk félkövér írásmóddal.info) S Egy vagy kétszámjegyű másodperc Ss Kétszámjegyű másodperc. Egy rácsháló tartalmazza a hónap számozott napjait. kiemelve őket a többi közül (fontos dátumok).a komponens címsávjában szereplő bal vagy jobb nyílra kattintva.info . A komponensen kijelölhetünk több dátumot is (megadható számú).C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Alapértelmezés szerint az aktuális nap a naptárban pirossal be van karikázva. hogy lekérdezzék és módosítsák a dátumot. pl. Ellentétben a hasonló DateTimePicker komponenssel. Tulajdonságok (properties): AnnuallyBoldedDates Tartalma az évenként előforduló fontos dátumok DateTime[] tömb Ez a 144. évenkénti vagy havi dátumok. oldal a 242-ből www. Ha a fenti betűk valamelyikét szeretnénk. ebben a komponensben több dátumot is kijelölhetünk. akkor csak be kell írni. A rács mellett megjeleníthetjük a hetek számait is. akár szöveg is.:hh:mm -> 11:23 hh’d’mm -> 11d23 Angol stílusú dátum-formátum: MonthCalendar komponens A MonthCalendar komponens egy grafikus felületet nyújt a felhasználóknak. Egy tulajdonság megváltoztatásával akár több naptár is lehet egymás mellett vagy alatt. A hét kezdő napja is megváltoztatható: Angliában a hét vasárnappal kezdődik. nullás kiegészítés T Egy betűs AM/PM kijelzés (délelőtt/délután) Tt Két betűs AM/PM kijelzés Y Egy számjegyű év (2001 megjelenítése: ”1”) Yy Két számjegyű év (2001 megjelenítése: ”01”) Yyyy Teljes év kiírása (2001 megjelenítése: ”2001”) A formátum-stringben szerepelhetnek még saját jelek. és fel van tüntetve a rács alatt is.hónapos lépésekben .kuruc. oszloponként rendezve a hét napjaihoz (hétfő-vasárnap).kuruc. betűk. Ha nem szerepeltetünk benne a fenti karakterekből. Lehet a dátumok között lépkedni . nálunk hétfővel. A komponens egy naptárat jelenít meg. A komponens kinézete változtatható. Ezek lehetnek egyedi dátumok. akkor két aposztróf közé kell írni.

kuruc.) az elérhető legkésőbbi dátumot a naptárItt állítjuk be ban Alapértelmezés: 9998. hogy a komponens bekarikázza-e az aktuális napot a naptárban Alapértelmezés: True Beállítja.31. hogy látható-e az aktuális dátum a komponens alján Alapértelmezés: True Beállítja.01.info . ha megváltozik a kijelölt dátumok intervalluma vagy előző/következő hónapra mozdul a naptár Akkor következik be. . hogy a komponens előre és vissza gombjaival hány hónapot lépjen a naptár Alapértelmezés: 0 (a következő/előző hónapra léptet) A komponensben kijelölt napok intervalluma Alapértelmezés: mindkét érték az aktuális dátumot tartalmazza Beállítja. hogy a komponensen a napok sorai előtt látszik-e a hét sorszáma (1-52) Alapértelmezés: False A komponens címsávjának háttérszíne Alapértelmezés: Kék A komponens címsávján megjelenő betűk színe Alapértelmezés: Fehér Az aktuális dátum Pl.05.06.info) BoldedDates CalendarDimensions Tartalma az egyedi fontos dátumok DateTime[] tömb A naptárak száma a komponensen belül (oszlop és sor) Alapértelmezés: Width=1. Beállítja a naptárban megjelenő előző és következő hónapból belógó napok színét Alapértelmezés: Szürke FirstDayOfWeek MaxDate MaxSelectionCount MinDate MonthlyBoldedDates ScrollChange SelectionRange ShowToday ShowTodayCircle ShowWeekNumbers TitleBackColor TitleForeColor TodayDate TrailingForeColor Események (events) DateChanged DateSelected Akkor következik be. ilyenkor a rendszertől kérdezi le a területi beállításokat Értéknek adhatjuk neki a hét napjainak nevét angolul (Monday. A naptárban kijelölhető napok maximális száma Alapértelmezés: 7 Itt állítjuk be az elérhető legkorábbi dátumot a naptárban Alapértelmezés: 1753. Tartalma a havonta előforduló fontos dátumok DateTime[] tömb Ez a változó állítja be.01..C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. ha a felhasználó kijelöl egy vagy több dátumot Ez a 145.: 2004.kuruc.12. oldal a 242-ből www. Height=1 A hét kezdő napja Alapértelmezés: Default..

havonta vagy évente előforduló dátumokat.info) Kiemelt dátumok kezelése Fontosabb dátumokat félkövér betűtípussal.kuruc. AnnuallyBoldedDates és MonthlyBoldedDates) tárolhatja ezeket az egyedi. AddMonthlyBoldedDate) (Használható még a RemoveMonthlyBoldedDate és RemoveAnnuallyBoldedDate parancs is) Az összes kiemelt dátum törlése: HorizontalScrollBar és VerticalScrollBar komponensek A ScrollBar komponensek segítenek sok elemen át vagy nagy mennyiségű információban keresni vízszintes vagy függőleges görgetéssel. A dátum kiemelése a komponenshez (komponens példányhoz) hozzáadással: (Három parancs: AddBoldedDate. mely DateTime objektumokból áll. oldal a 242-ből www. Három tulajdonság (BoldedDates.info .C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. beEz a 146. stb. AddAnnuallyBoldedDate. mint az egyéb komponensekben (textbox.kuruc. Hozzunk létre DateTime objektumot: 2. Hogyan lehet hozzáadni vagy elvenni ezek közül? Dátum hozzáadás: 1. kiemelten szerepeltethetünk a naptárban. A ScrollBar komponensek nem ugyanazok. Ezek a tulajdonságok tartalmaznak egy tömböt.) lévő.

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.info) épített görgetők. A komponensek Value értéke tárolja, hogy hol helyezkedik el a görgetődoboz (pozíciójelző). A ScrollBar komponensek a Scroll eseményt használják a pozíciójelző mozgásának figyelésére. Ennek a segítségével folyamatosan kérhető le a komponens Value értéke, miközben a pozíciójelzőt mozgatjuk. Tulajdonságok:

A Value értéke egész szám, mely kezdetben 0, és meghatározza a pozíciójelző elhelyezkedését a görgetőcsúszkán. Ha minimális az érték, akkor a pozíciójelző a csúszka bal szélén (vízszintes görgető) vagy tetején (függőleges görgető) van; ha maximális, akkor jobb szélen ill. alul van. Hasonlóan, ha a Value a minimális és maximális értékek számtani közepe, akkor a csúszka közepén van. A Value értéke csak a Minimum és Maximum által megadott intervallumban lehet. A pozíciójelző mozgatása nemcsak az irányokra kattintással lehetséges, hanem a pozíciójelző más helyre húzásával is történhet.

LargeChange
Ha a felhasználó lenyomja a PageUp vagy PageDown gombok valamelyikét, vagy a görgetősávon kattint a pozíciójelző valamelyik oldalán, úgy a Value érték a LargeChange érték szerint változik.

SmallChange
A nyílbillentyűk megnyomásakor, vagy a görgető iránygombjainak megnyomásakor a Value érték a SmallChange érték szerint változik.

Ez a 147. oldal a 242-ből www.kuruc.info

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.info)

Listbox
Egy listaablak lehetővé teszi a felhasználó által megadott adatok kiválasztását a listából.

SelectionMode: a ListBox adatait jelölheti ki a felhasználó, akár egyszerre több adatot is, a megfelelő beállításokkal. Négy lehetséges beállítás létezik: None: One: egyszerre egy adatot választhatok ki a ListBoxból, ha az egérrel a ListBoxra kattintunk, vagy kijelölhetünk a fel-, le-, balra- és jobbra-nyíl billentyűkkel. A One beállítás az alapértelmezett. MultiSimple: itt több adatot is kiválaszthatunk egyszerre, ha az egérrel a ListBox elemeire kattintunk, illetve ha a Space billentyűt nyomva tartjuk. MultiExtended: több adatot is kiválaszthatunk, ha a Shift billentyűt nyomva tartjuk, illetve az egér gomját lenyomva tartom, és a fentebb említett billentyűkkel le-föl mozgunk. HorizontalScrollBar: a görgetőket adhatjuk meg, ha a HorizontalScrollBar értéke true. Akkor látszanak a görgetők, ha true, ha false, akkor nem látszanak, a false az alapértelmezett beállítás. Ha a ListBox magassága nagyobb vagy egyenlő, mint a ListBox adatainak magassága, akkor nem látszik a görgető, hiába true a HorizontalScrollBar értéke.

Panel
Vannak olyan komponensek, amelyek képesek más komponensek tárolására. Ilyen tulajdonsággal rendelkező komponens a Panel. A Panel komponenshez az elemeket a tervezési idő alatt adjuk
Ez a 148. oldal a 242-ből www.kuruc.info

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.info) hozzá (pédául megtervezünk egy eszközsort). Amikor egy komponenst elhelyezünk a Panelen, akkor létrejön egy új szülő-gyermek kapcsolat a komponens és a Panel között. Ha a tervezési idő alatt valamilyen műveletet végzünk a Panellel (mozgatás, másolás, törlés stb.), akkor az érinti a tárolt komponenseket is.

A komponensek csoportba foglalásához először adjuk az alkalmazásunk Formjához a Panelt. A Panel komponens kijelölése után a szokásos módon elhelyezhetjük benne a komponenseket. Enadbled: Ha a Panel Enabled property-je false-ra, inaktívra van állítva akkor a Panel komponensei is inaktívak lesznek. Ilyenkor a menüelem szürke színnel kerül kijelzésre és nem választható ki. Például, ha egy gomb Enabled tulajdonságát inaktívra állítjuk, akkor nem tudunk a gombra kattintani.

BorderStyle: A Panel BorderSytle property-nél három beállítás közül válaszhatunk: None: a Panel nem különböztethető meg a Formtól, ez az alapbeálítás (a default) is. FixedSingle: a Panel körül jól látható keretet kapunk

Fixed3d: a Panel jól elkülöníthető a Formtól PictureBox

PictureBox
Ha képeket szeretnénk megjeleníteni alkalmazásunk Form-ján, akkor ennek legegyszerűbb módja a PictureBox komponens használata. Miután feltettük a Form-ra a PictureBox komponenst, az Image property-jére kattintva kiválaszthatunk egy Bmp, Gif, Jpg, Ico, Emf vagy Wmf formátumú képet, melyet betölthetünk, megjeleníthetünk a PictureBox területén.

Image:
Az Image property-n keresztül rendelhetünk képet a kontrolhoz, illetve érhetjük el Image típusEz a 149. oldal a 242-ből www.kuruc.info

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.info) ként. Fontos tudnunk, hogy az így betöltött kép bekerül a készítendő EXE állományba, így programunk szállításakor elegendő azt vinni, a kép állományt nem kell.

Sizemode:
A PictureBoxSizeMode típusú Sizemode property-n keresztül szabályozhatjuk, hogy miként jelenjen meg a betöltött kép. A PictureBoxSizeMode típus a következő elemeket tartalmazza: AutoSize: a komponens mérete akkora lesz, mint a betöltött kép

StretchImage: a kép mérete akkora lesz, mint amekkora a komponens:

CenterImage: a betöltött kép a komponens területének közepére igazodva jelenik meg

SizeModeChanged:
Amikor a SizeMode property értéke megváltozik, akkor kerül aktivizálásra a SizeModeChanged esemény. ClientSize: A betöltött kép méreteit állíthatjuk be, a Size.Width és Size.Height property-kkel adhatjuk meg a kép szélességét és magasságát.

Timer komponens
A timer komponens egy eseményt idéz elő rendszeres időközönként.

Az időtartam az Interval tulajdonságban van megadva ezredmásodpercben. Ha a timer engedélyezve van, a Tick esemény minden egyes alkalommal bekövetkezik, ha eltelt a megadott intervallum. A timer-t elindíthatjuk vagy leállíthatjuk. Ha megszakítjuk, visszaáll alaphelyzetbe. Nincs lehetőség a timer szüneteltetésére.

Ez a 150. oldal a 242-ből www.kuruc.info

NumericUpDown Megjegyzés A NumericUpDown ellenőrzés egyetlen numerikus értéket tartalmaz. A használó be is léphet egy értékbe.info . Például egy egyszerű óra Label komponensből: Az Interval határai: A változó értéke 1 és 64767 közé eshet. A rendszer 18 óraütést generál másodpercenként.info) Timer kezelése Lehetőség van a timer leállítására és elindítására az alábbi két paranccsal: Vagy más módon.kuruc. Itt állhat többsornyi programkód vagy egy egyszerű metódushívás is. Ez a 151.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.a leggyorsabb ütemezés csak a másodperc 18-ad része lehet. az Enabled tulajdonság igazra/hamisra állításával. Így . Hogy a pontosságot biztosítsuk. oldal a 242-ből www. de csak akkor.kuruc. Az időnként kívánt eseményeket a Tick eseménybe kell beleírni.még akkor is. ha az Interval tulajdonság ezredmásodpercben számolandó . amely növelhető vagy csökkenthető az ellenőrzés fel vagy le billentyűjére való kattintásával. ha a ReadOnly tulajdonság igazra van állítva. a timer-nek időnként ellenőriznie kell a rendszerórát. Nincs garantálva. hogy a megadott intervallum pontosan telik el. tehát a leghosszabb intervallum is alig hosszabb egy percnél.

melynek meghozatala a kéznél levő feladattól. hogy Minimum és Maximum értékek között legyen. ParseEditText-et előzőleg meghívja az érték felülírása és jóváhagyása érdekében. illetve a Ez a 152. Az értéket leellenőrzi. Különösen. Hexadecimal vagy a ThousandsSeperator tulajdonságok beállításával. állítsa be a ThousandsSeperator tulajdonságot true-ra. Részletezve a megengedett értékek sorát az ellenőrzés miatt. ThousandsSeperator bemutatásakor decimális számokban. A Value tulajdonság növelése vagy csökkentése akkor történik. Ha a Text tulajdonság be van állítva. állítsa a Hexadecimal tulajdonságot true-ra. amikor a felhasználó a fel vagy le nyílra kattint. Ha a Text tulajdonság be van állítva. Az ellenőrzésben történő hexadecimális értékek beállításakor. míg a UserEdit tulajdonság true-ra van állítva. míg a UserEdit tulajdonság falsera van állítva. amikor lehetséges. amikor rákattintunk a fel vagy le nyilakra a fel-le ellenőrzésnél. az új értéket jóváhagyja.info) A numerikus kijelző alakítható a DecimalPlaces. és az ellenőrzés felülíródik az új érték megfelelő formátumával. Kivétel True. oldal a 242-ből www. állítsa be a Minimum és Maximum tulajdonságokat. ProgressBar A Value Displayed beállítása a Windows Forms ProgressBar Control által A NET Framework számos különböző módot nyújt bemutatni egy adott értéket a ProgressBar Control-on belül.kuruc. Közelebb visz a döntéshez. ha használó(ja) megváltoztatta a Text tulajdonságot. hogy meghatározza a Value tulajdonság csökkenő vagy növekvő értékét.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Állítsa be az Increment értéket. ha UserEdit true-ra van állítva. másfelől false.info . A hiányérték 1. Pontosabban meghatározva a decimal symbol után bemutatott számok mennyiségét állítsa be a DecimalPlaces tulajdonságot a decimális helyek számához. akkor meghívja az UpdateEditText metódust. akkor a ValidateEditText metódust hívja meg. Amikor meghívja az UpButton vagy DownButton metódusokat kóddal vagy a fel vagy le gombra kattintással. majd meghívja az UpdateEditText metódust.kuruc.

Közvetlenül beállítható a ProgressBar Control értéke. Ezt megtehetjük tervezett vagy szokásos időben is. amikor egy egyszerű végösszeget mutat a Minimum és a Maximum között. A ProgressBar értékének növelése egy kijelölt intervallum által Ha haladást mutat. Hívja meg az Increment metódust.kuruc. vagy a fájlok számát. Növelje a ProgressBar mutatót egy értékkel. amikor betartja a páratlan műveletek sorozatának útvonalát úgy.info) megoldandó problémától függ. Ha beállította az érték tulajdonságát a Minimum és a Maximum által meghatározott határokon belül. amely változik. amely növeli a ProgressBar Control értékét az intervallum által. ez egy könnyű módja a megoldásnak. beállíthatja az értéket. mint az eltelt időt. használja ezt az eljárást. amely egy meghatározott intervallumból ered.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info . Állítsa be ProgressBar ellenőrzését Minimum és Maximum értékre. amelyet már feldolgozott egy ismert végösszegből. annak érdekében. Növelje a ProgressBar mutatót egy meghatározott értékkel. ábrázolva ezzel a ProgressBar bemutatott értékének növekedését. aztán meghív egy metódust. Hívja meg a PerformStep metódust. A ProgressBar értékének növelése változó mennyiséggel Végül növelheti a ProgressBar által bemutatott értéket úgy. A kódban állítsa be az ellenőrzés kódjának tulajdonságát egy integerre a Minimum és a Maximum értékek között. mintha lemezt olvasna egy adatforrásról. ha szükséges csökkenteni a ProgressBar által megadott értéket. oldal a 242-ből www. A ProgressBar növelése egy dinamikai érték segítségével Állítsa be a ProgressBar ellenőrzését Minimum és Maximum értékre. Ráadásul. amelyet már megadott. Ez a megközelítés hasznos. mint különböző méretű fájlok írásakor a merevlemezre vagy a haladás az egész százalékaként való mérésekor. ha az értéket csak egyszer vagy kétszer kell beállítani. hogy megváltoztassa a bemutatott értéket a Step tulajdonságban beállított mennyiségnek megfelelően. hogy minden egyes növelés páratlan értékű legyen. az ellenőrzés kiad egy ArqumentException kivételt. az értéktulajdonságának a beállítása. Állítsa be a ProgressBar ellenőrzését Minimum és Maximum értékre. Végül. A ProgressBar értékének közvetlen beállítása A legközvetlenebb út a bemutatott érték beállítására a ProgressBar által. Ez a megközelítés akkor hasznos. ahol ismeri a kimért adatok egészét. Ez a megközelítés hasznos azokhoz a feladatokhoz. ahol a haladást nem az egész százalékaként mérik. amikor a megadott értéket különböző összegekben ki kell cserélni. Állítsa be az ellenőrzés Step tulajdonságát egy egészre. úgy.kuruc. Ez hasznos az időzítők és más szövegkönyvek számára. Ez hasznos. hogy megváltoztassa az egész álEz a 153.

Miután létrehoztuk a TrackBar-t. LargeChange tulajdonság Adjon meg vagy állítson be egy értéket.info) tal meghatározott értéket. Ez megtartja a távolságot. hozzáadva vagy kivonva a Value tulajdonságból. hogy a felhasználó rangsorolja döntését egyedi érték vagy egymást követő értékek választása között. Ekkor meghatározunk egy típust. Hozzáadhatunk egy kulcsszót a segítséghez a SetHelpKeyword-el. A TrackBar egy kacskaringó ellenőrzés a ScrollBar ellenőrzéshez hasonlóan. hogy a TrackBar megfelelően változzon méretéhez képest. Az értékek ebben a sorrendben logical units-ként fordulnak elő. Alakíthatjuk a sorrendet a Minimum tulajdonság beállításával a sorrend alacsonyabb végének pontosításával és a Maximum tulajdonságot a sorrend magasabb végének pontosításával. A TrackBar akkor hasznos. amikor következőre kattint a slider egyik oldalán. hogy legyen 0-5 terjedő sorrendje. a Value tulajdonság a LargeChange tulajdonságban beállított érték szerint változik. hogy a logical units-nak kell. A LargeChange tulajdonság definiálja a növekedést hozzáadva vagy kivonva a Value tulajdonságból. Bejátszhatjuk ezt az adatot egy ellenőrzésben vagy kód használatával. amelyeket beállítottunk okozott tartalmazzák a Minimum és Maximum pozíciók beállítását a slider számára. akkor a slider csak hat pozíciót foglalhat el: egy pozíció a TrackBar bal oldalán és egy pozíció minden egyes növekvésre sorrendben. amely egy slider-t és tetszőleges mértékű jeleket tartalmaz. TrackBar-ellenőrzés A TrackBar egy ablak. be kell állítani a HelpNamespace tulajdonságot. akár egeret. Ez a 154. ha pontosítja. vagy a TrackBar-ra kattint a slider egyik oldalán. Amikor a felhasználó mozgatja a slider-t. HelpProvider HelpProvider minden kérelme karbantartja a hozzákapcsolódó komponensek referenciáit. hogy összekapcsoljuk a Help fájlt a HelpProvider objektummal. jeleket rajzolva. Használhatjuk ezt az ellenőrzést numerikus adat betöltésekor a Value tulajdonságon keresztül. használhatjuk TrackBar üzeneteket beállítani és helyrehozni néhány tulajdonságot.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. hogy a slider-t egy megadott jelhez mozgatja. Figyelembe kell venni a LargeChange tulajdonság beállítását a magasság vagy a szélesség értékek százalékaként. oldal a 242-ből www. amikor a scroll boksz nagyobb távolságban mozdul el. használhatja a TrackBar-t megengedve a felhasználónak a billentyűzet ismétlésének fokának beállítását azáltal. A slider egy TrackBar-ban akkor nő a meghatározott mértékben. Létrehozhatunk egy TrackBar-t a CreateWindowEx funkció használatával. pontosítva a TrackBar Class ablak osztályt. beállítva a választások sorrendjét és újrapozícionálja a slider-t. Kivétel(es )típus Feltétel Exception A megjelölt érték kevesebb mint nulla Amikor a felhasználó a PAGE UP vagy PAGE DOWN gombokat használja. Például. Tipikusan minden egyes pozíciót ezek közül egy jellel azonosít. amikor a felhasználó állítja be azt. amikor azt szeretnénk.info .kuruc.kuruc. a TrackBar üzenetekben közli a változást. Például. A TrackBar bemutatható vízszintesen és függőlegesen is. A változások. amit SetHelpNavigator-nak neveznek és hozzáadjuk a HelpNavigator értéket a specifikált komponenshez. Ahhoz. akár billentyűzetet használva.

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.info) Ahhoz, hogy hozzáadjunk egy jellegzetes Help stringet a komponenshez, használjuk a SetHelpString metódust. Ez a string ettől kezdődően egy pop-up menüben fog felvillanni, amikor a felhasználó rákattint az F1 billentyűre, persze csak akkor, ha a fókuszt az a komponens birtokolja, amelyikről segítséget akar kapni a felhasználó. Ha a HelpNamespace nincs még beállítva, akkor a SetHelpString-et kell hsználnod, hogy Help szöveget adhassunk. Ha már beállítottad a HelpNamespace-t és a Help string-et, akkor a Help HelpNamespace-ben van és elsőbséggel rebdelkezik.

Mintapélda
A bemutatandó példa demonstrálja, hogy a HelpProvider osztály, hogyan jeleníti meg a contextsensitive segítséget a formon, ami négy cím mezőt tartalmaz. A példa a SetHelpString-et használja, hogy beállítsa a segítségnyujtó ToolTip szöveget. Amikor a context-sensitive Help gombot (vagyis a kis kérdőjelet a jobb felső sarokban) használjuk és ráklikkeljük a Help kurzort a cím mezőre, akkor a ToolTip szöveg megjeleníti a hozzá fűzött szöveget. Amikor a fókusz valamelyik cím mezőn van és megnyomjuk az F1 billentyűt, akkor az mspaint.chm Help fájl kiíródik, mert a HelpNamespace tulajdonság az mspaint.chm-re van beállítva. A HelpProvider.SetShowHelp metódusa minden cím komponenshez hozzá van rendelve, hogy azonosítsa, hogy a Help tartalom elérhető.

Ez a 155. oldal a 242-ből www.kuruc.info

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.info)

Ez a 156. oldal a 242-ből www.kuruc.info

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.info)

Ez a 157. oldal a 242-ből www.kuruc.info

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.info)

ImageList
Függvényeket biztosít az Image objektumok gyűjteményének irányításához. Ez az osztály nem örökölhető.

Észrevételek ImageList-et tipikusan például ListView, TreeView, vagy ToolBar-nál szokás használni. ImageListhez adhatunk bitmaps, ikonokat, vagy meta fájlokat, és a különböző komponensek használhatják azokat, ha igényük van rá. ImageList használ egy fogantyút a képek listájának irányítására. Ez a fogantyú - „Handle” - mindaddig nem jön létre, amíg bizonyos műveletek nem hajtódnak végre, mint például az ImageList feltöltése képekkel.

Példa
A következő példa megmutatja a kijelölt képeket, megváltoztatja, és azután megjeleníti.

Ez a 158. oldal a 242-ből www.kuruc.info

kuruc.info . oldal a 242-ből www.info) Ez a 159.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.

info) Ez a 160.kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. oldal a 242-ből www.kuruc.info .

info .kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. oldal a 242-ből www.kuruc.info) Ez a 161.

vagy be tölthetjük egy Rich Text Format (RTF) fájlból. hogy a szöveg bold vagy italic legyen.info) Paraméterezés Tulajdonságok ColorDepth Contanier Handle HandleCreated Images ImagesSize ImageStream Site TransparentColor Beállítja a kép lista képeinek szín telítettségét Beállítja az IContaniert. A RichTextBox komponens olyan metódusokat is ad. A Ez a 162. amit fel tudunk használni a komponensen belül. A SelectionFont tulajdonság lehetőséget biztosít számunkra. a szövegen. amiket már más megnyitott velünk egy időben. mint egy mezei TextBox komponens. hogy belépjen és szerkessze a szöveget.info . Ezen felül még olyan fájlokat is meg tudunk nyitni.kuruc. SelectionColor tulajdonsággal a szöveg színe állítható be. ami mellett még több. Még arra is használhatjuk. Gyorslista készítéséhez. Ahhoz. A komponensen belüli szöveg lehet egyszerű karakteres vagy paragraph formátumú. beállíthatjuk a paragraph formátumot a SelectionIndent. hogy meghatározzuk a méretét vagy a betűképet. a SaveFile metódust is tudjuk arra használni. vagy egy egyszerű text fájlból. és SelectionHangingIndent tulajdonságokkal. hogy megfelelő RTF vagy ASCII fájl formátumban mentsünk el szövegeket. tartalmazó fájlokat nyissunk meg a komponensbe. SelectionRightIndent.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Észerevételek: A RichTextBox komponens megengedi a felhasználónak. használjuk a SelectionBullet tulajdonságot. amelyek funkcióival megnyithatunk vagy menthetünk fájlokat. Csak a kijelölt szövegben tudjuk megváltoztatni a karakter és paragraph formátumot. először ki kell jelölni. A LoadFile metódus megengedi. hogy egy megnyitott fájlba menthetünk. hogy megváltoztassuk a szöveg formátumát. annak bármelyik részén. Hasonló módon. mint a LoadFile metódus. oldal a 242-ből www. A SaveFile metódus megengedi. egymástól különböző formátumot is engedélyez. amit a komponens tartalmaz Beállítja a kép lista objektum bizonyos fogantyúját Beállítja az értéket ha Win32-es fogantyút készítettünk. A RichTextBox komponens ad egy számot a tulajdonságairól. hogy megfelelő RTF vagy ASCII szöveget.kuruc. Itt lehet a képeket az ImageListhez fűzni Képméret beállítása Beállíthatjuk a fogantyút az ImageListStreamerhez összekapcsolva az aktuális képlistával Beállítja az Isite-ot a komponenshez Szináttetszőség beállítása RichTextBox Reprezentál egy Windows rich text box komponenst. hogy alkalmazhassunk egy formátumot. A szöveget kijelölhetjük közvetlenül a komponensben.

amelyeket már a TextBox komponens is használ. méretét. akkor használhassuk a DetectUrls tulajdonságot. mondjuk egy web sitera.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. majd megkeresi az első helyet. ahol a "Text" kifelyezés jelen van. Alkalmazásokat. hogy a szöveg a komponensen belül védve legyen a felhasználók manipulációival szemben. Ezután a program megváltoztatja a kijelölt szövegrész betű típusát. hogy hasonló stringeket keress a szövegben. ami beolvas egy RTF fájlt.kuruc. A Find metódus arra is lehetőséget biztosít. hivatkozhatunk a Protected eventre. Ha a komponensen belüli szöveg tartalmaz egy linket. Ezután a LinkClicked eventtel elérhetjük. Az is megvalósítható. ha módosítani akarja. oldal a 242-ből www.info . azonban a RichTextBox komponens nem tartalmazza a TextBox 64k karakter kapacitás limitjét. Végezetül a megoldásban hozzáadja a Form felületéhez a RichTextBoxot. A SelectionProtected tulajdonsággal engedélyezhetjük azt. majd ezekkel a változtatásokkal visszamenti az eredeti fájlba.info) RichTextBox komponens olyan lehetőséget is ad. Példa: A bemutatandó példában készítünk egy RichTextBox komponenst. hogy lehet e módosítani a tartalmát Háttérkép Háttér szín Nem kliens tartalmának a mérete Ez a 163. könnyen bele lehet építeni a RichTextBox komponensbe. hogy megfelelően jelenjen meg a link a komponens szövegében. hogy adatot tároljon a memóriában. hogy stringeket keressünk a szövegben. Ezzel a levédett szöveggel a komponensen belül. hogy ez működjön is. amivel közölhetjük a mezei felhasználóval. Néhány fontosabb Tulajdonság: Dock AutoSize Enabled BackGroundImage BackColor Bounds Hogy hol helyeszkedjen el a formon belül Automatikusan beállítja a komponens méretét font változtatás után Meghatározza.kuruc. hogy ez a szövegrész számára nem módosítható. színét.

Például arra is használhatjuk. Például. hogy felhívják a felhasználók figyelmét a kontrol használatáról.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Hogy egy ToolTip szöveg kiíródjon.. hogy kiírja a képernyőre a kapcsolat aktuális sebességét is vagy az egér fókuszát. Összegezve a segítségen felül a ToolTp osztály futásközbeni információadásra is nagyon jól használható. A ToolTip osztályt valamennyi tárolóban használhatjuk. amit a kliens használ A felhasználó által használható terület hosszúságát és szélességét lehet beállítani Beállítja a komponens gyorsindító menüjét Tartalmazza a komponensen belül használható komponenseket Az egér mutató kinézete amíg a komponens felett van Beállítja a komponenst ha több gyermek származik belőle Magasság Szélesség Balról behúzás obbról behúzás Felülről Alulról Size ToolTip Reprezentál egy kis téglalap alakú. hozzá rendelhetünk egy TextBox komponenshez egy ToolTip szöveget..kuruc. hogy segítsünk a felhasználóknak.. Annak a téglalapnak a tulajdonságait lehet beállítani. amikor a felhasználó egy komponens fölé pozícionál az egérrel. amire az egérrel rápozícionálunk. mikor a felhasználó azt a PictureBox felett mozgatja. hogy specifikáljunk egy konténert. Észrevételek: A ToolTip osztály lehetőséget ad. felbukkanó ablakot. amit oda be lehet írni. ami tömör szövegben kijelzi annak a dolognak a tulajdonságát vagy használatát. oldal a 242-ből www. Ahhoz. használjuk a ToolTip komponens konstruktorát. A ToolTip szöveg a komponens öszEz a 164.info) ClientRectangle ClientSize ContextMenu Controls Cursor HasChildren Height Width Left Right Top Bottom Méret Stb. a ToolTip szövegnek össze kell lennie kapcsolva a komponenssel egy kérelem formájában a ToolTip osztályban.info . ha rápozícionálnak az egérrel egy komponensre. A ToolTip osztályt tipikusan arra használják. ami megadhatja a TextBox nevét és típusát.kuruc.

a RemoveAll függvényt használjuk. A kód ezután initalizál késleltető tulajdonságokat az AutoPopDelay. A SetToolTip függvény több mint egyszer tudja utasítani a különböző komponenseknek. Végezetül. Megjegyzés: A ToolTip szöveg olyan komponens fölé nem íródik ki. Ez a 165. törölhetjük stb. amikor rá pozícionálunk Az az idő amíg vár mielőtt megjelenik a szöveg Annak az időnek a hosszát lehet beállítani. Példa: A követendő példa készít egy hivatkozást és összeköti azt a Formmal egy beépített kérelemmel. Ha törölni akarjuk az összes ToolTip szöveget. amíg a Form fut. a példabeli megoldás összeköti a ToolTip szöveget két komponenssel a Formon. Például a TextBox-hoz rendelhetünk egy contextmenüt. így segítve a felhasználót. amit egy kontrol vagy a form fölött az egér JOBB gombjának lenyomásával érhetünk el. Ha azt akarjuk. amíg a Tooltip aktív.kuruc. InitialDelay. amíg várnia kell a szöveg felvillantásakor. hogy a szöveg össze legyen kötve a komponenssel. használjuk a GetToolTip függvényt. Automatikus késleltetés beállítása Itt állíthatjuk be azt az időt amíg a szöveg jelen legyen.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. hogy a ToolTip szövegek mindaddig megjelenjenek. oldal a 242-ből www. egy Button-al és egy CheckBox-al. hogy a MainMenu elemeit összeválogatva.info) szekapcsolására használd a SetToolTip függvényt. ami nincs engedélyezve.info . és ReshowDelay-el. amivel össze vannak kötve. ha a form nem aktív ISite Component ContextMenu A ContextMenu-ről általában: A ContextMenu osztály egy menüt szolgáltat. hogy változtassák meg a szövegüket. melynek segítségével beállítható a TextBox szövegének betütípusa vagy a vágólapra másolhatjuk. Ezt a menüt általában arra használjuk. mikor egyik komponensről a másikra megyünk át Szövegkijelzés beállítása.kuruc. az egyes területekhez rendeljük őket. Tulajdonságok: Active AutomaticDelay AutoPopDelay InitalDelay ReshowDelay ShowAllways Site Megadja vagy beállítja a kijelezendő értéket.A ShowAlways tulajdonság igazra állításával tudjuk beállítani.

A Toolbox-ban kattintsunk kettőt a ContextMenu komponensre. oldal a 242-ből www. ami tartalmazza ezt a menüt. Visszaadja. mielőtt a menü megjelenítésre kerül. ami tartalmazza ezt a menüt. Az objektumot String formára alakítja. Felszabadítja a nem használt ezközöket forrásokat a garbage collection előtt.info . A komponenshez tartozó esemény kezelők listáját adja vissza. amik a menüben vannak. A menüt egy megadott pozícióban jeleníti meg. Egyesíti egy menü MenuItem objektumait az aktuális menüével. Visszadaja az aktuális példány típusát.kuruc. hogy egyenlők -e.hogy a komponens design módban vane.kuruc. Visszaadja a MeniItem objektumokat. Egy eseménykezelőt ad. amihez hozzá akarjuk adni a ContextMenu-t. Elengedi a komponens által használt forrásokat. hogy melyik kontrol jeleníti meg a menüt. Bekövetkezik. Visszaadja a MainMenu-t.info) A ContextMenü részei: Publikus konstruktor ContextMenu konstruktor Publikus property-k Container MenuItems SourceControl Publikus metódusok Equals GetContextMenu GetMainMenu GetType MergeMenu Show ToString Public események Disposed Popup Protected property-k DesignMode Events Protected metódusok CloneMenu Dispose Finalize A ContextMenu osztály egy új példányát inicializálja. Visszaadja a ContextMenu-t. ami mutatja. Eldönti két objektum példányról. A ContextMenu-t a formhoz vagy kontrollokhoz rendelhetjük a Properties ablakban az objektumok Ez a 166. ami ekkor a komponens tálcához adódik. ami figyeli a komponens Disposed eseményét. ContextMenu hozzáadása a Windows Formhoz: Nyissuk meg a Windows Form Designerben azt a formot. Egy értéket ad vissza. Paraméterként lemásolja a menüt az aktuális menübe.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Visszaadja azt az Icontainer-t ami tartalmazza a komponenst.

ami tartalmazza a komponenst. ha az ikonra kattintunk a system tray-en. ha a system tray-en az ikon fölött mozgatjuk az egér mutatóját. Ez a 167. a ContextMenu property segítségével állíthajuk be. a hangerőszabályzó stb. ami figyeli a komponens Disposed eseményét. Az Icon property definiálja. Beállítható vagy lekérdezhető a tooltip szövege. Akkor következik be. A NotifyIcon osztály ezt a funkcionalitást kínálja a programok számára. A StatusBar-on helyet kap még a SizingGrip.info) ContextMenu property-jének beállításával. Ezeken a paneleken szövegek és/vagy ikonok találhatóak. lekérdezése. ha a system tray-en az ikon fölött lenyomjuk az egér gombját. hogy milyen felugró menü tartozzon hozzá. Akkor következik be. ha a system tray-en az ikon fölött elengedjük az egér balgomját. Visszaadja az Icontainer-t. hogy a formon található objektumokról információt szolgáltasson. ha az egér mutatóját az ikon fölött időztetjük.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. amelynek segítségével a form méreteit állíthatjuk be. ha az ikonra duplán kattintunk a system tray-en. ContextMenu beállítása. Egy eseménykezelőt ad. vagy újra megnyomjuk a jobb gombját. Akkor következik be. Akkor következik be.kuruc. NotifyIcon láthatóságának ki.kuruc. lekérdezése. StatusBar StatusBar-ról általában: A StatusBar kontrol StatusBarPanel-objektumokat tartalmaz. oldal a 242-ből www. Ikon beállitása. ami akkor jelenik meg. ha az egérmutatót a system trayen lévő ikon fölé helyezzük. milyen programok futnak a háttérben. Akkor következik be.és bekapcsolása. NotifyIcon részei: Public Konstruktor NotifyIcon Constructor Public Property-k Container ContextMenu Icon Text Visible Public Események Click Disposed DoubleClick MouseDown MouseMove MouseUp A NotifyIcon ősosztály egy új példányát initializálja. A StatusBar kontrol tipikusan arra szolgál. A Text tulajdonság pedig akkor jelenik meg. NotifyIcon NotifyIcon-ról általában: A System tray-en látható ikonok mutatják. hogy milyen ikon jelenjen meg a System tray-en. Ilyenek például a különböző virusírtó programok.info . Azt. Ezeken az ikonokon keresztül férhetünk e programok felhasználói interfészéhez.

kuruc.info) StatusBar részei: Public Konstruktor StatusBar Constructor Public Property-k Name AllowDrop ContextMenu Cursor Enabled Font Location Panels ShowPanels Size SizingGrip Text Visible Public Események Click DragDrop PanelClick A StatusBar osztály egy új példányát inicializálja. hogy az egérmutató milyen legyen. lekérdezése. lekérdezhető az értéke annak. Betűtipus beállítása. Ezzel lehet a StatusBar-t ki-bekapcsolni.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. ToolBar A ToolBar-ról általában: Ez a 168. StatusBar méreteinek beállítása.info . A panelok ki-. A SizingGrip ki-.kuruc. Az objektum neve. bekapcsolása a StatusBar-on. A pozíció beállítása. Drag-and-drop esemény bekövetkezésekor. amikor a ToolBar felé ér. Beállítható. ill. Beállítható. A StatusBarPanel collection-ja amiket a StatusBar tartalmaz. amit a felhasználó rádobott. hogy a kontrol elfogadja -e az adatot. oldal a 242-ből www. ContextMenu beállítása. Amikor valamelyik panelra kattintunk. bekapcsolása (melynek segítségével a form méretei állíthatóak) A StatusBar-on látható szöveg StatusBar láthatóságának ki-bekapcsolása. Mikor a kontrolra kattintunk.

info . Szegély stílusának beállítása. csak mindig szem előtt vannak. A gombokra képeket rakhatunk és különböző stílusúra állithatjuk őket. hogy ToolBarButton-okat jelenítsünk meg a képernyőn. így gyorsítva a munkát.kuruc. hogy a kontrol elfogadja -e az adatot.kuruc. mint egy menüt. A ToolBar-t úgy használjuk.info) A ToolBar kotrollokat arra használjuk. A ToolBar kontrol és a gombjai megjelenítésének beállítása és lekérdezése. Ez a 169. amit a felhasználó rádobott. illetve drop-down stílusú gombok lehetnek. oldal a 242-ből www. toggle. lekérdezhető az értéke annak. A Toolbar részei: Public konstruktor ToolBar Constructor Public Property-k AllowDrop Appearance AutoSize BorderStyle Buttons A ToolBar osztály egy új példányát inicializálja. ill. A ToolBar-on megjelenő ToolBarButtonok gyüjteménye. Beállítható.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Automatikus méretezés beállítása és lekérdezése. A gombok menüpontoknak felelnek meg. amik standard.

Beállítható.. minnél kisebb a %. hogy az egérmutató milyen legyen amikor a ToolBar felé ér. FixedSingle.info) ButtonSize ContextMenu Cursor Dock Enabled Font ImageList Location Name Size Visible Public metódusok DoDragDrop FindForm Public események ButtonClick ButtonDropDown DragDrop A ToolBaron lévő gombok méretének beállítása. Drag-and-drop esemény bekövetkezésekor. A ToolBar poziciójának beállítása. FixedDialog. Ne felejtsük módosítani a forráskódban is! Nem automatikus. HelpButton Menu MainMenu obj.) Font A form és a formon lévő kontrollok default fontbeállítása FormBorderStyle A form keretének stílusa: default: sizable None. A Toolbar neve. ha az értéke false. ContextMenu beállítása. oldal a 242-ből www. Drag-and-drop művelet engedélyezése. Neve.. Opacity Átlátszóság. hogy a ToolBar hol dokkoljon. Fixed3D. Beállítható. amin a kontrol rajta van. Akkor következik be. ha a ToolBar-on egy ToolBarButton-ra kattintunk. akkor nem jelenik meg a taskbaron a program. Minimized. height) A form mérete pixelben StartPosition A form megjelenéskor hol helyezkedjen el: WindowsDefaultLocation Manual CenterScreen CenterParent WindowsDefaultBounds (nem ajánlott) Text A form fejlécében megjelenő szöveg WindowState Form állapota [Normal. lekérdezése.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Látható.info . CancelButton. formok típusai Formok jellemzői: A form azonosítója. static void Main() { Application. Size (width. nem látható.. kiválasztható (jpg. maximized] (Name) Ez a 170. SizableToolWindow Buttons: A formra elhelyezett gombok alapértelmezett jelentése lehet AcceptButton. FixedToolWindow. Visszadja a formot. A Toolbar méretének beállítása. png. ha egy drop-down stílusú gombra vagy a nyilára kattintunk..kuruc. Ezzel lehet a ToolBar-t ki-bekapcsolni.Run(new frmMain()). Beálliható. Betűtipus beállítása. annál jobban átlátható a form ShowInTaskbar Default: true. lekérdezése. } BackColor Háttérszín BackgroundImage Háttérkép. hogy a gombok képei melyik ImageList-ből legyenek elérhetőek. Formok használata. bmp . 100% az átlátszatlan. Akkor következik be.kuruc. a programon belül hivatkozhatunk a formra ezzel.

Ennek a neve dr. Ha nyomógombokat is tartalmaz. Az első paramétere a megjelenítendő szöveg. Az első sorban létrehozunk a DialogResult osztályból egy példányt.info . vagy string típusú változó. A második paramétere szintén string.kuruc. akkor a visszatérési értéke egy DialogResult osztály példánya. hogy a felhasználó mely nyomógombra való kattintással zárta az üzenetablakot. de lehetőségünk van elhagyni is belőle. oldal a 242-ből www.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Az üzenetablak megjelenítését a Show metódus végzi. melynek a lehetséges értékei: AbortRetryIgnore Ok OKCancel RetryCancel YesNo YesNoCancel Ezek közül választhatunk a gombok kiválasztásánál. melynek paraméterei határozzák meg a megjelenést.kuruc. string konstans. A MessageBoxIcon segítségével az alábbi képecskéket választhatjuk: Ez a 171. A példaprogram Üzenet gombja bemutatja az alkalmazás módját. nyomógombokat. ez lesz a megjelenő form fejlécének felirata. melynek a segítségével meghatározhatjuk. Majd a MessageBox. A harmadik paraméter határozza meg. és képi szimbólumot. A MessageBoxButtons egy felsorolt típus. A példában a Show metódusnál kihasználtuk ezeket a paramétereket.Show metódushívással megjelenítjük az üzenetablakot. hogy milyen nyomógombok jelenjenek meg a formon. Ez tartalmazhat szöveget.info) A rendszer által biztosított üzenetablakok használata A MessageBox osztály segítségével tudunk egy üzenetablakot megjeleníteni a képernyőn. A negyedik paraméter a képi szimbólumot határozza meg.

hogy a felhasználó melyik nyomógombot választotta.info . azaz elhagyható az icon meghatározás.kuruc.info) Ez után egy egyszerű switch szerkezettel el lehet dönteni. hogy a MessageBox-nak lehetséges 3 paramétere is. Ebben a példában látható. oldal a 242-ből www.kuruc. Ez a 172.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.

Show().info . Erre látunk egy példát a következő képen. Így ha nem ellenőrizzük programból. A példaprogramban a ’Nem modális’ gombra kattintva érhetjük ezt el.kuruc. Példányosítás után megjelenítjük a formunkat. akkor a ShowModal() metódust kell használnunk. A form megjelenik. Ha a másik lehetőséget választjuk. A Show() metódus megjeleníti a formot. hanem akár más form.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. akár a hívó form újra aktivizálható.kuruc.info) Modális és nem modális formok A saját formok megjelenítésénél KÉT lehetőség között választhatunk. oldal a 242-ből www. frmKetto frmK = new frmKetto(). frmK. Ekkor a formunk egy dialógus boxként jelenik meg. de nem birtokolja a fókuszt kizárólagosan. akár több ugyanolyan form is megjeleníthető. Ez a 173. amelyik kizárolagosan birtokolja a fókuszt. a visible tulajdonságának true-ra állításával.

akkor a megjelenő formon lévő gombok tulajdonságai közül a DialogResult értéket állítsuk be a nekünk megfelelőre.kuruc. és látható formot sem. hogy melyik nyomógomb segítségével zárta be az ablakot a felhasználó.info .info) Nem aktiválhatjuk az őt hívó formot.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Ennek felhasználásával kiértékelhetjük. A megjelenítésre példa. Ez a 174. a programhoz tartozó. Ennek a metódusnak van visszatérési értéke. ami egy DialogResult példány.kuruc. oldal a 242-ből www. Ha szeretnénk használni a kiértékelés adta lehetőséget is. ha a ’Modális’ gombra kattintunk. majd a hívó helyen a megjelenítés köré szervezzünk egy vizsgálatot. vagy más.

NET elhelyezi a kódban!) A futtatáskor a következő kimenet látható: Ez a 175. egy fontDialog-ot és egy nyomógombot (button)! A listBox Items tulajdonságánál gépeljünk tetszőleges szöveget a listBox-ba.kuruc. paramétereket kérni tőle. hibaüzeneteket generálni. helyezzünk a Form-ra egy listBox-ot. mivel segítségükkel tudunk a felhasználóval kommunikálni.info . dialógusoknak fontos szerepe van a Windows alatt futó programok készítésénél. vagy beállításokat. A fontDialog A FontDialog elindítása és a fontkészlet kiválasztása a következő módon történik: a fontDialog ShowDialog() eseményével tudjuk aktivizálni azt a párbeszéd panelt.kuruc. valamely megfelelő osztályból történő származtatással is. Az eljárás hatására a listBox-ban tárolt szöveg fontja a fontDialog-ban kiválasztott font tulajdonságait kapja meg. vagyis a kívánt font típust. de elő lehet állítani őket dinamikusan. mivel a nyomógombhoz tartozó függvényt a . a nyomógomb eseménykezelőjébe pedig a fenti programrészletet írjuk! (Csak a függvényben lévő utasításokat gépeljük be. melyen a felhasználói beállítások elvégezhetőek.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. A dialógusok megtalálhatóak a komponens palettán. majd a megfelelő komponens fontkészletéhez hozzárendelhetjük a felhasználó választásának eredményét. oldal a 242-ből www. Amennyiben programot szeretnénk készíteni a fontDialog komponens kipróbálására.info) Dialógusok A különböző párbeszéd ablakoknak.

info . csak míg az a Ez a 176. Az alábbi táblázatban összefoglaltuk a fontosabbakat. (Természetesen a kiválasztott színt végül nekünk kell hozzárendelni az adott komponenshez.) A következő forráskód megmutatja a colorDialog használatát: Mint láthatjuk. ez a komponens is hasonlóan működik. ColorDialog Ez a komponens alkalmas a különböző hátterek. a FontDialog.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info) Az C# nyelv vizuális részében található többi dialógus is hasonló módon működik. mint az előző.kuruc. felületek színének kiválasztására.kuruc. oldal a 242-ből www.

: a Word ’’nyomtatási kép” ablakához. s a felhasználónak megmutatni a tényleges nyomtatás előtt. A nyomtatási kép megjelenítéséhez a printPreviewDialog komponenst használhatjuk. oldal a 242-ből www. mely hasonló pl.kuruc. Ilyen esetekben a nyomtatási képet nem árt megvizsgálni. hogy a programjainkból nyomtatóra szeretnénk küldeni bizonyos adatokat.info . A párbeszéd ablakot úgy aktivizáltuk. a programunkat az előző példa alapján építsük fel! Az így megírt program kimenete a következő: PrintPreviewDialog Sokszor előfordul. Amennyiben ki akarjuk próbálni ezt a komponenst is.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. ez a színek kiválasztására alkalmas. ahogyan az előzőeket: Ez a 177.info) fontok.kuruc.

MessageBox Fontos még megemlíteni a MessageBox osztályt is. hogy meghívjuk a showDialog() függvényüket.info . melynek metódusaival különböző párbeszéd paneleket tudunk megjeleníteni a képernyőn.Show("Üzenetablak komponensfutás közben"). mivel a Windows-ban megszokott fájltallózó ablakokat aktivizálják. Csak annyi a dolgunk velük.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. oldal a 242-ből www. s támogatják a fájlkezeléshez szükséges metódusokkal. Ha a fenti kódrészletet egy nyomógomb eseménykezelőjében helyezzük el. Ez a két komponens is könnyen használható. majd futtatjuk. majd a kiválasztott fájlt (fájlokat) a megfelelő metódusok segítségével elmentjük. de a megírása nem tartozik szorosan a fejezethez. az alábbi kimenethez jutunk: Ez a 178.kuruc.kuruc. Fájl megnyitása és mentése Az openFileDialog és a saveFileDialog a fájlok megnyitását és kimentését teszik egyszerűvé. segítve ezzel a kommunikációt a felhasználóval. amelyet meg szeretnénk jeleníteni. A következő forráskód részlet bemutatja a MsgBox használatát: MessageBox.info) A nyomtatás kezelése igényel még néhány sornyi forráskódot. vagy éppen betöltjük. A MesageBox osztály Show() metódusában tudjuk elhelyezni azt az üzenetet.

de hatékony támogatást ad azok készítéséhez. Egy processzor esetén nem fejezik be futásukat hamarabb. oldal a 242-ből www. hogy a szálkezelő elindítsa és vezérelje a szálakat. Előfordulhat. vagy egy program több szála fut egy időben. A futó alkalmazásunk is egy programszál. A .NET rendszerben akkor is szálkezelést valósítunk meg. még a számukat is megadhatjuk. (Az következőkben ismertetett programhoz a Microsoft által kiadott ”David S Platt: Bemutatkozik a Microsoft . gondoskodni kell arról. eszközzel kommunikál. Amennyiben tudatosan hozunk létre többszálú programokat. használja a különböző erőforrásokat és verseng a processzoridőért.NET” című könyvben publikált Párhuzamos Kódokat bemutató fejezetéből vettük az alapötletet. futtatása.kuruc. több processzoros rendszerek programozására. melyben a Form háttérszínét dialógus segítségével meg lehet változtatni! 3) Készítsünk programot. majd ezt fejlesztettük tovább és írtuk át C# nyelvre. A szálakat természetesen magunk is elindíthatjuk. Az említett könyv olvasása javasolt annak. vagy többszálú programok fogalma megtévesztő lehet. s mialatt az egyik szál adatokra vár. A párhuzamos. Természetesen az egyes szálakat valamilyen algoritmus ütemezi. A . vagy éppen egy lassabb perifériával.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. de mindenképpen jobb ezt a rendszerre bízni. és a szálak külön-külön sem futnak rövidebb ideig.NET újítása. segítségével lehetőség nyílik a processzor hatékonyabb kihasználására. mert talán így tudjuk a legegyszerűbben bemutatni a több szálú programokat.info) Feladatok 1) Készítsünk programot. a többi szál használhatja az értékes processzoridőt. amikor egyszerű programokat írunk.NET a szálkezelőnek átadott szálakat ütemezi.NET Ez a 179. Használjuk a fontDialog és a colorDialog komponenseket! 2) Készítsünk programot. amely lehetővé teszi. nagyban segítve ezzel a programozó dolgát. ami egymagában fut.kuruc. Egy processzoros rendszerekben is előnyt jelenthet a többszálú programok írása.info . aki a . A több szálat használó alkalmazások fejlesztésének lehetősége nem a . mely a printPreviewDialog ablakot aktivizálja! Többszálú programozás A többszálú programozás viszonylag új technika. s azok szeletei egymás után futnak és nem egy időben. viszont több processzor esetén a futási idő radikálisan csökkenhet. és megpróbálja a számukat is optimalizálni. hogy több program. hogy egy listBox-ba írt szöveg betűtípusát és a listBox háttérszínét a felhasználó meg tudja változtatni.

mint a ciklus lépésszáma. „futó” ikonra.ThreadPool. és mellettük néhány szál éppen alszik. A listView ablakában látszik. A programban egy időben több szál is fut. a sárgák az aktív szakasz utáni alvó periódust. futtatja. szimulálva egy valós program-szál működését: 1. a szálakat egy ImageList-ben tárolt képsorozat elemeivel szimbolizálja. majd leállítja azt.bői veszi). hogy egyszerre akár három. hogy egyszerre hány szál fut. A célfüggvény mellett adhatunk a metódusnak egy tetszőleges objektumot. (Az ikonokat egy imageList. hogy egy valós. vagy egyéb fontos esemény történik. s közvetett úton a célfüggvénynek: Végül átadjuk a példányt a célfüggvénnyel együtt a szálkezelőnek.kuruc. Az egyszerűség kedvéért a program célfüggvénye csak a szál ikonját és feliratát cserélgeti. mely feldolgozza ezeket. azután átírja az ikon feliratát: Ez a 180. Ütemezi. mely gondoskodik a szál sorsáról. ezzel átadva az adott szál sorszámát a szálkezelőnek. A program indulása után a Form.ra helyezett nyomógomb indítja el a szálkezelést. Beállítja a szál ikonját a piros. A programban szerepel egy célfüggvény. ezzel jelezve. a program annyi szálat hoz létre. Az egyszerre futó szálak számát nem a programozó határozza meg.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. A példában az egy mezőt tartalmazó Parameterek osztályt adunk át a paraméter listában. ami átadja ezeket a célfüggvénynek. viszont cserélgeti a futó szálakat.NET keretrendszer az erőforrások függvényében. hanem a . A célfüggvény a következő dolgokat végzi el. Induláskor közöljük a programmal a futtatni kívánt szálak számát. viszont azt. vagy négy szál is futhat. párhuzamos program ezen részében adatfeldolgozás. de a processzor egy időben csak eggyel foglalkozik. A nyomógomb eseménykezelőjében. Mivel a szálak létrehozását ciklusba szerveztük.QueueUserWorkltemO metódusnak. melyben paramétereket közölünk vele.info) rendszer használatát és finomságait teljes mértékben meg akarja ismerni!) A példaprogram egy listView komponens segítségével bemutatja. majd átadjuk a célfüggvényt a System.info . beállítjuk az elem ikonját és feliratát: Értékül adjuk a ciklusváltozóját az osztály i változójának.Threading. melyben az adott elem sorszámát közöljük a célfüggvénnyel. hogyan futnak egymás mellett a szálak. a FOR ciklusban példányosítjuk a Parameterek osztályt (minden szálhoz egyet): Hozzáadjuk a soron következő elemet a listView komponenshez. A Piros ikonok az aktív szakaszt mutatják. és a már nem futó szálakat szimbolizálják. mely a szálakhoz rendelt eseményt hajtja végre.kuruc. de lassabb gépeken ezek a számok növekedhetnek. a kék ikonok pedig a még feldolgozásra váró. a szálkezelő dönti el. oldal a 242-ből www.

majd az ikonja az eredetire vált: Sajnos a többszálú programozás közel sem ilyen egyszerű.Threading. ha tisztában vagyunk a használatukban rejlő előnyökkel.kuruc. A grafikus felületnek tartalmaznia kell a következő komponenseket: listView. a feliratát pedig „Alvó szál” . vagyis biztonságosan kell futniuk egymás mellett. A futó szálak nem használják egy időben ugyanazt az erőforrást. amit szeretnénk. és a lehetséges hibákkal is. A jól megírt többszálú programok optimálisan használják fel az osztott erőforrásokat.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.Thread. Bonyolultabb alkalmazások esetén egy probléma mindenképpen felvetődik. A rosszul megírt párhuzamos működésű programokkal éppen az ellenkezőjét érjük el annak. A System. „alvó” ikonra. a memória foglaltságát és a programok hatékonyságát. 2) Készítsen programot. Növeljük a lépésszámot. A progressBar állapota mutassa az aktuális szál feldolgozottságát! Ez a 181. oldal a 242-ből www.kuruc.info . imageList az ikonok rajzával (ezeket a Paint programmal rajzolja meg). majd átállítja a szálhoz tartozó ikont a sárga.ra: 3. de csak akkor használjuk fel a lehetőségeiket.info) 2. melynek grafikus felületén két progressBar komponens két futó programszál állapotát szimbolizálja! A Form-on egy nyomógomb segítségével lehessen elindítani a szimulációt.Sleep(1000) metódussal a szálkezelo várakoztatja a szálat. és egy nyomógombot a folyamat elindításához. A szál ismét várakozik. Feladatok 1) A fejezetben szereplő forráskódok és azok magyarázata alapján állítsa elő a tárgyalt programot.

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. oldal a 242-ből www.kuruc.kuruc.info) Programozás tankönyv XVI.info . Fejezet „Grafikai alapok!” Dr. Kovács Emőd Ez a 182.

kuruc. Képfeldolgozás: képek javítása átalakítása a későbbi feldolgozás érdekében. képek előállítása.kuruc. nem teljesen elkülönülő főterületet ölel fel: Generatív (létrehozó) grafikus adatfeldolgozás: képek és grafikus adatok bevitele. Síkbeli és térbeli objektumok modellezése. Mintafelismerés: Képekből meghatározott információk kiolvasása. GUI) Virtuális valóság (Virtual Reality) Multimédia-alkalmazások (Multimedia Application) Számítógépes játékok (Computer Games) Ez a 183. hanem számtalan alkalmazási területe van a grafikus adatok feldolgozásának is. Feladata a amely négy. A következő felsorolásban kísérletet teszünk arra. A számítógépes grafika (Computer Graphics) természetesen képekkel foglalkozik. oldal a 242-ből www.info . A csoportosításnál az volt a szempontunk. manipulálása és rajzolása leírások alapján. Grafikus képek tárolása a számítógépen és adathordozókon kódolt formában. Művészet és animáció (Art and Animation) Számítógéppel segített tervezés és gyártás: Computer Aided Design (CAD). hogy a számítógépi grafika témakörébe tartozó alkalmazásokat csoportosítsuk.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. leírások és adatok előállítása.info) A grafikus szoftver GRAFIKUS ADATOK FELDOLGOZÁSA. A számítógépi grafika önmagában nem csak a képekkel foglalkozik. hogy az alkalmazások milyen feladatcsoportot ölelnek fel és a használt módszerekben milyen összefüggések találhatók. Computer Aided Manufactoring (CAM) Bemutató és üzleti grafika (Presentation and Business Graphics) Tudományos és műszaki szemléltetés és szimuláció (Scientific Visualization and Simulation) Képelemzés és feldolgozás (Image analysis and processing) Grafikus kezelőfelületek (Graphics User Interfaces.

kuruc. A továbbiakban a C#-hoz kapcsolódó Ms-Windows GDI+ lehetőségeit tárgyaljuk GDI+ A GDI (Graphics Device Interface . Számos grafikus könyvtár létezik.grafikus eszközfelület) biztosítja az ablakosfelületet-használó grafikus alkalmazásoknak az eszközfüggetlen elkészítését.info) Egy komputergrafikai program a grafikus hardver szolgáltatásait grafikus könyvtárak segítségével éri el.info .C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. használni tudnak különböző nyomtatókat. legyen Ez a 184. amelyek egy része az operációs rendszerhez kötött.kuruc. Az így elkészült programok például képesek futni különböző képernyőfelbontásokban. oldal a 242-ből www. más része független.

System. Ez a struktúra megszabadítja a programozót a különböző hardver eszközök közvetlen programozásának fáradságos munkájától. Device Context: alapvető eszköz. Brushes. Bitmap. A System.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Osztályok és leírásuk: Bitmap. hogy a GDI+ API (Application Programming Interface) rugalmasabb és teljesebb.Forms névtérbe ágyazták be.Drawing. amit a számítógépen tárolunk. Graphics.kuruc. Font.Drawing névtér osztályai és struktúrái A System. A .poligonok kitöltésekhez) A szövegek formáinak a meghatározása (méret.Drawing osztályt és struktúrát. amelyet a Windows arra használ. Pen.Printing. nagyon sok újdonságot is megvalósítottak benne.Text. csak a benne rejlő lehetőségek izgalmasak számunkra.Drawing Namespace biztosítja az alapvető GDI+ funkciókat. A könyvünknek nem célja további részletességgel tárgyalni a GDI+ technikai leírását.Drawing. amelyeket a System. Például a Form-okhoz kapcsolódó osztályok a Windows. oldal a 242-ből www. hogy kezelje az output eszközt.NET-ben Névterek. A GDI+ egy új fejlődési pontja a GDI változatoknak.egy jóval magasabb szintű programozást tesz lehetővé. FontFamily Grafikus képek osztályai Ecset pl. ha erre a GDI közvetlenül nem képes.Drawing. Hasonlóan a GDI+ osztályok hat névtérbe vannak beágyazva. Image Brush. System.Drawing. A GDI réteg alkalmazására tekintsük meg a következő ábrát: A fenti ábrán jól látható hogy a GDI egy olyan réteg.. A Graphics osztály alapvető fontosságú a GDI+ban. System.NET könyvtárban minden osztályt névterekben (namespasce) csoportosítottak.(Windows-)alapú alkalmazás/környezet tölti be a memóriába.info . GDI: C++ osztályok halmaza. GDI+ osztály és interfész a .Drawing.vagy lézernyomtató. Olyan alapvető osztályokat tartalmaz. s az ablak.Imaging.dll tartalmaz. A Windows betölti a szükséges eszközkezelő programot (Device Driver) is.Drawing. mivel tartalmazza a megjelenítő eszköz (display device) rajzoló metódusait. mint a Brush. System.Drawing2D.info) az mátrix. mint az osztályhoz hasonló kategória. Amellett. GDI+ Namespaces: GDI+ a Drawing névtérben és a Drawing névtér öt alterében van definiálva. Font stb.Drawing. A következő listában felsoroltunk néhány alapvető System. A GDI+ . amelyek biztosítják a grafikus adatok eljuttatását a programokból a hardverek felé a Device Driver segítségével. a programozóknak már nem kell semmit sem tudniuk a hardver eszközökről. az ellipszisek.kuruc. System.NET rendszer GDI változata a GDI+. mint a GDI. A namespace nem más.szemben a GDI-jal . System. feltéve. amely elvégzi a grafikus parancs konvertálását a hardver eszköz számára érhető formába. A GDI egy programfájl. amely valójában egy olyan belső struktúra.Design. amely biztosítja a kapcsolatot a különböző hardver eszközök és az alkalmazások között. amikor egy grafikus output miatt szükség van rá. namespaces A Microsoft . Ez a 185.

DrawString Szöveg kiírása. left and width. Egyszinű kitöltési minta definiálása az ecset számára. A toll definiálása szakaszok (lines) és görbék rajzolására.kuruc.) A GDI+ grafikus felületének a megadása. Méret megadása téglalap alakú régiók esetében Sruktúrák és leírásuk: Color Point. DrawLine Szakaszrajzoló metódus. DrawPolygon Poligon rajzolása. DrawEllipse Ellipszis rajzolása. FillRectangles Téglalapok sorozatának kitöltése. A felület megadására két lehetőségünk adódik.(top. FillRegion Régió belső területének a kitöltése Ez a 186. Az OnPaint metódus paramétere PaintEventArgs típusú lesz. vagy felülírjuk a form OnPaint() metódusát. DrawBezier. FillPath Path belső területének a kitöltése.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. FillPie Kitöltött körcikk rajzolása. DrawPath Grafikus objektum sorozat (Path) előállítása. DrawClosedCurve Nyílt és zárt interpoláló görbe rajzolása. Ezen osztály metódusaival tudunk rajzolni a megjelenítőeszközünk felületére. DrawPie Körcikk rajzolása. DrawBeziers Bézier-görbék rajzolása. DrawRectangle Téglalap kontúrjának a megrajzolása. oldal a 242-ből www. FillRectangle Kitöltött téglalap rajzolása. height). FillPolygon Kitöltött poligon rajzolása.info .kuruc.info) stílus. PointF Rectangle. RectangleF Size A Graphics osztály A Graphics osztály a legfontosabb a GDI+ osztályai közül. DrawImage Kép megjelenítése. Vagy rajzoljuk a Form Paint eseményének segítségével. Téglalap definiálása a bal felső sarok koordinátáinak és a szélesség és magasság adatainak a megadásával. Szín definiálása Síkbeli pont megadása x. FillEllipse Kitöltött ellipszis rajzolása. Graphics Pen (curves) SolidBrush típus stb. y egész és valós koordinátákkal. DrawCurve. DrawArc Ellipszis ív rajzolása.

. a lépcsőhatás Cardinal Spline-ok A GDI+-ban lehetőségünk van a DrawCurve és a DrawClosedCurve metódusok segítségével interpoláló Cardinal spline-ok előállítására.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. A spline-t egy ponttömb (PointF[] myPoints ={.info . azaz lépcsőzetes színátmenet.kuruc.info) A GDI+ újdonságai Gazdagabb színkezelés és színátmenetek lehetősége Gradient Brushes. oldal a 242-ből www. mint pl..}) segítséEz a 187. Például lehetőség van egy téglalap vagy ellipszis lépcsőzetes kitöltésre: Programrészlet: Antialiasing támogatás A GDI+ lehetőséget biztosít a szépséghibák javítása.kuruc.

Előre definiált metódusok között válogathatunk (Translate. Skálázható régiók (Scalable Regions) Ez a 188. A téma részletes kifejtését a Ponttranszformációk fejezetben találjuk meg. Rotate.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Mátrix transzformációk A GDI+-ban széles lehetőségünk van síkbeli ponttranszformációk megadására. Shear) vagy az általános affinitás mátrixát (Matrix object) is megadhatjuk. A ponttranszformációkat transzformációs mátrixokkal írhatjuk le. A témáról részletesen leírást találunk az Interpoláció és appoximáció fejezetben. oldal a 242-ből www.info . Scale.kuruc. egymás utáni végrehajtására. az általuk meghatározott poligont kontrollpoligonnak nevezzük.info) gével tudjuk egyértelműen meghatározni. amelyek végrehajtási sorrendjét változtathatjuk. rugalmasan kezelhetjük.kuruc. A ponttömb pontjait kontrollpontoknak.

mintha pl. így keltve olyan érzetet. egy objektumot ablaküvegen keresztül.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Tekintsünk egy példát: Ez a 189.info . Az átlátszóság mértékét a blending technikában az ALFA értéke adja meg. oldal a 242-ből www. Ha egy kép minden pixeléhez rendeltek alfa-értéket. Ez az érték általában 0 és 1 között van.kuruc. és két kép keverésének arányát határozza meg.info) Alpha Blending A GDI+-ban az alfa-csatorna (Alpha Channel) értékének változtatásával lehetővé válik. hogy különböző képek egymás előtt jelenjenek meg. vagy víz alatt látnánk.kuruc. akkor beszélünk alfa-csatornáról.

EMF (Enhanced Metafile) EMF+ Bővített metafile. oldal a 242-ből www. vektoros file formátumok: WMF (Windows Metafile). A következő formátumokat támogatja: Raszteres formátumok: BMP Bitmap GIF (Graphics Interchange Format) JPEG (Joint Photographic Experts Group) EXIF (Exchangeable Image File) PNG (Portable Network Graphics) TIFF (Tag Image File Format) Metafile-ok.info .info) Sokféle grafikusfájl-formátum támogatása (Support for Multiple-Image Formats): GDI+ lehetőséget ad raszteres (Image).C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. menteni nem.kuruc. csak megjeleníti lehet.kuruc. bittérképes (Bitmap) és metafile-ok kezelésére. GdI+ és/vagy GDI rekordokkal Ez a 190.

Szakasz rajzoló eljárásunk meghívja a Garphics osztály DrawLine metódusát. oldal a 242-ből www. Az OnPaint metódus paramétere PaintEventArgs típusú lesz. hogy a (30.info) Néhány változás a GDI+ porgramozásban Vonalrajzolás GDI+ használatával Legyen feladatunk.info .100) pozícióba vonalat rajzolunk. vagy felülírjuk a form OnPaint() metódusát. Két lehetőségünk van a rajzolásra.kuruc. Most nézzük meg a két megvalósítást: Ez a 191. A GDI+-ban csak a Graphics és a Pen objektumokra lesz szükségünk.20) pozícióból a (300. Vagy megrajzoljuk a vonalat a Form Paint eseményének segítségével. A DrawLine első paramétere a Pen objektum.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.

Linerel. de különböző paraméter listával. Moverel jellegű utasítások sincsenek. Hasonlóan Lineto.kuruc. Szétválasztott metódus a rajzolásra (Draw) és a kitöltésre (Fill) GDI+-nak különböző metódusai vannak pl egy téglalap körvonalának megrajzolása és belső területének a kitöltésére. Van olyan methodus.Drawing.kuruc. hogy a a DrawLine összes változatában meg kell adni a kezdő és a vég pozíciót.info .info) Metódusok felülbírálása (Method Overloading) Nagyon sok GDI+ metódus felülbírált. azaz.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. oldal a 242-ből www. a FillRectangle metódus pedig a Brush objektummal használhatjuk. amelynek 12 változata van (System. mert például az előző részben láttuk. A DrawRectangle metódus a Pen objektummal. Tekintsünk egy példát: Ez a 192. számtalan metódus ugyanazon név alatt.Bitmap) Például a DrawLine metódus a következő négy formában: Többé nincs a grafikus kurzornak aktuális pozíciója (Current Position) Tehát nem használhatunk moveto jellegű parancsokat.

b). oldal a 242-ből www. és hoszszúságát (left.info) A FillRectangle és DrawRectangle metódusoknak a GDI+ használatakor az első paraméter mellett még meg kell adnunk a téglalap bal felső sarkának a koordinátáit.kuruc.a.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Más programozási nyelvek grafikus könyvtáraiban szokás az ellipszist középpontjával.kuruc.y. ugyanez a GDI+ -ban: Ez a 193. Teljesen hasonlóan járunk el az DrawEllipse és a FillEllipse metódusok használatakor is. s a téglalap szélességét. top. valamint a kis és nagy tengelyével megadni: Ellipse(x.info . width és height).

akkor ezeket az alakzatokat először a GraphicsPath objektum segítségével kell létrehoznunk.kuruc.info) A Color osztálynak négy paramétere van. Az első paraméter az Alpha Blending értéke. s ezzel transzparenssé tehetjük ábráinkat Regiók létrehozása A GDI+-ban könnyedén formázhatunk régiókat téglalapokból (Rectangle object) és grafikus objektumok sorozatából (GraphicsPath object) Ha tehát ellipszisre vagy kerekített téglalapra.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc. meghatározhatjuk a régiók metszetét. amely a rajzolószín és a háttérszín keverésének a mértékét határozza meg. oldal a 242-ből www. majd átadnunk a Region konstruktornak. Az utolsó három a szokásos RGB összetevők: piros (red).info . zöld (green) és a kék (blue). A Region osztály Union és Intersect metódusaival egyesíthetünk két régiót ill. Emellett Xor. Exclude és Complement metódusokat is használhatunk. Tekintsünk egy példát: Ez a 194. vagy egyéb grafikus alakzatra van szükségünk a régiók létrehozásánál.

Az Union metódus két régió esetén olyan régiót ad. oldal a 242-ből www.kuruc. amelynek pontjai mindkét régióhoz tartoznak (régiók metszete).kuruc. Ez a 195.info) Az Intersect metódus két régió esetén olyan régiót ad.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. amelynek pontjai vagy az első vagy a második régióhoz tartoznak (régiók uniója).info .

Az Exculde metódus két régió esetén olyan régiót ad. oldal a 242-ből www. de nem mindkettőhöz (Kizáró-vagy).info) Az Xor metódus két régió esetén olyan régiót ad. Ez a 196. amely nincs benne az első régióban (KOMPLEMENTERképzés).C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. amelynek pontjai vagy az első vagy a második régióhoz tartoznak.kuruc. A Complement metódus két régió esetén olyan régiót ad. amely nincs benne a második régióban (különbségképzés). amely az első régió minden olyan pontját tartalmazza. amely a második régió minden olyan pontját tartalmazza.kuruc.info .

info . valamint a t0 és ti érintő vektor. Az egységesebb szemléletmód miatt felírhatjuk a görbét mátrixalakban is: Ha a végpontbeli érintőket egyre nagyobb mértékben növeljük. polinom-együtthatókat kapjuk. Adott a p0 és p1 pont. Hermit-görbe A harmadfokú Hermit-görbe kezdő és végpontjával és a kezdő és végpontban megadott érintőjével adott.kuruc. oldal a 242-ből www.info) Interpoláció és approximáció Ebben a fejezetben a C# .NET GDI+ által nyújtott interpolációs és approximációs lehetőségek mellett a téma matematikai hátterét is megvilágítjuk. ahol a felső pont a derivált jele.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Keresünk egy olyan harmadfokú polinommal megadott görbét. amelyre teljesül. Ezeket visszahelyettesítve és átrendezve kapjuk: Az egyenletben szereplő együttható-polinomokat Hermite-polinomoknak nevezzük. Ez a 197. s ezzel lehetőséget adunk az általánosításra. akkor kialakulhat hurok a görbén. mint a kontrolladatok (a p0 és p1 pont.kuruc. és a következőképpen jelöljük: Ekkor a görbe felírható a Hermit-alappolinomok segítségével: Az előbbi összefüggés alapján az Hermit-görbét tekinthetjük úgy. valamint a t0 és t1) súlyozott összege. Ezek alapján az egyenletrendszer felírása és megoldása következik.

hiszen a szakasz osztópont meghatározása szolgál. Ezen tulajdonságot kihasználva. Ezeket később kontrollpontoknak. mivel a transzformált pontok által meghatározott Bézier-görbe megegyezik az eredeti görbe transzformáltjával. Ez a 198. Bézier-görbe Keressünk olyan görbét.info) azaz átmetszheti önmagát.1]. amely a megadott pontokat közelíti (approximálja) az előre megadott sorrendben és nem halad át (nem interpolálja) rajtuk. az általuk meghatározott poligont kontrollpoligonnak nevezzük. A Bézier-görbe előállítása Bernstein-polinommal Bézier-görbe néhány tulajdonsága A Bézier-görbe a kontrollpontjai affin transzformációjával szemben invariáns. oldal a 242-ből www.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.kuruc. A de Casteljau-algoritmus Adottak a sík vagy a tér b0…bn pontjai és u⋲[0. tükrözés.:eltolás. a görbe affin transzformációja (Pl. Most már elvégezhető a szerkesztés. elforgatás. párhuzamos vetítés) esetén elég a kontrollpontokra végrehajtani a transzformációt. vagy legalábbis nem mindegyeiken. skálázás. ahol az így meghatározott b n (u) pont a Bézier. Ez következik a de Casteljau-féle előállításból.info . Legyen A második egyenlet a jól ismert.görbe u paraméterhez tarozó pontja lesz. De centrális vetítésre nézve nem invariáns.

Ez utóbbi tulajdonságot nevezik úgy. Tehát a kezdő és a végpontban az érintők tartó egyenese a kontrollpoligon oldalai. akkor az egész görbe alakváltozáson megy keresztül.info) Ha u∈[0. oldal a 242-ből www. azaz. A görbe globálisan változtatható. hatása a görbe alakjára.1]. ha megváltoztatjuk egy kontrolpontjának a helyzetét.info .C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.kuruc. hogy a görbe Ez a 199. Bebizonyítható a Bernsteinpolinomok tulajdonsága alapján. akkor a Bezier görbe kontrollpontjainak konvex burkán belül van.

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info .görbe térgörbe lesz. akkor kézenfekvő megoldás a kapcsolódó harmadfokú Bézier-görbék alkalmazása. oldal a 242-ből www. amely négy négy kontrollponttal adott: a0..b1. Ez a 200.a3 és b0. amelyek természetesen Hermit-görbék is lehetnek. azaz nem találunk olyan síkot amelyre a görbe minden pontja illeszkedne.b3.a2.. A három kontrollpont esetén a másodfokú Bézier-görbe már egy jól ismert síkgörbe. A polinominális előállításból jól látható.bn pontot.1] csatlakozó görbe. Kapcsolódó görbeívek használata igen gyakori a modellezésben. azaz n+1 pontot n-edfokú görbével approximál.kuruc.kuruc. hogyan milyen kapcsolat van az Hermit-görbe és a Bézier-görbe között..a1. parabola lesz..info) pszeudolokálisan változtatható. Harmadfokú Bézier-görbék n = 3 esetén a görbe Bernstein-polinom alakja: A harmadfokú Beziér-görbék (s természetesen az Hermit-görbék is) változatos képet mutathatnak. Kapcsolódó Bézier-görbék Az előző fejezetben láttuk. Ha több mint két pontot szeretnénk összekötni interpoláló görbével. akkor a Bézier. azaz a kontrollpontok számának növekedésével nő a poligon fokszáma is. Ilyen esetekben a csatlakozásnál megadjuk a folytonosság mértékét. Ha az a(u). u⋲[0.b2. Tehát a Bézier-görbe alakváltozása jól prognosztizálható. hogy b0. Ha a harmadfokú Bézier-görbe kontrollpontjait nincsenek egy síkban.1] és b(u) u⋲[0.

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. elsőrendű C1. azaz: a(1) = b(0). hogy a ceruzánkat felemelnénk. azaz egyik érintő skalárszorosa a másiknak: A nulladrendű folytonossághoz elegendő. ezért a3 = b0 kell.info) A kapcsolódásnál megkövetelhetünk nulladrendű C0. A mi esetünkben ez akkor teljesül. G0 megegyezik C0-lal. és G1-folytonosan kapcsolódik a két görbe.kuruc. de a hosszuk nem feltétlenül egyezik meg. A matematikai folytonosság vagy parametrikus folytonosság mellett létezik geometriai folytonosság is. Gondoljunk arra. ha az első görbe végpontja megegyezik a második görbe kezdőpontjával. ha a csatlakozáskor keletkező görbe megrajzolható anélkül. illetve másodrendű C2 folytonosságot. hogy teljesüljön. Pl. Általánosságban azt mondhatjuk. hogy az út/idő függvény második deriváltja a gyorsulást adja. az n. ha az érintők a kapcsolódási pontban egy irányba néznek.info . és mivel ezen görbepontok megegyeznek a megfelelő kontrollpontokkal. Az elsőrendű. oldal a 242-ből www. animáció esetén a mozgó kamera által készített felvétel akkor lesz valósághű. hogy a2 felezi az a1m szakaszt. azaz ami geometriai szempontból azt jelenti. A gyakorlatban C2-folytonosságú kapcsolat elégséges. ha a második derivált is megegyezik. akkor szaggatott felvételt kapunk. ha az egyik görbe deriváltjai a végpontjában megegyeznek a másik görbe deriváltjaival a kezdőpontban. hiszen a Bézier-görbe a végpontokat interpolálja. b1 pedig felezi az mb2 szakaszt. pl. C1-folytonossághoz az érintőknek kell megegyezniük. tehát ha a kapcsolódási pontban megváltozik a gyorsulás. hogy két csatlakozógörbe kapcsolódása Cn-folytonos.kuruc. Ez a 201. hogy az a1a2 egyenes és a b1b2 egyenes m metszéspontjára teljesül. deriváltig bezárólag.

info) Cardinal spline A cardinal spline egy.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.és a Béziergörbe közötti kapcsolatot. ezért a cardinal spline megadhatjuk harmadfokú C1folytonosan kapcsolódó Bézier-görbék sorozataként is. Járjunk el az utóbbi módon! Ez a 202.kuruc. azaz az előre megadott pontokon adott sorrendben áthaladó görbe. oldal a 242-ből www. Mivel az előző fejezetben már kimutattuk a Hermit.info . tulajdonképpen elsőrendben folytonosan csatlakozó harmadfokú (kubikus) Hermit-görbék sorozata. a kontrollpontokat interpoláló.kuruc.

kuruc. Bézier szegmens kezdő és végpontja b0=pi. Ez a 203. b3 = pi+1.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. pl. Mivel a görbe érintője: ezért minden kontrollpont minden szegmens esetén most már meghatározható.info) Az i. hogy a harmadrendű Bézier-görbe négy pontjával (négy vektorral) adott. ha t = 0.kuruc. amely az érintők nagyságát befolyásolja.info .5 akkor a Catmul-Rom spline-t. akkor a kezdő és a vég pont. Az érintők meghatározásánál használhatunk egy t >= 0 tenziós értéket. akkor a kontrollpontokat összekötő poligont kapjuk meg. Bézier szegmens kezdő és végpontja a szomszédos a pi és pi+1 pontok. oldal a 242-ből www. vagy ha Hermit-görbeként adjuk meg. négy kontrollpont. A görbe deriváltja egy közbülső pi pontban párhuzamos pi-1 pi+1 egyenessel. valamint a kezdő és a végpontban az érintők. azaz Ne felejtsük el. Az i. Ha t = 0.

kuruc. oldal a 242-ből www.info .C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info) Az előbbi képeket előállító programrészlet: Ez a 204.kuruc.

hogy a cardinal spline csatlakozó Bézier-görbékből áll. A DrawBezier négy kontroll pontra illeszt közelítő görbét. amit az egységes mátrix reprezentáció érdekében teszünk. oldal a 242-ből www. kölcsönösen egyértelmű ponttranszformációkat lehet könnyedén megvalósítani. Ez a 205.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. ezért szükség van egy Bézier-görbét előállító metódusra is. Mivel a GDI+ kihasználja.info . hogy GDI+ segítségével lehetőségünk van cardinal spline előállítására DrawCurve metódussal.NET-ben síkbeli.kuruc.info) Ahogy a fenti programrészletből láthattuk.kuruc. míg a DrawBeziers pedig C0-folytonosan kapcsolódó Bézier-görbéket rajzol. Ponttranszformációk A GDI+ . A ponttranszformációk leírásánál homogén koordinátákat használunk.

amikor a harmadik koordináta 1 marad.NET-ben az általános affinitás mátrixának megadása: Ez a 206. 4]. x3=1 megfeleltetést használtunk. x2=y.info . ezért a visszatérésnél egyszerűen elhagyjuk. a homogén koordinátás alak [x. amely esetekben a harmadik koordináta egy lesz. Ha x3=0. Pl: [1. 0] homogén koordinátájú pont nem létezik. mint a [2. ha egy pont homogén koordinátája [x1. ezért most már szorozhatjuk a koordinátákat. M pedig a transzformációt megadó 3*3-as mátrix és|M|≠0. 0. Áttérés hagyományos Descartes koordinátákról homogén koordinátákra: Legyen egy síkbeli pont hagyományos valós koordinátája [x. Visszatérés homogén koordinátákról Descartes koordinátákra: A GDI+ esetében csak olyan transzformációkat fogunk használni. y]. x3] Arányosság: az [x1. egy tetszőleges nem nulla számmal. Ponttranszformációk A homogén koordináták felhasználásával most már egyszerűen megadhatjuk a ponttranszformációkat általános alakját p’= p*M ahol p illetve p’ a transzformálandó pont. A fenti mátrixegyenlet kifejtve: Mivel a GDI+ csak olyan esetekkel foglakozik.kuruc. ezért a következő alakra egyszerűsödik a helyzet: Ha elvégezzük a mátrixszorzást.info) Homogén koordináták A sík pontjait olyan rendezett számhármasokkal reprezentáljuk. amelyek arányosság erejéig vannak meghatározva. Ebben az esetben láthatjuk. @x3]. -2. és x3 nem nulla. Általánosan.kuruc. X2/X3. [0. hogy valójában az x= x1/x3 és az y= x2/x3 megfeleltetést használtuk. 1] lesz. x3]. x3] ugyanazt a pontot jelöli. 2] ugyanaz a pontot jelöli. A definíció értelmezése: Rendezett számhármas: [x1. GDI+ . @x2. mert az általunk használt ponttranszformációk esetében nem fordul elő. Tehát x1=x. x2. és mind a három koordináta egyszerre nem lehet nulla. y. ahol @ egy 0-tól különböző valós szám. akkor az első két koordinátát eloszthatjuk a definícióban foglalt arányossági tulajdonság miatt a harmadik koordinátával: [X1/X3. Mivel a homogén koordináták csak arányosság erejéig vannak meghatározva.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. akkor nincs hagyományos valós megfelelője a pontnak. illetve a transzformált helyvektora. ezzel az esettel nem foglakozunk. x2. oldal a 242-ből www. mint a [@x1. 1]. -4. x2. akkor a következő egyenletrendszerhez jutunk: A kapott egyenletrendszer az általános síkbeli affinitást írja le.

m31. egy téglalapot érintő ellipszisen.info .Transform metódussal végrehajtjuk a transzformációt a Graphics objektumain.TransformPoints(myArray) metódussal hajtjuk végre a myArray ponttömbön.Multiply metódussal. a Második példa: A következő példában három myMatrix által definiált ponttranszformációk szorzatát állítjuk elő a myMatrix.info) Matrix myMatrix = new Matrix(m11.m21. Első példa: A következő példában a myMatrix által definiált ponttranszformációt myMatrix.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.m22. majd a Graphics.m32). m12. oldal a 242-ből www.kuruc. A Multiply metódus MatrixOrder paramétere határozza meg a mátrix szorzás sorrendjét. amelynek lehetséges értékei: Append: az új transzformációt a régi után kell végrehajtani Prepend: az új transzformációt a régi előtt kell végrehajtani Ez a 207.

kuruc.info . Az első lehetőség.info) GDI+ transzformációs metódusai GDI+ két lehetőséget biztosít a ponttranszformációk végrehajtására.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. oldal a 242-ből www. hogy az Ez a 208.kuruc.

Matrix osztálybeli metódusokat.kuruc. mint a transzformációk szorzása.info) általános affinitást megadó Matrix osztályt alkalmazzuk.RotateTransform(alfa). A Graphics osztály számtalan metódust biztosít a különböző ponttranszformációk használatára. dy) . Elforgatás az origó körül alfa szöggel pozitív irányba: Az y tengely állása miatt a szokásos pozitív iránnyal ellentétesen. s az azoknak megfelelő Graphics vagy Drawing2D. myMatrix. oldal a 242-ből www.TranslateTransform(dx. A másik lehetőség. A forgatás mátrixa: e.Rotate(alfa). Matrix myMatrix = new Matrix(). hogy használjuk a GDI+ transzformációs metódusait.Graphics.RotateAt(alfa. Ez a 209.kuruc. Az alkalmazott névterek (Namespace): Eltolás: Graphics. myMatrix. //az alfát fokban kell megadni. az óramutató járásával megegyező irányt tekintjük pozitívnak.Translate(dx. Tekintsük sorban a transzformációs mátrixokat.dy). hiszen a transzformációs mátrixokat kell egymásután összeszorozni. s nem radiánban myMatrix. Ezen metódusok egymás utáni végrehajtása nem más.centerpont).info .C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.

amivel az egybevágó alakzatok egymással fedésbe hozhatóak.kuruc.info . ezért nekünk kell elkészíteni a szükséges mátrixokat.kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.: kicsinyítés. oldal a 242-ből www. Nyírás: Tekintsünk egy pontonként fix t egyenest. Skálázás: Az x. azaz. Erre nincs metódus a GDI+-ban. Ez a 210. illetve 0<sy valós számokkal történő skálázás: Ha sx=sy. ahol a csúsztatás mértéke (k) arányos a t egyenestől való távolsággal (d).info) Tükrözés: Koordináta tengelyekre tükrözünk. x tengelyre való tükrözésnél minden y koordináta az ellenkezőjére változik: y tengelyre való tükrözésnél minden x koordináta az ellenkezőjére változik: Az eltolást és az elforgatást összefoglalóan mozgásnak szokás nevezni. ha 1 <sx. A nyírás a sík pontjainak a t egyenessel párhuzamos elcsúsztatása. ha 0<sx<1 nagyítás. ugyanis ilyen esetben van olyan síkbeli mozgás. akkor skálázáshasonlóság. illetve az y tengely mentén 0<sx .

A Shear metódus két paramétere közül érdemes az egyiket nullának választani. hogy x vagy y tengely irányában nyírunk. • Nyírás az x tengely irányában: • Nyírás az y tengely irányában: Ez a 211.kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. attól függően.kuruc. különben előre nehezen meghatározható hatást érünk el.info) A GDI+-ban a koordinátatengelyek mentén vett nyírásokkal foglalkozunk.info . oldal a 242-ből www.

AddBezier. Körcikk. Lássunk egy példát: Nem szükséges. hogy átmenetileg megváltoztassuk egy grafikus objektum állapotát. Ellipszis ív. AddEllipse. AddPie. a Pen és a GraphPath objektumokra. A GraphicsPath objektum lehetőséget nyújt a grafikus elemek egyetlen blokként való kezelésére. Szöveg. AddRectangle. amelynek elemeit felsoroljuk. Cardinal spline. Bézier-görbe. AddClosedCurve.kuruc. A Garphics osztály DrawPath metódusának hívásával rajzolhatjuk meg a GarphicsPath szekvenciát. AddLines.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. oldal a 242-ből www. azaz path létrehozására.info) A koordináta rendszer transzformálása és a Path használata A GDI+-ban lehetőségünk van grafikus objektumok összefűzésére. Ellipszis. A GDI+ a konténerek használatával lehetővé teszi.kuruc. AddRectangles. hogy a Path objektumai össze legyenek kötve Grafikus konténerek Garfikus állapotot a Garphics objektumban tárolunk. AddBeziers. Téglalap. AddLine. Poligon. AddArc. AddString. Tehát a path megrajzolásához szükségünk van a Graphics. AddCurve. AddPolygon. a felfűzéshez szükséges metódusokkal: Szakasz.info . Összefűzött grafikus objektumok AddPath. A BeginContainer Ez a 212.

Ez a 213. A következő példában különböző helyekre tesszük ki a téglalapba írt szöveget.info . Figyeljük meg a vonatkoztatási pont.kuruc. oldal a 242-ből www. az origó eltolását.info) és az EndContainer metódusok között bármilyen változtatást hajtunk végre a grafikus objektumon.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc. az nem befolyásolja az objektum konténeren kívüli állapotát.

kuruc.info .info) Ez a 214.kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. oldal a 242-ből www.

NET Radványi Tibor Ez a 215.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.Az ADO. oldal a 242-ből www. Fejezet „Adatok kezelése!” .info) Programozás tankönyv XVII.info .kuruc.kuruc.

vagy egy másik számítógépbe csatakozunk. ha elindítjuk az Enterprise Managert. az elénk táruló kép hasonló más adatbázis menedzselő programokhoz. Segíségül hívhatjuk a sok előre elkészített varázslót az SQL Serverhez.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.felhasználók egy felhasználói felület segítségével menedzselhetik a server alkalmazást. azon belül a hozzáadott szervereinket. illetve jellemzőinek leírását. Az SQL Server Enterprise Manager elindításához válasszuk ki az Enterprise Manager ikont a Microsoft SQL Server programcsoportban. A serveralkalmazások létrehoznak egy komponenst. A bejegyzett szerver a SQL Server Enterprise Managerben fog látszódni. Létrehozhatunk és adminisztrálhatunk SQL Server adatbázisokat. Amelyik gépen Windows 2000 fut. Megjegyzés . és szkripteket interaktívan az SQL Query Analyzer segítségével. SQL Server Enterprise Manager a Microsoft SQL Server 2000 MMC komponense.info) Az ADO. Az egyes szervereket lenyitva kapjuk meg azok beállítási. mely egy általános felületet biztosít különböző szerveralkalmazások menedzselésére egy Microsoft Windows® hálózatban. Az egyes elemekre jobb gombot nyomva kapjuk meg azt a pop-up ablakot. egy jól használható felhasználói felületet. melyből kiválaszthatjuk az új alelem létrehozását vagy tulajdonságainak beállítását. A bal oldali panel TREEVIEW-ját ha lenyitjuk. mely a felhasználó számára lehetővé teszi. Batch-eket. login-okat. oldal a 242-ből www. hogy: Meghatározhatunk szervercsoportokat a futó SQL Serveren. Itt találhatók az adatbázisok is. Az MMC beillesztések is a Felügyeleti Eszközökből indíthatók. láthatjuk a szervercsoportjainkat. Meghatározhatunk és elvégezhetünk minden SQL Server adminisztrációs feladatot minden bejegyzett szerveren. Szerkeszthetünk és tesztelhetünk SQL utasításokat.kuruc. lehetőségeit. Ez az opció csak az SQL Server Enterprise Manager használatához kell. és biztosítja az Microsoft Management Console (MMC)-t. melyet az MMC használ. felhasználókat és engedélyezéseket minden bejegyzett szerverre. Ehhez nem kell alapbeállításként engedélyeznünk gyerekablak nyitásának lehetőségét.Ha bejegyzünk egy új SQL szervert a Felügyeleti Eszközökben.NET-adatkezelés C#-ban SQL Server Enterprise Manager Az SQL Server és az MMC Az SQL Server Enterprise Manager a fő adminisztrációs eszköz a Microsoft® SQL Server™ 2000-hez.kuruc. a szerver már nem fog látszani a Felügyeleti Eszközökben. MMC egy olyan eszköz. Új elemek létrehozása Feltelepítés után. objektumokat. és utána vagy bezárjuk a Felügyeleti Eszközöket. ott ugyanúgy indíthatjuk az SQL Server Enterprise Managert a Felügyeleti Eszközökben a Vezérlőpultban. Egyedi szervereket is bejegyezhetünk egy csoportba. azáltal az MMC. Az összes bejegyzett SQL server konfigurálása.info . Ez a 216.

Megadhatjuk. és ott a Set Primary Key opcióval elsődleges kulcsnak választjuk az elemet.és adatméret-kezelésének módját is.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. és kiválaszthatjuk az adattárolás könyvtárát is. létrejön az adatbázisstruktúra is. Felhasználókat. Mikor létrehoztuk az adatbázist. Bezáráskor menthetjük a táblát és adhatunk neki nevet. illetve a merevlemez szabad. A tábla létrehozása úgy történik. alapértelmezett értéket. hosszukat és hogy engedélyezzük-e a NULL-értéket.kuruc. Megadhatjuk. Ez a 217. hogy az adatbázis szerver hova mentse a napló fájlokat. Formulát és karakterkészletet. A kulcsok kiválasztásánál az adott mezőn jobb gombot kell nyomnunk.kuruc. Ezeken kívül megadhatunk még az egyes mezőkről leírást. mely tartalmazza Táblákat. oldal a 242-ből www. azok típusait. hogy egy mező egyedi legyen-e.info) A Databases/New DataBase-re kattntva létrehozhatunk egy új adatbázist. akkor azt az adott táblán jobb gombot nyomba a Design Table menüpontban tehetjük meg. Megadjuk a mezőneveket. Ezeknek a méretét maximálhatjuk. Tárolt eljárásokat. Itt meg kell adnunk annak nevét. Ha a listában lévő. Nézeteket. mint minden hasonló rendszerben.info . már létező táblákat akarjuk szerkeszteni.

kuruc. a sok és sokelemű tábláknál nyújthat nagy segítséget a tervezésben.info . ha a már Access-ben megszokott egyik elemtől a másikig húzzuk lenyomva az egeret. feliratozhatjuk. egy varázsló segít összeállítani a megjelenítendő táblákat. A kapcsolatot jelző összekötő szakaszt is tesreszabhatjuk. Amikor ebből újat hozunk létre.info) Manage Relationshipel tehetjük meg. Például. A táblán jobb gombra kattintva sok beállítási lehetőséget kapunk annak szerkesztésére. Beállíthatjuk. oldal a 242-ből www.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. akkor megjelenik a kapcsolatokat létrehozó form. hogy akár csak a kulcsokat lássuk. hogy látványosan szerkeszthessük a tábláinkat és a köztük lévő kapcsolatot.kuruc. A megjelenő tábláknál. KapcsolatokAT ugyanolyan típusú mezők közt hozhatunk létre. Ez arra szolgál. illetve megjelenítésére. Ezt az eszköztáron található Ez a 218. Ez a nagyobb projecteknél. kitöltve a megfelelő adatokkal. vagy csak a tábla neveit. hogy a kapcsolódó táblákat automatikusan a listába rakja-e. Az adatbázis elemei között található a Diagram is.

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. hogy melyik táblát akarjuk módosítani. Relation: A kapcsolatok. tulajdonosa. Majdnem minden olyan beállítást elvgezhetünk.kuruc. Ez a 219. Columns: Itt az egyes mezőket szabhatjuk testre. Mint például a tábla neve. egyedi mezője és a tábla leírása. A Column name-el pedig az adott mezőt választhatjuk ki. mint amit a Design table alatt. ahol a kapcsolatokat állítottuk be.info .kuruc.info) Nézzük meg jobban azt a formot. Itt a táblák teljes testreszabását elvégezhetjük Az első fül a Table: Itt az egyes táblák általános beállításai végezhetjük el. oldal a 242-ből www. Az említett beállításokon kívül még be lehet állítani. A table name mellé kattintva kapunk egy ComboBox-ot melyből kiválaszthatjuk. hogy hogyan módosuljon a gyerek tábla törléskor és módosításkor.

Ez a 220.kuruc.kuruc. oldal a 242-ből www. A kiválsztott mezdő mellett meg kell adnunk.info) Indexes/Keys: Itt hozhatunk létre új indexeket és a létezőket testreszabhatjuk. hogy növekvő vagy csökkenő indexet szeretnénk hozzárendelni.info .C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.

A string-ben mező-érték párokat találunk. mely kezeli az SQL Server-hez a kapcsolatot.egy objektum.NET használata SQLConnection osztállyal a formon dinamikusan. OLEDBCONNECTION . és egy meghatározott adatbázis eléréséhez. ADO. mely egy string-ből áll. ez az információ szükséges egy adatbázisba bejelentkezéshez. mely kapcsolatot kezeli bármely adattárolóhoz.kuruc. és kevés programozással. Connection String Minden KAPCSOLÓDÁSI OBJEKTUM nagyjából ugyanazon tagokkal rendelkezik. az OLE DB réteget megkerülve. mely kapcsolatot kezel egy adatforráshoz. mely Oracle adatbázisokkal való kapcsolatot kezeli.info . mely OLE DB-n keresztül elérhető. Bevezetés az ADO.egy objektum.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Optimizálva van SQL Server 7.kuruc.NET-ben kapcsolódásokat létrehozni és kezelni KAPCSOLÓDÁSI OBJEKTUMOKkal lehet: SQLCONNECTION . ODBCCONNECTION . melyet vagy kapcsolatstringgel (connection string) vagy ODBC-adatforrásnévvel hoztak létre.egy objektum.0 vagy újabb verzióhoz való használatra. oldal a 242-ből www.NET kapcsolódási eszközeihez Egy alkalmazás és egy adatbázis közti adatcseréhez először egy kapcsolat kell az adatbázishoz.egy objektum. Egy tipikus ConnectionString hasonlóképpen néz ki: Ez a 221. Az elsődleges tulajdonság egy kapcsolat-objektumnak a ConnectionString. ORACLECONNECTION .info) MS SQL szerver elérése C#-ból Az ADO.

és a kiépített kapcsolatok értékes erőforrásokat foglalnak. hogy a kapcsolat a Windows beépített védelmét használja (NT hitelesítés). hogy a kapcsolat már ki van-e építve.NET Web alkalmazásokban sok felhasználó kérdezhet le ugyanattól az adatbázistól. a metódusok felhasználják. akik azonos típusú adatbázis-elérést végeznek. melyek engedik végrehajtani vagy visszavonni a tranzakciót. A metódusok . végrehajtja a feladatát. ha minden adatillesztő külön épít ki és bont kapcsolatot. ha az alkalmazás megosztja. Például egy olyan alkalmazásban. de nem javasolt.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. az illesztő kiépíti a kapcsolatot. stb. Ez lehetőséget nyújt adatparancsok flexibilis.info) Ez a ConnectionString-részlet megadja. SqlConnection osztály használatakor a kapcsolatok megosztása automatikusan kezelve van. Ha adatillesztőkkel vagy adatparancsokkal dolgozunk. Az Open metódus a ConnectionString-ben lévő információt használja az adatforrás eléréséhez és egy kapcsolat kiépítéséhez. A felhasznáEz a 222. hogy ugyanazt az adatot kapják. Összetett kapcsolatok (Pooling Connections) Az alkalmazásoknak gyakran vannak különböző felhasználói. Ebben az esetben nem hatékony. mert ezek az értékek a programban lesznek eltárolva (fordításkor). egy SqlTransaction objektum).mint a szerver neve.info . ha meghívja a Fill metódusát.kuruc. Tranzakciók A kapcsolat objektumok támogatják a tranzakciókat.kuruc. Egy connection string-ben szerepelhet e helyett egy felhasználónév és jelszó. A kapcsolat bontása LÉNYEGES. tetszőlegesen változtathatóak. A tranzakciókat kódban kezeljük. minden illesztőhöz meghívhatjuk a Fill metódust. A kapcsolat beállításait ezért gyakran dinamikus tulajdonságként kezeljük. Ezekben az esetekben az alkalmazások teljesítménye növelhető. majd bontja a kapcsolatot. Ehelyett használhatunk egy kapcsolatot. nem adhatjuk meg a kapcsolatra vonatkozó adatokat tervezéskor . Ezt használhatjuk. Ha nincs. melyet több vásárló is használni fog. Tipikus módszer a kapcsolat tulajdonságainak dinamikus adatokként való létrehozása. ezért nem biztonságos. Mivel a dinamikus tulajdonságok egy konfigurációs fájlban tárolódnak (és nem fordítódnak az alkalmazás bináris fájljaiba). ha több adatillesztőnk osztozik egy kapcsolaton.mint a Fill . oldal a 242-ből www. a metódus ellenőrzi. majd végezetül bonthatjuk a kapcsolatot. ASP. A Close metódus lebontja a kapcsolatot. mivel a legtöbb adatforrás csak korlátozott számú kiépített kapcsolatot enged. de rendelkezésre állnak lehetőségek. saját kezű kiépítésére és bontására. a BeginTransaction metódussal egy tranzakció-objektum jön létre (pl.csak akkor építik ki és bontják a kapcsolatot automatikusan. de nem bontják le. Kapcsolat létrehozása és megszüntetése Két elsődleges metódus van kapcsolatokhoz: OPEN és CLOSE. ha még nincs kiépítve. nem kell állandóan magunknak kiépíteni és bontani a kapcsolatot. hogy a megosztást magunk kezeljük. összeadja (POOL) a kapcsolatot az adatforráshoz. A tranzakció objektum pedig rendelkezik metódusokkal. Például. Beállítható kapcsolattulajdonságok A legtöbb alkalmazásban a kapcsolat információi nem határozhatók meg tervezési időben. Ha van kiépített kapcsolat. Ha a fenti objektumok egy metódusát hívjuk meg (pl. az adatillesztő Fill vagy Update metódusa).

A Data Provider for SQL Server hasonló formátumú kapcsolat stringet támogat.ez a varázsló információkat kér a kapcsolatról. Az alábbi kód szemlélteti. Tallózhatunk a meglévő adatforrások között.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.NET Framework-be épített dinamikus tulajdonság szerkezet automatikusan megkapja az értékeket a konfigurációs fájlból. Kapcsolattervezési eszközök Visual Studio-ban Általában nincs szükség közvetlenül létrehozni és kezelni kapcsolat objektumokat Visual Studioban. létrehozhatunk és szerkeszthetünk adatbázis elemeket. melyeket nem zárunk be sajátkezűleg. magunk is hozzáadhatunk kapcsolat objektumokat a Formhoz vagy komponenshez. az meg fog jelenni a Server Explorer ablakban. mindig látható lesz a Visual Studioban (mindaddig.kuruc. mint az OLE DB (ADO) kapcsolat string formátuma. amiket tartalmaz. ha tranzakciókat akarunk használni. mely a feladata részeként kapcsolatobjektumot hoz létre: Data Adapter Configuration Wizard . Azonban néhány esetben alkalmasnak találhatjuk egy kapcsolat saját létrehozását. vagy a Dispose metódusát kell meghívni. oszlopokról.Open(). ha akarjuk. hanem csak adatokat olvasunk ki. Ehhez a kapcsolatobjektumnak vagy a Close. mint a Data Adapter varázsló.info) lónak ilyenkor valamilyen módot kell nyújtani (Windows Form vagy Web Form). Mindamellett. Azok a kapcsolatok. hogy tulajdonságokat állítsunk be egy új kapcsolat objektumhoz. nem juthatnak osztott kapcsolathoz.NET Framework beépített Data Provider for SQL Server (ADATSZOLGÁLTATÓ SQL SZERVERHEZ) SqlConnection objektummal elérést nyújt Microsoft SQL Server 7. Ha olyan eszközöket használunk. Ez hasznos. majd frissítse a konfigurációs fájlt. amikor egy alkalmazáson dolgozunk. hogyan építhetünk ki kapcsolatot egy SQL Server adatbázishoz: SqlConnection kapcsolat = new SqlConnection("Data Source=localhost.0 vagy újabb változatához. amíg a szerver elérhető. melyre a kapcsolat mutat). függetlenül egy meghatározott projekttől vagy Solution-től. oldal a 242-ből www. amin dolgozunk. Kapcsolat létrehozása SQL Server-hez ADO. és beállíthatjuk azok tulajdonságait.info . A tervezési időben létrehozott kapcsolatokról az információkat a saját gépünkön tároljuk. kapcsolat.NET használatával A . Lehetőségeink: Az alábbi eszközökből használhatjuk valamelyiket. amikor a tulajdonság kiolvasódik. ha az érték változik. Általában. a tervezés közben létrehozott kapcsolat információit arra használjuk. Ezért miután már létrehoztunk egy kapcsolatot tervezéskor. Integrated Security=SSPI. Kapcsolatok tervezéskor a Server Explorer-ben A Server Explorer lehetőséget ad tervezéskor. és frissíti a fájlt. általában nem szükséges magunknak létrehoznunk a kapcsolat objektumokat a Form-on vagy komponensen. és egyéb elemekről. Kapcsolat bontása JAVASOLT mindig A KAPCSOLAT BONTÁSA. Az alkalmazásunk nem közvetlenül használja az ez úton létrehozott kapcsolatokat.kuruc. Létrehozhatunk kapcsolat objektumokat. Ez a 223. Initial Catalog=adattabla"). megjeleníthetünk információkat a táblákról. hogy adatforrásokhoz kapcsolatot létrehozzunk.NET kapcsolat objektumok létrehozása Ha adateléréstervező eszközöket használunk Visual Studio-ban. amit az alkalmazáshoz adunk. ha befejeztük a használatát. az eszközök kérni fogják a kapcsolat adatait (azaz a connection string információkat) és automatikusan létrehoznak kapcsolat objektumokat a Form-on vagy komponensen. ADO. hogy a fontos adatokat meghatározza. A . ha nem adatillesztőkkel dolgozunk.

tervezési eszközökkel hozzunk létre kapcsolatot. az alkalmazás újrafordítása nélkül. SQL Server kapcsolat Server Explorer-ben Egyszerűen hozhatunk létre SqlConnection. 4) Vagy 5) Külön tulajdonságait állíthatjuk (DataSource. kijelölt oszlopokat vagy tárolt eljárást a Form-ra a Server Explorer-ből. Ez a megoldás akkor hasznos.info . 2) Az alapértelmezett elérés a Microsoft OLE DB Provider for SQL Server. Kapcsolat létrehozása 1) A Toolbox ablak Data csoportjából húzzunk egy kapcsolat objektumot a Form-ra vagy komponensre. vagy gépeljük be a szerver helyét. Ez a lehetőség létrehoz egy kapcsolat objektumot a Form-on vagy komponensen. használjuk a Microsoft OLE DB Provider for SQL Server eszközt. 7) Ha futási időben szeretnénk a tulajdonságokat beállítani. oldal a 242-ből www. 4) Az alkalmazásunk vagy az adatbázisunk szükségleteihez mérten válasszuk ki vagy a Windows NT Integrated Security-t. hogy a Server Explorerből a Formra húzzuk őket. 2) Válasszuk ki a kapcsolatot a tervezőben és használjuk a Properties ablakot a connection string beállításához. 5) Válasszuk ki az elérni kívánt adatbázist a lenyíló listából. Két módon kapcsolódhatunk szerverhez: Vizuálisan. Hozzunk létre egy különálló kapcsolatot. Húzzunk egy táblát. meg kell határozni a kapcsolat tulajdonságait. Database. vagy adjunk meg felhasználónevet és jelszót a bejelentkezéshez. 3) Válasszuk ki egy szerver nevét a lenyíló listából. Kapcsolat létrehozása SQL Server-hez Ha SQL Server-hez kapcsolódunk. 3) Beállíthatjuk a ConnectionString-et egy egységként. 6) Kattintsunk az OK gombra.a varázsló kapcsolat objektumot hoz létre a Form részeként.). 6) Átnevezhetjük a kapcsolat objektumot a Name tulajdonság változtatásával. SqlDataAdapter és SqlCommand objektumokat úgy. Ezen elemek Formra áthúzásakor létrejön egy adatillesztő és egy kapcsolat is.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Data Form Wizard . stb.kuruc. a kapcsolat string létrejön automatikusan. ha a kapcsolat tulajdonságait futási időben szándékozzuk beállítani. ahol az elérni kívánt adatbázis található. Megjelenik a Data Link Properties párbeszédablak. Programkóddal hozzunk létre a kapcsolatot. Ha külön állítjuk a tulajdonságokat. vagy ha egyszerűen a tulajdonságokat magunk szeretnénk beállítani a Properties ablakban. Hozzunk létre kapcsolatot kóddal. UserName. melynek a tulajdonságait magunknak kell beállítanunk.kuruc.info) mely egy adatillesztőhöz lesz kapcsolva. és válasszuk az Add Connection menüpontot. melyet konfigurál. Kapcsolat létrehozása: 1) A Server Explorer-ben kattintsunk jobb egérgombbal a Data Connections-re. Kapcsolódás SQL Server-hez az alkalmazásunkból Kapcsolódás létrehozása VIZUÁLIS ESZKÖZÖKKEL A kapcsolódási eszközöket vagy a Server Explorer-ből vagy a Toolbox ablak Data csoportjából használva hozzunk létre kapcsolatot: Server Explorer-ből Hozzunk létre egy Data Connection-t a Server Explorer-ben az SQL Server-hez a fentebb leírt móEz a 224.

kuruc. id++ ) { customerTable. hogy lehet a memóriában. mint a programból generált adatainkhoz. Lehetőségünk van arra is.NET két megközelítést támogat erre a műveletre: A DataTable Select metódusának használatát. hogy azok valóságos adatbázishoz kapcsolódnak. Ez a metódus szűrt és rendezett adatsorok tömbjével tér vissza.Columns. A Properties ablakban válasszuk ki a ConnectionString property-t. A következő kód egy példa a DataTable Select metódusának használatára: private static void GetRowsByFilter() { DataTable customerTable = new DataTable( "Customers" ). typeof(int) ). Egy SqlConnection objektum jeleni meg a komponenstálcán. mely nincs beállítva. customerTable. mintha egy tetszőleges típusú adatbázis egy-egy táblája lenne.Rows. Az ADO. // Tiz sor hozzaadasa a tablahoz for( int id=1. vagy kattintsunk a New Connection-re. Toolbox-ból Húzzunk egy SqlConnection objektumot a Form-ra. Válasszunk ki egy meglévő kapcsolatot a lenyíló listából.kuruc. find és sort metódusai. Ami a DESC (csökkenő) vagy az ASC (növekvő) szavakkal határozható meg.NET-ben Vizsgáljuk meg.Columns["id"] }. illetve rendezni. Egy SqlConnection objektum jelenik meg a komponens-tálcán.info) don.Unique = true. hogy egy tetszőleges adatforrást használjunk. Nézzünk egy példát a szűrőfeltétel felépítésére: A tipikus rendezési kifejezés: a mező neve és a rendezés iránya. vagy akár programból generáljunk adatokat. Ezt az osztályt használhatjuk valós adattáblák kezeléséhez éppúgy. customerTable. Húzzuk a létrehozott kapcsolatot a Form-ra. A kapcsolat kiépítése után az adatbázist kezelő eljárásokat kell létrehozni.PrimaryKey = new DataColumn[] {CustomerTable.Add( "name". customerTable. A DataTable osztály Adatokat nemcsak úgy kezelhetünk egy DataGrid-ben. id<=10. oldal a 242-ből www. A DataView objektum filter.Add( "id". A megoldás kulcsa a DataTable osztályban rejlik.Add( Ez a 225.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Ez az objektum hozzákapcsolható az adatmegjelenítésre képes objektumokhoz.Columns. Szűrés és rendezés az ADO. customerTable.info . typeof(string) ). melyeket ezek után épp úgy kezelhetünk.Columns[ "id" ]. és állítsuk be a kapcsolatot. DataSetben tárolt adatokat tovább szűrni.

kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info .kuruc. oldal a 242-ből www.info) Ez a 226.

Szűrés és rendezés a DataView objektum segítségével A DataView objektum lehetővé teszi.info .kuruc. hogy a DataTable-ban tárolt adatokhoz különböző nézeteket hozzunk létre. Ez a képessége a DataView objektumot ideális eszközzé teszi az adatkapcsolatokat kezelő programok számára. Erre a DATAVIEW használata ad lehetőséget. hogy a szűrés eredményeként kapott adatsorokat egy tömbben adja vissza. A szűrőkifejezés felépítése: egy oszlopnév.RowFilter tuljdonsága adhatunk meg egy szűrő feltételt a sorok megjelenítéséhez a DataViewban. illetve a sorok állapota.kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. operátor és egy érték a szűréshez. A DataView használatával a táblabeli adatokat különböző rendezési szempont szerint. Ez abban különbözik a DataTable Select metódusától. és milyen irányban. oldal a 242-ből www. Így itt is használható a rendezés. Az alapértelmezett nézet A DataTable. hogy mely oszlopok szerint szeretnénk rendezni a sorokat. Ez nem köthető sem a DataGridhez sem más adatmegjelenítésre alkalmas objektumhoz közvetlenül.info) Az alapvető probléma a DataTable Select metódusával. hanem egy DINAMIKUS táblában. szűrés és keresés a táblában. vagy kifejezések által meghatározott szűrők szerint mutathatjuk meg. Ezt a lehetőséget sokszor használjuk ki adatbázishoz kapcsolódó programoknál. melyben megadhatjuk. Rendezés a DataViewban A rendezéshez létre kell hoznunk egy string kifejezést. A RowFilter tulajdonság A DataView. hogy az eredménysorokat nem egy tömbben adja vissza.DefaultView tulajdonság a DataView objektumot kapcsolja a DatatTable-hoz. Ez a 227.

oldal a 242-ből www.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.info .kuruc.info) Egy táblához több nézet: Nézzünk egy példát erre: Ez a 228.

kuruc.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info . oldal a 242-ből www.info) Ez a 229.kuruc.

C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.info) Ez a 230.info . oldal a 242-ből www.kuruc.

kuruc.kuruc.info .info) Ez a 231.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. oldal a 242-ből www.

info .kuruc.info) Ez a 232. oldal a 242-ből www.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc.

mint a decimal Pénzérték a -263 és 263 -1 közötti tartományban a pénzegység egy tízezrelékének pontosságával Pénzérték a -214748. A nevét gyakran rövidítik T-SQL -re.4E+38 között Dátum. legfeljebb 8000 karakterig Változó hosszúságú nem Unicode karakterek.4E+38 és 3. és 9999.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. között. legfeljebb 8000 karakterig Változó hosszúságú nem Unicode karakterek. legfeljebb 231-1 karakterig Ez a 233.és időérték 1900.január 1.79E+308 és 1.info .3647 közötti tartományban a pénzegység egy tízezrelékének pontosságával Lebegőpontos érték -1. használatba vételük. és 2079. feltételes szerkezetek. között 1 perc pontossággal Rögzített hosszúságú.és időérték 1753.december 31. Alapvető programozási szerkezetek: Változók használata Feltételes szerkezetek használata Case utasítások használata While ciklusok használata Continue utasítás Break utasítás Return utasítások használata Waitfor utasítások használata Kurzorok használata Függvények használata Felhasználói függvények létrehozása Változók A következő típusokat használhatjuk: Típus Leírás Bigint Egész érték -263 és 263 -1 közötti tartományban Int Egész érték -231 és 231 -1 közötti tartományban Smallint Egész érték -215 és 215 -1 közötti tartományban Tinyint 0 és 255 közötti egész érték Bit 1 vagy 0 értékű egész Decimal Rögzített pontosságú és méretű számérték -1038 +1 .33 ezredmásodperc pontossággal Dátum. amelyekben a szokványos programozási szerkezetek is megtalálhatók (változók.kuruc. 3.január 1. nem Unicode karakterek.tol 1038 -1 -ig Numeric Money Smallmoney Float Real Datetime Smalldatetime Char Varchar Text Ugyanaz. A T-SQL segítségével olyan SQL-utasításokat tartalmazó programokat írhatunk. amely programozási szerkezetekkel egészíti ki a nyelvet. június 6.info) Tárolt eljárások Tárolt eljárások futtatása.79E+308 között Lebegőpontos érték -3.kuruc. Mi is az a Transact-SQL? A Transact-SQL a Microsoft SQL megvalósítása. oldal a 242-ből www. eljárások és függvények). új tárolt eljárások készítése. rögzítése adatbázisban. ciklusok.3648 és 214748.

csak a szintaktika más.kuruc. ntext és timestamp típusúakat Sorok halmazát tárolja Egyedi bináris szám. legfeljebb 231-1 bájtig Hivatkozás kurzorra (sormutatóra). CASE utasítások A következő példában a SELECT utasítás eredményeként kapott értéket egy változóban tároljuk: Ez a 234.info . Egy sorban több változót is bevezethetünk. kivéve text. legfeljebb 8000 bájtig Változó hosszúságú bináris adat. amelyet a változó neve és típusa követ. csak ilyenkor BEGIN-END közé kell írnunk a kívánt utasításokat. Egyszerre több utasítást is megadhatunk. vagyis sorok egy halmazára Bármilyen SQL SERVER adattípust tárolhat. mint már megszoktuk. legfeljebb 2311 karakterig Rögzített hosszúságú bináris adat. egy táblában csak egy timestamp oszlop lehet Globálisan egyedi azonosító (GUID. legfeljebb 4000 karakterig Változó hosszúságú Unicode karakterek. globally unique identifier) A változókat a DECLARE utasítással vezetjük be. legfeljebb 8000 bájtig Változó hosszúságú bináris adat. amely minden sormódosításnál frissül. Az IF utasítások bármilyen szintig egymásba ágyazhatóak. A változó neve elé egy kukacjelet (@) kell írnunk. legfeljebb 8000 karakterig Változó hosszúságú Unicode karakterek.kuruc. oldal a 242-ből www. A változók null kezdőértéket kapnak.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info) Nchar Nvarchar Ntext Binary Varbinary Image Cursor Sql_variant Table Timestamp Uniqueidentifier Rögzített hosszúságú Unicode karakterek. értéküket a SET utasítással állíthatjuk be: Feltételes szerkezetek használata A feltételes szerkezetek ugyanúgy működnek.

de csak ha tárolt eljáráshoz használjuk. átugorva a ciklusból még esetleg hátralévő kódrészeket. mielőtt bizonyos műveleteket végrehajtanánk. hogy azt szeretnénk. A WAITFOR utasítással adhatjuk meg. Az utasítással értéket is visszaadhatunk. Az utasítás hatására a végrehajtás kikerül a ciklusból. oldal a 242-ből www.kuruc. a RETURN -t követő egyetlen utasítás sem hajtódik végre. például éjszaka frissítenénk a felhasználói rekordokat.info) While ciklusok Ha egy vagy több utasítás többszöri végrehajtására van szükségünk. Az utasítás hatására a végrehajtás visszaugrik a ciklus elejére. hogy a program megállna. hogy mennyi ideig várjon a program a többi utasítás végrehajtása előtt. Az utasításforma a következő: A CONTINUE utasítás A CONTINUE utasítással azonnal egy WHILE ciklus következő ismétlésére ugorhatunk. WAITFOR utasítások használata Előfordulhat.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. RETURN utasítások használata A RETURN utasítással egy tárolt eljárásból vagy utasítások egy csoportjából léphetünk ki. amíg a megadott feltétel igaz. Az utasítás formája: WAITFOR [DELAY ’időtartam’ | TIME jelenlegi idő’] DELAY: várakozási időtartam.kuruc. és a program futása a ciklus utáni utasításokkal folytatódik.info . A BREAK utasítás Ha egy WHILE ciklusnak azonnal véget szeretnénk vetni. Néhány példa: Ez a 235. TIME: pontos időpont. a BREAK utasítást használhatjuk. A WHILE ciklusok addig futnak. akkor WHILE ciklusokat használhatunk.

Az utasítás egyszerűsített formája a következő: RAISERROR ({szám | leírás}{. Egy példaprogramon keresztül bemutatjuk a kurzorok használatát. Bezárjuk a kurzort.kuruc. hogy hogyan jeleníthetjük meg a kurzor segítségével a PRODUCTS tábla ProductID. amellyel az adatbázisból kinyert sorokat egyenként dolgozhatjuk fel.info) RAISERROR utasítások használata A RAISERROR utasítással hibaüzenetet állíthatunk elő. Ez nem mindig megfelelő. a súlyosság a hiba fokozata. Kiolvassuk a sorokat a kurzorból. Kurzor használatakor a következő lépéseket kell követnünk: 1) 2) 3) 4) 5) Változókat vezetünk be a SELECT utasítás által visszaadott oszlopértékek tárolására. hogy egy adott sor visszakapott oszlopértékei alapján valamilyen műveletet szeretnénk végezni. hogy mi is az a kurzor. amelynek 50001 és 2147483648 között kell lennie. Megnyitjuk a kurzort. megadva a megfelelő SELECT utasítást. állapot}) Itt a szám a hiba száma. ProductName és UnitPrice oszlopait: Ez a 236.kuruc. akkor EGYSZERRE kapunk meg minden sort. ha valamelyik tárolt eljárásban hiba következik be. KURZOROK használata Felmerülhet a kérdés. oldal a 242-ből www. Általában akkor van szükség erre. s mire lehet használni. az állapot pedig egy tetszőleges érték 1 és 127 között. A kurzor segítségével végiglépkedhetünk az adott SELECT utasítás által visszaadott sorokon. Ehhez egy KURZORt (SORMUTATÓT) kell használnunk. ami a hiba hívási állapotát mutatja. előfordulhat például. Nos amikor végrehajtunk egy SELECT utasítást.info . Bevezetjük a kurzort.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. ami 0 és 18 között lehet. súlyosság. a leírás egy 400 karakternél nem hosszabb üzenet. mely megmutatja.

a kurzor megnyitása az OPEN paranccsal történik.kuruc. Ahhoz hogy a sorokat ki tudjuk olvasni a kurzorból.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. oldal a 242-ből www.info) Mint a példaprogramban is látható.kuruc. így egy WHILE ciklust.info . Mint láthatjuk. A KURZOR BEVEZETÉSE abból áll. amíg a kurzort meg nem nyitjuk. s a @@FETCH_S_TATUS-t kell alkalmaznunk annak megállapítására. A SELECT utasítás addig nem hajtódik végre. hogy megadjuk a kurzorhoz rendelendő nevet. A @@FETCH STATUS függvény visszatérési értékei: Ez a 237. illetve a végrehajtani kívánt SELECT utasítást. a változók típusa meg kell. A kurzort a DECLARE utasítás használatával vezetjük be. hogy egyezzen a kinyert sorok oszlopainak típusával. A kurzorban számos sor lehet. a FETCH utasításra van szükségünk. hogy a ciklusnak mikor kell véget érnie.

és három fajtájuk van: Skalárfüggvények . Függvények használata Az SQL Server számos függvényt bocsát a rendelkezésünkre. ntext. -2: A lekért sor hiányzik. kivéve a text.info . oldal a 242-ből www. mint egy szabályos adatbázistábla. Függvénykategóriák: Összesítő függvények: egy tábla egy vagy több sora alapján adnak vissza információkat Matematikai függvények: számítások végzésére használatosak Karakterlánc-függvények: karakterláncokon hajtanak végre műveleteket Dátum. de a helyben kifejtet táblaértékű függvényektől eltérően több T-SQL utasítást tartalmazhatnak. például a táblákról adnak információt Biztonsági függvények: az adatbázis felhasználóiról és szerepköreiről nyújtanak információt Rendszerstatisztikai függvények: statisztikai adatokat adnak vissza az SQL Serverről Szöveg. illetve annak elemeiről. meghívhatjuk. A kurzort a CLOSE s a DEALLOCATE utasítással zárhatjuk be a kurzorra való hivatkozást.és képfüggvények: szöveg.info) 0: A FETCH utasítás sikeresen visszaadott egy sort.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. Helyben kifejtett táblaértékű függvények .A többutasításos táblaértékű függvények is table típusú objektumokat adnak vissza. mellyel felszabadíthatjuk az általa használt rendszererőforrásokat. A helyben kifejtett táblaértékű függvények egyetlen SELECT utasítással kinyert adatokat adnak vissza. csak a memóriában tárolódnak. -1: A FETCH utasítás hibázott. úgynevezett felhasználói függvényeket is készíthetünk. Példa egy skalárfüggvényre: .és időkezelési műveleteket hajtanak végre Rendszerfüggvények: az SQL Serverről szolgáltatnak információt Beállítási függvények: a kiszolgáló beállításairól adnak információt Kurzorfüggvények: a kurzorokról szolgáltatnak információt Metaadatfüggvények: az adatbázisról. image. A felhasználói függvények létrehozására a CREATE FUNCTION utasítás szolgál. amelyekkel értékeket nyerhetünk ki az adatbázisokból. ami bármilyen típusú lehet. Többutasításos táblaértékű függvények .kuruc.és időfüggvények: dátum.A DiscountPrice kiszámítja egy termék új árát az eredeti ár és a leértékelési szorzó alapján Ha létrehoztuk a függvényt. Egy tábla sorainak számát például a COUNT ( ) függvénnyel kaphatjuk meg.és képkezelési műveleteket hajtanak végre Felhasználói függvények létrehozása Az SQL Serverben saját.A helyben kifejtett (inline) táblaértékű függvények table típusú objektumokat adnak vissza. table és timestamp típusokat.A skalárfüggvények egyetlen értéket adnak vissza. illetve a felhasználói adattípusokat.kuruc. A skalárfüggvények meghívása a következő: Ez a 238. vagy a kért sor az eredményhalmazon kívülre esett. Egy ilyen függvénnyel kiszámíthatunk például egy kedvezményes árat az eredeti ár és egy szorzó alapján. cursor. A table objektumok olyanok.

*/ Többutasításos táblaértékű függvények Példaprogram. Példa egy helyben kifejtett táblaértékű függvényre: /*Visszaadja a Products tábla azon sorait. vagy azzal egyenlő érték szerepel.info) tulajdonos. a függvénynév pedig a függvény neve. oldal a 242-ből www. vagy azzal egyenlő érték szerepel.info .C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.függvénynév Itt a tulajdonos a függvényt létrehozó adatbázis-felhasználó neve.kuruc. és beszúr egy új oszlopot Reorder néven: Ez a 239. Helyben kifejtett táblaértékű függvények A helyben kifejtett (inline) táblaértékű függvények TABLE típusú objektumokat adnak vissza. Itt nincs BEGIN és END utasítások közé zárt utasításblokk.kuruc. amelyeket egyetlen SELECT utasítás tölt fel. a függvény mindössze egy SELECT utasítást tartalmaz. mely visszaadja a Products tábla azon sorait. amelyek UnitsInStock oszlopában a paraméterként átadott újrarendelési szintnél kisebb. amelyek UnitsInStock oszlopában a paraméterként átadott újrarendelési szintnél kisebb.

Általában akkor készítünk tárolt eljárást. Fontos. például ProcedureTest névvel. Lokális ideiglenes eljárás létrehozásához az eljárás neve elé tegyünk egy # karaktert. hogy JÓVAL TÖBBFÉLE ADATTÍPUST ADHATUNK VISSZA. ami erőteljesen igénybe veszi az adatbázist. ezzel szemben a GLOBÁLIS eljárást más kapcsolatból is használhatják. majd az AS után jöhet a T-SQL kód.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.info) Az SQL Server lehetővé teszi. Ezt követően adhatjuk meg az eljárás nevét.info . hogy mit is végezzen el a létrehozott eljárás. hogy az egyes felhasználóknak ne kelljen ugyanarra a feladatra saját programokat írniuk. hogy az adatbázisokban ELJÁRÁSOKAT tároljunk. és egy tábla néhány adattal. ha már minden kapcsolat lezárásra került. ha olyan feladatot kell elvégeznünk. vagy ha központosítani szeretnénk a kódokat. míg a globálisak csak akkor. Tárolt eljárás létrehozásához a CREATE PROCEDURE utasítást kell használnunk. Létrehozhatunk úgynevezett lokális és globális ideiglenes eljárásokat is. amelynek segítségével a számlákat frissítjük a nap végén. a globálisnál Ez a 240. A tárolt eljárások abban különböznek a felhasználói függvényektől.kuruc.kuruc. Tárolt eljárások létrehozása: Szükségünk lesz egy adatbázisra. oldal a 242-ből www. A LOKÁLIS csak a saját kapcsolatban használható. Az intenzív adatbázis-használatára jó példa lehet egy banki alkalmazás. azt más kívülről más nem tudja majd használni. központosított kódra pedig akkor lehet szükség. hogy a lokális változatok automatikusan törlődnek a kapcsolat lezárásával. ha a felhasználók hozzáférését az adatbázistáblákhoz korlátozni akarjuk.

oldal a 242-ből www. Az SQL Server számos függvényt bocsát a rendelkezésünkre. A paraméternév mindig egy @ jellel kezdődik. amelyekkel értékeket nyerhetünk ki az adatbázisokból. Futtassuk az imént létrehozott eljárást: Kioldók A KIOLDÓK (TRIGGER) olyan különleges tárolt eljárás. hogy jóval többféle adattípust adhatnak Ez a 241. Összefog(lal)ás A Transact-SQL-ről láthattunk egy rövid ismertetőt. ha egy tábla oszlopértékeinek változásait szeretnénk ellenőrizni. Na de nézzünk egy példát: Tárolt eljárások végrehajtása: A tárolt eljárások végrehajtására az EXECUTE utasítást használhatjuk. ezek között úgy tudunk különbséget tenni. hogy az adatbázisokban eljárásokat tároljunk. amikor egy meghatározott INSERT. A T-SQL segítségével olyan SQL-utasításokat tartalmazó programokat írhatunk. Az SQL Server azt is lehetővé teszi. Az SQL Serverben saját.info) pedig ## karaktert. A kioldó egy INSERT.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www. akkor a típus után az OUTPUT jelzőt kell írnunk. A tárolt eljárások abban különböznek a felhasználói függvényektől.kuruc. Ha olyan paramétert szeretnénk megadni.kuruc.info . hogy ha törölni akarjuk az eljárásokat a DROP PROCEDURE utasítással. akkor elegendő megadni az eljárás nevét és annak öszszes változata törlésre kerül. úgynevezett felhasználói függvényeket is készíthetünk. A név után a paraméter típusát adhatjuk meg. Természetesen paramétereket is adhatunk a tárolt eljárásnak. Ezt az eljárás neve után tehetjük meg egy vesszővel elválasztott felsorolásban. A kioldókat a CREATE TRIGGER utasítással hozhatjuk létre. melyen keresztül értéket is adnánk vissza. Több eljárásnak adhatunk azonos nevet is. UPDATE vagy DELETE utasítást egy bizonyos adatbázistáblán végrehajtunk. Ennek ott lesz előnye. UPDATE vagy DELETE utasítás helyett is elindulhat. amelyekben a szokványos programozási szerkezetek is megtalálhatók. A kioldók igen hasznosak például akkor. hogy a név után pontosvesszővel megadunk egy sorszámot. amelyet az adatbázis-kezelő automatikusan futtat.

info) vissza. ha olyan feladatot kell elvégeznünk. vagy ha központosítani szeretnénk a kódokat. ami erőteljesen igénybe veszi az adatbázist.C#-programozás a felsőoktatásban (ezt is nézd azért meg: www.kuruc. hogy az egyes felhasználóknak ne kelljen ugyanarra a feladatra saját programokat írniuk.info .kuruc. oldal a 242-ből www. Ez a 242. Általában akkor használjuk.