Láposi Zoltán, Kiss Tibor - C# Programozási Segédlet

Láposi Zoltán —Kiss Tibor
programozási segédlet
szegsz.Text = "
05
csoki.Checked
CSl = false;
tea.Checked = false;
kave.Checked = false;
capu.Checked = false;
I tej.Checked = false;
cukor.Checked = false; ouble a = o, b = o, c = o;
citrom.Checked = false; if (asz.Text ± = "") asz.Text = "o";
if (bsz.Text = = "") bsz.Text = "o";
a = Convert.ToDouble(asz.Text);
b = Convert.ToDouble(bsz.Text);
if (jel.Text = = "+") c = a + b;
if (jel.Text = = c = a - b;
if (jel.Text = = "*") c = a * b;
l if (jel.Text = = ”/ ”) c = a / b;
:sz.Text = Convert.ToString(c);
Műszaki Könyvkiadó
Láposi Zoltán-Kiss Tibor
C# programozási segédlet
és munkafüzet
5. kiadás
Műszaki Könyvkiadó
A kiadvány tankönyvi engedélyét meghosszabbította a Nemzeti Fejlesztési Minisztérium.
Határozati szám: IGF/19256/2018-NFM
Kapcsolódó kerettantervek:
Szcs. Szakképesítés M odul Tantárgy, tém akör
száma az. száma m egnevezése sz. neve m egnevezése
Infokommunikációs hálózatépítő és
Programozás és adatbázis
6 54 481 03
üzem eltető
54 481 01 CAD-CAM informatikus Programozás
és Programozás
11625-16
kezelés
54 481 02 Gazdasági informatikus gyakorlat tantárgy,
54 213 05 Szoftverfejlesztő a Java vagy C# nyelv
7 alapjai, programozási
54 481 05 Műszaki informatikus
típusfeladatok
54 481 06 Informatikai rendszerüzemeltető
54 482 01 IT mentor
Szakmai lektor: Bacskó Sándor

© Láposi Zoltán, Kiss Tibor, 2018
© Műszaki Könyvkiadó Kft., 2018
A kiadvány szerzői jogi védelem alatt áll, arról másolat készítése, más (papír, elektronikus
stb.) formában való felhasználása a kiadó előzetes írásbeli engedélye nélkül tilos. A kiadvány
másolása és jogosulatlan felhasználása bűncselekménynek minősül.
ISBN 978 963 275 124 5
Kiadói kód: TM-11205
A könyvet a Tankönyvmester Kiadó fejlesztette ki.
Kiadja a Műszaki Könyvkiadó Kft.
2519 Piliscsév, Topol utca 3., 1032 Budapest, San Marco utca 57.
Telefon: 06 33 473 473, info@mkkonyvkiado.hu, www.mkkonyvkiado.hu
Felelős kiadó Simon István ügyvezető igazgató
Felelős szerkesztő Hercegi Zsolt
Műszaki szerkesztő Haász Anikó
Borítóterv Dömyei Péter
Tördelés Formula Stúdió
Terjedelem: 15,02 (A/5) ív
A kiadvány tömege: 185 gramm
5. kiadás
lm agyár
nyomdatermék
NYOMD*- ÉS PAPÍRIPARI SZÖVETSÉS
Nyomta és kötötte Érdi Rózsa Nyomda

Felelős vezető Juhász László ügyvezető igazgató
Tartalom j egyzék
BEVEZETÉS................................................................................................................ 5
1. A MICROSOFT.NET FRAMEWORK..................................................................6
1.1. A programozás szintjei és a C# nyelv.......................................................... 6
1.2. A C# beszerzése.............................................................................................. 7
2. PROGRAMOZÁSI ALAPOK.................................................................................8
2.1. A C# indítása.................................................................................................11
2.2. Kiíró utasítások............................................................................................. 15
2.3. Változó értékének kiíratása......................................................................... 18
2.4. Kifejezések és műveletek............................................................................ 22
2.4.1. A kifejezések kiértékelése.................................................................23
2.5. Beolvasás billentyűről................................................................................. 24
2.6. Konvertálás................................................................................................... 24
2.7. Matematikai függvények............................................................................. 25
2.8. Elágazás.........................................................................................................28
2.9. Logikai műveletek........................................................................................32
2.10. Véletlen számok előállítása......................................................................... 33
2.11. Ciklusok.........................................................................................................35
2.11.1. Elöltesztelő ciklus............................................................................ 36
2.11.2. Hátultesztelő ciklus......................................................................... 38
2.11.3. Előírt lépésszámú ciklus..................................................................40
2.12. Többirányú elágazás.....................................................................................43
2.13. A töm b...........................................................................................................46
2.14. A goto utasítás.............................................................................................. 52
2.15. Hibakeresés, tesztelés...................................................................................54
3. PROGRAMOZÁSI TÉTELEK............................................................................ 57
3.1. Összegzés......................................................................................................57
3.2. Megszámolás................................................................................................ 58
3.3. Eldöntés.........................................................................................................59
3.4. Kiválasztás.................................................................................................... 60
3.5. Maximum- (minimum) kiválasztás............................................................ 61
3.6. Kiválogatás................................ 66
3.7. Szétválogatás................................................................................................ 67
3.8. Lineáris keresés............................................................................................ 68
3.9. Rendezés....................................................................................................... 69
3.9.1. Minimum (maximum) kiválasztásos módszer................................ 70
3.9.2. Szomszédos elemek cseréjén alapuló módszer............................... 73
4. ALPROGRAMOK ÉS FÁJLKEZELÉS............................................................. 76
4.1. Eljárások........................................................................................................76
4.2. Függvények.................................................................................................. 84
4.3. Fájlkezelés.................................................................................................... 88
4.3.1. Hibakezelés..................................................................................... 89
5. ÖSSZETETT ADATSZERKEZETEK.................................................................98
5.1. Stringek..........................................................................................................98
5.2. A felsorolt típus.......................................................................................... 104
5.3. Struktúra (rekord)....................................................................................... 105
5.4. Lista............................................................................................................. 107
5.5. Szótár........................................................................................................... 110
5.6. Halmaz......................................................................................................... 112
6. ÖSSZETETT FELADATOK...............................................................................114
6.1. Kéktúra (Ágazati érettségi mintafeladat: 2017)......................................114
6.2. Helsinki 1952 (Ágazati érettségi feladat: 2017 május)........................... 120
7. WINDOWS FORM APPLICATION ................................................................129
7.1. A Windows Formok használata................................................................ 129
7.2. ALabel .......................................................................................................130
7.3. A B u tto n ......................................................................................................131
7.4. A TextBox...................................................................................................133
8. WINDOWS PRESENTATION FOUNDATION.............................................. 155
8.1. A WPF használata ..................................................................................... 155
8.2. A B utton.....................................................................................................157
8.3. A TextBox...................................................................................................158
8.4. Az Image ....................................................................................................161
8.8. A T im er......................................................................................................169
Felhasznált irodalom ................................................................................................175
Új szakkifejezések....................................................................................................176
5
Az összeállítás magas szintű, objektumorientált programozási nyelv, a C# segítsé

gével igyekszik bevezetni olvasóját a programozás világába. A megírásra azért volt
szükség, mert a szakközépiskolai programozás oktatáshoz a tankönyvpiacon nem
található megfelelő könyv. A könyvek egy része túlmutat a szakközépiskolai tan
anyagon, nyelvezete nehezen érthető, és az ára is eléggé magas. A könyvek másik
(szakkönyvek) része a profi programozóknak szól, mindenre kiterjedő részletes
séggel tárgyalja a témaköröket. Ezek is drágák, és az ismerkedés időszakában fe
lesleges is.
A programozás elméleti részét nem kívánjuk részletesen taglalni, csak az adott
feladat megoldásához elengedhetetlenül fontos fogalmakat, definíciókat említjük
meg. Elsősorban kezdőknek ajánljuk ezt a segédletet. Olyanoknak, akik először
tanulnak programozást, vagy már tanultak, de más programozási nyelven. (PL:
Pascal, C, C++, stb.) Lépésről-lépésre haladunk előre, így akik már jártasak vala
melyest a programozásban, és a C# nyelv sem teljesen új számukra, azok gyorsab
ban haladhatnak. Reméljük azonban, hogy számukra is mutatunk majd néhány
hasznos, tanulságos példaprogramot.
Egy konkrét feladat megoldása az algoritmuskészítéssel kezdődik. Ekkor határoz
zuk meg a lépések sorozatát amely során a kiindulási állapotból a végállapotba ju
tunk. Az algoritmuskészítést követően elkészítjük a programot amely során az algo
ritmust a számítógépnek érthető nyelven megfogalmazott utasításokkal írjuk le.
A programozási módszerek általában függetlenek a programozási nyelvtől, csupán
a nyelvi sajátosságok különböznek. A nyelv kiválasztása régebben a feladattól
függött. Ma már nehezen képzelhető el olyan programozási probléma, amely ne
lenne megoldható egy C alapú nyelv segítségével. Többek között ezért is válasz
tottuk a C# nyelvet, annak is az ingyenesen elérhető és letölthető változatát.
A szoftver letöltésében és telepítésében is igyekszünk segítséget nyújtani. Itt azon
ban meg kell említeni, hogy a nyelv folyamatos fejlesztése miatt a letöltés helye,
és a szoftver évszáma is változik majd a későbbiekben.
A C# nyelv tárgyalásakor említést kell tennünk a .NET keretrendszerről, amely
nagymértékben megkönnyíti a munkánkat.
6
1. A MICROSOFT.NET FRAMEWORK
A Microsoft.NET Framework egy keretrendszer, amely programcsomagként mű

ködik a Windows operációs rendszer alatt. A rendszer lényege, hogy megbízható
és gyors programfejlesztési környezetet, valamint programfuttatást tesz lehetővé.
Gazdag osztálykönyvtár rendszere is van. Használatával sok hiba elkerülhető, se
gítve ezzel a kezdő programozók munkáját.
Ezt a keretrendszert használja többek között a C#, J#, VB.NET, és a Jscript nyelv
is. Mi a továbbiakban a C# nyelvvel fogunk megismerkedni.
1.1. A programozás szintjei és a C# nyelv
A programozási nyelvek csoportosítása sokféleképpen történhet. A kezdeti idő

szakban a programozás egy nagyon szűk felhasználói réteg számára volt elérhető.
Az itt használt programozási nyelv a számítógép számára közvetlenül érthető
nyelv, a gépi kód volt. A nyelv elemei a processzor számára közvetlenül érthetőek
és bináris illetve hexadecimális alakban kerültek megadásra. (Pl.: 8B D4 70 00 00
90 48 75 FC C3)
A fejlődésnek köszönhetően egyre nagyobb felhasználói kör ismerkedett meg a
számítógépekkel és ez magával hozta a nyelv változását is. A kezdeti szűk progra
mozói kör az assembly nyelvnek köszönhetően folyamatosan bővült, hiszen az
utasítások itt már könnyebben megjegyezhető angol nevekkel (mnemonikus kód)
látták el. A nyelv azonban már közvetlenül nem értelmezhető a processzor számá
ra, ezért gépi kódúvá kellett fordítani futtatás előtt. (Pl.: MOV AX,7)
A programozás elterjedését azonban a magas szintű nyelvek megjelenése tette le
hetővé. Az ilyen nyelvek könnyebben használhatóak, és platform függetlenek.
Ilyen a C#, PHP, Pyton, Perl, Ruby, Java, stb. A segédlet további részében a C#
nyelv jellemzőit fogjuk bemutatni a teljesség igénye nélkül.
A C# nyelv első változata 2001-ben jelent meg és azt követően is folyamatos fej
lesztés alatt áll. Ezt a munkát a kezdetektől Anders Hejlsberg vezeti, aki a Turbo
A C# BESZERZÉSE
7
Pascal kidolgozásában szerzett elévülhetetlen érdemeket. A C#, a C++-ra épülő

objektum-orientált nyelv. Érdemes megjegyezni a nyelv egyik fontos tulajdonsá
gát, amely a programfutás közben van segítségünkre. Ez pedig az automatikus
szemétgyűjtés a garbage collection. Feladata a dinamikusan lefoglalt memóriaterü
letek felszabadítása. Ez nagy mértékben gyorsítja a program futását.
1.2. A C# beszerzése
A program az internetről letölthető ingyenesen a Microsoft honlapjáról.

A https://www.visualstudio.com/downloads/ oldalon a free downloadra kattintva
egy néhány Mb-os fájl töltődik le, amelyet elindítva letöltődik a teljes C# program
a megfelelő könyvtárszerkezettel.
Amíg ez megtörténik, addig folyamatos on-line internet kapcsolat szükséges. Ezt
követően a helyes működéshez csupán regisztrálni kell, így szükség van egy létező
e-mail címre is.
8
2. PROGRAMOZÁSI ALAPOK
A programozás során konkrét feladatot/feladatokat oldunk meg. Nézzünk egy

konkrét feladatot!
Készítsünk programot, amely bekéri egy téglalap alakú földterület oldalhosszúsá
gait és meghatározza, hogy mennyi kerítésdrótra van szükség a terület körbekerí
téséhez.
A feladat vagy feladatok megoldása során több, jól meghatározott lépést kell ten
nünk a feladat megfelelő elvégzése érdekében.
Ezek a következők:
a) Specifikálás
Az első lépés a feladat lehető legpontosabb leírása, adott esetben megbeszélés
a program készíttetőjével. Ebben a lépésben arra keresünk választ, hogy miből
mit kell előállítani, milyen módszerrel. A leírás lehetőleg legyen mindig rövid,
tömör, egyértelmű. A specifikálás során szöveges, ill. matematikai leírásokat is
használhatunk. A mi példánkban alapvetően egy téglalapból kell kiindulnunk,
amelynek 2 oldalhosszúsága van. Az egyik oldalhosszúságot jelöljük a-val,a
másikat b-vel. Erre a 2 adatra feltétlenül szükségünk van a feladat megoldásá
hoz. Ez lesz a bemenet. A bemenetek azonban csak pozitív számok lehetnek.
A bemenetre vonatkozó kikötéseket nevezzük előfeltételnek. A feladatból kiol
vasható, hogy annak a téglalapnak a kerületét kell meghatároznunk, amit K-val
jelölünk, és a program kimenetét fogja jelölni. A számítási képlet: K = 2 • (a + b),
ami megadja az eredmény meghatározásának módját, azaz az utófeltételt. A fel
adat azonban nem eléggé pontos, mivel nem tudjuk hogy a kapott adatok mi
lyen mértékegységben (cm, m, km) vannak megadva, ill. azt sem, hogy az
eredményt milyen mértékegységben (cm, m, km) kell meghatározni. Az egy
szerűség kedvéért a bemenő és kimenő adatokat is egész méterben kezeli a
rendszer (máskülönben átváltásra van szükség).
• Bemenet: a, b egész szám [mértékegység: méter],
• Előfeltétel a > 0 és b > 0.
• Kimenet: K egész szám [mértékegység: méter].
• Utófeltétel: K = 2 • (a + b).
P rogramozási alapok
9
b) Tervezés
A specifikáció alapján meg lehet tervezni a programot, elkészülhet a megoldás
algoritmusa és az algoritmus által használt adatok leírása. Az algoritmusok le
írása megvalósítható folyamatábrával, struktogrammal, Jackson-diagrammal,
mondatszerű elemekkel, vagy mondatokkal leírva is. Az első három rajzos
megvalósítás nyelvfuggetlen, ezért sokszor ezt használják. A konkrét feladat
folyamatábrája:
a: egész
b: egész
K: egész
ó-
Be: a
igaz
< >
hamis
6-
Be: b
igaz
< b<-° >

hamis
K = 2 • (a + b)
10
c) Kódolás
Az előzőleg megtervezett algoritmus megvalósítása a megbeszélt nyelven. A meg
valósításhoz a konkrét programozási nyelv alapos ismerete szükséges. A prog
ramkód C# nyelven:
s ta tic v o i d M a i n ( s t r i n g [] args)
int a, b, K;
C onsole.W riteL in e("T ég lalap k e rü le té n e k k is z á m itá s a " ) ;
do
{
C o n s o l e . W r i t e L i n e ("Kérem a d j a meg az első o ld al
hosszúságot egész m éterben");
a = C o n v ert. T oInt32(C onsole.R eadL ine());
} w hile ( a <= 0 ) ;
do
{
C o n s o l e . W r i t e L i n e ( " K é r e m a d j a meg a z m á s o d i k o l d a l
hosszúságot egész m éterben");
b = C o n v ert.T oInt32(C onsole.R eadL ine());
} w hile (b <= 0 ) ;
K = 2 * (a + b) ;
C o n so le.W riteL in e("A szükséges k eritésd ró t {0} m é t e r
", K);
C o n so le . ReadKey();
}
d) Tesztelés
A program kipróbálása, esetleges hibák feltárása, a hibalista elkészítése. A tesz
telés során a programunkat kipróbáljuk, lefuttatjuk különböző tesztadatokkal.
A megfelelő tesztelés minden program fontos része, és napjainkban külön szoft-
vertesztelőket alkalmaznak a programozó cégek. A példánkban ilyen teszteset
lehet a (5, 6 ; 5, -6; -6, -8; -7, 8 ) számpárok alkalmazása. Ilyen teszt lehet az is,
hogy mi történik akkor, ha az oldalhosszúságnál törtszámot (PL: 3.5) adunk meg.
A C# INDÍTÁSA
11
e) Hibakeresés
A hiba pontos helyének meghatározása. Hol és mit rontottunk el. Gondoljuk
végig mit akartunk csinálni és mit csináltunk valójában. Ha sikerült a hibát
(hibákat) pontosan beazonosítani, kezdhetjük a következő lépést.
f) Hibajavítás
Hogyan lesz jó a program a hiba kijavítása után. A javítás után ismételt tesztelés
szükséges, hiszen a kijavított kódban is lehetnek hibák! A teszteléssel, hibake
reséssel, hibajavítással a későbbiekben részletesebben foglalkozunk. sshp469
g) Minőségvizsgálat, hatékonyság
Jobbá tehető-e a program, megvalósítható-e a gyorsabb programlefutás? Ennek
elvégzése a programozási nyelv és algoritmusok nagyfokú ismeretét igényli,
ezért nem tárgyaljuk részletesen.
h) Dokumentálás
A program készítéséről, felhasználásáról, telepítéséről megfelelő dokumentáci
ót kell készíteni. A felhasználói dokumentáció a felhasználónak szól, így ábrák
kal magyarázatokkal kell bemutatni a program használatát. A fejlesztői doku
mentáció a program felépítését, a megvalósított gondolatmenetet (algoritmus és
kód) az elvégzett teszteseteket, esetlegesen előforduló hibákat és azok javítása
it tartalmazza. A telepítési dokumentáció a program telepítésének lépéseit írja
le a szükséges hardver és szoftver követelményekkel együtt.
i) Használat, karbantartás
A nagyobb programokat időnként módosítani kell. Ilyen karbantartást igényel
nek pl. a könyvelőprogramok (adókulcsváltozás, törvényváltozás), a számlázó
programok stb. A szükséges módosításokat mindig el kell végezni, és a módo
sításokat ismételten tesztelni kell.
2.1. A C# indítása
Mielőtt bármilyen nyelven hozzákezdenénk egy program írásához, meg kell ismer
kedni néhány fontos fogalommal. A nyelvek többségében - így C#-ban is - beépí
12
tett szövegszerkesztő segítségével írhatunk programot. Ez a szövegszerkesztő kü

lönböző mértékben segíti a munkánkat attól függően, hogy melyik nyelven prog
ramozunk. A program különböző módszerekkel - zárójelekkel, utasításokkal stb.
- részekre tagolható. Ezeken a részeken belül kisebb egységnek tekinthetők a so
rok (mondatok) vagy utasítások, amelyek lehetnek összetettek is. A sorok szavak
ból, a szavak karakterekből állnak. Ez a legkisebb egység, amely tovább már nem
bontható. Összességében tehát elmondható, hogy a program szövege betűkből,
számjegyekből és egyéb karakterekből áll. Ezek után tisztázni kell, mi a betű, a
számjegy és az egyéb karakter.
• Betű: Programnyelvtől függ, hogy mi a betű, de az angol ABC 26 db nagy
betűje minden nyelven betű. A nyelvek többségénél a 26 db kisbetű is annak
számít, de kérdés, hogy tesz-e különbséget a kis- és a nagybetű között. A Pascal
pl. nem tesz különbséget, a C# viszont igen, tehát C#-ban a nagy „A” és a
kis „a” két különböző betűnek számít.
• Számjegy: A 0-tól 9-ig terjedő decimális számjegyek minden programozási
nyelven számjegynek tekintendők.
• Egyéb karakterek: Minden, ami az előző kettőből kimaradt, zárójelek,
műveleti jelek, pontok, vesszők stb.
Mindezek tisztázása azért volt nagyon fontos, mert a programok nagyrészt kulcs
szavakból (utasításokból) és azonosítókból állnak.
• Kulcsszó (utasítás): Az utasítások olyan szavak, amelyeket az adott prog
ramnyelv képes értelmezni.
• Azonosító: Olyan karaktersorozat, amely betűvel kezdődik és betűvel vagy
számjeggyel folytatódhat.
Azonosítókkal a programozó a saját eszközeit nevezi meg. Az azonosítók közül a
leggyakrabban a változót használjuk. Az azonosítót célszerű úgy („sokatmondóan”)
megválasztani, hogy a későbbiekben akár mi, akár mások szeretnék megérteni, utólag
módosítani a programot, akkor minél több információval szolgáljon például egy vál
tozó neve. A „tiszta kód” elve alapján tehát a változó (azonosító) neve utaljon annak
programbeli szerepére. Ezt a későbbiekben a változók deklarációjánál látjuk majd.
Javaslat az azonosítók elnevezésére:

• a név utaljon a tartalomra
• lehetőleg rövid legyen
• egy programon belül hasonló elvek alapján képződjenek
• ne legyenek egymáshoz nagyon hasonló elnevezések, ha ez nem feltétlenül
szükséges
A C# INDÍTÁSA
13
• változóknál és metódusoknál (függvényeknél) összetett szavak esetén az

első szó utáni szavakat célszerű nagy kezdőbetűvel ellátni, a többi kisbetű:
PL: lottoSzamok
• metódusoknál az elnevezés többnyire ige
• az osztályok neve általában főnév, ahol a szókezdőbetűk nagybetűk, a többi
kisbetű
• a név legyen angol, vagy ha ezt nem feltétlenül kell alkalmazni, akkor leg
alább mellőzzük az ékezetes betűket. Még akkor is, ha az adott nyelv engedi
az ékezetes betűk használatát.
• a konstansok neve csupa nagybetű
Nem lehet azonban teljesen egységes elvek alapján megválasztani a neveket, mivel
nehéz két, vagy több ellentmondó feltételnek egyszerre megfelelni. Például a
Random veletlenSzam = new Random(); esetén két feltétel nem teljesül, egy vi
szont igen. A név utal a tartalomra, de nem angol és nem rövid. Lehetne például
vszam, ami rövid, még talán kellőképpen utal a tartalomra, de ez sem angol. Lehet
még rövidebb, a magyar nyelvben alkalmazott rövidítést is alkalmazni, ha csak
vsz-ként használjuk az azonosítót, hasonlóan a darab, db névhasználathoz.
A véletlenszámoknál gyakran láthatjuk a rand és rnd azonosítónév használatát, ha
az angol nyelv az elvárt a programozás során. Ilyen esetekben a programozó dön
tésén, kreativitásán múlik a nevek kialakítása, de igyekezni kell az ajánlásokból
minél többnek megfelelni.
Itt jegyeznénk meg, hogy C#-ban az ékezetes betűk is használhatók a programozás
során az azonosítók névadásánál, de több esetben is ékezetmentes nevet haszná
lunk, mert a gyakorlatban néhány esetben még problémát okoz az ékezetes betűk
használata. (Pl.: könyvtárszerkezet kialakítása programból és hivatkozás ékezetes
betűt tartalmazó könyvtárra)
A változó: Olyan programozási eszköz, amely négy részből áll.
• Név: Egy azonosító, tehát a változónak is úgy adunk nevet, ahogy azt az
azonosítónál láttuk.
• Típus: Meghatározza, hogy a változó milyen értéktartományból vehet fel
értéket. Az EXCEL-ben és az ACCESS-ben tanult típusokhoz hasonlók kö
zül választhatunk. A típus egyben meghatározza a változóval végezhető
műveleteket is. Pl.: a szám típusú változóra értelmezhető az összeadás vagy
a szorzás művelet, de egy szöveg típusra csak az összeadás (összefűzés).
A változóhoz tartozó típust a deklarációban kell megadni, az esetek többsé
gében explicit módon a programozó végzi ezt.
• Cím: A tárnak az a területe, címe, ahol a változó értéke elhelyezkedik.
• Érték: Az előbb említett tárcímen elhelyezkedő bitkombináció.
14
Az értéket hozzárendelhetjük a változóhoz:

• értékadó utasítással: PL: a = 5; vagy b = b + 3;
• input utasítással, vagyis billentyűről vagy háttértárolóról kap értéket a változó,
• kezdőérték-adással: megteheti a programozó is (általában a deklarációnál),
de lehet automatikus kezdőérték-adás is, ha az adott programozási nyelv
ismeri ezt a lehetőséget.
A programírás megkezdése előtt már csak egyetlen fontos részt kell megemlíteni:
ez pedig a programírás szabálya. Minden programozási nyelv saját nyelvtannal,
szabályrendszerrel rendelkezik, ugyanúgy mint az emberi nyelvek. A magyar, az
angol, a német stb. nyelveknek is vannak szabályai, amit be kell tartani, csak úgy
kapunk értelmes szöveget. Hiába ismerünk szavakat, ha azokat helytelen sorrend
ben a nyelvtani szabályoknak nem megfelelően használjuk.
Ezért két fogalommal kell megismerkednünk:
• Szintaktika: A szöveg összeállítására vonatkozó szabályok összessége.
Ezek a nyelvtani szabályok. Ha ezeket nem tartjuk be, a C# azonnal közli
velünk egy hibajegyzékben, hogy hol van és milyen jellegű a hiba.
• Szemantika: A program működésére vonatkozó szabályok összessége.
Nyelvtanilag jó program még nem biztos, hogy azt csinálja majd, amit mi
szerettünk volna.
Ha elindítjuk Start-Programokból a C#-ot, akkor célszerű a File-New Project me

nüpontot kiválasztani. A megjelenő ablakban ki kell választani a program típusát,
amely esetünkben a Console Application lesz, és alul a Name részben nevet kell
adni a Projectunknak.
A név legyen: Első
Az OK-ra kattintva megjelenik a program nyelvtanilag helyes váza, amely még
nem csinál semmit, de hiba sincs benne. A menü és ikonrendszer alatt található a
program, amelyet - egyelőre - kizárólag a
static void M a i n ( s t r i n g [] args)
kapcsos zárójelei közé fogunk írni. Ezt a nagyon fontos szabályt tartsuk be
mindaddig, amíg nem ismerjük a using, a namespace és class részek jelentőségét.
A jobb oldalon a Solution Explorer-ben a nevet láthatjuk, alatta a Properties a
References és a Program.es található. Számunkra egyelőre csak a Program.es lesz
a fontos. Ha a Solution Explorer nem látszik, akkor a menüsor View részében kap
K iíró utasítások
15
csoljuk be. Ugyanitt célszerű beállítani a program alatt megjelenő hibalistát, az

Error List táblázatot. Ha mindez megtörtént, írhatjuk a programot.
2.2. Kiíró utasítások
1. feladat:
írjuk ki a képernyőre az „Első C# programom” szöveget!
A neve legyen: Első
Ehhez meg kell ismerkednünk a C# kiíró utasításaival, amely a ConsoleWrite() és
a Console.WriteLine() utasítás. A Console most egy kimeneti konzolt, a monitort
jelenti, a Write írást, a Line pedig sort jelent. Lefordítva magyarra: írj egy sorba a
képernyőre! Hogy mit írjon a gép, azt a zárójelek közötti idéző jelek közé kell
begépelni, így:
C o n so le.W riteL in e("A z első C# p r o g r a m o m " ) ;
Ha a ConsoleWrite-ot használnánk, akkor a kiírás után a kurzor közvetlenül a kiírt

szöveg után állna, így viszont a következő sor elején lesz.
Vegyük észre, hogy a sort egy sorvégjel a ; (pontos vessző) zárja. Ez a későbbiekben
fontos szabály lesz, amely alól csak néhány kivétel esetén térhetünk el.
Az utasítások begépelése során láthatjuk, hogy a programnyelv szövegszerkesztője
hathatós támogatást nyújt a gépelés során, hiszen megpróbálja kitalálni mit szeret
nénk beírni. Vigyázzunk, mert a C# utasítások nagybetűvel kezdődnek. Ha pontosak
akarunk lenni, akkor célszerű használni a legördülő menüt, amelyben mindig he
lyesen vannak az utasítások és innen Tab billentyűvel beszúrhatjuk a megfelelő
utasítást. Ha kisbetűvel kezdtük a begépelést, a Tab-ot használva mindenképpen
helyesen jelenik meg a beírandó utasítás, ezért erősen ajánlott a használata.
Az első programunk tehát így néz ki helyesen:
Megoldás:
using System ;
using S y ste m .C o lle ctio n s.G enerik
us ing S y stem .L inq;
using S ystem .T ext;
nam espace E lső

16
{
eláss Program
{
{
C o n s o l e . W r i t e L i n e ( "Az e l s ő C# p r o g r a m o m " ) ;
}
}
A programot mentsük el! A legegyszerűbb, ha az ikonok közül a Savé All (három

egymás mögött lévő kislemez) ikont használjuk. Ekkor beállíthatjuk a program
nevét és a mentés helyét. Célszerű elfogadni a program által ajánlottakat és máris
megtörtént a mentés.
A program futtatása is több módon történhet. Válasszuk a leggyorsabbat, az F5
billentyűt, vagy az ikonok közül a zöld háromszöget (Start Debugging).
Meglepve tapasztalhatjuk, hogy a hibátlan program lefut, és mégsem látunk sem
mit. Ennek egyszerű oka van. A program egyetlen utasítást tartalmaz, mégpedig a
megadott szöveg kiíratását. Ezt meg is teszi, majd azonnal visszatér a szövegszer
kesztő részbe. Ha szeretnénk látni a kiírt szöveget, akkor meg kell állítani a prog
ram futását. Ezt több módon is megtehetjük. Beállíthatunk egy időértéket
millisecundumban, amelynek lejárta után a program befejeződik. Jobb megoldás
azonban, ha a Console.ReadKeyO utasítást használjuk. Itt a Console bemeneti
konzolt, azaz a billentyűt jelenti, a Read (be)olvasást, a Key pedig egy billentyű
lenyomást jelent. így a program mindaddig várakozik, amíg egy billentyűt meg
nem nyomunk.
Módosítsuk a programunkat az alábbiaknak megfelelően.
Megjegyzés: A továbbiakban csak a program számunkra fontos részét írjuk le, te
hát csak a static void, és az azt követő kapcsos zárójelek közti részt. A Main függ
vény után a C# beírja a zárójelek közé automatikusan a string[] args részt,
{
C o n so le.W riteL in e("A z első C# p r o g r a m o m " ) ;
C o n s o l e . R e a d K e y () ;
}
Most már valóban láthatjuk a képernyőn az első C# programunkat, amelynek csak
akkor van vége, ha egy tetszőleges billentyűt lenyomunk.
VÁLTOZÓ ÉRTÉKÉNEK KIÍRATÁSA
17
Vegyük észre a C# szövegszerkesztő azon segítségét, hogy különböző színekkel

írja a program részeit. Pl. az idézőjelek közötti rész mindig piros lesz.
Szintén fontos szabály, hogy minden zárójelnek van párja. Kapcsosnak is, nem
kapcsosnak is. Hasonlóan az idézőjelek is párban vannak. Ha helyes programot
szeretnénk készíteni, célszerű az alábbi szabályt betartani a gépelés során:
A párban lévő írásjeleknek mindig tegyük ki a nyitó után azonnal a zárópárját,
majd szükség esetén lépjünk vissza a zárójelek, idézőjelek közé és ott folytassuk a
beírást. Ha így cselekszünk szintaktikailag, nyelvtanilag helyes lesz a programunk
ezen része.
Üres sort a Console.WriteLine(); utasítással lehet kihagyni, amely azt jelenti a gép
számára, hogy a képernyőre írjon egy sort. Mivel nincs idézőjel és közte szöveg,
így csak az alaputasítást hajtja végre.
2. feladat:
írjuk ki a képernyőre az „Első C# programom” szöveget, alatta hagyjunk ki egy
üres sort, és ez alá írjuk ki a „Már üres sort is tudok” szöveget!
Név: Második
Megoldás:

{
C o n s o l e . W r i t e L i n e ( "Az e l s ő C# p r o g r a m o m " ) ;
C o n so le .W rite L in e ();
C o n s o l e . W r i t e L i n e ( "Már ü r e s s o r t i s t u d o k " ) ;
C o n so le .ReadKey();
}
Ugyanezt az eredményt kapjuk, ha az üres sornál használjuk az idézőjeleket így:
Console. WriteLine(””);
Az idézőjelek közé írt részt szövegkonstansnak nevezzük. Kiíratni szövegkonstanst
és változó vagy kifejezés értékét lehet. Kifejezésnek nevezzük a változókkal végzett
- többnyire - matematikai műveletek végeredményét. PL: a/b vagy y*y/(x+z)
A C# sok utasítást függvényként kezel. A függvények egyik fontos jellemzője,
hogy zárójeleket használunk a függvények neve után. A zárójelek közé többnyire
írunk is valamit, de néhány esetben csak az üres zárójeleket használjuk.
Programozási alapok
18
Az eddigi ismereteink alapján melyik az a 3 utasítás, amelyiknél a függvényhez

hasonlóan zárójeleket használtunk?
1,
2,
3,
2.3. Változó értékének kiíratása
Ahhoz, hogy egy változót használhassunk a programban, először deklarálni kell.

A deklaráció során meghatározzuk a változó típusát. A C# típusaival a feladatok
megoldása során fokozatosan ismerkedünk meg.
Leggyakoribb típusok:
Típus neve Értéktartomány A szám típusa

byte 0-tól 255-ig Egész szám
short -3 2 768-től 32 767-ig Egész szám
ushort 0-tól 65 535-ig Egész szám
int - 2 147 483 648-tól 2 147 483 647-ig Egész szám
uint 0-tól 4 294 967 295-ig Egész szám
- 9 223 372 036 854 775 808-tól
long Egész szám
9 223 372 036 854 775 807-ig
ulong 0-tól 18 446 744 073 709 551 615-ig Egész szám
float ±1.5 • 10^5 pontossággal ±3.4 • 1038 között Valós szám
double ±5 • 10_324pontossággal ±1.7 • 10308 között Valós szám
decimai ±1 • 10“28 pontossággal ±7.9 • 1028 között Valós szám
char Egyetlenegy karakter Ertékadás ’között’
string karaktersorozat (szöveg) Értékadás ’’között”
0 => mindig false minden
bool Logikai tipus (true vagy false)
más érték => true
VÁLTOZÓ ÉRTÉKÉNEK KIÍRATÁSA
19
A változó definiálása:
típus változónév;
• int a; //az a nevű változó int típusú egész adatokat fogadhat,
• float c , x , y ; //egyszerre több változót is deklarálhatunk, ha vesszővel eh
választva felsoroljuk őket
• string kiírás;
• char választás;
• bool ismétlés;
A változó deklarációja:
Néhány példa szám típus deklarációjára
A változókat célszerű kezdőértékkel ellátni, már a deklarációnál.

típus változónév = érték;
• int a = 0 , negyzetTerulet=0;
• double a = 0 , b = 0 , x l = 0 , x 2 = 0;
• string kiiras=”a művelet eredménye”;
• char valasztas=’b’;
• bool ismetles=false;
Ezek után nézzünk egy konkrét feladatot.
3. feladat:
írjuk ki a képernyőre az a változó értékét! Először adjunk 0 kezdőértéket a válto
zónak, majd a programban legyen egy értékadás, a változó értéke legyen 5 és
utána írjuk ki a változó értékét!
Név: Változókiírási
Megoldás:

{
i n t a = 0;
a = 5;
C o n so le .W riteL ine ( a ) ;
20
C o n s o le .ReadKey();
}
Most a képernyőn csupán egy 5-ös jelenik meg, és alatta villog a kurzor várva egy
billentyű leütését. Nézzük meg, hogyan lehet szövegkonstanst és változó értékét
egy sorba kiíratni: Legyen a = 4 és b = 6, típusuk pedig egész.
Ekkor a
C o n so le .W rite L in e("A z 1. szám = {0}, a m ásodik szám =
{ 1 } ff , a , b ) ;
utasítás miatt a képernyőre kiíródik az idézőjelek között lévő szövegkonstans, ki
véve a kapcsos zárójelek közötti 0 és 1. A 0 és az 1 helyén az a és a b változó ér
téke jelenik meg. Az idézőjel után vesszővel elválasztva meg kell adni a kiírandó
változók (kifejezések) listáját, amely listában sorszámozva vannak a változók (ki
fejezések) 0-tól kezdve.
Esetünkben tehát a 0. változó az a, az 1. pedig a b.
Ha a kiírandó változó nem egész típusú, akkor a változó sorszáma után kettős pon
tot kell tenni és meg kell adni az egészek, majd a pont után a tizedesjegyek számá
nak megfelelően nullákat.
PL:
double a = 3.45, b = 2.345;
C o n s o l e . W r i t e L i n e ( "Az 1. szám={ 0 :0 .0 0 } , a 2.
szám={1 : 0 . 0 0 0 } " , a , b ) ;
Hasonlóan írhatjuk ki egy kifejezés értékét is:
C o n s o l e . W r i t e L i n e ( " A z 1. s zá m = {0 : 0 . 0 0 } , a m ásodik
szám={1 :0 .0 0 0 } " , a / b , b * b );
A kiírandó változó természetesen nem csak szám típusú lehet, hanem akár szöveg
vagy karakter típus is.
4. feladat:
írjuk ki a képernyőre az x*y, majd alá 4 tizedes pontossággal az x/y értékét, ha x = 2,
y = -11! Az sz változó string típusú legyen és értéke: ” művelet eredménye:" szöveg
Név: Változókiírás2
Megoldási:
K ifejezések és műveletek
21
i n t x = 2, y = -1 1 ;
s t r i n g s z ö v e g = 11 m ű v e l e t e r e d m é n y e :
C o n s o l e . W r i t e L i n e (" x * y { 0 } {1} % sz ,x * y ) ;
C o n s o l e . W r i t e L i n e (" x / y { 0 } { 1 : 0 . 0 0 0 0 } ",sz, x / y ) ;
}
A monitoron ez jelenik meg:
x*y művelet eredménye: -22
x/y művelet eredménye: 0,0000
Az x/y esetén sajnos rossz eredményt látunk, amelynek oka a helytelen típusvá
lasztás az x és az y esetén. Ha a változók egész típusúak, akkor két egész szám
szorzata szintén egész lesz. Ezzel nincs is gond, de ha osztani kell, akkor már lehet
nem egész is a végeredmény. Esetünkben biztos nem lesz egész az x/y, ezért látunk
rossz értéket a számítás után. Ha x/y is egész lenne (pl: x = 9, y = 3), akkor ismét
helyes eredményt kapnánk. Egy jó program azonban minden lehetőségre fel van
készítve, ezért ilyenkor érdemes valós típust választani. (pl.:double vagy float)
Megoldás2:
{
f l o a t x = 2, y = -1 1 ;
s t r i n g s z ö v e g = 11 m ű v e l e t e r e d m é n y e : " ;
C o n s o l e . W r i t e L i n e (" x * y { 0 } { 1 } ", s z ö v e g ,x * y ) ;
C o n s o l e . W r i t e L i n e (" x / y { 0 } { 1 : 0 . 0 0 0 0 } " , szöveg, x / y ) ;
}
A monitoron most már helyesen ez jelenik meg:
x*y művelet eredménye: -22
x/y művelet eredménye: -0,1818
Megjegyzés: A kiíratásnál mindkét sorban a 0. változó a szöveges szöveg nevű változó volt.
Itt térünk vissza arra, hogy a változó nevének, az azonosítónak a megválasztását
milyen szempontok alapján célszerű elvégezni, a tiszta kód érdekében. Az első
megoldásnál a számok elnevezése x és y. Ez érthető is, mivel a matematikában
gyakran jelölünk így számokat helyettesítő értékeket. Az sz változó már nem igazán
„sokatmondó” egy külső szemlélő számára, de a második megoldásban a szöveg
név már egyértelművé teszi, hogy a szöveg változó szöveg (string) típusú lesz.
22
2.4. Kifejezések és műveletek
A programozás során nagyon sokszor az adatokkal valamilyen műveletet kell vé

gezni. A teljesség igénye nélkül tekintsük át a legfontosabb operátorokat és jelen
tésüket.
Operátor Jelentése Magyarázat
- Aritmetikai negálás Negatív előjel
! Logikai negálás NEM művelet
* Szorzás
/ Osztás Egy osztás egészrészét adja
% Maradékos osztás Egy osztás maradékát adja
+ Összeadás
- Kivonás
= Ertékadás
++ Incrementálás Változó értékének növelése 1-el
— Deckrementálás Változó értékének csökkentése 1-el
o Zárójelek A beleírt műveleteket hajtja végre először
Az előző táblázat néhány operátora további magyarázatra szolgál. Kezdjük az ér

tékadás operátorral. Az egyenlőségjel bal oldalán olyan kifejezés áll, amely felve
szi az új értéket, és a jobb oldalán az értéket adó kifejezés áll. Egyszerűbben fogal
mazva, az értékadás bal oldala megkapja a jobboldali kifejezés értékét.
Az értékadó operátor egy speciális esete amikor a baloldalon álló változó a jobb
oldalon is megjelenik. Gyakori példa az i = i+ 1; utasítás. Hogyan történik ilyen
kor a kifejezés kiértékelése? A megoldás a következő: Először kiértékelődik a
jobboldalon álló kifejezés, majd az érték átkerül a baloldali változóba. Szemlélete
sebben a következőképpen írható le:
i változó új értéke = i változó régi értéke + 1
Gyakran azonban az = operátorral együtt használjuk az aritmetikai operátorokat is.
Pl.: +=, *=, %=.
Példával illusztrálva: x += 3; ennek értelmezése a következőképpen történik: a
baloldalon található változó új értéke egyenlő lesz a baloldali változó régi értéké
nek és a jobboldali kifejezés = előtti operátor által meghatározott művelet eredmé
nyével. Átírva „egyszerűbb”alakban a jelentése: x = x + 3;
Az inkrementáló/dekrementáló oporátorok növelik, ill. csökkentik egy váltotó ér
tékét. Az operátor állhat a változó előtt, ekkor prefix formáról beszélünk. Pl:
a = ++b ennek jelentése b = b + 1 majd a = b (először növel).
B eolvasás billentyűről
23
Ha az operátor a változó után áll akkor postfix formáról beszélünk. Pl: a = b++
ennek jelentése a = b majd b = b + 1. (utólag növel)
2.4.1. A kifejezések kiértékelése
A kifejezés kiértékelése lépésről-lépésre történik, mindig ’belülről kifelé’. Az utol

só operátor kiértékelésének eredménye adja meg a kifejezés értékét és típusát. Ha
egy kifejezésben több operátor is van, akkor először mindig a magasabb prioritású
operátorokat kell kiértékelni.
A prioritási sorrend a matematikai sorrendnek megfelelő, azaz a zárójeles rész ki
értékelése az első, ezt követi a szorzás, osztás, majd végül az összeadás, kivonás.
Ha több azonos prioritási szintű operátor is van egy kifejezésben, akkor az adott
szint „kötési iránya” dönt. A kötési irány általában balról-jobbra irányt jelent,
vagyis először a legbaloldalibb azonos szintű operátort választjuk ki, majd a tőle
eggyel jobbra lévőt és ezt folytatjuk, amíg a végére nem érünk.
Néhány példa az operátorok használatára:
1. inta = 6 , b = 1 8 , c = 2 3 , x , y , z ;
x = a + b; //először megtörténik az összeadás, majd az eredmény az x változóba
kerül. Értéke: 24
x = x + 1; //először megnézi az x értékét ( 24 ) hozzáad egyet, és az így kapott
eredmény lesz az x változó új értéke
b - = a; //jelentése b = b - a ez viszont már egyértelmű b új értéke: 12
2. int a = 6, b = 18 , c = 23 , x , y , z ;
y = b / a ; Ily változó értéke 3 lesz
z = c % a ; H z változó értéke 5 lesz a % jel az osztás maradékát adja!!!
x=(c+b-a)%a; //először a zárójelen belüli rész értékelődik ki, majd elvégződik
a maradékos osztás x értéke 5 lesz
Mi lesz az alábbi kifejezések értéke?
1. Ha int i = 1, i++=..............., ha int j = - 1, j - - = ................,

ha bool A = true , ! A = ....................
24
2. Ha int a = 5, b= - 2 és c = 3 ,
(a + b) * c = ............... , 3 * a - (c / b) = ............. , ( - a - c) / b =
3. Ha int a = 10, b= - 1 és c = 6 ,
(a % c) * (- c) = ......., a - (c / b) = ............, - (b % c) + (a / 2) * 7 =
4. Ha int a = 8, b= - 3 és c = 9 ,
(a % b) * c * 2 = ....... , - b / a + (c * c) = ........, a * c - 4 * (a % b) =
2.5. Beolvasás billentyűről
Az adatbevitel egyik leggyakrabban használt módja a billentyűről történő beolva

sás. Ehhez a beolvasás szó angol megfelelőjét használjuk: Read, ill. ReadLine
(beolvasás a sor végéig). Mivel a billentyű is egy konzol, ezért a teljes utasítás:
Console.Read(); vagy : Console.ReadLine(). A beolvasás eredményét egy változó
ban kell tárolni:
Pl.: a = Console.ReadLine();
2.6. Konvertálás
C#-ban csak szöveg típusú adatot lehet beolvasni. Ezért ha számot szeretnénk be
kérni, akkor célszerű azonnal átváltani, konvertálni a megfelelő számtípusra a be
kért szöveget. Pl.:
egesz=Convert.ToInt32(Console.ReadLine()); vagy:
valos= Convert.ToDouble(Console.ReadLine());
Az első esetben egesz egész szám, valós pedig double típusú valós szám lesz a
konvertálás után. Most már el lehet végezni a számokra jellemző matematikai mű
veleteket.
M atematikai függvények
25
5. feladat:
írjunk programot, amely bekér két egész számot a billentyűről és kiírja az össze
güket!
Név: Adatbekérés 1
Megoldás:

{
i n t a = 0, b = 0;
C o n s o l e . W r i t e L i n e (" K ét szám ö s s z e g é n e k k i -
s z á m itá s a " );
C o n so le .W riteL ine ();
C o n s o l e . W r i t e (" Kérem a z 1. s z á m o t : " ) ;
a = C o n v e rt. T o I n t3 2 ( C o n s o le . R eadLine ( ) ) ;
C o n s o l e . W r i t e (" Kérem a z 2 . s z á m o t : " ) ;
b = C o n v e r t. T o I n t3 2 ( C o n s o le . R eadLine ( ) ) ;
C o n s o l e . W r i t e L i n e (" A k é t s z á m ö s s z e g e : { 0 } " , a + b) ;
}
2.7. Matematikai függvények
Néhány fontos matematikai függvényt meg kell említeni, amelyek a számításokat

segítik.
További függvények:
négyzetgyökvonás: Math.Sqrt(szam);
hatványozás: Math.Pow(alap,kitevő);
szinusz: Math.Sin(x);
koszinusz: Math.Cos(x);
kerekítés: Math.Round(valosszam); vagy
Math.Round(valos_szam, egeszjegy);
Az első kerekítés a matematika szabályának megfelelően kerekít egész számra, a
második pedig a megadott tizedesjegyig. Pl.: Ha a = 4,672834, akkor
Math.Round ( a ) = 5 illetve Math.Round ( a , 3 ) = 4,673
26
6. feladat:
írjunk programot, amely bekér két egész számot, az alapot és a kitevőt a billentyű
ről és kiírja a hatványt, majd ennek a számnak a gyökét 2 tizedes pontossággal!
írjuk ki a képernyőre, hogy az alap csak pozitív lehet!
Név: Matekl
Megoldás:
static void M ain (strin g [] args)
{
i n t a = 0, x = 0;
d o u b l e h a t v á n y = 0, g y o k = 0 ;
C o n s o l e . W r i t e L i n e (" H a t v á n y é s g y ö k k i s z á m í t á s a " ) ;
C o n s o l e . W r i t e L i n e (" Az a l a p p o z i t í v l e g y e n ! " ) ;
C o n s o l e . W r i t e (" K é r e m a z a l a p o t : " ) ;
a= C onvert. T oIn t3 2 (C o n so le.R eadL ine());
C o n s o l e . W r i t e (" K é r e m a k i t e v ő t : " ) ;
x = C o n v ert. T o In t3 2 (C o n so le.R eadL ine());
h a tv án y = M ath. P o w (a ,x );
C o n s o le .W r ite L in e ( " A h a tv á n y : {0}", h a tv á n y ) ;
gyök = M ath. S q rt ( y ) ;
C o n s o le .W rite L in e (" A h a tv á n y gyöke: { 0 :0 .0 0 } " , gyök);
}
7. feladat:
írjunk programot, amely bekér egy szöget fokban, és kiírja a szög szinuszát 4 tize
des pontossággal! Ne felejtsük el, hogy a szöget át kell váltani radiánba. Mivel
180° = 7C, ezért a n értékét meg kell szorozni a számítandó szög 180-ad részével.
Név: Matek2
Megoldás:

{
d o u b l e x = 0, s z ö g = 0;
C o n s o l e . W r i t e L i n e (" S z ö g s z i n u s z á n a k k i s z á m í t á s a " ) ;
C o n s o le .W rite L in e ();
C o n s o l e . W r i t e (" K é r e m a s z ö g e t : " ) ;
szo g = C o n v ert. T oD ouble(C onsole.R ead L in e());
x = M ath. S in (M ath . P I* sz o g /1 8 0 );
C o n s o l e . W r i t e L i n e (" A s z ö g s z i n u s z a : { 0 : 0 . 0 0 0 0 } " , x ) ;
M atematikai függvények
27
}
8. feladat:
Kérjük be egy kör sugarát, és írjuk ki a kerületét és a területét 2 tizedes pontossággal!
Név: Matek3
Megoldás:

{
d o u b l e r = 0, K = 0, T = 0;
C o n s o l e . W r i t e L i n e ( " Kör k e r ü l e t é n e k é s t e r ü l e t é
nek s z á m ítá s a " ) ;
C o n s o l e . W r i t e (" K é r e m a k ö r s u g a r á t : " ) ;
r = C o n v e r t . T o D o u b le ( C o n s o le . R e a d L i n e ()) ;
K = 2 * r * M ath.PI;
T = r * r * M ath.PI;
C o n s o l e . W r i t e L i n e (" K= { 0 : 0 . 0 0 } " , K ) ;
C o n s o l e . W r i t e L i n e (" T= { 0 : 0 . 0 0 } " , T ) ;
}
Gyakorló feladatok:
1. Kérje be egy kocka oldalának hosszát és számítsa ki a kocka felszínét és térfo
gatát! Az eredményt írja ki 3 tizedes pontossággal a képernyőre!
2. Kérje be egy henger sugarát és magasságát, majd számítsa ki a henger felszínét
és térfogatát! Az eredményt írja ki 2 tizedes pontossággal a képernyőre!
3. Kérjen be egy számot, és írja ki a köbgyökét 4 tizedes pontossággal!
4. Készítsen programot, amely segít a pénztárosnak a papírpénzek értékének meg-
számolásánál! Kérje be melyik bankjegyből (500, 1000, 2000, 5000, 10000,
20000) hány darab van, és a végén adja meg az összes bevételt.
Pl:
Bankjegy (Ft) Példa 1 (db) Példa 2 (db)
500 3 6
1000 5 5
2000 3 0
5000 2 7
28
Bankjegy (Ft) Példa 1 (db) Példa 2 (db)

10000 8 3
20000 5 1
Összesen (Ft) 202500 93000
5. Egy pénztáros a napi bevételének 5%-át megkapja jutalomként. Kérje be a napi
bevételt, és írja a képernyőre mennyi ajutalom! A jutalmat kerekítse egész értékre!
6. Adott egy derékszögű háromszög 2 befogója. Határozza meg ennek ismereté
ben az átfogót! (Segítség: Pitagorasz-tétel +
7. írja be a táblázatba az első 3 feladat megoldásához szükséges változók nevét és
típusát, valamint az alkalmazott matematikai függvényt!
Feladat száma Változó neve Változó típusa Matematikai függvény
2.8. Elágazás
A program bizonyos részein szükség lehet arra, hogy egy adott feltételtől függően
kell végrehajtani valamit. Gyakori probléma, ha a számítások során negatív szám
van a gyök alatt, vagy egy tört esetén 0 van a nevezőben. Ilyenkor feltételhez kell
kötni a matematikai művelet elvégzését, és csak akkor végezni el, ha az lehetséges.
Magyarul a feltételes mondatot HA-val kezdjük. Ennek megfelelően C#-ban az
angol if utasítás szükséges, majd zárójelben a logikai kifejezés, amely egy relációs
művelet. A kifejezés értéke igaz, vagy hamis lehet.
E lágazás
29
Feltételes utasítás végrehajtása
• Az if- else utasítás alakja:

if( kifejezés) Ji
1. utasítás(ok) ^ v Hamis (0)
^ kifejezés ^
else( kifejezés) ^
2. utasítás(ok)
Igaz (nem 0)
• a '?' operátor használatával rövidíthetünk
1 f
• Általános alak: 1. utasítás(ok) 2. utasítás(ok)
kíf1 ? k if2 :k if3 ;
• Ha kif1 értéke igaz, akkor egyébként
kif3 lesz ennek a kifejezésnek az értéke f
Az összehasonlító művelet eredménye tehát bool típus lehet, amelyet eddig még
nem említettünk. Ez a C# logikai típusa, amelynek értéke TRUE (igaz), vagy
FALSE (hamis) lehet.
Relációs műveletek:
a>b a nagyobb, mint b,
a >= b a nagyobb vagy egyenlő, mint b,
a<b a kisebb, mint b,
a <= b a kisebb vagy egyenlő, mint b,
a==b a egyenlő b-vel,
a != b a nem egyenlő b-vel.
Az a és b változó, vagy kifejezés lehet.
A feltételes utasításnak 2 alapvető alkalmazása van és C#-ban ez így valósul meg:

1. Ha a feltétel igaz, akkor csináljunk valamit. A folyamatábra részletről jól látható,
hogy a feltétel hamis ágán nincs utasítás, igy azt elhagyhatjuk.
i f ( a > b )
{
C o n so le .W rite L in e( ' ' a nagyobb m int b ' ');
30
2. Ha a feltétel igaz, akkor csináljunk valamit, ha hamis, akkor valami mást. A fo
lyamatábra részletből megállapítható, hogy a feltétel igaz és hamis ágán is van
utasítás igy azt egyértelműen meg kell adni a programozási nyelven is.
i f ( a > b )
{
C o n s o le .W rite L in e ( ' ' a nagyobb m int b ' ');
else
C onsole.W riteL ine ( ' ' a k iseb b , vagy e g y e n lő m int b ' ' ) ;
9. feladat:
Kérjünk be egy egész számot a billentyűzetről, és ha a szám nagyobb mint 0, akkor
írjuk ki a képernyőre, hogy "A szám pozitív"!
Név: Feltételes 1
Megoldás:
static void M a in (strin g [] args)
{
i n t a = 0;
C o n s o l e . W r i t e (" K érek egy szám ot: ");
L ogikai műveletek
31
a = C o n v ert. T o In t3 2 (C o n so le.R eadL ine());

if ( a > 0)
{
C on so le.W riteL in e("A szám p o z i t í v " ) ;
}
}
Megjegyzés: Ha a logikai kifejezés után csak 1 utasítás áll, akkor a { } zárójelek
elhagyhatók. Pl.: if (a > 0) Console. WriteLine("Aszámpozitív");
Láthatjuk azonban, hogy ez a program semmit nem csinál, ha a bekért szám nem
pozitív. Ha arra az esetre is van tennivaló, amikor a logikai kifejezés hamis, akkor
azt az else után kell megadni. Ilyen eset fordul elő a másodfokú egyenletek gyöke
inek kiszámításánál, ha a megoldóképletben a diszkrimináns értéke negatív. A kö
vetkező példa ezt mutatja be.
10. feladat:
Kérjünk be a másodfokú egyenlet együtthatóit és számítsuk ki a gyököket 2 tizedes
pontossággal! Ha a diszkrimináns negatív, írjuk ki a képernyőre: "Nincs megoldás"!
Név: Másodfokú
Megoldás:
{
d o u b l e a = 0 , b = 0 , c = 0 , d = 0 , x l = 0 , x2 = 0 ;
C o n s o l e . W r i t e L i n e (" M á s o d f o k ú e g y e n l e t g y ö k e i n e k
szám ítása:");
C o n s o l e . W r i t e (" a= " ) ;
a = C o n v e rt. T oD ouble(C onsole.R ead L in e());
C o n s o l e . W r i t e (" b = " ) ;
b = C o n v e rt. T oD ouble(C onsole.R ead L in e());
C o n s o l e . W r i t e (" c = " ) ;
c = C o n v e r t . T o D o u b le ( C o n s o le . R e a d L i n e ()) ;
d = b * b - 4 * a * c ;
i f ( d < 0)
{
C o n s o l e . W r i t e L i n e (" N incs m egoldás");
}
else
{
xl = (-b + M ath. S q rt(d ) ) / (2 * a);
32
x2 = ( - b - M a t h . S q r t ( d ) ) / (2 * a ) ;
C o n s o l e . W r i t e L i n e (" x l = { 0 : 0 . 0 0 }
x2={ 1 :0 .0 0 } " ,x l , x2 );
}
C o n s o le . ReadKey();
}
A program nem tökéletes, ami kiderül, ha a = 0. Most azonban nincs is értelme
ezzel foglalkozni, mivel ha a = 0, akkor az egyenlet nem másodfokú, márpedig mi
most kizárólag a másodfokú egyenletek gyökeit akartuk kiszámolni.
Módosíthatnánk a programot úgy, hogy ekkor is kiszámolja az x tengellyel való
metszéspontot, de az xl és az x2 kiszámítása előtt az else ágba egy új if-ben meg
kellene vizsgálni a értékét, és ha az 0, akkor x = - c / b-vel számoljuk a gyököt,
így az xl és x2 kiszámítása és kiíratása egy újabb else ágba kerülne. A későbbiek
ben majd látjuk, hogy lesz ennél szebb megoldás is, amelyben nem engedjük az
a = 0 lehetőséget, tehát csak másodfokú egyenletek esetén működik a program.
2.9. Logikai műveletek
A logikai műveletek az életben is gyakran előfordulnak, amikor a nem, az és, ill. a vagy
szót használjuk. A programozásban is hasonlóan használhatjuk ezeket a „műveleteket”.
• A tagadás vagy negáció jele: !
Pl.: ! kifejezés Az ellenkezőjére változtatja a kifejezés értékét.
• Az ÉS, vagy konjukció jele: &&
Pl.: A && B. Csak akkor lesz igaz, ha mindkét állítás igaz.
• A VAGY, vagy diszjunkció jele: | | (Alt Gr+W)
PL: A | | B. Akkor lesz igaz, ha bármelyik kifejezés igaz.
1. Kérjünk be 2 számot. írjuk a képernyőre a nagyobbat!
2. írjuk ki 2 tetszőleges szám hányadosát. (!!¡Nullával nem lehet osztani!!!)
3. Három tetszőleges számról döntsük el, hogy lehetnek-e egy háromszög oldalai!
(háromszög szerkeszthetősége szabály)
4. Adott egy tetszőleges pont koordinátáival. Határozza meg, melyik síknegyedben van!
5. A középszintű érettségin maximum 150 pont szerezhető. Kérje be egy tanuló
elért pontszámát és írja ki, milyen érdemjegyet kapott (betűvel és számmal) ha
a százalékos értékelés a következő:
VÉLETLEN SZÁMOK ELŐÁLLÍTÁSA
33
Százalékérték Érdemjegy
0-19% Elégtelen (1)
20-39% Elégséges (2)
40-59% Közepes (3)
60-79% Jó (4)
80-100% Jeles (5)
6. Egy tetszőleges számról mondjuk meg, hogy osztható-e maradék nélkül 3-mal!
7. Ha ismerjük a víz hőmérsékletét, adjuk meg milyen halmazállapotú (szilárd,
folyékony, gáz)!
8. Kérjen be 2 számot és a nagyobbat ossza el a kisebbel! Az eredményt
2 tizedesjegy pontossággal írja ki! (!!! Nullával nem lehet osztani!!!)
2.10. Véletlen szám ok előállítása
Az életben előforduló esetek szimulálására gyakran használunk véletlen számokat.

Az előre nem látható események bizonyos valószínűséggel történő bekövetkezése
a véletlen számok segítségével könnyen kezelhető. Az időjárás előrejelző progra
mok és a szerencsejátékok használják ezt a módszert. A különböző programnyel
vek hasonló módon alkalmazzák a véletlen számok előállítását.
A C# a Random utasítást (osztályt) használja a véletlen szám előállítására az alábbi
módon:
Random veletlen = new Random();
Ekkor a veletlenszam nevű változó egész számot vehet fel értékül a következő uta
sítás segítségével:
veletlenSzam = veletlen.Next(lOO);
Itt veletlenSzam csak egész típusú változó lehet, melynek legkisebb értéke 0, leg
nagyobb pedig 99 lehet. A 100 az előállítható számok darabszámát adja meg, ezért
0-ról indulva mindig a zárójelben megadott érték-1 lehet a legnagyobb szám.
Ha negatív számokat is elő szeretnénk állítani, arra 2 mód is van.
1. veletlenSzam = veletlen.Next(101)-50;
2. A C# értelmezi az alábbi formulát is:
veletlenSzam = veletlen.Next(-50,51);
34
Mindkét esetben veletlenSzam a [-50, 50] intervallumból vesz fel értéket.

Megjegyzés: Az első módszer megfelelő átalakítással lehetővé teszi nem egész
számok véletlenszerű előállítását is, meghatározott tizedes jegyig. Itt már vigyázni
kell a változó deklarációjával is.
11. feladat:
Állítsunk elő véletlenszerűen két egész számot a [0,10] tartományból, és írjuk ki a
számokat a képernyőre, majd azt, hogy melyik szám a nagyobb! Ha egyenlők, írjuk
ki: ”A két szám egyenlő” !
Név: Véletlen 1
Megoldás:
static void Main(string[] args)
{
int a = 0, b = 0;
Random vsz = new RandomO;
Console.WriteLine(" Két szám vizsgálata");
a = vsz.Next(11);
b = vsz.Next(11);
Console.WriteLine(" a= {0}",a);
Console.WriteLine(" b= {0}",b);
if (a > b) Console.WriteLine(" A(z) {0} nagyobb,
mint {1}", a, b) ;
else
if (a < b) Console .WriteLine (" A(z) {0} nagyobb,
mint {1}", b, a);
else Console.WriteLine (" A két szám egyenlő");
Console.ReadKey();
}
Megfigyelhető, hogy az if és az else után is csak 1 utasítás van, ezért a {}-ek elhagyhatók.
12. feladat:
Állítsunk elő véletlenszerűen egy egész számot az [l,10]-ból, és írjuk ki, hogy a
szám páros-e vagy páratlan!
Név: Véletlen2
Megoldás:
{
int szám = 0;
Random vsz = new RandomO;
szám = vsz.Next(lO) + 1;
C iklusok
35
i f ( s z á m % 2 == 0) C o n s o l e . W r i t e L i n e ( 11 {0} : A
szám p á r o s " , s z á m ) ;
e l s e C o n s o l e . W r i t e L i n e (" { 0 } : A s z á m p á r a t l a n " ,
szám);
}
Egészítsük ki a következői programsorokat a példához hasonlóan!
Példa: Állítsunk elő egész számokat véletlenszerűen az [l,60]-ból!

szam=vsz.Next(60)+1; vagy szam=vsz.Next( 1,61);
1. Állítsunk elő egész számokat véletlenszerűen a [0,60]-ból!

szam=vsz.Next( ) ; vagy szam=vsz.Next( , );
2. Állítsunk elő egész számokat véletlenszerűen a [-100,100]-ból!

%
3. Állítsunk elő egész számokat véletlenszerűen a [15,80]-ból!
szam=vsz.Next(( ) ; vagy szam=vsz.Next( , );
4. Állítsunk elő egész számokat véletlenszerűen a [-15,-5]-ból!

2.11. Ciklusok
A ciklusok feladata, hogy a program valamely pontján ugyanazokat az utasításokat

többször is végrehajtsa.
A ciklusok 3 fő részből állnak:
• fej,
• mag,
• vég.
36
A fejben vagy a magban lehetnek az ismétlődésre vonatkozó információk. A mag

ban az ismétlendő utasítás vagy utasítások szerepelnek.
A ciklusok 3 olyan fajtáját említjük meg, amelyeket igen gyakran használunk a
különböző problémák megoldása során:
• elöltesztelő ciklus,
• hátultesztelő ciklus,
• előírt lépésszámú ciklus.
2.11.1. Elöltesztelő ciklus
Az ismétlődésre vonatkozó információk a fejben vannak. Pontosabban: a fejben

van a ciklusba való belépés feltétele, amely egy logikai kifejezés. Ha ennek értéke
igaz, akkor a magban lévő utasítások végrehajtódnak. Mindaddig ez fog történni,
amíg a belépési feltétel hamissá nem válik. Ha ez nem történik meg, akkor végtelen
ciklus jön létre, ami súlyos hiba és ezért kerülendő. Ezért a ciklusmagban gon
doskodni kell arról, hogy a belépési feltétel valamikor hamissá váljon. Előfor
dulhat üres ciklus is, amikor a belépési feltétel mindig hamis, így egyszer sem fut
le a ciklusmag. Ez viszont nem számít hibának, mivel ilyen eset a megoldandó
probléma jellegétől függően előfordulhat.
While ciklus
while(kifejezés)
utasítás(ok);
Igaz (nem 0)
utasítás(ok)
13. feladat:
Kérjünk be egy számot és írjuk ki, hogy az prímszám-e vagy sem!
Név: Elöltesztelő
Megoldás:
long s z á m = 0;
double fele = 0, oszto=0;
C iklusok
37
bool prim = true;

C o n s o l e . W r i t e L i n e (" P rím k e re s ő " );
C o n s o le .W r it e L in e ();
C o n s o l e . W r i t e (" Kérek egy számot: ");
szám = C o n v e r t . T o l n t 6 4 ( C o n s o l e . R e a d L i n e ( ) ) ;
f e l e = szám / 2;
oszto = M a t h . R o u n d ( f e l e ) +1;
while (oszto >= 2 && p r i m )
{
if (szám % o s z t o = = 0) prim = false;
oszto— ;
}
C o n so le .W r it e L in e ();
if ( p r i m | | szám < 3 ) C o n s o l e . W r i t e L i n e (" A
{0} p r í m s z á m " , s z á m ) ;
e l s e C o n s o l e . W r i t e L i n e (" A { 0 } n e m p r í m s z á m " , s z á m ) ;
}
A long típust már korábban láthattuk egy összefoglaló táblázatban. Ebből kiderül,
hogy ez is egy egész típus, de bővebb tartománnyal rendelkezik, mint az int.
A bool egy logikai típus, amelynek értéke csak igaz (true) vagy hamis (false) lehet.
Érdemes megjegyezni, hogy ha egy logikai típusú változó neve önmagában - érték
nélkül - szerepel a program szövegében, akkor a változó értéke: igaz.
Ezt használtuk ki a while utáni ciklusfejben, és később az if után a kiíratásnál.
A fele nevű változót azért célszerű bevezetni, mert egy számot nincs értelme a fe
lénél nagyobb értékkel osztani, ha maradékul nullát szeretnénk kapni. A prímszá
mok keresésének lényege pedig éppen az, hogy van-e olyan szám - az 1-en és a
kérdéses számon kívül - amellyel maradék nélkül osztható.
Az előltesztelő ciklus fejrészészében belépési feltételként meg lehet adni, hogy
csak akkor lépjen be, ha a szám nagyobb, mint 2. Erre azért van szükség, mert az
1 és a 2 prímszám, így azt felesleges vizsgálni. További belépési feltétel, hogy a
prim nevű változó igaz legyen. Tehát feltételezzük, hogy a vizsgált szám prím. Ha
mégsem az, akkor a cikluson belül az osztás után a prim értéke megváltozik falsé
ra. A ciklusból kilépni 2 esetben lehet.
1. Ha az oszto értéke - folyamatosan csökkenve - eléri a 2-t.
2. Ha a prim értéke false lesz.
38
A második esetben nincs értelme tovább vizsgálódni, az oszto értékét csökkenteni,

mivel a false érték miatt már biztosan nem prím a szám.
2.11.2. Hátultesztelő ciklus
Az ismétlődésre vonatkozó információk a ciklus végén vannak. A fej csupán egy

do utasításból áll, amelyet kapcsos zárójel követ, majd a ciklus magja. Ezt kapcsos
zárójel zárja, és utána a while utasítást követően meg kell adni a ciklusban maradás
feltételét, amely egy logikai kifejezés. Ha ez igaz, akkor visszalépünk a ciklusba,
ha nem, kilépünk belőle.
do-while ciklus
Igaz (nem 0)
Üres ciklus nem lehet, mert mindenképpen belépünk a ciklusba, így legalább egy
szer lefutnak a benne lévő utasítások. Végtelen ciklus viszont lehet, így erre ügyel
ni kell, hogy ilyen ne forduljon elő. A magban gondoskodni kell a ciklusban való
bentmaradás feltételének hamissá válásáról.
Gyakori feladat, hogy az adatbekérést hátultesztelő ciklussal szabályozzuk, azaz
csak akkor fut tovább a program, ha számunkra megfelelő adat kerül bevitelre.
Ezzel tudjuk védeni a programot a felhasználó által elkövetett véletlen, vagy szán
dékos hibáktól.
14. feladat:
Kérjünk be egy mobil telefonszámot, és csak akkor fogadjuk el, ha az valóban
mobilszám! írjuk ki, hogy a szám melyik szolgáltatóhoz tartozik!
Név: Mobilszámvizsgáló
Megoldás:
{
VI ff .
strin g szám =
C iklusok
39
C o n s o l e . W r i t e L i n e ( 11 Mobilszámellenőrző
p ro g ram ");
do {
C o n s o l e . W r i t e (" Kérem a telefonszám ot (a 06
u t á n i r é s z t ) : ") ;
s z á m = C o n s o l e . R e a d L i n e () ;
} w h i l e ( s z a m . L e n g t h != 9 | | ( s z á m [ 0 ] . T o S t r i n g ()
!= " 2 " ) && ( s z a m [ 0 ] . T o S t r i n g () != " 3 " ) &&
(szam[0] . T o S t r i n g O !="7") ) ;
i f (sz ám [ 0 ] . T o S t r i n g ()= ="2" ) Console.
W r i t e L i n e ("T e le n o r" ) ;
i f ( s z a m [ 0 ] . T o S t r i n g () = = "3") Console.
W r i t e L i n e ("Telekom ");
i f ( s z a m [ 0 ] . T o S t r i n g () = = "7") Console.
W r i t e L i n e ("V odafone") ;
}
Itt a string típus tulajdonságai közül használtunk ki kettőt, v
1. A szam.Length megadja a szám nevű, string típusú változó hosszát.
Eredménye egy int típusú egész szám lesz. Esetünkben a hossznak 9-nek
kell lenni, hiszen ennyi jegyből áll egy mobilszám.
2. Egy szövegnek - mint karakterláncnak - bármely elemére (karakterére) hi
vatkozhatunk egy szögletes zárójelben megadott sorszámmal, melynek érté
ke 0-tól a szöveg hossza-1-ig terjedhet.
Megjegyzés: A ToString()-re azért van szükség, mert a C# az 1 hosszúságú szöveget
karakternek tekinti. Mivel a szám nevű változónk nem 1 hosszúságú, ezért át kell
váltani, hogy a program szövegként kezelje.
A program egy hátultesztelő ciklusban megvizsgálja a szám hosszát és az első
karaktert. Ha a szám hossza nem 9, akkor bent marad a ciklusban és újból bekéri a
telefonszámot.
De nem csak a szám hossza fontos, hanem az első karakter értéke is. Ha ez rossz,
akkor sem léphetünk ki a ciklusból. A két állítás között VAGY kapcsolat van, így
bármelyik állítás hamis, kiléphetünk a ciklusból.
Nézzük ezt a programrészt szövegesen leírva:
A ciklusban való maradás feltétele, hogy a While utáni két állítás igaz legyen,
vagyis A VAGY B igaz legyen. VAGY esetén elég, ha az egyik állítás igaz.
40
1. a telefonszám hossza NEM 9. Ez akkor igaz, ha a hossz 9-nél kisebb vagy

nagyobb. Ekkor a megadott szám nem mobilszám, ezért be kell kérni újból.
2. a telefonszám első karaktere NEM egyenlő 2-vel sem, 3-mal sem és 7-el sem.
3. Ez egy újabb összetett logikai kifejezés ÉS kapcsolattal, amely csak akkor
igaz, ha mindhárom állítás egyszerre igaz. Tehát ha az első karakter nem 2,
nem 3 és nem is 7, akkor az állítás igaz. Ekkor viszont B is igaz lesz, tehát
maradunk a ciklusban és újból bekérjük a számot.
Megjegyzés: A program ciklus utáni részét azonban másként is írhattuk volna, ha
az i f helyett a case utasítást használjuk.
2.11.3. Előírt lépésszámú ciklus
A fejben van az ismétlődésre vonatkozó információ. Általában akkor használjuk,

ha pontosan tudjuk hányszor fut le a mag. így, ha odafigyelünk nehezebben lehet
végtelen vagy üres ciklust írni. A ciklusváltozó a fejben kap kezdő- és végértéket
és itt kell megadni a lépésközt is.
A fór utasítás alakja:

fór (kifejezés 1; kifejezés2; kifejezés3)
utasítás (blokk)
A kifejezések általában a következőket jelentik:

• kifejezési : Kezdeti értékadás a ciklusváltozónak.
• kifejezés2: A lefutási feltétel(ek) megfogalmazása. Lefutási feltételként nem
csak a ciklusváltozóval kapcsolatos feltételt lehet megadni, hanem bármilyen
más feltételt is.
• kifejezés3: A ciklusváltozó növelése vagy csökkentése.
Nézzünk erre egy példát C#-ban:
fór ( i = 1 ; i <= 10 ; i++ )
{
utasítások
}
A fór utasítás után van a ciklus fej része. Ebben az i a ciklusváltozó, melynek kez
dőértéke 1, végértéke 10. Az i++ pedig egy speciális C# utasítás, amely az i jelen
legi értékét növeli eggyel. ( Az i— pedig csökkenti ) Mindez azt jelenti, hogy a
magban lévő utasítások lefutnak pontosan 10-szer, amikor is az i = 1, az i = 2, ...
és végül az i = 10.
C iklusok
41
15. feladat:
Állítsunk elő véletlenszerűen öt egész számot az [0,50]-ból, és írjuk ki a képernyő
re egymás mellé 5 karakternyi helyet lefoglalva a számoknak!
Név: Előírtciklus 1
Megoldás:
{
int szám = 0, i = 0;
Random vsz = new Random();
fór (i = 1 ; i < = 5 ; i + + )
{
szam=vsz.N e x t (51);
Console.Write("{0,5}", szám);
}
Console.ReadKey();
}
Megjegyzés: A ciklusfejben az i<=5 helyett értelemszerűen az i<6 is használható.
A ”{0,5} ” részben a 0. sorszámú változó (szám) értékét írja ki a program öt helyet
lefoglalva számára és jobbra igazítva.
Ez különösen akkor előnyös, ha több számot szeretnénk táblázatos formában egy
más alá írni és a számokat helyiérték szerint akarjuk rendezni.
16. feladat:
Állítsunk elő véletlenszerűen 40 egész számot a [-100,100]-ból, és írjuk ki a kép
ernyőre egymás mellé 6 karakternyi helyet lefoglalva, de egy sorban csak 8 szám
legyen! A kiírás végén adjuk meg hány darab pozitív szám van!
Név: Eőírtciklus2
Megoldás:
{
int szám = 0 , i = 0, pozdb=0;
fór (i = 1; i <= 40; i++)
{
szám = vsz.Next(-100,101);
if (szám > 0) pozdb++;
if (i % 8 = = 0) Console .WriteLine (" {0, 6}11,szám) ;
else
42
C o n s o le .W r i t e ("{0,6}" , szám);
}
C o n s o le .W r i t e L i n e ();
C o n s o l e . W r i t e L i n e ("{0} db p o z i t í v szám
van." ,pozdb);
}
A kiírásnál kihasználtuk a következő lehetőséget: ha az i ciklusváltozót elosztjuk
nyolccal és a maradék 0 lesz, akkor WriteLine utasítással írjuk ki a számot, és ezért
a következő sor elején folytatjuk a kiírást. Egyébként Write utasítással egymás
mellé írjuk a számokat.
Mi a különbség a 16-os és alábbi feladat között?

static void M ain (strin g [] args)
{
int szám = 0 , i = 0, pozdb=0;
Random v s z = new R a n d o m O ;
fór (i = 0; i < 40; i++) ;
{
szám = v s z . N e x t ( - 1 0 0 , 1 0 1 ) ;
if ( s z á m > 0) pozdb++;
if ( i % 8 = = 7) C o n s o l e . W r i t e L i n e ( " { 0 , 6 } " , s z á m ) ;
else
C onsole.W rite ("{0,6}", szám);
}
C o n s o l e . W r i t e L i n e (" { 0 } d b p o z i t í v s z á m v a n . " , p o z d b ) ;
}
Melyik sorban van a különbség?
Mi a következménye a változásnak?
Mi az oka ennek?............................................................................................................
T öbbirányú elágazás
43
2.12. Többirányú elágazás
A többirányú elágazást akkor használjuk, ha sok if utasításra lenne szükség, mivel

egy változó értékétől függően több irányban is továbbhaladhatunk. Ilyenkor cél
szerű a case szerkezetet használni.
Formája:
switch ( kifejezés)
{
case érték:
utasítás(ok);
break;
case érték :
utasítás(ok);
break;
default:
utasítás(ok);
break;
}
A switch után meg kell adni azt a kifejezést, amelynek több értéke is lehet. Ezek
az értékek a case után lesznek felsorolva kettősponttal lezárva a sort. Ez után jön
nek a végrehajtandó utasítások és végül a break. A default rész nem kötelező, csak
akkor használjuk, ha van olyan tevékenység, amelynek alapesetben kell lefutnia,
tehát ha a kifejezés egyik megadott értékkel se egyenlő.
Nézzük a módosított programrészt:
switch (s z á m [ 0 ] . T o S t r i n g ())
{
case "2":
C o n s o le .W r i t e L i n e (" T e l e n o r " ) ;
break;
case "3":
C o n s o le .W r i t e L i n e ("Telekom" ) ;
break;
case "7":
C o n s o le .W r i t e L i n e ("V odafone");
break;
}
44
Ezt a 3 if-es sor helyett kell beírni, és így is lefut a program. Az eddig látott, hasz
nált típusok nagy hátránya, hogy nagyobb adathalmaz létrehozása, kezelése (ren
dezés, kiválasztás) nehezen megoldható.
17. feladat:
írjunk oktatóprogramot, amely az összeadást és a kivonást gyakoroltatja! Az egész
számokat véletlenszerűen állítsuk elő! A felhasználó csak -5 és +15 között képes
a műveleteket elvégezni. Adjunk 10 feladatot, és a felhasználó minden helyes meg
oldása 1 pontot érjen! Osztályozzuk le a feladatsort, és az osztályzatot írjuk ki a
képernyőre úgy, hogy 0-2-ig elégtelen, 3-4-ig elégséges, 5-6-ig közepes, 7-8-ig jó,
e fölött pedig jeles legyen!
Név: Oktatóprogram
Megoldás:
{
i n t a = 0, b = 0, e r e d m e n y = 0, i = 0 , v a l a s z =
0, p o n t = 0;
C o n s o l e . W r i t e L i n e ( 11 O k t a t ó p r o g r a m " ) ;
C o n s o le .W r ite L in e ();
f ó r ( i = 1; i <= 1 0 ; i + +)
{
a = v s z . N e x t (20) ;
do
{
b = v s z .N e x t(20)-10;
eredmeny = a + b;
}while (eredmeny>15 || e r e d m e n y < - 5 ) ;
C o n s o l e . W r i t e (" {0} {l}",i,a);
i f (b >= 0) C o n s o l e . W r i t e ( " + " ) ;
C o n s o l e . W r i t e (" { 0 } = " ,b) ;
v á l á s z = C o n v e r t . T o I n t 3 2 ( C o n s o l e . R e a d L i n e ()) ;
i f ( v a l a s z = = eredmeny) pont++;
}
s w itc h (pont)
{
case 0
case 1
case 2
T öbbirányú elágazás
45
C o n s o le .W r i t e L i n e (" E l é g t e l e n ” );
break;
case 3 :
case 4 :
Console.W riteL ine("E légséges");
break;
c a s e 5:
c a s e 6:
C onsole.W riteL ine("Közepes");
break;
case 7 :
case 8 :
C o n s o le .W r i t e L i n e (" J ó " );
break;
c a s e 9:
c a s e 10:
C o n s o le .W r i te L i n e (" J e l e s " );
break;
}
}
A for ciklusban előállítjuk az a értékét a megadott határokon belül. Majd egy
hátultesztelő ciklusban előállítjuk a b-t is, de a ciklusból mindaddig nem léphetünk
ki, amíg az eredmény rossz, azaz 15-nél nagyobb, vagy -5-nél kisebb. Ekkor b-t
addig fogjuk újra és újra előállítani, amíg megfelelő eredményt kapunk. Ekkor el
hagyhatjuk a ciklust.
Ezt követően kiírjuk a feladat sorszámát ( i ) és az a -t. A b kiírása előtt meg kell
vizsgálni, hogy negatív-e, mert ha nem, akkor egy + jelet elé kell írni, mivel elője
let csak akkor ír ki a számítógép ha negatív.
Jó válasz esetén növeljük a pont értékét, majd switch case segítségével kiírjuk a
megfelelő érdemjegyet.
1. Készítsen programot, ami számokat kér be mindaddig, amíg 0-át nem adunk meg!
2. Készítsen programot, ami számokat kér be addig, amíg az utolsó két szám meg
nem egyezik!
3. Készítsen számkitalálós programot! A gép véletlenszerűen találjon ki egy szá
mot 1 és 100 között! A felhasználótól kérjen be tippeket, és mondja meg, hogy
46
a gondolt szám a tipptől nagyobb-e vagy kisebb! A tippelés addig megy, amíg
a felhasználó el nem találta a megadott számot.
4. Bővítse az előző feladatot úgy, hogy a szám eltalálásakor írja ki hány tippelés-
ből sikerült eltalálni a számot!
5. Készítsünk programot, amely 15 darab *-ot ír ki a képernyőre!
6. Készítsünk programot amely az első sorba kiír 15 *-ot, a másodikba 14 *-ot,...,
a tizennegyedik sorba 2 *-ot, a tizenötödik sorba pedig 1 *-ot! A csillagok ki
írása a sor elején kezdődjön!
7. Készítse el az előző feladatot úgy, hogy a 2. sortól kezdődően a *-ok jobbra
legyenek igazítva, az első sor utolsó csillagához!
8. írassa ki a számokat 1-től 20-ig és mellé a négyzetüket is!
9. írassa ki 99-től csökkenő sorrendben az összes pozitív, 3-al osztható egész
számot!
10. Számítsa ki a gép 10 véletlen szám összegét, szorzatát, átlagát és írjuk ki a
képernyőre!
11. Szimuláljon egy felhasználótól bekért számú kockadobást! A gép véletlensze
rűen meghatározza a dobás értékét (1 ...6) és kiírja a dobás eredményét. A meg
felelő szám elérése után a program készítsen statisztikát a dobások gyakorisá
gáról! írjuk ki, melyik szám hányszor fordult elő!
12. Készítsen programot, amely addig kér be számokat, amíg -30 és 40 közé nem
esik egy szám!
13. Készítsen programot, amely bekér egy szöveget és kiírja:
a. A szöveg minden második karakterét!
b. Minden 5. karakterét!
c. Hátulról az utolsó 5 karaktert!
d. A beírt szöveget fordított sorrendben!
e. A szavak betűit fordított sorrendben!
f. Határozza meg van-e a szövegben t betű!
g. Határozza meg található-e a szövegben „fa” szóösszetétel!
h. Adja meg hány magánhangzó van a szövegben!
2.13. A tömb
Létre tudunk hozni több számot véletlenszerűen és kiírhatjuk a képernyőre is, de

nem tudunk sorba rendezni, mivel a második számot ugyanaz a változó veszi fel
A TÖMB
47
értékül, így mindig „elfelejti” az előzőt. Ezt a problémát egy új adattípussal lehet
megoldani. A tömb olyan adatszerkezet, amelynek elemei azonos típusúak lehet
nek. A tömb elemeire a tömb nevével és sorszámával hivatkozhatunk. A program
nyelvek többségében, így a C#-ban is a szögletes zárójelek közé kell írni az elem
sorszámát: tomb[2] , ahol tömb a tömb neve, a 2 pedig a sorszáma.
VIGYÁZAT!
A tömbök C#-ban mindig 0-tól kezdik az elemek sorszámozását, így az utolsó
sorszám az elemek száma - 1 lesz.
0. elem 1. elem 2. elem 3. elem 4. elem
A tömb deklarációja:
típus [ ] tömbnév = new típus [elemszám];
Például:
int [ ] a = new int [6]
0. elem 1. elem 2. elem 3. elem 4. elem 5. elem

5 14 -5 9 41 -4
A tömb elemei nem csak egész típusúak lehetnek, hanem string, double, long stb is.
18. feladat:
Állítsunk elő 20 egész számot a [-50,20] intervallumból és írjuk ki a képernyőre
2 sorba! írjuk ki a pozitív páros számokat! Ha ilyen nincs, akkor írjuk ki, hogy
„A számok között nincs pozitív páros szám”!
Név: Tömbl
Megoldás:
{
i n t [ ] t ömb = new i n t [ 2 0 ] ;
i n t i=0;
b o o l van = f a l s e ;
C o n s o l e . W r i t e L i n e (" A 20 s z á m : 11) ;
f ó r ( i = 0 ; i <= 1 9 ; i + +)
{
tomb[i] = vsz.Next (-50,21);
48
i f ( i % 10 = = 9) C o n s o l e .
W r i t e L i n e ( " { 0 , 6 } " , t ö m b [i ] ) ;
else
C o n s o l e . W r i t e ( " { 0 , 6 } " , t ö m b [ i ] );
}
C o n so le .W r ite L in e ();
fór (i = 0; i <= 1 9 ; i++)
{
if (tomb[i] % 2 = = 0 && t o m b [ i ] > 0 )
{
i f ( v a n = = f a l s e ) C o n s o l e . W r i t e L i n e (" A pozitiv
p á r o s számok: ");
C o n s o l e . W r i t e (" { 0 ,4 } ", tö m b [i ] ) ;
van=true;
if (van = = f a l s e ) C o n s o l e . W r i t e L i n e ( "A számok

k ö z ö tt n in cs p o z i t i v p áros szám");
}
A tömb típusra azért volt szükség, mert a kiírt 20 szám után még a pozitív, páros
számokat is ki kellett íratni, amihez a tömb elemeit ismét meg kellett vizsgálni.
A 2 sorba történő kiíratásnál kihasználtuk, hogy a 10-el való osztás után akkor lesz
a maradék 9, ha a 9. és a 19. sorszámú elemnél járunk, amelyek a tömbben 10. és
20. elemek. Hasonlóan jó megoldáshoz jutunk, ha az
if(i % 10 = = 9)helyére if((i+ l) % 10 = = 0) kerül.
Az if (van= =false) Console. WriteLine(” A pozitív páros számok: sorra azért
volt szükség, mert a A pozitív páros számok: szöveget illik kiírni, de csak akkor, ha
vannak ilyen számok.
Az i f (tomb[i] % 2= = 0&& tomb[i]>0) elé nem írhatjuk, mert
hogy vannak ilyen számok. Ha viszont egyszerűen beírjuk az if után minden felté
tel nélkül, akkor annyiszor írja ki ezt a szöveget - feleslegesen - ahány pozitív,
páros szám van.
Ezért kellett a feltétel: csak akkor írja ki, ha belépett az if utáni részbe, de még a van
nevű változó értéke hamis. Ez jelenti azt, hogy most először talált pozitív, páros szá
mot és a szám kiírása után a van értéke igaz lesz, tehát többé nem írja ki a szöveget.
A TÖMB
49
Két- vagy többdimenziós tömbök

Az egydimenziós tömbök (vektorok) mellett kétdimenziós tömböt (táblázatok) is
használhatunk az alábbi módon. Kétdimenziós tömb deklarációja:
int [ , ] egeszTomb = new int [ 5 , 6 ]; vagy
string [ , ] szöveg = new string [ 1 2 , 8 ] ;
Ehhez hasonlóan háromdimenziós tömb deklarációja:
double [ , , ] tomb3d = new double [ 5 , 6 , 9 ] ;
További dimenziók használata a fentiek alapján értelemszerűen történik: vesszők
kel választjuk el a dimenziók számát. A többdimenziós tömbök feltöltését több
egymásbaágyazott ciklussal végezzük el.
Nézzünk erre egy példát:
19. feladat:
Töltsünk fel egy kétdimenziós tömböt véletlenszerűen a [-1 , 1 ] intervallumból 2
tizedes pontosságú számokkal! A tömbnek 4 sora és 7 oszlopa legyen! A sorok és
oszlopok végére írjuk ki az adott sor, ill. az oszlop összegét!
Név: Tömb2d
Megoldás:
{
d o u b l e [ , ] tomb=new d o u b l e [ 4 , 7 ] ;
i n t i = 0, j = 0;
d o u b l e s o r O s s z e g = 0, o s z l o p o s s z e g = 0;
Random v s z = new R a n d o m ( ) ;
C o n s o l e . W r i t e L i n e ("1 2 3 4 5 6 7
s o r ö s s z e g " );
f ó r ( i = 0 ; i <= 3 ; i + + )
{
fór (j = 0; j <= 6 ; j++)
{
tömb [ i , j ] = v s z . N e x t ( - 1 0 0 , 1 0 1 ) ;
tömb [ i , j ] = tömb [ i , j ] / 100;
i f ( t ö m b [ i , j ] < 0 ) C o n s o l e . W r i t e (" { 0 : 0 . 0 0 }
", tömb [i , j ] ) ;
e l s e C o n s o l e . W r i t e (" {0:0.00} " , t ömb [ i , j ] ) ;
sorOsszeg + = t [ i , j l ;
}
if (sorOsszeg < 0) C o n s o l e . W r i t e L i n e
(" {0:0.00} ", s o r O s s z e g ) ;
50
else
C o n s o l e . W r i t e L i n e (" {0:0.00}”, sorO sszeg);
s o r O s s z e g = 0;
}
C o n s o l e . W r i t e L i n e () ;
f ó r ( j = 0 ; j <= 6; j + + )
{
fór (i = 0; i <= 3 ; i++)
{
oszlopOsszeg += t ö m b [i,j];
}
i f ( o s z l o p O s s z e g < 0) C o n s o l e . W r i t e
(” {0:0.00} ”, oszlopOsszeg);
else
C o n s o le .W rite (” {0:0.00} ” , oszlopOsszeg);
o s z l o p O s s z e g = 0;
}
}
A tömb feltöltése az egymásba ágyazott ciklusban történik. Figyelni kell a ciklusvál
tozók kezdő és végértékére, mert a tömbök esetében az indexelés 0-tól kezdődik.
Ha nem egész számot szeretnénk előállítani véletlenszerűen, akkor azt két lépésben
tehetjük meg. Először előállítjuk az egész számot a megfelelő intervallumban, de
double típusúként, majd osztjuk a megfelelő számmal.
Az osztás után azért van szükség az if-re, mert a kiíratásnál a számok csak akkor
kerülnek egymás alá a helyi érték szerint, ha figyelembe vesszük az előjelet is.
A sorOsszeg+=t[i,j]; ugyanazt jelenti, mint a sorOsszeg = sorOsszeg + t [ i , j ];
A C# a + = jelekkel egyszerűbben írja le a kifejezést.
Az oszlopösszeg kiszámításánál nem sor, hanem oszlopfolytonosan kell bejárni a
tömböt, ezért lett a j ciklus a külső, az i pedig a belső.
20. feladat:
Állítsunk elő ötös lottószámokat véletlenszerűen mindaddig, amíg azt a felhaszná
ló szeretné!
Név: Lottó
Megoldás:
{
i n t [] lsz = new i n t [ 5 ] ;
A GOTO UTASÍTÁS
51
i n t i = 0 , j=0;
char karakter=' ' ;
bool v o lt = true;
C o n s o l e . W r i t e L i n e ( ,f A l o t t ó s z á m o k : 11) ;
do
{
f ó r ( i = 0 ; i <= 4 ; i + + )
{
if (i > 0)
{
do
l s z [ i ] = v s z . N e x t ( 9 0 ) + 1;
volt = false;
f ó r (j = 0; j < i ; j + +) i f (lsz[i] = =
lsz [j]) volt = true;
} while (volt = = t r u e ) ;
}
e l s e l s z [ i ] = v s z . N e x t ( 9 0 ) + 1;
C o n s o l e . W r i t e ( 11 { 0 , 5 } " , l s z [ i ] ) ;
}
k arak ter= 'n ';
C o n s o l e . W r i t e ( " L e g y e n ú j s o r s o l á s ? ( i ) Más
b ille n ty ű re kilép! ");
karak ter= C o n v ert. ToChar(Console.ReadLine());
} w h i l e ( k a r a k t e r = = ' i ' );
}
A feladat megoldása során figyelembe kellett venni, hogy nem lehetnek azonos
számok a kihúzottak között. Ezért egy hátultesztelő ciklusban figyelni kellett az
esetleges ismétlődést, és ha volt, (volt = true) akkor újból elő kell állítani a számot.
A fór ciklusnak pedig mindig az aktuális számig kell végezni az összehasonlítást,
pl.: a 3. számot a 2-kal és az 1-vel kell összehasonlítani. Az if (i > 0) azért szüksé
ges, mert az 1. számot csak elő kell állítani, de összehasonlítani még nem kell.
A program a „lottószámok” szöveg kiírása után azonnal egy do ciklusba lép és
mindaddig ott is marad, amíg a k karakter típusú változó értéke T nem lesz. Ha
bármely más billentyűt kap értékül, akkor kilép a ciklusból és programból is.
A karakter típusú változót a char típus után kell megadni, az értékét pedig a ’ ’jelek
közé kell tenni.
52
A programot többször is le kell futtatni, tesztelni, hogy lássuk: valóban nincs is
métlődő szám. Erre viszont van egy olyan módszer, amely egyetlen futtatás során
is bizonyítja, hogy nem lehet 2 azonos szám a kihúzottak között. Ehhez csupán két
helyen kell megváltoztatni a programot.
Melyik az a két sör és mit kell változtatni?
2.14. A goto utasítás
A következő feladatban a program helytelen adatokkal való működését akadályoz

zuk meg egy hátultesztelő ciklus és a goto utasítás segítségével. A goto-val bárho
vá ugorhatunk, csak meg kell adni a címke nevét a goto után, és el kell helyezni a
program megfelelő pontjára a címkét, (kettősponttal lezárva) oda, ahova a vezér
lésnek ugrani kell.
21. feladat:
Kérjük be a másodfokú egyenlet együtthatóit, és számítsuk ki a gyököket 2 tizedes
pontossággal! Ha a diszkrimináns negatív, írjuk ki a képernyőre: ” Nincs megol
dás” ! Ha az a értéke 0, figyelmeztessük a felhasználót, és kérjük be újra az adatot!
Ha a felhasználó 3-nál többször hibázik lépjünk ki a programból!
Név: Másodfokú
Megoldás:
{
d o u b l e a = 0, b = 0, c = 0, d = 0, xl = 0, x2 = 0;
int hiba = 0;
C o n s o l e . W r i t e L i n e (" Másodfokú egyenlet gyökeinek
s z á m í t á s a : 11) ;
H ibakeresés, tesztelés
53
do
if (hiba = = 4) goto vege;

C o n s o l e . W r i t e (" a= ");
a = C o nvert.ToDouble(Console.ReadLine());
i f ( a = = 0) C o n s o l e . W r i t e L i n e (" Az a nem l e h e t
0, m i v e l e k k o r nem m á s o d f o k ú a z e g y e n l e t ! " ) ;
hiba++;
} while ( a = = 0 );
C o n s o l e . W r i t e (" b= ");
b = Convert.ToDouble(Console.ReadLine());
C o n s o l e . W r i t e (" c = " ) ;
c = C o nvert.ToDouble(Console.ReadLine());
d = b * b - 4 * a * c ;
C o n so le .W r ite L in e ();
i f ( d < 0)
{
C o n s o l e . W r i t e L i n e (" Nincs megoldás");
}
else
{
x l = ( - b + M a t h . S q r t ( d ) ) / (2 * a ) ;
x 2 = ( - b - M a t h . S q r t ( d ) ) / (2 * a ) ;
C o n s o l e . W r i t e L i n e (" x l = { 0 : 0 . 0 0 }
x2={0 :0 .0 0 } ", x l, x 2 ) ;
}
vege:
C o n so le.ReadKey();
}
A program matematikai része már a 10. feladatban látható volt. Most egy
hátultesztelő ciklussal megakadályozzuk az = érték bevitelét. A ciklusban a
hiba változó értékét növeljük. Ha túllépi a 3-at, akkor a goto utasítással kilépünk a
ciklusból a program végén lévő vege címkére. Hasonló eredményt érnénk el, ha a
goto vege helyett a return utasítást használnánk, mivel a return utasítással kilép
hetünk egy utasításcsoportból úgy, hogy a return után álló utasítások nem lesznek
végrehajtva. Ekkor természetesen a vege: címkére sincs szükség.
54
2.15. Hibakeresés, tesztelés
A hibakereséssel megállapíthatjuk a hiba helyét, okát és futás közben információt

kaphatunk a programról, a programozás során használt eszközeink, változóink
aktuális értékéről. A hibák egy részét már a kódbeírás közben azonnal láthatjuk és
javíthatjuk is. Vannak azonban olyan hibák, amelyek csak futtatás közben derülnek
ki. Ezt a fordítóprogram jelzi, megszakítja a program futását és magyarázatot is fűz
a hiba megjelenésének helyén. Ezen hibák javítására van több lehetőség is, amely-
lyel könnyen javíthatjuk a munkánkat.

{ double a = 0 ; b = 0 , c = 0 , d = 0 , xl = 0 , x2 = 0 ;
int hiba = 0 ;
Console.WriteLine(” Másodfokú egyenlet gyökeinek számítása:”);
Console.WriteLine();
do
{
if (hiba == 4 ) return;
Console.Write(” a= ");
a = Convert.ToOouble(Console.ReadLine());
if (a == 0 ) Console.WriteLine(" Az a nem lehet 8 , mivel ekkor nem másodfokú az egyenlet!");
hiba++;
} while ( a == 0 );
Console.Write(" b= ”);
b = Convert. ToDouble (Console. ReadLineQ)
Console.Write(" e= ”); <7 ?23msdőp5ed
c * Convert.ToDouble(Console.ReadLine())
if (d < 0 )
A fenti ábrán a 21. feladat megoldásának részlete látható, futás közbeni állapotában.
C#-ben utasításonként futtathatjuk a programunkat az F 11 billentyű segítségével,
ami nagy segítség lehet a tesztelés, hibakeresés során. A hibakeresés során még két
nagyon hasznos lehetőség áll rendelkezésünkre, amelyek igazán megkönnyítik a
munkánkat. Az egyik a töréspont elhelyezése, a másik pedig a nyomkövetés, a vál
tozók aktuális értékeinek megtekintése. Mindez az alábbiak szerint valósulhat meg:
A program kódjának tetszőleges sorában a sor elejére kattintva töréspontot hozunk
létre és megjelenik egy kis piros kör, ahol a program futása megáll. A töréspontok
ból igény szerint több is elhelyezhető a programban.
Ha tehát a programot futtatjuk a start gombra kattintva vagy az F5 billentyűvel,
akkor a program lefut a szokásos módon addig a sorig, amelyben a kis piros kör van.
H ibakeresés, tesztelés
55
Ezt követően a hibakeresés, vagy tesztelés során célszerű az FI 1-el áttérni az utasí
tásonként futtatásra és ezzel egy időben a bal alsó részen a Locals ablakban láthat
juk a programban használt eszközeink - többnyire a változók - aktuális értékét.
A futtatás során további segítség, hogy az éppen aktuális sor sárga háttérrel jelenik
meg és sor elején egy sárga, jobbra mutató nyíl látható.
Mindeközben láthatjuk a programunk futásának aktuális állapotát is.
Ezen lehetőségekkel nagyon könnyű az esetleges hibát, hibákat megkeresni és javí
tani, ill. a programot tesztelni
1. Készítsen programot, amely egy 10-es számrendszerbeli számot átvált 2-es
számrendszerbe!
2. Készítsen programot, amely egy 2-es számrendszerbeli számot átvált 10-es
számrendszerbe!
3. Egy tanuló 10 kérdésből álló tesztlapot tölt ki. Minden kérdésre a választ az abc
első 4 betűje (a, b, c, d) jelöli. Ismerjük a 10 kérdés helyes megoldását a
betűjelekkel megadva. Készítsünk programot, amely bekéri a tanulótól a felada
tonként! megoldásokat, majd meghatározza hány helyes válasza(pontja) volt a
tanulónak! Minden helyes válasz 1 pontot ér.
4. Bővítse az előző programot azzal, hogy csak a lehetséges tippeket fogadja el a
program a tanulótól.! (A válaszok csak a, b ,c, d lehet.).
5. Bővítse úgy a 3. feladatot, hogy több tanuló tölti ki a tesztet! A program kérdez
ze meg a tanulók számát és utána kérje be egyesével a tanulók válaszait!
6. A 3. feladatot bővítse tovább úgy, hogy az eredményt osztályozza is le a prog
ram! Az osztályozáshoz szükséges százalékok:
Százalékérték Érdemjegy
0-19% Elégtelen (1)
20-39% Elégséges (2)
40-59% Közepes(3)
60-79% Jó(4)
80-100% Jeles(5)
7. A 3. feladatot oldja meg úgy is, hogy a feladatok különböző pontszámot érje
nek! Számítsa ki az összpontszámot, a maximális összpontszámot, és a 6. fel
adat táblázata alapján végezze el az osztályozást!
56
8. Kérjünk be egy számot 1 és 100 között, majd írassuk ki betűvel!

9. írassuk ki n-től m-ig a 7-tel osztható számokat, n nem feltétlenül kisebb, mint m!
10. írassuk ki While ciklussal 0-100-ig a 3-mal osztható számokat!
11. A következő feladat bekér egy 0 és 1 közötti számot, amelyet radiánként kezel
és megadja a hozzátartozó szinusz és koszinusz szöget. A program 10 hibát
tartalmaz. Melyek ezek és hol vannak? Javítsa ki úgy a programot, hogy az
helyesen működjön és futtatható legyen!
using System;
using S y ste m .C o lle ctio n s.Generic;
using System.Linq;
using System Text;
namespace Radian
{
Program
{
static void Main ( s t r i n g a r g s )
{
d o u b le fok=0 r a d i a n = 0;
C o n s o l e . W r i t e ( " K é r e m a r a d i á n t ")
ra d ia n = C o n v e rt. ToD ouble(C onsole. R ead L in e();
i f ( r a d i a n < 0) f o k = M a t h . A s i n ( - r a d i a n ) *
180 / M ath.Pl;
fok = Math.Asin (radian) * 180 / Pl;
C o n s o l e . W r i t e L i n e ( "A r a d i á n s i n { 0 : 0 . 0 0 } f o k
és,fok);
C o n s o l e . W r i t e L i n e (" s i n {1:0.00} fok", 1 8 0 - f o k ) ;
C o n s o le .W r i te L i n e ("V alam int cos {0:0.00} fok
é s", 90-fok);
C o n s o l e . W r i t e L i n e (" cos {0:0.00} fok",
360 - f o k ) ;
57
3. PROGRAMOZÁSI TÉTELEK
A programozási tételek olyan algoritmusok, amelyeket gyakran használunk a prog

ramírás során. A matematikai, logikai, adatkezelési feladatok megoldásánál általá
nosan alkalmazhatók ezek a módszerek.
Ilyen az
• összegzés,
• megszámolás,
• eldöntés,
• kiválasztás,
• maximum- (minimum) kiválasztás,
• kiválogatás,
• szétválogatás,
• lineáris keresés,
• rendezés.
Ezek a műveletek általában a tömbökhöz kötődnek és a tömb elemeivel végezzük
a műveleteket.
3.1. Ö sszegzés
Többnyire egy tömb eleminek összegzését értjük rajta. Általános „képlete” az

összeg=összeg+aktuális elem, ami matematikailag helytelen, de programozásban
megszokott módszer, amelyet így értelmezünk:
az új összeg = a régi összeg + az aktuális elem.
A C# ennek egyszerűsített változatát is engedélyezi, ahol a += jelet használva ál
lítjuk elő az összeget: összeg+= aktuális elem.
22. feladat:
Állítsunk elő véletlenszerűen 8 egész számot a [0 , 100]-ból, és írjuk ki a képer
nyőre 1 sorba! Számoljuk és írjuk ki a számok átlagát 3 tizedes pontossággal!
P rogramozási tételek
58
Név: Összegzés
Megoldás:
{
int[] a = new i n t [ 8 ] ;
int összeg = 0, i = 0;
double atlag = 0;
for (i = 0; i < 8; i++)
{
a[i] = v sz .N e x t (101);
ö s s z e g += a [ i ] ;
C o n s o l e . W r i t e ( w { 0 , 5 } ,f, a [ i ] ) ;
}
atlag = C o n v e rt. ToDouble(összeg) / 8;
C o n s o l e . W r i t e L i n e (" A s z á m o k átlaga: {0:0.000}",
atlag);
}
Az összegzést az összeg += a[i]; -vei végeztük, amely teljes mértékben megegye
zik az osszeg=osszeg+a[i]; -vei.
3.2. M egszám olás
Megszámoljuk, hogy hány adott tulajdonságú elem van a tömbben. Itt ajánlatos az
összegzésnél tanult módszerrel növelni a számláló értékét, vagy még egyszerűbben
a ++ jelet használni, mivel a számláló értéke egyesével nőhet csak.
23. feladat:
Állítsunk elő véletlenszerűen 12 egész számot a [ - 5 0 ,50]-ból, és írjuk ki a képer
nyőre 1 sorba! Számoljuk meg és írjuk ki, hogy hány negatív és hány pozitív szám
van köztük!
Név: Megszámolás
E ldöntés
59
Megoldás:
{
i n t [ ] a = new i n t [ 1 2 ] ;
i n t d b p o s = 0 , d b n e g = 0, i = 0;
f ó r ( i = 0; i < 1 2 ; i + + )
{
a [ i ] = v s z . N e x t ( - 5 0 , 51) ;
i f ( a [ i ] > 0) d b p o s + + ;
i f (a [ i ] < 0) d b n e g + + ;
C o n s o l e . W r i t e ( " { 0 , 5 } " , a [i ] );
}
C o n s o l e . W r i t e L i n e (" {0} db p o z i t í v szám v a n . " ,
dbpos);
C o n s o l e . W r i t e L i n e (" {0} db negatív s z á m v a n . 11,
dbneg);
}
A megszámolás a két if-es sorban történik a ++ jel felhasználásával, amelynek
eredménye: ha igaz a logikai kifejezés, akkor növeljük dbpo,s ill. dbneg értékét
eggyel.
3.3. Eldöntés
Az algoritmus eldönti, hogy van-e a tömbben adott tulajdonságú elem. Amint talál
egyet, a ciklus leáll. Feltételezve, hogy a megoldáshoz ciklusra van szükség.
A 15-ös feladatban pontosan ez történt, hiszen egy adott számról kellett eldönteni,
hogy az prímszám-e vagy sem. A döntés eredményét pedig kiírtuk a képernyőre.
24. feladat:
Állítsunk elő véletlenszerűen 6 egész számot a [ 0 , 50]-ból, és írjuk ki a képernyő
re 1 sorba! írjuk ki, hogy van-e 3-mal osztható szám!
Név: Eldöntés
60
Megoldás:
static void M a in (s trin g [] args)
{
i n t [ ] a = new i n t [ 6 ] ;
i n t i = 0;
b o o l van = f a l s e ;
Random v s z = new Random ( ) ;
f o r ( i = 0 ; i < 6; i + + )
{
a [i ] = v s z . N e x t (51);
C o n s o l e . W r i t e ( 11 { 0 , 5 } 11, a [i ] ) ;
i = 0;
do
i f ( a [ i ] % 3 = = 0) v a n = t r u e ;
i++;
} w h i l e ( v a n = = f a l s e && i < 6 ) ;
i f ( v a n ) C o n s o l e . W r i t e L i n e (" Va n 3 - m a l osztható
s z á m . 11) ;
3.4. Kiválasztás
Kiválasztás esetén az adatok közül kiválasztunk valamilyen szempont alapján egy

vagy több olyan elemet, amely a megadott szempontnak megfelel. Az algoritmus
megadja, hogy a tömbben egy bizonyos elem hol (hányadik helyen) van.
25. feladat:
Állítsunk elő véletlenszerűen 10 egész számot a [ - 5 0 ,50]-ból, és írjuk ki a képer
nyőre 1 sorba! írjuk ki az 1. pozitív szám értékét és indexét, ha van ilyen! Ha nincs,
írjuk ki, hogy „Nincs pozitív szám” !
Név: Kiválasztás
Megoldás:
M aximum - ( minimum ) kiválasztás
61

{
int[] a = new int[10];
int i = 0;
bool van = false;
Random vsz = new Random ();
for (i = 0; i < 10; i++)
{
a [i] = vsz.Next(-50,51);
Console.Write("{0,5}", a [i]);
}
i = 0;
do
if (a[i]> 0) van = true;

i++;
} while (van = = false && i < 10) ;
if (van) Console.WriteLine(" Az 1. pozitiv
szám: {0} indexe: {1}",a[i-1],i-1);
else
Console.WriteLine("Nincs pozitiv szám");
Console.ReadKey();
}
Ha van a feltételnek megfelelő szám (jelen esetben pozitív), akkor kilépünk a
hátultesztelő ciklusból a van=true miatt. Ekkor viszont tudjuk az i értékét, így csak
ki kell íratni az indexnek megfelelő elem értékét és sorszámát. Azért kell az z-7-et
kiírni, mert a do while ciklusban a pozitívság megállapítása után növeltük az i ér
tékét az /++ -al.
3.5. Maxim um - (minimum) kiválasztás
Rendezetlen elemek közül kiválasztjuk a legnagyobbat vagy a legkisebbet. Karakter

és szöveg típusú változókra is érvényes. Az algoritmus lényege: a fór ciklus meg
kezdése előtt kinevezzük az 1. elemet maximumnak (vagy minimumnak), majd
belépünk a ciklusba, ahol i = 2-től megyünk az utolsó elemig. A ciklusban a
2. elemtől kezdve minden elemet összehasonlítunk a maximummal, és ha az aktuá
lis elem nagyobb mint a maximum, akkor az aktuális elem lesz az új maximum.
62
26. feladat:
nyőre 1 sorba! írjuk ki a legnagyobb számot a képernyőre!
Név: Maximumkiválasztás
Megoldás:
{
i n t [ ] a = new i n t [ 5 ] ;
i n t i = 0, max =0 ;
f ó r ( i = 0; i < 5; i + + )
{
a [i ] = v s z . N e x t (501) ;
C o n s o l e . W r i t e ( 11 { 0 , 5 } " , a [i] ) ;
}
ma x = a [ 0 ] ;
f ó r ( i = 1; i < 5; i++)
{
if (a[i]>max) max=a[i];
}
C o n s o l e . W r i t e L i n e (" A l e g n a g y o b b s z á m : {0}",max);
}
írjuk át a programot úgy, hogy a legkisebb számot válasszuk és írjuk ki!
Mely sorokat kell átírni és hogyan?
63
27. feladat:
Kérjünk be 5 karaktert és írjuk ki az angol ABC szerinti elsőt!
Név: Minimumkiválasztás
Megoldás:

{
char[] a = new char[5];
int i = 0;
char min = '
Console.WriteLine(" Kérem a karaktereket:");
Console.WriteLine(" Csak az angol ABC betűit
használjuk!") ;
fór (i = 0; i < 5; i++)
{
a[i] = Convert.ToChar(Console.ReadLine());
}
min = a [0];
fór (i = 1; i < 5; i++)
{
if (a [ i ] < min) min = a[i];
}
Console.WriteLine() ;
Console.WriteLine(" Az angol ABC szerinti első
karakter: {0}", min);
Console.ReadKey();
}
Karakter és szöveg típusú változók esetén a < > jelek a karakternek megfelelő
ASCII kód értékétől függően döntik el, hogy melyik a nagyobb.
Pl.: ’a’= ASCII 65
’c’= ASCII 67 , tehát c > a mert nagyobb az ASCII kódja, vagyis hátrébb
van az ABC-ben. Az ékezetes betűk azért „borítják fel” a magyar ABC sze
rinti sorrendet, mert az ASCII kódjaik nem az ABC sorrendnek megfelelően
lettek kiosztva.
Ezt kihasználva viszont bármilyen nagybetűt kisbetűvé alakíthatunk a Convert.
ToChar(nagybetuASCIIkod+32); utasítással.
64
1. Egy futóversenyre egyesületenként jelentkeztek a versenyzők. Az egyesületek
megadják hány versenyzőt neveznek. Határozzuk meg az egyesületek számá
nak ismeretében hány induló lesz a versenyen!
2. 12 hónapon keresztül spóroltunk. Minden hónapban változó összeget félretet
tünk. Az összegek ismeretében adja meg, mennyi pénzünk van! Mekkora
összegünk lesz, ha a megtakarításunkat 3 hónapra lekötjük, évi 10,5%-os ka
mat mellett?
3. Adott egy tekéző sorozata (melyik fordulóban hány fát ütött). írjunk progra
mot, amely meghatározza a versenyző összesített eredményét!
4. Egy horgászverseny adatait egy táblázatban tároljuk. A horgászok száma 6, a
fogható halfajok száma 8. A táblázat 1 cellája M(i,j) azt jelenti, hogy az i hor
gász a j halfajból mennyit fogott.
a. írjunk programot, amely kiszámítja, hogy a horgászok összesen hány halat
fogtak az egyes halfajokból!
b. írjunk programot, amely meghatározza, hogy az egyes horgászok hány
halat fogtak összesen!
5. 12 napig megmértük a napi csapadék mennyiséget. Határozzuk meg mennyi
eső esett összesen!
6. Egy labdarúgó bajnokságban tudjuk minden csapatról hogy hányszor győzött
és hányszor játszott döntetlent. Adjuk meg, melyik csapatnak hány pontja van
(győzelem 3 pont, döntetlen 1 p o n t)!
7. Ismerjük 9 autó fogyasztását. Döntsük el, hogy minden autó 10 liter alatt fo-
gyasztott-e?
8. Egy halgazdaság próbafogást végez. Minden hal súlyát és hosszát tárolják.
A vizsgát halak száma 14. Készítsen programot amely:
a. Megadja a halak összsúlyát, és az átlagos hosszúságot!
b. Megadja azon halak számát, amelyek 70 dkg-nál nagyobbak!
c. Megadja azon halak számát, amelyek 50 dkg-nál nagyobbak és 28 cm-nél
hosszabbak!
d. Van-e 2 kg-nál nagyobb hal?
e. Van-e a kifogott halak között olyan, amelyik 40 dkg alatti?
f. Mekkora a mérete a legkisebb súlyú halnak?
g. Mekkora a súlya a legnagyobb méretű halnak?
Az adatokat beírhatja a programba (legegyszerűbb módszer), bekérheti billen
tyűről (időigényes az adatbeírás), vagy előállíthatja véletlenszerűen (érdekes
eredmények lehetnek pl. nagy súly, kis hossz vagy fordítva).
65
9. Ismerjük 11 ember magasságát. Készítsen programot, amely megadja, hogy

van-e olyan ember, aki alacsonyabb, mint a mögötte állók valamelyike!
10. Határozzuk meg, hogy egy adott hónap melyik évszakba esik!
11. Olvassunk be neveket addig, míg nem írtunk egymás után két azonos nevet!
12. A kosaras csapat nyilvántartásában tároljuk minden játékos nevét és magassá
gát. A játékosok száma 18. Határozzuk meg van-e a csapatnak 210 cm-nél
magasabb játékosa. Ha van, írjuk ki a nevét (egy személy elég, ha van, de ki
írathatjuk mindet)!
13. Egy repülőgépről a szárazföldön kezdve 500 méterenként megmértük a felszín
tengerszint feletti magasságát. A mérések száma 500. A méréssorozatot száraz
föld felett fejeztük be. Ahol a mérés eredménye 0, ott tenger van, mindenhol
máshol föld.
a. Határozza meg van-e sziget a mérési helyen!
b. Hány sziget található a mérési helyen?
c. Mekkora a hossza az egyes szigeteknek?
d. Milyen távolságba vagyunk a kiinduláskor a tengertől?
e. Melyik a legrövidebb, ill. a leghosszabb sziget?
f. Melyik a szárazföld legmagasabb pontja?
g. Melyik a sziget legmagasabb pontja?
h. Milyen távolságban vagyunk a mérés végeztekor a tengertől?
14. Nyelvvizsgán a 20 tanuló pontszámait ülési sorrendben jegyezték föl. Adja
meg azoknak a vizsgázóknak a sorszámát, akik ugyanannyi pontot értek el,
mint a szomszédjuk!
15. Állítson elő véletlenszerűen 28 számot [-10,10] tartományból.
a. Állapítsa meg pozitív vagy negatív számból van-e több! A választ és a
darabszámokat írja a képernyőre!
b. Hányszor fordult elő a 7 szám?
c. Van-e a számok között 0, ha igen hányadik volt?
d. Adja meg a negatív számok átlagát!
e. Melyik volt a pozitív számok közül a legkisebb?
f. Melyik volt a negatív számok közül a legnagyobb?
16. A műkorcsolyában a versenyző teljesítményét 7 bíró pontozza. Az összpont-
számot úgy számítják ki, hogy a leggyengébb és a legjobb pontszámot nem
veszik figyelembe, az összes többit pedig átlagolják. Van 6 versenyzőnk és az
eredményük. írjunk programot amely:
66
a. Meghatározza az egyes versenyzők összes pontszámát!

b. Meghatározza a legnagyobb pontszámot, és azt, hogy hányadik versenyző
kapta!
c. Az összes pontszámok alapján meghatározza a versenyzők átlagát és meg
mondja hányán voltak átlag alatt!
d. Meghatározza a legkisebb összpontszámot!
17. Adott a síkon 7 db pont a koordinátáival. Határozzuk meg, melyik esik legtá
volabb az origótól!
18. Kérjünk be 0 végjeiig számokat, írassuk ki a legnagyobbat, legkisebbet, és
hogy hány szám volt összesen!
3.6. Kiválogatás
Kiválogatásról beszélünk, ha egy tömb elemi közül kiválogatunk egy vagy több
feltételnek megfelelő elemeket. Ezeket az elemeket kiírhatjuk a képernyőre, vagy
elhelyezhetjük egy másik tömbben.
28. feladat:
Állítsunk elő véletlenszerűen 15 egész számot a [0-100]-ban, és írjuk ki a képer
nyőre 1 sorba! írjuk ki és tegyük egy másik tömbbe az 5-el osztható számokat!
Név: Kiválogatás
Megoldás:
{
i n t [ ] a = new i n t [15];
i n t [ ] b = new i n t [15];
int i = 0 , j = 0 , d b =0 ;
Random v s z = new RandomO;
f ó r ( i = 0; i < 15; i++)
{
a [i ] = v s z . N e x t (101);
C onsole.W r ite ("{0,5}", a [i ] ) ;
i f (a [ i ] % 5 = = 0)
{
b [db] = a [i ] ;
db++;
S zétválogatás
67
}
}
Console.WriteLine(" Az öttel osztható számok: ");
fór (j = 0; j < db; j++) Console.Write ("{0,5 }",
b[j] );
Console.ReadKey() ;
}
A b tömböt azért kell ugyanolyan méretűre deklarálni, mert elvileg előfordulhat olyan
eset is, amikor mind a 15 szám öttel osztható lesz. Bármilyen kicsi is ennek a valószí
nűsége, a programot úgy kell megírni, hogy minden esetben működőképes legyen.
3.7. Szétválogatás
Szétválogatáskor egy tömb minden elemét elhelyezzük adott feltételektől függően

más tömbökben. Ekkor az eredeti tömb elemszáma egyenlő a szétválogatás után
létrejött tömbök elemeinek összegével.
29. feladat:
Állítsunk elő véletlenszerűen 15 egész számot a [0-100]-ban, és írjuk ki a képer
nyőre 1 sorba! Válogassuk szét 3 különböző tömbbe a kettővel osztható, a kettővel
nem, de hárommal osztható és az egyéb számokat, majd írjuk ki a tömbök tartalmát
egymás alá!
Név: Szétválogatás
Megoldás:
{
int[] kettő = new int[15];
int[] három = new int[15];
int[] egyeb = new int[15];
int i = 0 ,j = 0 , dbketto = 0 , dbharom = 0 ,
dbegyeb =0 ;
fór (i = 0; i < 15; i++)
68
a[i] = vsz.Next (101);

Console.Write("{0,5}", a[i]);
if (a [i] % 2 == 0)
{
kettő[dbketto] = a [i];
dbketto++;
}
else
if (a [i] % 3 == 0)
{
három[dbharom] = a[i];
dbharom++;
}
else
{
egyeb[dbegyeb] = a[i];
dbegyeb++;
}
}
Console.WriteLine(" A kettővel osztható
számok: ");
fór (j = 0; j < dbketto; j++) Console.
Write("{0,5}", kettői j]);"
Console.WriteLine(" A kettővel nem, de hárommal
osztható számok: ");
fór (j = 0; j < dbharom; j++) Console.
Write("{0,5}", harom[j]);
Console.WriteLine(" Az egyéb számok: ");
fór (j = 0; j < dbegyeb; j++) Console.
Write("{0,5}", egyeb[j]);
Console.ReadKey() ;
}
3.8. Lineáris keresés
Ha van egy N elemű sorozatuk, és keresünk benne egy T tulajdonságú elemet,

akkor lineáris kéréséről beszélünk. Ekkor a programban lévő algoritmusnak el kell
dönteni, hogy van-e T tulajdonságú elem a sorozatban. Ha van, akkor meg kell adni
a sorszámát Ez tehát az eldöntés tétele egy kicsit kibővítve.
R endezés
69
30. feladat:
Legyen adott egy 8 elemű tömb, amelyben lineáris kereséssel állapítsuk meg a
keresett szám indexét és írjuk ki a képernyőre! Ha a keresett szám nincs a tömbben,
írjuk ki, hogy nincs benne!
Név: Lineáris keresés
Megoldás:
static void Main()
{
i n t [ ] t ö m b = { 4 , 5 , 1 5 , 9, 4 , 2 , 11 , 2 };
i n t n = tomb.Length;
i n t k e r e s e t t S z a m = 9; / / K e r e s e t t é r t é k
i n t i = 0;
w h i l e ( i < n && t o m b [ i ] != k e r e s e t t S z a m )
i++;
i f ( i < n)
C o n s o l e . W r i t e L i n e ( "A k e r e s e t t s z á m i n d e x e :
{0}", i ) ;
else
C o n s o l e . W r i t e L i n e ( " A k e r e s e t t szám n i n c s b en n e
a töm bben” );
}
Az elöltesztelő ciklus mindaddig növeli az i változó értékét, míg az kisebb, mint a
tömb elemszáma és a keresett szám nem egyezik meg a tömb aktuális elemének
értékével. Ha megegyezik a szám a keresett értékkel, akkor a ciklus nem fut le, az
i értéke nem nő és mivel nyilvánvalóan igaz, hogy az i kisebb, mint az elemszám,
ezért kiírja az indexet.
Ha viszont a ciklus azért fejeződik be, mert az i értéke elérte az elemszámot, akkor
az elágazás else ága fut le.
3.9. Rendezés
Rendezéskor az elemeket valamilyen tulajdonságuk alapján sorba rendezzük. Álta

lában növekvő vagy csökkenő sorrendbe állítjuk az adatokat. Szám típusú adatokat
nagyságuk szerint rendezünk, szöveg vagy karakter típusúakat pedig (angol) ABC
sorrend vagy ASCII kód szerint.
70
Rendezésnél több módszer közül választhatunk melyiket használjuk. A jegyzet a

módszerek közül kettőt mutat be részletesen. Az elemek száma és rendezettségük
foka dönti el melyik a jobb módszer, azaz melyik a gyorsabb.
1. Minimum (maximum) kiválasztásos módszer
2. Szomszédos elemek cseréjén alapuló módszer.
3.9.1. Minimum (maximum) kiválasztásos módszer
Két egymásba ágyazott fór ciklus segítségével rendezzük az elemeket. A külső ciklus
2-től az utolsó előtti elemig, a belső az aktuális elem+1 indexétől az utolsóig megy.
A ciklusban összehasonlítja az elemeket, és ha a sorrend rossz, akkor megcseréli őket.
Ciklus i= 1-től n-l-ig
Ciklus j=i+1-től n-ig
Ha a[i]>a[j] akkor csere
Nézzünk egy példát:

Legyen az 5 elemünk a következő: 23, 45, 12, 63, 44.
Állítsuk növekvő sorrendbe a számokat!
Vesszük az 1. elemet (i=l) a 23-at, és összehasonlítjuk a belső ciklusban először a
(j=i+l, azaz j=2) 2. elemmel a 45-tel. Ha a[l]>a[2] (23>45) igaz lenne, akkor cse
rélni kellene, de most ez nem igaz, tehát nem cserélünk. Vesszük a belső ciklusban
a következő elemet (léptetjük j-t, így j=3), és összehasonlítjuk az (i=l) 1. elemmel,
(i-t nem léptethetjük, mivel a külső ciklusváltozó csak akkor lép, ha a belső ciklus
minden j érték mellett lefutott már).
Ha a[l]>a[3] (23>12) igaz, akkor csere. Mivel az állítás igaz, ezért cserélünk, te
hát a[l]=12 és a[3]=23. Léptetjük j-t tovább, így j=4 esetén összehasonlítjuk az 1.
és 4. elemet. Most már az 1. elemünk a 12 lesz, és ezt hasonlítjuk a 63-mal. Mivel
a[i] nem nagyobb mint a[j], ezért nem cserélünk. Ugyanez történik az utolsó ösz-
szehasonlításkor, mert 12 kisebb, mint 44. Most a j ciklus végére értünk és a szá
mok sorrendje ez lett: 12, 45, 23, 63, 44.
Vagyis az 1. helyre került a legkisebb szám. Ezt a számot most már kihagyjuk a
későbbi összehasonlításokból - nála kisebb már nem lehet a számok között - lép
tetjük a külső ciklus változóját, az i-t. Ha i=2, akkor a belső ciklusban j=3 lesz az
első összehasonlítandó elem. Mivel a[2]>a[3] (45>23) igaz, ezért cserélni kell. így
a[2]=23 és a[3]=45. Nézzük a 2. és 4. elemet a 22-t és 63-at. Itt jó a „növekvő”
sorrend, nem kell cserélni, mint ahogy az utolsó szám esetén is igaz, hogy 23<44.
Az új sorrend: 12, 23, 45, 63, 44.
R endezés
71
Látható, hogy a j ciklus lefutásakor mindig az első helyre kerül a legkisebb szám.
Az i=3 esetén a 45-öt hasonlítjuk a 63-mal, (itt jó a sorrend) majd a 44-el, ahol
viszont rossz a sorrend, ezért cserélünk.
Az új sorrend: 12, 23, 44, 63, 45.
Az i=4 esetén j=5 lesz, vagyis az utolsó előtti elemet hasonlítjuk az utolsóval.
Mivel a sorrend rossz, ezért cserélni kell a[4]=45 és a[5]=63.
A végső sorrend: 12, 23, 44, 45, 63. Ez már valóban növekvő sorrend.
Csökkenő sorrendet a „ha a[i]<a[j] akkor csere” módon állíthatunk elő maximum
kiválasztásos módszerrel.
Az algoritmus működése most már egyértelmű, de maradt még egy kérdés mielőtt
a programot megírnánk: hogy lehet 2 elemet megcserélni?
Úgy, ahogy 2 pohár tartalmát megcserélnénk a valóságban. Kell egy 3. üres pohár
ideiglenesen.
A kávét átöntjük az üres pohárba (1), a helyére a teát töltjük (2), majd a tea helyé
re az ideiglenes pohárból a kávét öntjük (3). A csere tehát megtörtént.
Programozásban ez így néz ki:
s=a[j];
aLj]=a[i];
a[i]=s;
72
31. feladat:
nyőre 1 sorba! Rendezzük növekvő sorrendbe a számokat, és írjuk ki a képernyőre!
Név: Rendezési
Megoldás:
{
i n t [] a = n e w i n t [ 5 ] ;
int i = 0 , j = 0 ;
C o n s o l e . W r i t e L i n e (" A számok
fór ( i = 0; i < 5; i++)
{
a [i ] = v s z .N e x t (101);
Console.W rite ("{0,5}", a [i ] ) ;
}
fór ( i = 0; i < 4; i++)
f ó r (j = i + 1 ; j < 5; j + + ) if (a[i] > a [ j ])
{
i n t s= a [i ];
a [i ] = a [j ] ;
a [j ] = s ;
}
C o n s o l e . W r i t e L i n e (" A számok r e n d e z v e : " ) ;
fór ( i = 0; i < 5; i++) C o n so le.W rite ("{0,5}",
a[i] ) ;
C onsole.R eadK ey();
}
A programban kihasználtuk azt a C# által biztosított lehetőséget, hogy egy változót
csak akkor deklarálunk, amikor azt a programban először használjuk. De az eddig
megszokott módon, a program elején is deklarálhattuk volna az s-t.
A rendezési algoritmus azonban nem minden típus esetén működik a C#-ban. Egyes
programnyelvekben a karakter típusnál látható ASCII kód alapján a szöveg típusú
változókat is sorbarendezhetjük az eddig tanult módon. C#-ban ez nem működik,
mivel a < és > relációs jel szöveg típusú változókra nem értelmezhető (mint később
látni fogjuk: van mód szöveg típusú változók összehasonlítására a CompareTo-val).
A C# viszont egy tömbökre alkalmazható rendezési utasítást épített be az Array.
Short(tömb) néven. Alkalmazását a következő feladat mutatja be.
R endezés
73
32. feladat:
Kérjünk be 5 nevet és rendezzük ABC szerint sorrendbe!
Név: Rendezés2
Megoldás:
s t r i n g [ ] n é v = new s t r i n g [ 5 ] ;
i n t i = 0;
C o n s o l e . W r i t e L i n e ( 11 K é r e m a n e v e k e t : 11) ;
f ó r ( i = 0 ; i < 5; i + + ) n é v [ i ] = C o n s o l e . R e a d L i n e ( ) ;
Array.Sort(név);
C o n s o l e . W r i t e L i n e (" A nevek re n d e z v e :" );
f ó r ( i = 0; i < 5; i + + ) C o n s o l e . W r i t e L i n e ( " { 0 , 5 ]
n é v [ i ] );
Az Array.Sort utasítással számokat is hasonlóan rendezhetünk növekvő sorrendbe.
3.9.2. Szomszédos elemek cseréjén alapuló módszer
A módszer lényege, hogy egy hátultesztelő ciklusban addig végezzük a szomszé

dos elemek cseréjét, amíg minden elem a helyére nem kerül.
Ciklus
Ciklus i= 1-től n-l-ig
Ha a[i]>a[i+l] akkor csere
amíg volt csere
A hátultesztelő ciklusból csak akkor léphetünk ki, ha már nem volt szükség cseré
re, tehát az elemek sorrendje megfelelő. Természetesen a relációs jel megfordítá
sával csökkenő sorrendbe állíthatjuk az elemeket.
Most ismételjük meg a 30. feladatot ezzel a módszerrel!
33. feladat:
nyőre 1 sorba! Rendezzük növekvő sorrendbe a számokat és írjuk ki a képernyőre!
Név: Rendezés3
74
Megoldás:
{
i n t [] a = n e w i n t [ 5 ] ;
i n t i = 0;
bool v o ltcsere = false;
C o n s o l e . W r i t e L i n e (" A számok :");
f ó r ( i = 0; i < 5; i + + )
{
a [i ] = v s z . N e x t (1 0 1 );
C o n so le .W rite("{0,5}", a [i ] );
}
do {
voltcsere = false;
f ó r ( i = 0 ; i < 4; i++) if (a [ i ] > a[i+l])
{
i n t s = a [i] ;
a [ i ] = a [i + 1 ];
a [ i + l ] = s;
voltcsere=true;
}
}while ( v o l t c s e r e ) ;
C o n s o l e . W r i t e L i n e ( 11 A számok r e n d e z v e : " ) ;
fór ( i = 0; i < 5 ; i + + ) C o n s o l e . W r i t e ( " { 0 , 5 }" ,
a [i ] ) ;
1. Adott egy 10 elemű számsorozat. Rendezzük a számokat növekvő sorrendbe,
majd kérjünk be egyenként további számokat, és döntsük el róluk megtalálha-
. tóak-e az eredeti 10 szám között! Amennyiben van ilyen szám, mondja meg
hogy hányadik, különben írja ki, hogy nincs. Az új számokat addig kérje be,
míg egymás után kétszer 0-át adunk meg.
2. Az iskolában egyéni és összetett versenyt tartottak. A versenyben összesen
20 tanuló vett részt. A versenyek száma 8. Ismerjük versenyenként a diák nevét
és pontszámát. Összetett versenybe csak az indulhat, aki az összes egyéni ver
senyben indult, és elérte a versenyenként megadott minimális pontszámot.
a. Adjuk meg az egyéni versenyek rangsorát!
b. Adjuk meg az összetett versenyben értékelendő tanulók számát!
R endezés
75
c. Adjuk meg az összetett versenyben értékelendő tanulók nevét!

d. Adjuk meg az összetett verseny rangsorát!
e. Adjuk meg versenyenként a tanulók névsorát!
f. Adjuk meg azok nevét, akik csak 1 versenyen indultak!
g. Adjuk meg azon tanulók névsorát, akik valamilyen versenyen indultak és
elérték a versenyenkénti minimális pontszámot!
h. Adjuk meg azon tanulók névsorát, akik valamilyen versenyen indultak és
nem érték el a verseny enkénti minimális pontszámot!
i. Adjuk meg a versenyenként első 3 helyezettet!
j. Döntsük el, hogy az összetett verseny győztese, minden számban győztes
volt-e!
k. Döntsük el, hogy volt e valamelyik versenyben holtverseny!
l. Döntsük el, hogy az összetett verseny győztese holtversenyben győzött-e!
m. Állapítsuk meg hogy volt-e olyan tanuló, aki minden versenyen elindult, de
nem érte el a minimális pontszámot!
3. írjunk programot, amely mértékegységeket kezel! A program a standard beme
netről sorokat olvas be, amelyekben tömegmennyiségek vannak megadva kü
lönböző mértékegységben. A program írja a szabványos outputra ezek összegét
grammban, majd a következő sorba ugyanezt tonna, mázsa, kilogramm, deka
gramm, gramm formában! Mindig a lehető legnagyobb mértékegységgel legye
nek a mennyiségek kifejezve! A bemeneti sorok mindig egy nem negatív egész
számból (mennyiség) és egy karakterből (t - tonna, m - mázsa, k - kilogramm,
d - dekagramm, g - gramm) állnak, ezeket egy szóköz választja el egymástól.
A bemenet végét a ”0 0\n” tartalmú sor jelzi. A bemenetről érkező sorok közül
több is tartalmazhatja ugyanazt a mértékegységet, és a mértékegységek sor
rendje is tetszőleges. A program azokat a mértékegységeket is írja ki, amelyek
hez 0 mennyiség tartozik! A mértékegység nem maradhat le: az összegnél egy
szóközzel elválasztva a ’’gramm” szót, a felbontásnál pedig szintén egy szóköz
zel elválasztva a mértékegység betűjelét is ki kell írni!
Példa:
bemenet kimenet
1k 3000 gramm
2k Ot
00 Om
3k
Od
0g
76
4. ALPROGRAMOK ÉS FÁJLKEZELÉS
Az első program megírása előtt egy fontos szabály betartására hívtuk fel a figyel
met: Mindig csak a
static void M ain(string[] args)
zárójelei közé írjunk.

Most eljött az ideje annak, hogy ezen változtassunk. A using után azokat a rend
szereket (névtereket) soroljuk fel, amelyek a program elkészítéséhez szükségesek.
Ilyen a using System.Text; is, amely a szöveggel kapcsolatos osztályokat tartal
mazza. Az IO (Input-Output) osztályok pedig a System.IO névtérben vannak.
Ezt követően a programban a namespace után a program neve szerepel, majd a
eláss Program a Program nevű osztály kezdetét jelzi, amelyben a static void
Main(string[] args) után, a már ismert részben írhatjuk meg a főprogramot.
De ha van főprogram, akkor lenni kell alprogramnak is. A C# a programozási nyel
vek többségéhez hasonlóan engedi ezek használatát.
Az alprogram lehet eljárás, vagy függvény.
4.1. Eljárások
Ha hosszú programot kell írnunk, érdemes a programot részekre tagolni, így átte
kinthetőbb lesz a munkánk, nem kell mindent a main után bezsúfolni. A program
több pontjáról is hivatkozhatunk egy eljárásra, így azt elég egyszer megírni.
Amikor pl. számokat állítunk elő véletlenszerűen, majd kiíratjuk a képernyőre
később rendezve is szeretnénk kiírni, akkor a kiíratást célszerű eljárásban megírni,
és hivatkozni rá mindkét esetben. Az eljárások részfeladatokat láthatnak el: kiírást,
rendezést, keresést stb. Az eljárásra a programban a nevével hivatkozhatunk, amely
után () -eket kell tenni. A zárójelek között lehetnek paraméterek.
E ljárások
77
Az eljárásnak van
• neve (ez egy azonosító),
• visszatérési értéke, amely csak void lehet,
• törzse, amely tartalmazza az utasításokat,
• és lehetnek paraméterei.
Az eljárást a static void Main(string[] args) elé vagy után is tehetjük.
Például:
static void eljarasNev()
{
U tasitások
}

{
U tasitások
}
Az eljárások tehát mindegy milyen sorrendben követik egymást, csak az a fontos,
hogy ugyanabba az osztályba (eláss) kerüljenek. Sőt nem csak a főprogramnak
lehet alprogramja (eljárása), hanem eljárásnak is lehet eljárása. Ha tehát a főprog
ramra úgy tekintünk mint egy szülőre, akkor az általa használt eljárások vagy
függvények az ő gyerekei, ezen alprogramok által használt eljárások, függvények
pedig már a főprogram unokái. Természetesen ezek a mélységükben tagozódó el
járások (függvények) továbbfokozhatók, de a mi programjainkhoz legfeljebb
„unoka” szintű alprogramokra van szükség.
A változó használata viszont bonyolultabbá válik, mivel az eljárások nem ismerik
egymás vagy a főprogram változóit. A változók hatásköre csak az őket tartalmazó
eljárásra vonatkozik. Ha azt szeretnénk, hogy egy változót minden eljárás ismer
jen, akkor közvetlenül az adott osztály megnevezése után deklaráljuk és írjuk a
típus elé: static
eláss Program
{
static i n t a=0;
static v o i d M a i n ( s t r i n g [] args)
{
U tasitások
E l j á r á s ();
}
A lprogramok és fájlkezelés
78
static void E l j á r á s ()
{
a=10;
Az eljárások alkalmazása során megismerkedünk a dátum típussal is.
34. feladat:
Kérjük be a legközelebbi születésnap dátumát (év, hó, nap), majd írjuk ki, hogy
hány nap van még a születésnapig és az év végéig! Használjunk eljárásokat az
adatbekéréshez és a kiíratáshoz!
Név: napok
Megoldás:
namespace napok
{
class Program
{
static DateTime evVege, szulN ap;
static i n t ev, ho, nap;
static v o i d a d a t b e k e r e s ()
{
C o n s o l e . W r i t e (" é v
ev = C o n v e r t . T o I n t 3 2 (C o n so le . R e a d L in e ( ) ) ;
C o n s o l e . W r i t e (" h ó n a p : " ) ;
ho = C o n v e r t . T o I n t 3 2 ( C o n s o l e . R e a d L i n e ( ) ) ;
C o n s o l e . W r i t e (" n a p : " ) ;
nap = C o n v e r t . T o I n t 3 2 ( C o n s o l e . R e a d L i n e ( ) ) ;
}
static void kiiratas()
{
D a t e T i m e m a i D a t u m = D a t e T i m e . Now;
e v V e g e = new D a t e T i m e ( 2 0 1 7 , 12, 3 1 ) ;
C o n s o l e . W r i t e L i n e (" A m a i d á t u m é s i d ő :
{0 }" , m a i D a t u m ) ;
C o n s o l e . W r i t e L i n e (" Év v é g é i g {0} n a p v a n
m ég", e v V eg e. S u b t r a c t (m aiDatum). Days);
C o n s o l e . W r i t e L i n e (" A s z ü l i n a p i g {0} n a p v a n
még", szu lN a p . S u b t r a c t (maiDatum). D ays);
E ljárások
79
}
{
C o n s o l e . W r i t e L i n e (" K é r e m a l e g k ö z e l e b b i szüli-
nap dátumát ");
a d a t b e k e r e s ();
s z u l n a p = new D a t e T i m e ( e v , h o , n a p ) ;
k i i r a t a s ();
}
}
}
Azokat a változókat, amelyeket az eljárásokban is szeretnénk használni, már köz
vetlenül a eláss után deklaráltuk. Az evVege és a szulNap két dátum típusú válto
zó, amelyet a programban bárhol használhatunk.
A szulnap = new DateTime(ev, ho, nap); segítségével létrehoztuk a változó egy
konkrét példányát.
A maiDatum változót csak a kiiratas eljárásban használjuk, ezért itt deklaráltuk, de
megtehettük volna program elején is. A DateTime maiDatum = DateTime.Now; dek
larálja a maiDatum nevű változót, és kezdőértékként beállítja a mai nap dátumát a
now-val. Az év végének konkrét értéket adunk meg (ha már nem 2017-et írunk, ak
kor azt értelemszerűen lehet változtatni), majd az ewege.Subtract(maiDatum).Days
kifejezéssel megadja a maiDatum és az evVege közti különbséget napokban. Két
dátum között eltelt időt számolhatunk órákban (Hours), percekben (Minutes), má
sodpercekben (Seconds), sőt akár ezredmásodpercekben (Milliseconds) is, ha a
Days helyett a zárójelben lévő utasítások valamelyikét írjuk.
35. feladat:
Kérjünk születési dátumot (órára pontosan) majd számoljuk és írjuk ki, hogy hány
napos és hány órás az illető! A kiírásnál használjuk a könnyebb olvashatóság miatt
a hármas tagolást (ezres csoportosítást)!
Név: szülinap
Megoldás:
namespace szülinap
{
eláss Program
{
static int i 0;
80
static s t r i n g szöveg = szovegl =

static void fo rd it()
{
sl =
f o r ( i = s z ö v e g . L e n g t h - 1; i >= 0 ; i — )
s z o v e g l = s z o v e g l + C o n v e r t . T o S t r i n g ( s z ö v e g [ i ] );
szöveg = szovegl;
}
static void s z o k o z ()
{
s z o v e g l = " M;
f o r (i = 0 ; i < s z ö v e g .Length; i++)
{
szovegl = szovegl + C o n v e r t . T o S t r i n g ( s z ö v e g [ i ] );
i f ( ( i + 1) % 3 == 0) s z o v e g l = s z o v e g l + " " ;
static void v i s s z a F o r d i t K i i r ()
{
f o r (i = s l . Length - 1; i >= 0 ; i— ) Console.
W rite(sl [ i ] ) ;
}
{
D a t e T i m e s z u l N a p = new D a t e T i m e ( ) ;
i n t e v , h o , n a p , o r a , p e r c , mp, o r a s z a m ;
C o n s o l e . W r i t e (" K é r e m a s z ü l e t é s i é v e t : " ) ;
ev = C o n v e r t . ToI n t 3 2 ( C o n s o l e . R e a d L i n e ( ) ) ;
C o n s o l e . W r i t e (" K é r e m a h ó n a p o t : " ) ;
ho = C o n v e r t . T o I n t 3 2 ( C o n s o l e . R e a d L i n e ( ) ) ;
C o n s o l e . W r i t e ( 11 K é r e m a n a p o t : " ) ;
nap = C o n v e r t . T o I n t3 2 ( C o n s o le .R e a d L in e ( ) ) ;
C o n s o l e . W r i t e (" K é r e m a z ó r á t : " ) ;
ora = C onvert.ToInt32(C onsole.ReadLine());
p e r c = 0;
mp = 0 ;
s z u l N a p = ne w D a t e T i m e ( e v , h o , n a p , o r a , p e r c , mp);
s z ö v e g = C o n v e r t . T o S t r i n g ( D a t e T i m e . Now.
Subtract(szulN ap).D ays);
f o r d i t ();
s z o k o z ();
E ljárások
81
C o n s o l e . W r i t e (" E n n y i n a p o s v a g y : " ) ;
v i s s z a F o r d i t K i i r () ;
oraSzam = C o n v e r t . T o I n t 3 2 (M ath.Round(DateTime.
N o w .S u b tr a c t( s z u l n a p ) . T o ta lH o u rs ));
szöveg = C o n v ert.T oS tring(oraszam );
f o r d i t ();
szokoz ();
C o n s o l e . W r i t e (" E n n y i ó r á s v a g y : " ) ;
v i s s z a F o r d i t K i i r ();
C o n so le.ReadKey();
}
A főprogramban elvégeztük az adatbekérést, de a percet és másodpercet 0-nak
vesszük, mivel nem valószínű, hogy valaki tudja ilyen pontossággal a születési
idejét. Dátum típust viszont vagy napra, vagy másodpercre pontosan lehet csak
használni a C#-ban, tehát ha az órákat is tudni akarjuk pontosan, akkor fel kell
venni a perceket és másodperceket is.
Az szöveg = Convert.ToString(DateTime.Now.Subtract(szulNap) sorban
szöveggé alakítjuk a jelenlegi időpont (DaíeTime.Now) és a születés (szulNap)
között eltelt időt napokban számolva.
A program nehezebb része azonban a kiíratás tagolásában rejlik. Több módszer
közül választhatunk. Az egyik a programban látható: először megfordítjuk az s
sztringet és hátulról, azaz jobbról balra haladva egy ciklusban minden 3. karakter
után beillesztünk egy szóközt. A fordit eljárásban az szovegl-be kerül a szöveg
szöveg fordítottja, a szokoz eljárásban pedig beillesztjük a megfelelő helyekre a
szóközöket. A visszaForditKiir eljárásban pedig az szovegl-et írjuk ki fordítva,
most már szóközökkel a megfelelő helyeken.
A 3 eljárást kétszer is meg kell hívni, mivel a napok és az órák esetén is ugyanazt
a problémát kell megoldani a kiírásnál.
Eddig csak olyan eljárásokkal foglalkoztunk, amelyeknek nem voltak paraméterei,
ha viszont az eljárás kimenő adatokat is előállít, akkor szüksége van bemenő ada
tokra, paraméterekre is. Vannak tehát olyan esetek, amikor szükség van az eljárás
és a főprogram, vagy az eljárások között paraméterek, adatok átadására. Ilyenkor
a főprogramban az eljárás neve után zárójelben meg kell adni azoknak a változók
nak a nevét vesszővel elválasztva, amelyeket paraméterként akarunk átadni. Az
eljárásban pedig az eljárás neve után, az eljárás „fejrészében” zárójelben megadjuk
a változók típusát és nevét.
82
Pl.: formális paraméterlista
static void eljaras(int a,int b)

{
Eljárás törzse, ahol a-t és b-t használjuk.
}
{
A főprogram, ahonnan az eljárást meghívjuk.
eljaras(a,b);
i ^
aktuális paraméterlista
Az eljárásban használt a és b egész típusú változóknak az eljáráson belül más nevet is

adhatunk, nem kell megtartani a foprogramban használt neveket. Az eljárásban, alprog-
ramban szereplő változók listáját formális paraméterlistának nevezzük. Az eljárás
meghívásának helyén felsorolt változókat pedig aktuális paraméterlistának nevezzük.
Fontos szabály, hogy aktuális és a formális paraméterlistában ugyanannyi adat le
gyen, tehát annyi adatot adjunk át az eljárásnak, amennyit az vár. Továbbá az átadott
adatok típusainak is meg kell egyezni. Illetve az automatikus típuskonverzió miatt az
alprogramnak átadott egész típust valósként használhatjuk az alprogram törzsében.
C#-ban, akár tömböt is átadhatunk paraméterként.
36. feladat:
Jók-e az alábbi paraméterlisták:
Aktuális paraméterlista Formális paraméterlista Jó Nem jó
int a = 0, f = 0; (a, f) (int d, int b)
int x = 0; double y = 0; (x, y) (int x, int y)
string a = ” ” ; int y = 0; (a, y) (string név, int y)
char k = ’ ’ ; bool v = true; (k, v) (string k, bool v)
double x = 0; byte y = 0; (x, y) (int x, byte y)
string x = ” double y = 0; (x, y) (char x, double y)
int x = 0; string szó = 0; (x, szó) (int a, string szöveg)
bool x = 0; double y = 0; (x, y) (bool x, double z)
E ljárások
83
Paraméterátadás:
C#-ban a paraméter átadása kétféle módon történhet.
1. Referencia szerint
2. Érték szerint
A kulcsszó dönti el, hogy melyik alapján történik a paraméterátadás.
Érték szerinti paraméter átadás:
Érték szerinti átadásnál valójában csak az eredeti változó egy másolatát adjuk át.
Ilyenkor mindent érték szerint adunk át, ezért nincs kulcsszó.
Pl.: eljaras(a,b);
Referencia szerinti paraméter átadás:
Referencia szerinti átadásnál a ref vagy az out kulcsszót kell használnunk.
Ekkor a ref kulcsszót kell a változó neve előtt megadni, ill. az alprogram fejrészé
ben a változó típusa és neve előtt.
Ebben az esetben változókat átadhatunk úgy is az alprogramnak, hogy később az
itt kiszámolt (előállított) értékeket a főprogramban is tudjuk majd használni.
37. feladat:
Számolja ki egy henger felszínét és térfogatát, majd írja ki a képernyőre 3 tizedes
pontossággal! A kör területét és kerületét eljárásban számítsa ki, majd adja vissza
a kiszámolt értékeket a főprogramnak!
Név: Henger
Megoldás:
namespace Henger
{
eláss Program
{
s t a t i c void kor(double r, r e f double t, ref double
k) / / ( o u t d o u b l e t , o u t d o u b l e k)
{
II k = 0;
// t = 0;
t=r*r*M ath.P l;
k =2 * r *M a t h . P I ;
}
84
d o u b l e r = 0, m = 0 , V = 0, A = 0 , t = 0 , k
= 0; IIt , k ;
C o n s o le .W r i te ( " K é r e m az a l a p s u g a r á t : " ) ;
r= C onvert.ToDouble(Console.R eadLine());
C o n s o l e . W r i t e ("Kérem a m a g a s s á g o t : " ) ;
m = C o n v e r t . T o D o u b l e ( C o n s o l e . R e a d L i n e ()) ;
kor(r, ref t, ref k ); / / kor(r, out t, out k );
V = t * m;
A= 2 * t + k * m ;
C o n s o l e . W r i t e L i n e (" A h e n g e r t é r f o g a t a :
{0:0.000}",V);
C o n s o l e . W r i t e L i n e (" A h e n g e r f e l s z í n e :
{0:0.000}", A );
Mint látható, a kör kerületét és területét a főprogramban deklaráltuk, ott adtunk

kezdőértéket k-nak és /-nek. A kor nevű eljárás meghívásakor átadjuk a sugá
azt nem hozzuk vissza a föprogramba, ezért nem kell elé a ref kulcsszó. A program
akkor is helyesen működne, ha a ref helyett az out szerepelne minden esetben, és
az eljárás elején adnánk kezdőértéket ¿-nak és /-nek. Ebben az esetben a főprogram
elején nem kell - de lehet - kezdőértéket adni a kerületnek és a területnek. Ez annyi
ban lenne más, hogy az out-tal jeleznénk: csak kimenő értékkel rendelke
zik, és a bemenő értéke lényegtelen. Ha az out-os módot választjuk, akkor a prog
ram megfelelő soraiban a // jel utáni részt kell értelemszerűen behelyettesíteni.
4.2. Függvények
A függvények olyan alprogramok, amelyek nagyon hasonlítanak az eljárásokra, de

van egy nagyon fontos, lényeges különbség.
A függvény definiálása során legyünk tekintettel a tiszta kód szabályaira.
Célszerű a metódusok (függvények) definiálásánál figyelembe venni az alábbi
ajánlásokat:
• minél kevesebb argumentumot tartalmazzon
• lehetőleg legyen rövid
F üggvények
85
• jól elkülönülő részekből álljon

• a sorok legyenek rövidek
• csak egy dolgot csináljon
• lépésenkénti haladás
• követhető legyen szerkezet
• minél kevesebb behúzási szint legyen benne
A függvény minden esetben előállít egy értéket, és ezzel az értékkel tér vissza a
főprogramba. Ezért mindig meg kell adni a függvény neve előtt a visszatérési érték
típusát. Ezt a void helyett kell beírni a fejrészbe. A visszatérési értékkel rendelkező
változó elé pedig, a return kulcsszót kell írni. Ha viszont egy alprogramban több
értéket szeretnénk előállítani, akkor a függvényt nem használhatjuk, mivel az csak
egy értéket képes előállítani, és az lesz a visszatérési értéke.
Mint azt már korábban említettük, az alprogramokat - melyek lehetnek eljárások
vagy függvények - a föprogram vagy más alprogram hívja meg, de egy eljárás
vagy függvény meghívhat további eljárásokat vagy függvényeket is.
38. feladat:
Állítson elő 8 egész számot a [0 ; 100]-ban, és írja ki őket egy sorba! Egy függvény
segítségével számolja ki a számok átlagát és írja ki 2 tizedes pontossággal!
Név: Átlag
Megoldás:
namespace Átlag
{
eláss Program
{
static i n t i = 0;
static d o u b l e a t l a g F u g g v e n y ( i n t [] a)
{
d o u b l e ö s s z e g = 0 , a t l a g = 0;
f ó r ( i = 0; i < 8; i + +) ö s s z e g = ö s s z e g + a[i];
a tla g = C o n v ert. ToDouble(összeg / i ) ;
return atlag;
}
s ta tic v o id M a i n ( s t r i n g [] args)
{
i n t [] a = n e w i n t [ 8 ] ;
Random s z a m o k = new R a n d o m ( ) ;
fór (i = 0; i < 8; i++)

{
a [i ] = szamok.Next(101);
Console .Write (” {0 }" ,a [i ]) ;
}
Console.WriteLine ();
Console.WriteLine (” A tömb elemeinek átlaga:
{0:0.00}”, atlagFuggveny(a));
Console.ReadKey();
}
A függvény az a tömböt kapja meg paraméterként, és az aílag értékével tér vissza

a függvényhívás helyére. A függvény értékének típusa double, ezért az atlag válto
zó típusának is ilyennek kell lenni. Mivel az i egész típusú, ezért az összeg/i (valós
/ egész) csak akkor lesz valós, ha a ConvertToDouble segítségével azzá tesszük.
39. feladat:
Kérje be egy másodfokú egyenlet együtthatóit, és számolja ki a [-6 , 6]-bán az
egész x értékekhez tartozó függvényértékeket és írja ki a képernyőre egy sorba az
x értékeit és alá a megfelelő y értékeket!
Az együtthatók értéke a [-5 , 5]-bán legyen! Használjon függvényeket az adatbe
kéréshez és a függvényérték számításához!
Név: Függvényérték
Megoldás:
namespace Függvényérték
{
eláss Program
{
static double függvény (double a, double b, double c,
double x)
{
double y = 0;
y = a * x * x + b * x + c;
return y;
}
sta tic void M ain (strin g[] args)
{
double a = 0, b = 0, c = 0;
F üggvények
87
int x=0;
Console.Write (" Kérem az a értékét: ");
a = b e k e r ();
Console .Write (11 Kérem az b értékét: ");
b = b e k e r ();
Console.Write (" Kérem az c értékét: ");
c = b e k e r ();
for (x = -6; x < 7; x++) Console.W r i t e ("{0,5}",x ) ;
for (x = -6; x < 7; x++) Console .Write ("{ 0,5 }",
függvény(a, b, c, x ) );
Console.ReadKey();
}
static double b e k e r ()
double adat = 0;
do {
adat = Convert.ToDouble(Console.ReadLine()) ;
} while (adat>5 || adat<-5);
return adat;
Az adatbekérést a beker függvény segítségével végeztük el, ahol egy hátultesztelő

ciklussal csak a helyes értéket fogadjuk el. A függvényérték kiszámítása a valós
típusú függvény függvénnyel történik, ahová az együtthatók és az x értéke paramé
terként kerül át.
A függvény visszatérési értéke pedig az y ,amelyne
sal írjuk ki. Mint látható a függvényekre is érvényes: mindegy, hogy a főprogram
elé vagy után helyezzük el az alprogramokat. Ennél a feladatnál a program futtatá
sa során célszerű, ha egész értékeket adunk meg az együtthatóknak a kiíratás miatt.
1. írjunk olyan függvényt, amely egy gömb térfogatát számolja ki!
2. Készítsünk függvényeket, amelyek téglalap területét és kerületét számítják ki!
3. Készítsünk olyan függvényt, amely egy szám négyzetét, köbét, és negyedik
hatványát adja vissza!
4. Készítsünk függvényt, amely eldönti, hogy a paramétere páros vagy páratlan
természetes szám!
88
5. írjunk olyan programot, amely bekér egy mondatot, és kiírja úgy, hogy minden
szavának kezdőbetűjét nagybetűvé alakítja!
6. írjunk olyan programot, amely bekér egy mondatot, és kiírja minden második
karakterét!
7. Készítsünk olyan programot, amely bekér egy karaktersorozatot, és minden
karakterét megduplázza!
8. írjunk olyan programot, amely bekér egy karaktersorozatot, és ha a hossza
páratlan, akkor írja ki a középső karakterét, ha páros, akkor írja ki a karakter-
sorozatunk első felét!
9. Kérjünk be egy karaktersorozatot a billentyűzetről és írjunk olyan függvényt,
amely megszámolja és kiírja a előforduló ‘e’ és ‘i’ betűk számát!
10. Kérjünk be egy karaktersorozatot a billentyűzetről, és írassuk ki magánhang
zók nélkül egy függvény segítségével!
11. írjunk olyan programot, amely bekér egy karaktersorozatot, és írassuk ki any-
nyiszor, ahány ‘a’ betű van benne!
12. írjunk olyan programot, amely bekér egy karaktersorozatot, és kiíratja az első
előforduló ”sz” karaktersorozattól kezdődően!
4.3. Fájlkezelés
Ha figyelmesen végignézzük az eddig megírt programokat, akkor észrevehetőnk

egy nagyon lényeges, közös tulajdonságot: a program futása után, de legkésőbb a
számítógép kikapcsolásakor minden adat, érték, tevékenység, amelyet a program
előállított vagy elvégzett, megszűnik létezni. Ami történt, az csak a memóriában
jött létre. Ha nem nyomtatjuk ki az eredményt, vagy nem tároljuk háttértárolón,
akkor nincs maradandó nyoma annak, amit csináltunk.
Ezért sok esetben szükség lehet és van is, az előállított adatok tárolására háttértá
rolón. Ezt az állománykezelő (fájlkezelő) utasítások teszik lehetővé.
C#-ban ehhez az 10 (Input/Output) osztályokra van szükségünk, amelyeket a using
System.IO segítségével érhetünk el.
Egy szöveg típusú változóban tároljuk a háttértárolón megjelenő fizikai fájl nevét.
A létrehozott fájlt a megadott néven találjuk meg a háttértárolón. Ha nem adunk
meg elérési utat, akkor azt a Project könyvtárban az aktuális program bin/debug
könyvtárában találjuk meg.
Fájlkezelés
89
Pl.: string fízikaiFajlNev = ’’fajl.txt”;

A fizikai fájl nevét azonban nem fogjuk használni a programban, helyette egy lo
gikai fájlnévvel fogunk dolgozni. Ehhez először létrehozzuk az üres logikai fájlt.
Pl.: StreamWriter logikaiFajl = null;
A két fájlt még össze kell rendelni:
Pl.: logikaifaji = new StreamWriter(fízikaiFajlNev);
4.3.1. Hibakezelés
Mielőtt megírnánk az első fájlkezelő programot meg kell említeni a C# hibakezelő

(kivételkezelő) eszközrendszerét. A nyelv ennek segítségével a program futás közbe
ni hibáit szűri ki. A kivételkezelő eljárásokkal tehát a futás közben megjelenő hiba
üzeneteket kerüljük el, így védve a programunkat a váratlan „lefagyástól”, leállástól.
Az I/O műveletek során is szükség van ilyen kivételkezelő használatára, mivel
előfordulhat olyan hardverhiba, ami miatt nem tudunk a háttértárolóra írni, vagy
onnan olvasni.
A C#-ban a try utasítással a program megfelelő részeihez hibakezelő eljárásokat
írhatunk, amelyek megakadályozzák a program leállását.
A catch paranccsal pedig „elkapjuk” azokat a kivételeket, hibákat, amelyek a try
programrészben jöttek létre. Itt adhatjuk meg, hogy milyen hibakezelő eljárások
fussanak le, és hogyan kezeljék a fellépő hibákat.
40. feladat:
Állítsunk elő véletlenszerűen 5 egész számot a [0,100]-ból, majd írjuk ki a számo
kat a képernyőre és a háttértárolóra a program BIN/DEBUG könyvtárába!
Név: Fájlbaír
Megoldás:
u s i n g System;
using S y ste m .C o lle c tio n s.Generic;
using System.Linq;
u s i n g S y s t e m . 10;
using System.Text;
namespace F á j l b a i r
{
class Program
90

{
string fajlNev = "szamok.txt";
int i = 0;
StreamWriter ir = null;
Console .WriteLine (11 A számok :" );
for (i = 0; i < 5; i++)
{
a[i] = vsz.Next(101);
Console .Write (11{0 ,5 }" , a [i] ) ;
}
try
{
ir = new StreamWriter(fajINev);
for (i = 0; i < 5; i++) ir.Write (" {0,4 }",
a [i ]) ;
ir.Close();
}
catch (IOException)
{
Console.WriteLine(" I/O hiba");
}
Console.ReadKey();
Láthatjuk, hogy a usingok között most már felsoroltuk a I/O műveletekhez szüksé
ges using System.IO-t is.
A string fajlNev = ’’szamok.txt”; sor megadja a háttértárolón megjelenő fájl nevét
és elérési útvonalát. Ha elérési út nincs megadva, akkor a BIN/DEBUG könyvtár
ban jön létre a fájl. Ez lesz a fizikai fájl neve.
A StreamWriter ir = null; sorban megadjuk a logikai fájl nevét és egyben beállít
juk a kezdőértékét, amely egy üres fájl lesz.
Az ir = new StreamWriter(fajlNev); sorban egymáshoz rendeljük a fizikai és lo
gikai fájlokat. Az alatta lévő sorban pedig egy fór ciklussal az ir.Write(”{0,4}”,
a[i]); segítségével kiírjuk a szamok.txt-be a számokat egy sorb
lalva egy számnak.
Az ir.Close(); pedig bezárja az ir logikai fájlt.
Fájlkezelés
91
Mivel a háttértárra írás a try blokkban van, ezért ha a kiírás során hiba lépne fel,
akkor a catch (IOException) segítségével a hibát kezeljük és kiírjuk a képernyőre
a hiba jellegét.
Mint láthatjuk a fájlba írás ugyanúgy történik, mint a képernyőre írás, de itt a
Console helyett a logikai fájl nevét adjuk meg.
A fájlba írás után nézzük meg a fájlból olvasást. Szinte mindent úgy kell csinálni,
mint az írás során, de értelemszerűen a Write vagy WriteLine helyett a Read vagy
ReadLine utasítást használjuk, ill. a StreamWriter helyett a StreamReader segítsé
gével hozzuk létre a logikai fájlunkat.
41. feladat:
Hozzunk létre egy szövegfájlt az alábbi adatokkal, és mentsük a programunk BIN/
DEBUG könyvtárába fajl.txt néven!
Barna Barbara
Kiss István
Nagy Róbert
Pót Csaba
Nagy Evelin
Kovács Virág
írjunk programot, amely beolvassa az adatokat egy 6 elemű szövegtömbbe soron

ként és kiírja a képernyőre!
Név: Beolvas
Megoldás:
u s i n g System;
usin g System.Linq;
usin g System.Text;
namespace Beolvas
{
e l á s s Program
{
sta tic void M a i n ( s t r i n g [] args)
{
S t r e a m R e a d e r o l v a s = new S t r e a m R e a d e r ( " f a j 1.
tx t");
s t r i n g [] n é v = n e w s t r i n g [ 6 ] ;
92
i n t i = 0;
C o n s o l e . W r i t e L i n e (" Név");
try
{
f ó r ( i = 0 ; i < 6; i++)
{
n e v [ i] = o l v a s . ReadLine ();
C o n s o le .W r i te L i n e ( n é v [ i ] );
}
o l v a s . C l o s e ();
}
catch (IO E xception)
{
C o n s o l e . W r i t e L i n e (" I/O hiba");
}
Az olvas logikai fájlt összerendeljük a fajl.txt fizikaival, majd a ciklusban beol

vassuk a név tömbbe az adatokat soronként, és kiírjuk a képernyőre. A beolvasása
után lezárjuk a fájlt a Close utasítással.
42. feladat:
Kérjünk be 6 nevet és a hozzátartozó átlagot, majd írjuk ki a háttértárolóra a prog
ramunk BIN/DEBUG könyvtárába nevatlag.txt néven! A nevek két részből állja
nak, az átlagok 2 tizedes pontossággal legyenek megadva! A név és a hozzátartozó
átlag egy sorban legyen! A sorokat tömbben tároljuk!
Név: Névátlag
Megoldás:
u s in g System;
using System.Linq;
using System.Text;
namespace N ev atlag
{
eláss Program
{
Fájlkezelés
93

{
s trin g fajlN ev = " n e v a tla g .tx t" ;
s t r i n g név =
s t r i n g [] a = n e w s t r i n g [ 6 ] ;
i n t i = 0;
d o u b l e a t l a g = 0;
Stream W riter k i i r = n u ll;
f ó r ( i = 0 ; i < 6; i + + )
{
C o n s o l e . W r i t e (" Kérem a n e v e t
nev=C onsole.R eadL ine();
C o n s o l e . W r i t e (" Kérem az á t l a g o t
a tla g = C o n v ert.ToDouble(Console.ReadLine());
a [ i ] = név + " " + a t l a g ;
}
try
{
k i i r = new S t r e a m W r i t e r ( f a j I N e v ) ;
f ó r ( i = 0 ; i < 6; i + + ) k i i r . W r i t e L i n e ( a [ i ] ) ;
k i i r . C lose ();
}
catch (IOException)
{
}
}
Az adatbekérés során az aktuális nevet és átlagot egy szóközzel választottuk el, ki
használva a szöveg típusú változóknál alkalmazható + operátort. Ezt követően már
csak ki kellett írni az a[i]-t, mint szöveget egy fór ciklussal a már ismert módon.
43. feladat:
Másoljuk az előző feladatban létrehozott nevatlag.txt fájlt a programunk BIN/
DEBUG könyvtárába! Olvassuk be az adatokat, és írjuk ki a képernyőre!
Számoljuk ki az átlagok átlagát és írjuk ki a képernyőre a következő szöveg után:
„A csoport átlaga:”
94
Név: Nevatlagbeolvas
Megoldás:
using System;
using System .C o l le c t i o n s .Generic;
using S ystem .Linq;
using S y s t e m . 10;
using System .Text;
namespace N évétlagbeolvas
{
class Program
{
{
StreamReader olvas = new S t r e a m R e a d e r ( " n e v a t l a g .
t x t M) ;
s t r i n g [] nev = new s t r i n g [ 6 ] ;
string a t l a g S t r i n g = " ", szoveg=" " ;
int i = 0 , j = 0 , d b = 0;
double atlag = 0, összeg = 0;
C o n s o l e . W r i t e L i n e ( fl Név átlag") ;
try
{
for (i = 0; i < 6; i++)
{
nev[i] = o l v a s .R e a d L in e ();
C o n s o le .W r i te L i n e ( n e v [ i ] );
}
o l v a s . C l o s e ();
}
catch (I O E x c e p tio n )
{
}
for (i = 0; i < 6; i++)
{
szöveg = nev[i];
Fájlkezelés
95
for (j = 0; j < szö v e g . Length; j++)

{
if (szoveg[j] = = ' ') db++;
i f ( d b = = 2) a t l a g S t r i n g = a t l a g S t r i n g +
C o n v e r t . T o S t r i n g ( s z ö v e g [j ] ) ;
}
atlag = C onvert.ToD ouble(atlagString) ;
összeg = összeg + atlag;
db = 0; atlagString =
}
C o n s o l e . W r i t e L i n e (" A csoport átlaga:
{ 0 :0 .0 0 } " ,ö s s z e g / 6);
A név egy szövegtömb típusú változó, ebbe olvassuk be a háttértárolóról a sorokat.

Minden sorban van azonban egy vezetéknév, egy keresztnév és egy átlag, amelye
ket szóköz választ el egymástól. Ezért a beolvasás után egy külső ciklusban soron
ként megvizsgáljuk a szöveget és megkeressük a belső j ciklussal a szóközöket.
Erre azért van szükség, mert a szöveg típusú változóból, azaz a sorból a második
szóköz után szeretnénk leválasztani az átlagokat, és számmá konvertálni, mert csak
így számolhatunk később átlagot.
Ezt minden sorban elvégezzük és képezzük az összeget, majd nullázzuk a szókö
zök darabszámát (db)és az átlagot, mint szöveget (atlagString).
A fájlok írása, olvasása mellett gyakori probléma a már létező fájlok bővítése. Ezt
a FileSream utasítás után adhatjuk meg. Ekkor a zárójelben nem csak a fájl nevét
(és elérési útvonalát) adjuk meg, hanem azt is, hogy mit szeretnénk az állomány
nyal. A fájlnévtől vesszővel elválasztva a FileMode.Append paranccsal hozzáfűz
hetünk a már meglévő állományunkhoz újabb adatokat. Ekkor a fájlba újabb ada
tokat írhatunk a meglévők után, mivel a rendszer automatikusan az Appenddel
megnyitott fájl végére áll.
44. feladat:
Másoljuk a 41-es feladatban létrehozott nevatlag.txt fájlt a programunk BIN/
DEBUG könyvtárába! A meglévő adatokhoz írjunk még újabbakat! Az adatbevitel
ENTER végjeiig tartson!
96
Név: Hozzáfűz
Megoldás:
using System;
using System.10;
namespace Hozzáfűz
{
class Program
{
static public void Main()
{
FileStream adatok = new FileStream("nevatlag.
txt", FileMode.Append);
StreamWriter iras = new StreamWriter(adatok) ;
string név = " 11;
string[] a = new string[100];
double atlag = 0;
int i = 0;
try
{
while (név != "")
{
Console.Write(" Kérem a nevet :”);
név = Console.ReadLine();
if (név != "")
{
Console.W r i t e (” Kérem az átlagot :");
atlag = Convert.ToDouble(Console.ReadLine());
a[i] = név + " " + atlag;
iras.WriteLine(a[i]);
}
}
iras.Close ();
Fájlkezelés
97
catch (IOException)
{
Console.WriteLine(" I/O hiba");
}
iras.Close();
adatok.Close();
Console.WriteLine("Az adatokat kiírtam
a háttértárolóra!");
Console.ReadKey();
}
}
Fontos megemlíteni, hogy a névváltozó deklarációjánál az
nem a „semmit” adtuk meg kezdőértéknek, hanem egy szóközt. Erre azért volt
szükség, mert az előltesztelő ciklusba csak akkor tudunk belépni, ha a név értéke
nem „semmi”. Amíg a név valamilyen értéket kap, addig a ciklusban marad a ve
zérlés és bekérjük a nevet és az átlagot. Ha az adatbevitelkor a név megadásánál
csak entert ütünk, akkor a név értéke nullérték lesz, tehát befejeztük az adatbevitelt,
akkor az átlagot már nem kell bekérni, a ciklust elhagyhatjuk.
98
5. ÖSSZETETT ADATSZERKEZETEK
5.1. Stringek
A string típusú változók néhány tulajdonságát már megismerhettük a mobilszám

ellenőrző programban. A C#-ban, mint objektumorientált nyelvben a string nem
csak típus, hanem osztály is. Az egy típusba tartozó változókat, a hozzájuk tartozó
műveleteket és operátorokat osztálynak nevezzük.
A string osztályhoz tartozó műveletek közül már ismerünk kettőt a fent említett
programból:
Szöveghossz meghatározása
A szam.Lengthmegadta a szám string hosszát a pedig a szöveg
1. karakterért.
Összeadás
Fontos megemlíteni, hogy az összeadás művelet értelmezhető stringeken, de ered
ménye nem azonos a számtípusoknál megismerttel. Itt a szövegeket egymás után
fűzi a + operátor.
Pl.: ” objektum”+” orientált”= ” objektumorientált” , ami talán nem meglepő, de
számokból álló stringek esetén már érdekesebb, mert:” 77” +” 23”= ” 7723” lesz.
Összehasonlítás
A stringek 1 karakterére értelmezhető a < és a > jel ebben a formában:
szoveg[4]>szoveg[ 1]
A teljes stringre viszont csak az = = , vagy != relációs jelek értelmezhetők.
Természetesen a C# nem lenne magasszintű programozási nyelv, ha ilyen hiányos
ságban szenvedne.
Mint a 32. feladat előtt utaltunk rá a CompareTo segítségével a teljes stringre is
tudjuk alkalmazni a < > relációs jeleket. A következő feladat ezt mutatja be.
S tringek
99
45. feladat:
Kérjünk be két szöveget és írassuk ki a képernyőre az ABC-ben előbb lévőt, majd
alá az ABC-ben hátrébb levőt!
Név: Szövegrendezés
Megoldás:
{
string szovegl, szoveg2;
Consolé.WriteLine(" Kérem az 1. szöveget");
szovegl=Console.ReadLine() ;
Consolé.WriteLine(" Kérem az 2. szöveget");
szoveg2 = Consolé.ReadLine();
Consolé.WriteLine(" ABC sorrendben:");
if (szovegl.CompareTo(szoveg2) > 0)
{
Consolé.WriteLine("1. {0}",szoveg2);
Consolé.WriteLine("2. {0}",szovegl);
else
{
C o n s o l é . W r i t e L i n e ("1, {0}", szovegl);
C o n s o l é . W r i t e L i n e ("2 , {0}", szoveg2);
}
C o n s o l é . R e a d K e y () ;
Két string összehasonlításakor 3 eset lehetséges:

1. Ha szovegl > szoveg2 , vagyis szovegl előbb van az ABC-ben, akkor a
szovegl. CompareTo(s2) =—l
2. Ha szovegl < szoveg2 , vagyis szovegl később van az ABC-ben, akkor a
szovegl .CompareTo(s2)=l
3. Ha szovegl = szoveg2 , akkor a szovegl.CompareTo(szoveg2)=0
További műveletek:
Levágás
A levágás a Trim(), a TrimStart() és a TrimEnd() segítségével jön létre. Ha a
zárójelek közé nem írunk paramétereket, akkor a Trim() levágja a szöveg elejé
ről és végéről, a TrimStart() csak az elejéről, a TrimEnd() csak a végéről a
szóközöket.
Ö sszetett adatszerkezetek
100
Ha szöveg egy string típusú változó, akkor a szöveg. Trim(’b’); levágja a szöveg
elejéről és végéről az összes ’b’ karaktert. A TrimStart(’b’) csak az elejéről, a
TrimEnd(’b’) csak a végéről vágja le az összes ’b’-t.
Átalakítás (kisbetű - nagybetű)

Átalakítani nagybetűkké a ToUpper() kisbetűkké a ToLower() segítségével lehet.
Pl.: Ha szöveg = ’’félév” , akkor a szoveg.ToUpperO; után az szöveg = ’’FÉLÉV” lesz.
Másolás
Egy szövegből tetszőleges részt másolhatunk a Substring(kezd,db) segítségével,
ahol a kezd és a db egész típusú változók és a sztringből a kezd karaktertől db
darab karaktert másolhatunk ki. Ha a zárójelek között csak egy paraméter van,
akkor a kezd értéktől egészen a szöveg végéig másolhatunk ki részsztringet.
Ha sz = ” Paróka” , akkor sz.Substring(2) = ’’róka” . Ne felejtsük el, hogy itt is
0-tól kezdjük a sztring karaktereinek számozását, mint a tömböknél.
Keresés
Az IndexOff) függvénnyel megtudhatjuk, hogy az adott karakter vagy karakterso
rozat szerepel-e a sztringben, és ha igen, hol. Ha benne van, akkor a függvény ér
téke 0 vagy pozitív, ha nincs benne, akkor -1 lesz. Ha a függvény értéke nem -1,
akkor a kapott érték azt mutatja meg, hogy hányadik karaktertől találjuk meg a az
adott karaktersorozatot a szövegben.
Pl.: Ha a szoveg.IndexOf(szo)=3, akkor a szöveg szövegben a szó szó a 4. pozíció
tól található meg. (PL: szoveg=” M á t é s z a 1 k a” és szo=” é s z ” )
46. feladat:
Kérjünk be egy szöveget és egy karaktert majd írjuk ki, hogy a szövegben hányszor
fordul elő a megadott karakter!
Név: Karakterszamlalas
Megoldás:
{
string szöveg ;
char karakter='
int db = 0 , i = 0 ;
Console.W rite("Kérem a szöveget: " );
S tringek
101
szöveg = C o n s o le . ReadLine ();

Console.W rite("Kérem a karaktert: ");
karakter = C onvert.ToChar(Console.ReadLine());
fó r ( i = 0 ; i < sz ö v e g . Length ; i + + ) if
( k = = ( s z ö v e g [ i ] ) ) d b + +;
C o n s o l e . W r i t e L i n e (" A ( z ) {0} k a r a k t e r b ő l {1}
db v an a s z ö v e g b e n ", k a r a k t e r , d b ) ;
}
Mivel csak szöveget lehet bekérni billentyűről, ezért a k bekérésénél karakterré
kell konvertálni.
47. feladat:
Kérjünk be egy szöveget és egy szót majd írjuk ki, hogy a szövegben hányszor
fordul elő a megadott szó!
Név: Szoszamlalas
Megoldás:
{
s tr in g szöveg,szó;
i n t db = 0 , i=0 ;
C o n s o l e . W r i t e ("Kérem a s z ö v e g e t : " );
szöveg = C o n s o le .R e a d L in e ();
Console.W rite("Kérem a szó t: ");
szó = (C onsole. R ead L in e());
f ó r ( i = 0; i < = s z o v e g . L e n g t h - s z o . L e n g t h ; i + + )
i f ( s z ö v e g . S u b s t r i n g ( i , s z ó . L e n g t h ) = = szó) db++;
C o n s o le .W r i te L i n e ();
C o n s o l e . W r i t e L i n e (" A ( z ) {0} s z ó b ó l {1} d b v a n
a szövegben " ,s z o ,d b );
}
A fór ciklus a szót a szövegben a 0. karaktertől kezdve keresi a szöveg hossza-szó
hossza értékig. Ha tehát a szöveg 10 hosszú, a szó pedig 3, akkor 10-3=7 lesz az i
végértéke, tehát 0-tól 7-ig 8-szor fut le a ciklusmag. Utoljára az szoveg.Substring(7,3)
értékét hasonlítjuk össze a szóval, vagyis a szöveg 7., 8., 9. karakterét hasonlítjuk a
3 hosszúságú szóval és ha megegyezik, akkor növeljük db értékét.
102
48. feladat:
Kérjünk be egy szöveget, és írjuk ki visszafelé! A fordított szöveg csak nagybetű
ből álljon!
Név: Szovegmegfordito
Megoldás:
{
s t r i n g s z o v e g = " 11, f o r d i t o t t S z o v e g = " 11;
i n t i = 0;
C o n s o l e . W r i t e ("Kérem a s z ö v e g e t : " ) ;
szöveg = C o n s o le .R ead L in e();
f ó r ( i = s z ö v e g . L e n g t h - 1 ; i >= 0 ; i — )
forditottSzoveg = forditottSzoveg + sz [i];
C o n s o l e . W r i t e L i n e (" A s z ö v e g m e g f o r d í t v a : " ) ;
C onsole.W riteLine(forditottSzoveg.ToU pper());
}
A fór ciklust most a szöveg vége-1-től 0-ig visszafelé kell léptetni és az új, meg
fordított szöveghez egyesével kell hozzáfűzni az aktuális, 1 hosszúságú szöveget.
49. feladat:
Kérjük be egy személy nevét, amely vagy 2 vagy 3 részből áll! írjuk ki a vezeték
nevet, majd alá a keresztnevet és ez alá a második keresztnevet, ha van!
Név: Nevkiiras
Megoldás:
{
s t r i n g n ev= "", vNev="", kNev="", k2Nev="";
i n t i = -1;
C o n s o l e . W r i t e L i n e (" K é r e m a n e v e t : " ) ;
n é v = C o n s o l e . R e a d L i n e () ;
do
{
i++;
vnev= vnev+ C onvert. T o S t r i n g ( n é v [ i ] );
}while ( n e v [ i] ! = ' ');
C o n s o l e . W r i t e L i n e (" A v e z e t é k n é v : { 0 } " , v N e v ) ;
do
S tringek
103
{
i++;
kNev = kNev + Convert.ToString(név[i]);
} while (nev[i] != ' ' && i + l ! = n e v . L e n g t h ) ;
C o n s o l e . W r i t e L i n e (" A k e r e s z t n é v : { 0 } " , k N e v ) ;
i f ( n é v [i ] = = ' ')
{
do
i++;
k2Nev = k2Nev + C o n v e r t . T o S t r i n g ( n é v [ i ]) ;
} w hile (i < n é v . L e n g th -1 ) ;
C o n s o l e . W r i t e L i n e (" A 2 . k e r e s z t n é v : {0}n,
k2Nev);
}
}
A program megírásánál abból indulunk ki, hogy a neveket szóköz választja el egy
mástól. Ha egy szóköz van a szövegben, akkor csak vezeték és keresztnév van, ha
két szóköz, akkor második keresztnév is van. Ezért a név bekérése után egy hátul
tesztelő ciklusban addig tesszük a szöveg karaktereit a vnev változóba, amíg az 1.
szóközig elérünk. Ekkor már a vezetéknevet ki is írjuk a képernyőre.
A szövegben továbbhaladva a keresztnevet kapjuk meg. Addig kell a ciklusban
maradni, amíg két feltétel egyszerre teljesül:
1. nev[i] != 4 4 vagyis a szöveg aktuális karaktere nem egyenlő szóközzel és
2. i+l!=nev.Length tehát a következő karakter sorszáma nem az utolsó a szövegben.
Nézzük fordítva: Kiléphetünk a ciklusból, ha szóközhöz érünk - ekkor nem teljesül
az első feltétel - vagy ha a szöveg utolsó karakteréhez értünk. Ha szóköz volt a
szövegben, akkor egy újabb ciklusban előállítjuk a 2. keresztnevet és kiírjuk, ha
nem, befejezzük a programot.
Mi lesz az alábbi szövegfuggvényekkel végzett műveletek eredménye?
1, Ha s z - ’süveges”; , akkor sz.Trim(Y) =
2, Ha sz=”Messi a messiás”; , akkor sz.IndexOf(”si”) =

104
3, Ha sz = ’’Paróka” , akkor sz.Substring(2,2) = .......
4, Ha sz = ’’Ouagadougou” , akkor sz.Substring(8) =
5.2. A felsorolt típus
Az előző fejezetben láthattuk, hogy nem csak a stat ic void Main (string []
args) { }részbeírhatunkaprogramkészítéssorán,ígymostmármegismerkedhetünk
a felsorolt típussal.
A felsorolt típus olyan adatszerkezet, amely névvel ellátott, megadott értékekből áll.
A felsorolt típust az enum kulcsszó után adjuk meg. Először megadjuk a nevet,
majd { } jelek között felsoroljuk az új típus elemeit. Ha nem adunk értéket az
elemeknek, akkor azok értéke nullától kezdve egyesével fog nőni. Ha egy
tetszőleges elem értéket kap, de az utána következő nem, akkor ennek az elemnek
az értéke az előzőhöz képest eggyel nagyobb lesz.
A felsorolt típust az enum kulcsszóval deklaráljuk:
PL: enum
Enum típust csak metóduson kívül (tehát jelen esetben a static void Main(string[]
args) részen kívül, de osztályon belül, vagy “önálló” típusként) deklarálhatunk.
50. feladat:
írjuk ki felsorolás típusban megadott sportágakat és az indexüket (sorszámukat)!
Név: Felsorolás
Megoldás:
namespace felsorolt
eláss Program
{
enum s p o r t A g a k { l a b d a r ú g á s , t e n i s z , formai,
a tle tik a = 5 , jégkorong , v íz ila b d a }
S truktúra ( rekord )
105

{
sportAgak a = sportAgak.tenisz;
C o n s o l e . W r i t e L i n e ( "A s p o r t á g neve: {0},
s o r s z á m a : { 1 } 11, a , (int)a);
sportAgak b = sportA gak. jegkorong;
C onsole.W riteLine("A sportág neve: {0},
s o r s z á m a :{1}", b, (int)b);
}
5.3 Struktúra (rekord)
Különböző típusú adatok tárolására a rekord adattípust használhatjuk, amelyek egy

adattáblához hasonlítanak, ahol sorok és oszlopok vannak. A C#-ban az adatokat
struktúra segítségével számunkra megfelelő szerkezetbe, rendszerbe szervezhet
jük. Eddig csak azonos típusú adatokat tudtunk tárolni a memóriában egy adatszer
kezeten belül, mivel a tömbben csak azonos típusú adatokat lehetnek.
Ha struktúrába szervezzük az adatokat, akkor először megadjuk a struktúra nevét,
amelyet típusként használunk a későbbiekben, majd az oszlopok típusát és nevét.
Szükség lesz egy tömbre is, amely az adattábla sorszámát adja meg.
51. feladat:
Hozzunk létre egy adattáblát, amelynek maximum 500 sora lehet, az oszlopok
neve pedig név, osztály és átlag legyen! Kérjük be az adatsorok számát és ennek
megfelelően az adatokat, majd írjuk ki a háttértárolóra a programunk BIN/DEBUG
könyvtárába adatok.txt néven!
Név: Rekord
Megoldás:
using System;
using System.Collections.Generic;
106
using S ystem .Text;

namespace Rekord
{
class Program
{
struct tanuló
{
public string nev;
public string osztály;
public double atlag;
public ta n u ló (string nev, string osztály, double
atlag)
{
this.nev = nev;
t h i s . osztály = osztály;
this.atlag = atlag;

{
string fajlN ev = "Tanulók adatai.txt";
StreamW riter kiirtxt = null;
tanulót] tanulok = new t a n u l o [ 5 0 0 ] ;
int i = 0, n = 0;
C o n s o l e . W r i t e ( 11 Adatsorok száma: ");
n = C o n v e r t . T o I n t 3 2 ( C o n s o l e . R e a d L i n e () ) ;
fór (i = 0; i < n; i++)
{
C o n s o l e . W r i t e ( n Név: ");
t a n u l o k [i ] . nev = C o n s o le . R ead L in e();
C o n s o l e . W r i t e (" Osztály: ");
tanulok[i].osztály = C o n s o le . R ead L in e();
C o n s o l e . W r i t e (" Á t l a g : ");
tanulok[i].atlag = C o n v ert.ToDouble(Console.
ReadLine ());
L ista
107
}
try
{
kiirtxt = new S t r e a m W r i t e r ( f a j I N e v ) ;
for (i = 0; i < n; i++)
{
i f ( i = = 0) k i i r t x t . W r i t e L i n e ( " { 0 , 1 1 }
{1,12} { 2 : 0 .0 0 } " , "Név", " O s z t á l y " ,
"Á tlag");
k i i r t x t .W r ite L in e ("{0,15} {1,8}
{2:0.00}", t a n u l o k [ i ] . név, t a n u l o k [ i ] .
osztály, ta n u lo k [i].a tla g );
}
k i i r t x t .C l o s e ();
}
catch (IOException)
{
}
}
A Struct után megadtuk a rekord szerkezetét, azaz az oszlopok nevét és típusát.
Ezzel egy úgynevezett „saját típust” hoztunk létre, amelyet a tanulok nevű tömb
deklarációjánál használunk, ahol az adattábla sorainak számát adtuk meg. Az adat
sorok értékét az n változó veszi fel, majd egy fór ciklusban bekérjük az adatokat
egy másikban pedig kiírjuk ’’Tanulók adatai” néven a háttértárolóra.
5.4 Lista
A lista gyakorlatilag egy változó elemszámú tömb. Mint korábban láthattuk a tömb
deklarációjánál meg kell adni az elemek számát, amelynél a helyet le kell foglalni
akkor is, ha nem töltjük fel valós adatokkal.
108
A listánál memóriahelyet takarítunk meg, mivel dinamikusan változhat az elemek

száma és pontosan annyi helyet foglalunk le a lista számára, amennyire éppen
szükségünk van.
A lista tehát index-érték párokból áll, ahol egy elemre az index vagy az érték se
gítségével hivatkozhaunk.
Lista deklarációja:
List<tipus> listanev = new List<tipus>();
Műveletek listaelemekkel:
• elem hozzáadása: listanev.Add(elem),
• több elem hozzáadása a már meglévő lista végéhez: listanev.
AddRange(elemek) Az „elemek” lehet tömb, vagy lista.
• elem eltávolítása: listanev.Remove(elem). Ha értéke false, akkor az elem
nem szerepel a listán.
• adott indexű elem eltávolítása: listanev.RemoveAt(elemindexe).
• egy elem sorszámát adja vissza: listanev.IndexOf(elemindexe): (ha nincs a
listán, akkor pedig -1-et)
• lista kiürítése: listanev.Clear().
A lista elemeit a [] operátorral érhetjük el.
52. feladat: Hozzunk létre egy 6 elemű listát, amely egész számokból áll! A számo
kat véletlenszerűen állítsuk elő a 0-20 intervallumból, majd írjuk ki a képernyőre
az elemeket és a lista elemszámát!
Töröljünk egy tetszőleges sorszámú, majd tetszőleges értékű elemet a listából és
írjuk ki az elemeket és aktuális elemszámot!
Töröljük a listát és írjuk ki az elemszámot!
Név: lista
Megoldás:
namespace lista
{
class Program
static void M a i n ()
{
Random v s z = n e w R a n d o m () ;
L ista
109
List<int> lista = new L i s t < i n t > ( ) ;

C o n s o l e . W r i t e L i n e (" A lista e le m e i:");
fór (int i = 0; i < 6; i++)
{
lista .A d d (v sz .N e x t (21));
C o n s o l e . W r i t e (" { 0 , 5 } 11, l i s t a [ i ] ) ;
}
C o n s o l e . W r i t e L i n e ( 11 A l i s t a elemeinek száma:
{0 } 11, l i s t a . C o u n t ) ;
C o n s o l e . W r i t e (" Hányadik sorszámú elemet töröl
j ü k ? 11) ;
int indexDel =C onvert. T oIn t3 2 (C o n so le.R eadLine());
l i s t a .RemoveAt(indexDel);
f ó r ( i n t i = 0; i < 5; i + + ) Console.
W r i t e (" { 0 , 5 } " , l i s t a [ i ] );
C o n s o l e . W r i t e L i n e (" A l i s t a elemeinek száma:
{0}n , l i s t a . C o u n t ) ;
C o n s o l e . W r i t e (" Melyik elemet töröljük? ");
in t ertekD el = C onvert.ToInt32(Console.
R e a d L i n e ()) ;
lista.R em ove(ertekD el);
f ó r ( i n t i = 0; i < 4; i + + ) Console.
W r i t e (" { 0 A5 } 11, l i s t a [ i ] ) ;
C o n s o l e . W r i t e L i n e ( 11 A l i s t a elemeinek száma:
{ 0 } M, l i s t a . C o u n t ) ;
l i s t a . C lear ();
C o n s o l e . W r i t e L i n e (" A t ö r ö l t lista elemeinek
száma: {0}",
l i s t a .Count);
}
110
5.5 Szótár
A szótár segítségével elempárokat tárolhatunk és kezelhetünk.

Az elempárok közül az egyik a kulcs, amely azonosítja az elempárt, másik pedig
az érték. Minden kulcsnak egyedinek kell lenni.
A szótár olyan, mint egy lista, ahol az elemek indexe tetszőleges típusú lehet, akár
szöveg is.
A szótár deklarációja:
Dictionary<tipuskulcs, tipusertek> szotamev = new Dictionary< tipuskulcs,
tipusertek >();
Műveletek szótárelemekkel:
• érték hozzáadása kulccsal: szotamev.Add( kulcs, érték),
• megadj a, hogy szerepel-e egy kulcs a szótárban: szotamev. ContainsKey (kulcs),
• megadja,hogy szerepel-eegy értékaszótárban: szotamev.ContainsValue(ertek),
• eltávolít egy elemet a szótárból: szotamev.Remove(kulcs),
• a szótár elemeinek törlése: szotamev.Clear().
A szótárat foreach ciklussal lehet bejárni és a szótárból KeyValuePair (kulcs-érték
pár) típusú elemeket kapunk. Ezek Key és Value mezői adják a megfelelő kulcs és
érték párokat.
53. feladat:
Hozzunk létre [0-9]-ból véletlenszerűen egész számokat és helyezzük el egy 15
elemű tömbben!
Hozzunk létre egy szótárt, amelyben a véletlenszerűen előállított szám lesz a kulcs,
a számok darabszáma pedig az érték! írjuk ki a 15 számot egymás mellé, majd alá
a szótár elemeinek kulcsát és az értékeket, azaz a számokat és a darabszámokat!
Név: szótár
Megoldás:
namespace szótár
{
eláss Program
{
S zótár
111

{
int[] s z a m o k = new i n t [ 1 5 ] ;
fór (int i = 0; i < 15; i++)
{
szamok[i] = vsz.Next(lO);
C o n s o l e . W r i t e (” { 0 , 5 } ” , s z a m o k [i ] ) ;
}
D ictionaryCint, i n t > szamokDarab = new
D ictionary<int, in t> ();
fór (int i = 0; i < szamok. Length; i++)
{
if (szam okD arab. C o n t a i n s K e y ( s z a m o k [i ]))
s z a m o k D a r a b [ s z a m o k [ i ] ]++;
else
szamokDarab.Add(szamok[i], 1);
}
foreach (KeyValuePair<int, int> elem in
szamokDarab)
{
C o n s o l e . W r i t e L i n e ( ,fA s z á m : {0} ennyi van
b e l ő l e : {1}
db”, C onvert.ToString(elem .Key), elem .V alue);
}
}
}
}
112
5.6 Halmaz
Egy halmaz egymástól különböző objektumok összessége. De felfoghatjuk úgy is,

mint egy olyan lista, amelyben nem lehetnek azonos elemek. Ebben a tekintetben
is megfelel a matematikai halmaz fogalomnak.
A halmaz deklarációja:
HashSet<tipus> halmaznév = new HashSet<tipus>();
Műveletek halmazelemekkel:
• érték hozzáadása a halmazhoz: halmaznev.Add(ertek),
• eltávolít egy elemet a halmazból: halmaznev.Remove(ertek),
• a halmaz elemeinek törlése: halmaznev.Clear(),
• az alaphalmaz és a halmaz unióját hozza létre az alaphalmazban: alaphalmaz.
Union With(halmaz),
• a halmaz számossága: halmaznev.Count.
54. feladat:
írjunk programot, amely halmaz segítségével állítja elő a hatoslottó nyerőszámait
és kiírja a képernyőre egymás mellé, majd a halmazt tömbbé alakítja és növekvő
sorrendben kiírja a számokat egymás mellé!
Név: halmaz
Megoldás:
namespace halmaz
{
eláss Program
{
{
HashSet<int> lottoő = new H a s h S e t < i n t > ( ) ;
w h ile ( l o t t o 6 . Count < 6) l o t t o 6 .A dd(vsz.
N e x t(45)+1);
foreach (int szám i n lotto6) Console.
H almaz
113
W r i t e ("{0, 5 } " , szá m );

int[] lottoTomb = new i n t [ 6 ] ;
lottotom b = l o t t o 6 . T o A rray ();
C o n s o l e . W r i t e L i n e ("Növekvő s o r r e n d b e n : ") ;
A rray.Sort(lottoTom b);
f ó r ( i n t i = 0 ; i < 6; i + + ) C o n s o l e .
W r i t e ( " { 0 , 5 } " , l o t t o T o m b [i ] ) ;
}
114 ------------------------------------------------------------------------
6. ÖSSZETETT FELADATOK
6.1. Kéktúra (Ágazati érettségi mintafeladat: 2017)
A feladat megoldásához szükséges forrásállományt le lehet tölteni az alábbi

linkről:
https://www.nive.hu/index.php?option=com_content&view=article&id=738
(ez 4 feladathoz tartozó forrást tartalmaz tömörített állományban) vagy:
http://www.gepeszeti.hu/websuli/diak.htm (ez csak a programozás feladat
forrását tartalmazza)
A feladat leírása:
Az Országos Kéktúra Magyarország északi részén végighaladó folyamatos, jelzett
turistaút. A Kéktúrának a Balaton-felvidéken is több, rövidebb idő alatt bejárható
túrája van. Egy ilyen túra adatait kell feldolgoznia ebben a feladatban.
A megoldás során vegye figyelembe a következőket:
• A képernyőre írást igénylő részfeladatok eredményének megjelenítése előtt
írja a képernyőre a feladat sorszámát (például:3. feladat:^/
• Az egyes feladatokban a kiírásokat a minta szerint készítse el!
• Az ékezetmentes kiírás is elfogadott!
• A program megírásakor a fájlban lévő adatok helyes szerkezetét nem kell
ellenőriznie, feltételezheti, hogy a rendelkezésre álló adatok a leírtaknak
megfelelnek!
• A megoldását úgy készítse el, hogy az azonos szerkezetű, de tetszőleges input
adatok mellet is helyes eredményt adjon!
A kektura.csv állomány első sorában a túra kezdetének tengerszint feletti magassá
ga található méterben megadva. A további sorok a túra egy-egy szakaszához tarto
zó adatokat tárolják. Az adatokat pontosvessző választja el egymástól. Például:
Hidegkúti major;Leteres a Sztupahoz;3,903;153;53;n
A sorokban lévő adatok rendre a következők:
• A túraszakasz kiindulópontjának a neve. Például: „Hidegkúti major”
K éktúra (Á gazati érettségi mintafeladat : 2017)
115
• A túraszakasz végpontjának a neve. Például: „Leteres a Sztupahoz”

• A túraszakasz hossza [km]. Például: „3,903”
• A túraszakaszon mért emelkedések összege [m]: Például: „153”
• A túraszakaszon mért lejtések összege [m]: Például: „53”
• A szakasz végpontja pecsételőhely is egyben: Például: „i” vagy „n”
1. Készítsen programot a következő feladatok megoldására, amelynek a forrás
kódját kektura néven mentse el!
2. Olvassa be a kektura.csv állományban lévő adatokat, és tárolja el egy úgy, hogy
a további feladatok megoldására alkalmas legyen! A fájlban legfeljebb 100 sor
lehet!
3. Határozza meg, és írja ki a képernyőre a minta szerint, hogy hány szakasz talál
ható a kektura.csv állományban!
4. Határozza meg, és írja ki a képernyőre a minta szerint a túra teljes hosszát!
5. Keresse meg, és írja ki a képernyőre a túra legrövidebb szakaszának adatait a
minta szerint! Feltételezheti, hogy nincs kért egyforma hosszúságú szakasz!
6. Készítsen logikai értékkel visszatérő függvényt (vagy jellemzőt) HianyosNev
azonosítóval, amelynek segítségével minősíteni tudja a túraszakaszok végpont
jainak a nevét! Hiányos állomásneveknek minősítjük azokat a végpontneveket,
amelyek pecsételőhelyek, de a „pecsetelohely” karakterlánc nem található meg
a nevükben. Ebben az esetben logikai igaz értékkel térjen vissza a függvény
(vagy jellemző), egyébként pedig hamissal.
7. Keresse meg, és írja ki a minta szerint a képernyőre a hiányos állomásneveket!
Ha nincs hiányos állomásnév az adatokban, akkor a „Nincs hiányos állomás
név!” felirat jelenjen meg!
8. Ismerjük a túra kiindulópontjának tengerszint feletti magasságát és az egyes
túraszakaszokon mért emelkedések és lejtések összegét. Az adatok ismeretében
keressük meg a túra legmagasabban fekvő végpontját és határozzuk meg a vég
pont tengerszint feletti magasságát! Feltételezheti, hogy nincs kettő vagy több
ilyen végpont!
9. Készítsen kektura2.csv néven szöveges állományt, amely szerkezete megegye
zik a kektura.csv állományéval! A kimeneti fájl első sora a kiindulópont tenger
szint feletti magasságát tartalmazza! A további sorokban a túra szakaszainak
adatait írja ki! Azoknál a pecsételőhelyeknél, ahol nem található meg a végpont
nevében a „pecsetelohely” karaktersorozat, ott kerüljön be a végpont nevének
a végére egy szóközzel elválasztva a „pecsetelohely” szó!
Ö sszetett feladatok
116
Minta:
3. feladat: Szakaszok száma: 16 db
4. feladat: A túra teljes hossza: 44,624 km
5. feladat: A legrövidebb szakasz adatai:
Kezdete: Sümeg, vasutallomas
Vége: Sümeg, buszpályaudvar
Távolság: 1,208 km
7. feladat: Hiányos állomásnevek:
Zalaszanto, romai katolikus templom
Gyöngyösi csarda
Heviz, leteres az autobuszallomashoz
Keszthely, leteres a vasutallomashoz
8. feladat: A túra legmagasabban fekvő végpontja:
A végpont neve: Kék rom jelzes kezdete Tatika várához
A végpont tengerszint feletti magassága: 398 m
Megoldás:
using System;
using System .C o lle c tio n s .Generic;
using System.Text;
using System .Threading.Tasks;
namespace érettségi2017
{
class Program
struct túra // saját tipus létrehozása túra néven

{
public string kezdet;
public string vég;
public double hossz;
public int emel;
public int lejt;
public bool ph;
117
static bool függvény(string vég, bool phfuggveny)

{
bool hiány = false;
if (phfuggveny == t r u e )
i f (v é g . In d e x O f(" p e c s e t e l o h e l y " ) < 0) hiány =
true;
else hiány = false;
re tu rn hiány;
}
{
s t r i n g [] a d a t o k = F i l e . R e a d A l l L i n e s ( " k e k t u r a . c s v " ) ;
int turaSorszam = a d a to k . Length;
t ú r a [] sor = new t ú r a [ 1 0 0 ] ;
int tszfm = i n t . P arse (ad ato k [0]);

int i = 0;
fór (i = 1 ; i < a d a to k . Length; i++)
{
s t r i n g [] darabol = a d a t o k [ i ] . S p l i t ( f ; T) ;
s o r [ i ] .kezdet = d a r a b o l [0];
s o r [ i ] .vég = d a r a b o l [1];
s o r [i ] . h o s s z = double. P a rse (d a ra b o l[2]);
s o r [i ] . emel = i n t . P a rs e (d a ra b o l[3]);
s o r [ i] .lej t = i n t . P a r s e ( d a r a b o l [4] ) ;
string phely = d a r a b o l [5];
if (phely == "i") sor[i].ph = true;
else sor[i].ph = false;
}
// 3. feladat
C o n s o le .W r i t e L i n e ("3. feladat: Szakaszok száma:
{0} d b ” ,
adatok.Length - 1);
double osszHossz = 0;
f ó r (i = 1 ; i < adatok.Length; i++) osszHossz +=
sor[i].hossz;
// 4. feladat
118
C o n s o le .W rite L in e ("4. feladat: A túra teljes

h o s s z a : {0}",
osszHossz);
// 5. feladat
double minHossz = s o r [1 ].hossz;
i n t m i n i = 0;
if (minHossz >= s o r [ i ] . h o s s z )
{
minhossz = s o r [ i ] . h o s s z ;
mini = i;
}
C o n s o le .W r i te L i n e ("5. feladat: A legrövidebb sza
kasz a d a ta i: ");
C o n s o l e . W r i t e L i n e (" \ t " +s o r [m ini] . k e z d e t ) ;
C o n s o l e . W r i t e L i n e ( 11\ t " + s o r [mini] . vég) ;
Console.WriteLine( "\t{0} km", sor[mini].hossz);
// 7. feladat
int db = 0;
C o n s o le .W r i te L i n e ("7. feladat: Hiányos állom ás
n e v e k : ") ;
if ( f g v ( s o r [ i ] .vég, sor[i].ph) == t r u e )
{
db++;
Console.W riteLine("\t" + s o r [i] . v é g ) ;
}
if ( d b == 0) C o n s o l e . W r i t e L i n e ( " N i n c s hiány");
// 8. f e l a d a t
C o n s o le .W r i t e L i n e ("8. feladat: A túra legmagasab
ban fekvő p o n t j a i : " ) ;
int maxMagasság = tszfm, aktMagasság = tszfm;
string maxMagassagVegPont = "";
{
a k t M a g a s s á g += s o r [ i ] . e m e l - s o r [ i ] . l e j t ;
i f (maxMagasság < a k tM a g a s s á g )
{
119
maxMagasság = aktMagasság;
maxMagasságvégpont = sor[i].vég;
}
C onsole.W riteL ine("\tA végpont neve: {0}",
maxMagassagVegPont) ;
C o n s o le .W r i t e L i n e (" \tA végpont tengerszint fe
l e t t i magassága::
{0} m", maxMagasság );
// 9. feladat
fór (i = 1; i < a d a to k . Length; i++)
i f (függvény(sor[i].vég, so r[i].p h ) == t r u e )
s o r [i ] . vég+=" p e c s é t e l ő h e l y " ;
// Az ö s s z e s adat elhelyezése listába
List<string> sorok = new L i s t < s t r i n g > ( ) ;
sorok.A dd("192");
fór (i = 1; i < adatok.Length; i++)
{
so ro k .A d d (so r[i]. kezdet + + sor[i].vég +
!»r. If 'I
s o r [ i] . h o s s z . T o S tr in g ()+"; " + sor[i].em el.
T o S trin g ()+";" +
s o r [ i ] . l e j t .T o S trin g ()+";" + sor[i].
p h .T oS tring());
}
try
{
F i i é .W r i t e A l l L i n e s (" k e k t u r a 2 . c s v " , sorok);
}
catch (IOException)
{
}
120
A fájlkezelést elősegítő utasításokkal ( F i i é . R e a d A llL in e s é s F i i é .

W r i t e A l l L i n e s ) egyszerűen olvashatunk be és írhatunk ki háttértárolóra ada
tokat.
A programban hasznos lehetőséget használunk ki a Split utasítás segítségével. A be
olvasott adatokat soronként, megadott határolójelek mentén fel lehet darabolni.
A saját típusban létrehozott adatok típusának és számának meg kell egyezni a da
rabolás utáni adatok típusával és számával.
A logikai típusú fgv nevű függvényben a függvény hívásakor átadott sor[i].ph para
métert vizsgálj uk meg, amelyet aphfgv változó vesz át, és ha igaz, hogy pecsételőhely
az adott állomás, akkor megnézzük, hogy veg.IndexOf("pecsetelohely") értéke
negatív-e. Ha igen - azaz nincs benne a keresett szöveg - akkor a függvény false
értékkel tér vissza.
A kiírásnál az idézőjelek között a \t tabulálást eredményez. A \n pedig új sort ered
ményezne, ha használnánk.
Több jó megoldás is létezik, mindenki a saját gondolatmenete szerint, az általa
ismert utasítások segítségével oldja meg a feladatot.
6.2. Helsinki 1952

(Ágazati érettségi feladat: 2017 május)
A feladat megoldásához szükséges forrásállományt le lehet tölteni az alábbi

linkről:
https://www.oktatas.hu/kozneveles/erettsegi/feladatsorok/
kozepszint_2017tavasz/kozep_9nap
(ez 4 feladathoz tartozó forrást tartalmaz tömörített állományban)
A feladat leírása:
Az 1952-ben Helsinkiben rendezett nyári olimpián nagyon szépen szerepeltek a
magyar színekben induló olimpikonok. Ebben a feladatban az általuk elért helye
zésekkel kapcsolatos számításokat kell elvégeznie.
A megoldás során vegye figyelembe a következőket:
• A képernyőre írást igénylő részfeladatok eredményének megjelenítése előtt
írja a képernyőre a feladat sorszámát (például: 3 . f e l a d a t :) /
H elsinki 1952 (Á gazati érettségi feladat : 2017 május )
121
• Az egyes feladatokban a kiírásokat a minta szerint készítse el!

• Az ékezetmentes kiírás is elfogadott.
• A program megírásakor a fájlban lévő adatok helyes szerkezetét nem kell
ellenőriznie, feltételezheti, hogy a rendelkezésre álló adatok a leírtaknak
megfelelnek.
• Amegoldását úgy készítse el, hogy az azonos szerkezetű, de tetszőleges be
meneti adatok mellett is helyes eredményt adjon!
• A h e l s i n k i . t x t állomány soronként tartalmazza az 1952-es nyári olim
pián elért pontszerző helyezéseket (1-6. hely). Az első három helyezés
egyben azt is jelentette, hogy arany-, ezüst- vagy bronzérmet szerzett a spor
toló vagy a csapat. Az adatokat a szóköz karakter választja el egymástól.
Például: 3 4 a t l é t i k a 4xl00m _valtofutas
A sorokban lévő adatok rendre a következők:
• Az elért helyezés. Például: „ 3 "
• A helyezést elérő sportoló vagy csapat esetén sportolók száma. Például: „ 4 "
• A sportág neve. Például: „atlétika”
• A versenyszám neve. Például: „ 4 x l 0 0 m _ v a l t o f u t a s "
1. Készítsen programot a következő feladatok megoldására, amelynek a forrás
kódját h e l s i n k i l 9 5 2 néven mentse el!
2. Olvassa be a h e l s i n k i . t x t állományban lévő adatokat és tárolja el egy
olyan adatszerkezetben, amely a további feladatok megoldására alkalmas!
A fájlban legfeljebb 200 sor lehet.
3. Határozza meg, és írja ki a képernyőre a minta szerint, hogy hány pontszerző
helyezést értek el a magyar olimpikonok!
4. Készítsen statisztikát a megszerzett érmek számáról, majd összesítse az érmek
számát a minta szerint!
5. Az olimpián az országokat az elért eredményeik alapján rangsorolják. Az 1-6.
helyezéseket olimpiai pontokra váltják, és ezt összegzik. Határozza meg és írja ki
a minta szerint az elért olimpiai pontok összegét az alábbi táblázat segítségével!
Helyezés Olimpiai pont

í. 7
2. 5
3. 4
4. 3
5. 2
6. 1
Ö SSZETETT FELADATOK
122
6. Az úszás és a torna sportágakban világversenyeken mindig jól szerepeltek a

magyar sportolók. Határozza meg, és írja ki a minta szerint, hogy az 1952-es
nyári olimpián melyik sportágban szereztek több érmet a sportolók! Ha az érmek
száma egyenlő, akkor az „Egyenlő volt az érmek száma” felirat jelenjen meg!
7. A h e l s i n k i . t x t állományba hibásan, egybeírva „kajakkenu” került a ka
jak-kenu sportág neve. készítsen szöveges állományt h e l s i n k i 2 . t x t né
ven, amelybe helyesen, kötőjellel kerül a sportág neve! Az új állomány tartal
mazzon minden helyezést a forrásállományból, a sportágak neve elé kerüljön be
a megszerzett olimpiai pont is a minta szerint! A sorokban az adatokat szóköz
zel válassza el egymástól!
8. Határozza meg, hogy melyik pontszerző helyezéshez fűződik a legtöbb sporto
ló! írja ki a minta szerint a helyezést, a sportágat, a versenyszámot és a sporto
lók számát! Feltételezheti, hogy nem alakult ki holtverseny.
Minta a feladathoz:
3. feladat:
Pontszerző helyezések száma: 64
4. feladat:
Arany: 16
Ezüst: 10
Bronz: 16
Összesen: 42
5. feladat:
Olimpiai pontok száma: 269
6. feladat:
Torna sportágban szereztek több érmet
8. feladat:
Helyezés: 1
Sportág: labdarúgás
Versenyszám: ferfi_csapat
Sportolók száma: 15
H elsinki 1952 (Á gazati érettségi feladat : 2017 május)
123
Minta a h e l s i n k i 2 . t x t állományhoz:
2 1 5 kajak-kenu kenu_egyes_10000m
2 1 5 kajak-kenu kajak_egyes_1000m
2 1 5 birkózás kotott_fogas_pehelysuly
2 8 5 torna noi_osszetett_csapat
3 1 4 sportlövészét sportpisztoly
3 1 4 vivas kardvivas_egyeni
Források:
https://hu.wikipedia. org/wiki/Magyarország_az_l952._évi_nyári_olimpiaiJátékokon
(utolsó megtekintés: 2017.01.30.)
Megoldás:
using System;
using System .C o l le c t i o n s .Generic;
using System .Text;
namespace helsinki
{
class Program
{
s tru c t egyadat /^Adatszerkezetnek m egfelelő
struktúra elkészítése*/
{
public int helyezes;
public int hányán;
public string sportág;
public string vszam;
};
//hasznát változók
Ö ssz e t e t t feladatok
124
s t a t i c e g y a d a t [] a d a t o k = new e g y a d a t [ 2 0 0 ] ; //adatok
nevű de s t u k t u r a szerin ti felépitésű
static int i, darab = 0; //beolvas és 3 feladat
static bool hiba=false;
static int arany = 0; //4 feladat
static int bronz = 0;
static int ezüst = 0;
static int osszErem = 0;
static int osszPont = 0; //5 feladat
static int úszás = 0; //6 feladat
static int torna = 0;
static int legtobb=0; //8 feladat
static int legTobbSorszam=0;

{
//fügvényhivások
Beolvas ();
i f (¡hiba) //csak akkor h a j t j a végre ha fájlolvasás
sikeres
F e l a d a t 3 () ;
F e l a d a t 4 () ;
F e l a d a t 5 () ;
F e l a d a t 6 () ;
F e l a d a t 7 () ;
F e l a d a t 8 () ;
}
static void BeolvasO
{
try
{
S t r e a m R e a d e r o l v a s = new
S tr e a m R e a d e r(" h e l s i n k i . t x t "
H elsinki 1952 (Á gazati érettségi feladat : 2017 május)
125
E ncoding. D e f a u lt); //a

bin/debug könyvtárba
i = 0;
w h i l e ( ! o l v a s . EndOfStream)
{
string egysor = o l v a s .R e a d L in e ();
string [] egySorDarabolva= e g y s o r . S p l i t ( 1 ') ;
a d a to k [i].h e ly e z e s = Convert.
ToInt32(egySorD arabolva[0]);
a d a to k [i].hanyan = Convert.
ToInt32(egySorDarabolva[1]);
adatok[ i ] .sportág = e g y S o rD a ra b o lv a [2];
a d a t o k [ i ] . v s z a m = e g y S o r D a r a b o l v a [ 3] ;
i++;
}
darab = i;
o l v a s . C lose ();
}
catch (IO E xception)
{
//... nem s i k e r ü l t a file megnyitása ...
C o n s o l e . W r i t e L i n e ( ,fH i b a a f á j l m e g n y i t á s k o r ") ;
hiba = true;
/ / ---------------------------------------
static void Feladat3()
{
C o n s o l e . W r i t e L i n e ("3. f e la d a t:");
C o n s o le .W rite L in e (" P o n tsze rző helyezések száma:
{0}", d a r a b ) ;
}
//
Ö ssz etett fela d ato k
126

{
C o n s o le .W r i t e L i n e ("4. f e la d a t:");
fór (i = 0; i < darab; i++)
{
if ( a d a t o k [i ] . h e l y e z e s == 1) arany++;
if (adatok[i].helyezes == 2) ezust++;
if ( a d a t o k [i ] . h e l y e z e s == 3) bronz++;
}
osszerem = arany + ezüst + bronz;
C onsole.W riteLine("A rany: {0}", arany);
C o n s o le . W r i te L i n e (" E z ü s t : {0 } " , ezüst);
C o n s o le . W r i te L i n e (" B ro n z : {0 } " , b r o n z );
C o n s o le .W rite L in e (" Ö sszese n : {0 } " , osszErem);
}
/ / --------------------------------------------------------------------
{
int[] alappont = { 0, 7, 5, 4, 3, 2, 1 };
C o n s o le . W r i te L i n e ("5. f e la d a t:");
{
osszPont = osszPont + alapPont[adatok[i].
helyezes];
}
Console.W riteLine("O lim piai pontok száma: {0}",
osszPont);
/ / ---------------------------------------------------------------------------------
static void F e l a d a t é () //!!!csak érmesek!!!
{
C o n s o le .W r i t e L i n e ("6. f e la d a t:");
{
H e l s in k i 1952 ( Á g a z a t i érettségi fe l a d a t : 2017 m á ju s)
127
if (adatok[i].helyezes < 4)
{
if (adatok[i] . sportág == "úszás") uszas++;
if ( a d a t o k [i ] . s p o r t á g == "torna") torna++;
}
i f (úszás > to rn a ) C o n s o l e . W r i t e L i n e ("Úszás
sportágban s z e re z te k több é r m e t" ) ;
i f (úszás < torna) C onsole.W riteL ine("T orna
sportágban s z e re z te k több é r m e t" ) ;
if ( ú s z á s == t o r n a ) C o n s o le .W r i t e L i n e ("Egyenlő
v o l t az érmek s zá m a ");

{
int[] alapPont = { 0, 7, 5, 4, 3, 2, 1 };
try
{
S t r e a m W r i t e r i r = new S t r e a m W r i t e r ( " h e l s i n k i 2 .
tx t" ) ; / / a bin/debug könyvtárba
fór (i=0;i<darab;i++)
{
ir.W rite(adatok[i].helyezes+" ");
i r .W r i t e ( a d a t o k [i ] . hanyan+" ");
i r .W r i t e ( a l a p P o n t [ a d a t o k [i ] . h e l y e z e s ]+" ");
if (a d a to k [i]. sportag=="kajakkenu")
{i r . W r i t e ( " k a j a k - k e n u ") ; }
else {i r . W r i t e ( a d a t o k [ i ] . s p o r t a g + " "); }
ir.W riteLine (adatok[i].vszam );
}
i r . C l o s e ();
catch
Ö ssz e t e t t fela d ato k
128
{
II... nem sikerült a fileművelet
Console.WriteLine("Hiba a fájlirásakor") ;
}
/ / -----------------------------------------------
{
Console.WriteLine("8. feladat:");
fór (i=0;i<darab;i++)
{
if (legtobb<adatok[i].hányán)
{
legtobb=adatok[i].hányán;
legtobbsorszam=i;
}
Console.WriteLine("Helyezes: {0 }",
adatok[legTobbSorszam].helyezes);
Console.WriteLine("Sportág: {0 }",
adatok[legTobbSorszam].sportág);
Console.WriteLine("Versenyszám: {0}",
adatok[legTobbSorszam].vszam);
Console.WriteLine("Sportolók száma: {0}",
adatok[legTobbSorszam].hányán);
Console.ReadKey();
}
}
}
Az érettségi mintafeladat megoldásától eltérően itt az egyes feladatrészeket - kivé

ve a 1. és 2. feladatot - külön eljárásban oldottuk meg.
Az adatok beolvasását egy elöltesztelő ciklusban valósítottuk meg EndOfStream
utasítással, amíg el nem éri a fájl végét.
129
7. WINDOWS FORM APPLICATION
Eddig csak olyan programokat írtunk, amelyek a futáskor egy egyszerű, szöveges
képernyőn, fekete háttérben fehér betűkkel jelenítette meg az eredményt. A prog
ramírás kezdetén a Console Application-t választottuk minden esetben. Most azon
ban áttérünk a grafikai, a Form jellegű programok írására. Mindazt, amit eddig
megismertünk továbbra is használni fogjuk. Az összes eddig megírt programunk
Form-os környezetben is elkészíthető, így színek és ablakok használatával szebb
formában tarthatjuk a kapcsolatot a felhasználóval.
Ehhez meg kell ismerkedni a Windows Form-ok nyújtotta lehetőségekkel. Mivel
ezen lehetőségek száma nagyon nagy, ezért mi csak a lehetőségek töredékét kíván
juk bemutatni.
7.1. A W indow s Formok használata
Ha Windows Form-ot szeretnénk használni, akkor a New Project után a Windows

Form Applications-t kell választani, és megadni a Project nevét. Ekkor az előttünk
megjelenő képernyő így jelenik meg:
W in d o w s f o r m a p p l ic a t io n
130
Ha mégsem ezt látnánk, akkor célszerű az alábbi beállításokat elvégezni:

A View menü alatt válasszuk ki az Error List, a Properties Window, a Solution
Explorer és a Toolbox almenüket.
A programkészítést most már két részre kel bontani.
1. a megjelenés a (design) kialakítása (grafikus képernyő, egérhasználat),
2. a program szerkezeti felépítése, működése (szöveges képernyő).
A Solution Explorer ablakban válthatunk a kettő között, ahol a Forml.es a grafi
kus, a Program.es pedig a szöveges rész.
A munkavégzés területe elsősorban a középen elhelyezkedő Forrni.cs[Design] ab
lakban lesz, amely mellet a fejrészben Start Page látható.
A Properties ablakban az aktuális (kijelölt) objektum tulajdonságait állíthatjuk be,
amelyről majd később lesz szó részletesen.
A programkészítéshez először a Toolbox menüben található eszközökkel kell meg
ismerkedni. Egyelőre csak a a legfontosabb elemekkel ismerkedünk meg.
Ilyen elem a Button (gomb) és Label (címke). Az egérrel a megfelelő elemet be
húzhatjuk a Forrni ablakba. Az elhelyezésben segítenek a rendező vonalak, ame
lyek a pontos, vízszintes és függőleges beállítást teszik lehetővé.
7.2. A Label
A Label olyan elem, amelyben szöveget jeleníthetünk meg. Az eddig tanultak kö
zül a Console. Write-hoz hasonlítható leginkább. A felhasználó nem tud a Label-be
írni. A címkének sok tulajdonsága van, amelyet beállíthatunk. Erre a Properties
ablakban van lehetőség.
Nézzünk néhány fontosabb tulajdonságot:
A legfontosabb a Label neve. Ezt a (Name) sorban adhatjuk meg és minden esetben
van egy default, alapértelmezett neve. Később ezzel a névvel hivatkozhatunk a
programban a címkére.
Az AutoSize tulajdonsággal a címke átméretezhetősége állítható be. Az alapérték
a True. Ekkor a címke ablaka nem méretezhető át.
• A BackColorral a háttérszínt állíthatjuk be.
• A BorderStyle segítségével a megjelenés formáját választjuk ki.
• A Cursorral a kurzor formája adható meg.
• A Font a betűtípust, stílust és méretet állítja be.
A B utton
131
• A ForeColor a címkében megjelenő szöveg színét módosítja.

• Az Image háttérként képet állít be a címkének.
• Az ImageAlign pedig a képet igazítja.
• A Location a címke helyzetét állítja be.
• A Size a méretet adja meg.
• A Text a címke alapértelmezett értékét állítja be. Ha üres címkét szeretnénk,
akkor több szóközt adjunk meg a Text-ben.
7.3. A Button
A Button olyan elem, amelyre a program futása során kattintva valamilyen ese
mény következik be. A Button tulajdonságai hasonlóak a címkéhez. Csak néhány
eltérés van, amelyet itt nem részletezünk. Fontos viszont, hogy a Button-hoz ese
ményt tudjunk rendelni.
Ezt úgy tehetjük meg, ha a gombra kettőt kattintunk. (Ha csak egyet kattintunk,
akkor a tulajdonságait módosítjuk.)
Ekkor a C# automatikusan átlép a Forrni.cs[Design]-ból a Forml.cs-be és az
eddig megszokott szöveges módban láthatjuk a programunkat. A C# a program
azon részébe lép, ahova nekünk írnunk kell ahhoz, hogy a Button-hoz eseményt
rendeljünk. Ha megnézzük a program szerkezetét láthatjuk, hogy a különböző
elemekhez egy-egy eljárás tartozik. Az eljárások törzsébe írva eseményt rendelhe
tünk a Buttonhoz.
Egy fontos esemény az ablak bezárása, vagyis a program befejezése. Ezt úgy ér
hetjük el, ha a Buttonra kattintva a hozzátartozó eljárásba beírjuk az ablakbezáró
utasítást: this.Close();
A másik fontos esemény, ha egy címkének adunk értéket. Ekkor a megfelelő
Button-ra kattintva beírjuk a következő utasítást:
cimkeNev.Text = ’’Tetszőleges szöveg”;
Ezek után megírhatjuk első Form-os programunkat.
55. feladat:
Hozzunk létre két címkét és gombot egy ablakban! A címkék kezdetben üresek
legyenek a gombok felirata pedig OK és KILÉP! Az OK-ra kattintva a címkékben
132
a következő szöveg jelenjen meg egymás alatt: „Első Form-os programom” és

alatta: „Sárga háttér, kék betű”. A KILÉP-re kattintva az ablak záródjon be.
Név: Formfeladatl
Megoldás:
A megszokottól eltérően most nem elegendő a program kódjának leírása, hiszen itt a
megjelenés, a design kialakítása jóval több időt vesz igénybe, mint maga a kódolás.
Először tehát a New Project-el és a Windows Forms Application-t választva adjuk
a programunknak a Formfeladatl nevet. A szükséges beállításokat elvégezve a
Toolbox-ból húzzunk 2 Lábéit egymás alá elhelyezve a Forrni ablakba, majd két
Button-t egymás mellé. A címkék és a gombok betűtípusa 12 pontos Arial legyen,
a szöveg pedig középre igazított. A címkéknél az átméretezhetőség, az AutoSize
False legyen, a méretek pedig mindkét esetben: Size = 200;20 A gombok esetében
a Size = 70;30 legyen és a bal oldali Text mezőjébe az OK, a jobb oldali Text me
zőjébe a KILÉP szöveget írjuk félkövéren.
A felső Label hátterét állítsuk fehérre, az alsóét világossárgára és itt a betűszínt
állítsuk kékre a ForeColorral. A Forrni ablakra kattintva állítsuk be az ablak mére
tét: Size = 370;370. A Text-hez írjuk be: Ablak
A címkék helyzete: Location = 90;70 és az alatta lévőnek 90; 140. Ugyanez a gom
bok esetén: Location = 90;230 és 220;230.
A felső címke Name részéhez írjuk be : al, az alsóhoz pedig a2.
Az események hozzárendelése a gombokhoz:
Az OK gombra kattintva, belépünk a program kódrészébe a
p riv áté void b u tto n l_ C lick (o b ject sender, E ventA rgs e)
eljárás törzsébe. A zárójelek közé beírjuk a következő utasításokat:

al.T ex t = "E lső Form -os program om ";
a2 .T ex t = "S árg a h á t t é r , kék b e tű " ;
Ezzel az al és az a2 nevű, szöveges címke értékét állítottuk be a kívánt értékre.
Visszatérünk a Forrni.cs[Design]-ba és a KILÉP gombra kattintva a
p riv áté void butto n 2 _ C lick (o b ject sender, EventA rgs e)
{
}
eljárásba beírjuk a zárójelek közé:
t h i s .C lose ();
Ezzel kész az első Form-os programunk már csak el kell menteni, majd futtassuk
le az F5-tel, vagy Start Debugging ikonnal.
A Design részt, a megjelenítést mindenki tetszés és ízlés szerint módosíthatja.
A T extB ox
133
A program érdemi része gyakorlatilag 3 sorból áll. A címkék értékadásából és az

ablak bezárását végrehajtó utasításból. Lényeges még a címkék elnevezése is, mi
vel értékadásnál a címke nevét használjuk.
Szöveget tehát már ki tudunk íratni, de most nézzük mag az adatbekérés módját.
7.4. A TextBox
A TextBox a Labelhez hasonló szöveges vezérlő, amely a felhasználótól beérkező

üzenetet képes fogadni. Mivel minden esetben csak szöveget tudunk bekérni, elfo
gadni a felhasználótól, így itt szükség van konvertálásra, ha később más típusú
adatként szeretnénk használni a szövegdoboz tartalmát. Az átváltást itt is a
ConvertTo utasítással végezhetjük.
56. feladat:
Hozzunk létre egy szövegdobozt, egy címkét és két gombot egy ablakban! írjuk ki
a szövegdobozban megadott szám kétszeresét!
Név: Formfeladat2
Megoldás:
Húzzunk a Forrni ablakba egy TextBox-ot fehér, egy Label-t piros háttérrel és 2
Button-t az alábbi ábra szerint!
A KILÉP gombra kattintva írjuk be a button2_Click eljárásba: this.Close();

W in d o w s fo r m a p p l ic a t io n
134
Az OK gombhoz tartozó eljárásba pedig az alábbiakat:

d o u b l e szá m = 0;
szám = C o n v e r t . T o D o u b l e ( s z a m S t r i n g . T e x t ) ;
s z ö v e g . T e x t = (2 * s z á m ) . T o S t r i n g ( ) ;
}
vagy egyszerűbben:
p riv ate void b u tto n l_ C lick (o b ject sender, E ventA rgs e)
{
s z ö v e g . T e x t = (2 * C o n v e r t . T o D o u b l e
( s z a m S t r i n g . T e x t ) ) . T o S t r i n g () ;
}
Ne felejtsük el, hogy minden bekért és kiírt adat szöveges típusú, ezért a szamString
nevű TextBox értékét konvertálni kell Double típussá, majd a szám kétszeresét a
ToStringgel szöveggé kell alakítani.
57. feladat:
Kérjük be a másodfokú egyenlet együtthatóit három szövegdobozban és írjuk ki
az egyenlet gyökeit két tizedes pontossággal! Ha nincs gyök, akkor írjuk ki:
„Nincs gyök”.
Név: Formfeladat3
Megoldás:
Hozzuk létre az alábbi formának megfelelő ablakot!
as Project Debug Data Format
S Másodfokú egyenlet gyökeinek

& Formfe!adat3
m m Properties
B i&l References
¿ i Forrni .cs
Forml.Designer.es
% Formt .resx
Program.es
Forrni Sytfem.VWnttow.Forntt.Form
ShowlnTaskbar True
Másodfokú egyer
False
□....... i
The text associated withthe control.
A T extB ox
135
Az Escgombra kattintva írjuk be a kilépéshez szükséges this.Close(); utasítást,

majd a számítás gombra kattintva az alábbi programrészletet!
{
d o u b l e x l = 0 , x2 = 0, a = 0, b = 0, c = 0,d=0;
s t r i n g sz =
a = C o n v ert.T o D o u b le(aS trin g .T ex t);
b = C o n v ert.T o D o u b le(b S trin g .T ex t);
c = C o n v ert. T o D o u b le(cS trin g . T e x t);
d = b * b - 4 * a * c ;
i f ( d >= 0)
{
x l = ( - b + M a t h . S q r t ( d ) ) / (2 * a ) ;
x l = M ath. R ound(xl * 1 0 0 )/1 0 0 ;
x 2 = ( - b - M a t h . S q r t ( d ) ) / (2 * a ) ;
x2 = M a t h . R o u n d ( x 2 * 100) / 1 0 0 ;
s z = x l . T o S t r i n g () ;
x l S t r in g .Text = sz;
s z = x 2 . T o S t r i n g () ;
x 2 S tr in g . Text = sz;
}
else n in cs.T ex t = "N incs gyök";
}
Ez a program semmivel sem tud többet a 10. feladatban láthatónál, de szebb és az
egér használata is pluszként jelentkezik.
Itt érdemes megjegyezni, hogy az FII billentyű segítségével egy soronkénti prog
ramfuttatásra van lehetőségünk, amelynek során a változók futás közbeni aktuális
értékét is nyomon követhetjük. Ez a módszer rendkívül hasznos a programok mű
ködésének megértésekor.
Most nézzünk meg egy olyan programot, ahol nem csak egy (vagy több) gombhoz
tartozó alprogramba kell írnunk, hanem azon kívül is.
Előfordulhat olyan eset is, amikor a változók deklarációja nem kerülhet az alprog-
ramon belülre. Ilyenkor az adott gombhoz tartozó programrész fölé célszerű elhe
lyezni a változók deklarációját.
58. feladat:
írjunk programot, amely gondol egy számot 0 és 100 között, majd vár egy tippet
és ennek értékétől függően tájékoztatja a felhasználót, hogy a tipp nagyobb-e, ki-
sebb-e, mint a gondolt szám vagy egyenlő azzal! írjuk ki a tippek számát is!
136
Név: Formfeladat4
Megoldás:

Fie Edit View Project Búid Debug Data Format Tods Window Help
-JULflL&aüb
A szövegdoboz neve legyen szamString a „Jó a tipp?” utáni címke neve

talalString a „Tippek száma” utáni címkéé pedig tippekSzama! A Bezár gombhoz
írjuk a már szokásos this.Close(); utasítást!
A „Jó a tipp?” gombhoz tartozó programrész:
in t t i p p S z a m = 0 , g o n d o l = 0;
p riv a te void b u tto n l_ C lic k (object sender, E v e n t A r g s e)
{
i n t szám = 0;
t a l a l S t r i n g . Text = "";
i f ( t i p p S z a m = = 0)
g o n d o l = v s z . N e x t (101) ;
}
szam = C o n v e r t .T o Int1 6 (szamString.T e x t ) ;
if (szám = = gondol) talalString. Text = "Eltaláltad” ;
if (szám > gondol) talalString.Text = "Ennél kisebb";
A T extB ox
137
i f (s zám < g o n d o l ) t a l a l S t r i n g . T e x t = " E n n é l n a g y o b b " ;

tippszam ++;
tippekS zam a. Text = C o n v e rt. T o S trin g (tip p S z a m );
Megjegyzés:
A tippSzam és gondol egész típusú változókat a priváté void buttonljOlick rész
előtt kell deklarálni különböző okokból.
Ha a tippSzam változónak az eljáráson belül adnánk 0 kezdőértéket, akkor a
tippSzam+ + utasítás mindig 1 lenne, mivel a „Jó a tipp?” gombra kattintva állan
dóan nulláznánk az tippSzam értékét.
A gondol változó értékét csak egyszer szabad előállítani véletlenszerűen a
buttonl_Click-ben, ezért nem lehet az alprogramban deklarálni és 0 kezdőértéket
adni neki. Ezt az egyszeri előállítást az if (tippSzam = = 0) részben valósítjuk
meg, vagyis csak akkor kap értéket a gondol, amikor először kattintunk a „Jó a
tipp?” gombra.
A következő feladat megoldásához szükség lesz 3 új elem, a GroupBox a RadioButton

és CheckBox ismeretére.
A GroupBox egy logikailag összefüggő területet jelöl ki, amelyben különböző vezér
lőelemek helyezhetők el. A GroupBox megjelenhet felirattal vagy felirat nélkül.
A GroupBoxban általában RadioButton vagy CheckBox elemeket helyezünk el.
A CheckBox és a RadioButton feladata majdnem megegyezik. Mindkét esetben
egy listából választhat a felhasználó, de a CheckBoxnál a lista elemeinek kombi
nációját választhatjuk ki, a RadioButtonnal viszont csak egy elemet.
59. feladat:
írjunk programot, amely egy italautomata által felajánlott italok és hozzávalók
kiválasztását teszi lehetővé! Az italok: mogyorós csoki, tea, kávé, capuccino. A le
hetséges hozzávalók: tej, cukor, citrom. A mogyorós csokihoz ne lehessen hozzá
valót választani, a teánál a tejet, a kávénál, és a capuccinónál pedig a citromot
tiltsuk le! Az ár gombra kattintva írjuk ki a kiválasztott termékek árát, a törlés
gombra pedig töröljük az árat! Az árak: mogyorós csoki és kávé 60 Ft, tea és
capuccino 50 Ft. A tej 15, a cukor 10 a citrom pedig 5 Ft legyen!
Név: Formfeladat5
Megoldás:
138
I Forinteladót!) •Microsoft Visual t # 200$ Express Edition aa

Fie Ed Vfew Project BuUd Debug Date Format Took Window Help
:;.a ^ja a & M a
A RadioButton gombokhoz tartozó megnevezések: csoki, tea, kave, capu.

A CheckBox-okhoz tartozó megnevezések: tej, cukor, citrom.
Az Ár gomb melletti label neve: osszegsz
A CheckBox és a RadioButton használata esetén két fontos lehetőséget kell meg
említeni.
1. a vezérlőelemek állapotának, beállításának módja.
2. a vezérlőelemek jelölhetőségének, engedélyezésének, vagy tiltásának módja.
Az állapotok beállítsa:
CheckBox 1.Checked = true; ( a vezérlőelem ki van jelölve)
vagy
CheckBox 1.Checked = false; ( a vezérlőelem nincs kijelölve)
Ajelölhetőség engedélyezése: CheckBox LAutoCheck = true;

A jelölhetőség tiltása: CheckBox LAutoCheck = false;
A CheckBox 1 helyén természetesen a vezérlőelemek neve szerepel a programban,

akár RadioButtonról, akár CheckBoxról van szó.
A TextBox
139
A program:
nam espace Form feladat5
{
p ublic p artia l class Form l : Form
{
p u b lic F o r m l ()
{
I n itia liz e C o m p o n e n t();
}
p r i v a t e v o id checkB ox3_C heckedC hanged(object se n d e r,

E v e n t A r g s e)
{
p r i v a t e v o id checkB ox4_C heckedC hanged(object sen d e r,

{
p riv a te void b u tto n l_ C lic k (o b je c t sender, E v e n t A r g s e)

{
i n t ö s s z e g = 0;
i f ( c s o k i . C hecked) ö s s z e g = 60;
i f ( t e a . Checked) ö s s z e g = 50;
i f ( k a v e . C hecked) ö s s z e g = 60;
i f ( c a p u . C hecked) ö s s z e g = 50;
i f (t e j . C h e c k e d ) ö s s z e g = ö s s z e g + 1 5 ;
i f ( c u k o r . C hecked) ö s s z e g = ö s s z e g + 10;
i f ( c i t r o m . C h e c k e d ) ö s s z e g = ö s s z e g + 5;
o s s z e g s z . Text = C o n v ert. T o S trin g (ö s s z e g );
}
p riv ate v o id Form l_L oad(o b je c t sender, E v e n t A r g s e)

{
p r iv a te void csoki_C heckedC hanged_l(object sender,

{
o s s z e g s t r i n g . T ext=" ";
i f ( c s o k i . Checked)
140
{
t e j . Checked = f a l s e ;
c u k o r . Checked = f a l s e ;
c i t r o m . Checked = f a l s e ;
t e j .A utoCheck = f a l s e ;
c u k o r .A utoCheck = f a l s e ;
c i t r o m . A utoC heck = f a l s e ;
}
else
{
t e j .A utoC heck = t r u e ;
c u k o r .A utoC heck = t r u e ;
c i t r o m . A utoC heck = t r u e ;
p riv ate void kave_C heckedC hanged(object sender,

{
o s s z e g s tr in g . Text = " ";
i f ( k a v e . Checked)
{
t e j . Checked = f a ls e ;
}
else
{
c i t r o m . A utoC heck = true;
p riv ate void tea_C heckedC hanged(object sender,

{
o sszeg strin g .T ex t = " ";
i f ( t e a . Checked)
{
t e j .A utoC heck = f a l s e ;
}
else
{
A TextBox
141
t e j .A utoC heck = tru e;
}
}
p riv ate void capu_C heckedC hanged(object sender,

{
o s s z e g s tr in g . Text = "
i f ( c a p u . Checked)
{
}
else
{
c i t r o m . A utoC heck = tru e;
p riv ate void tej_C heckedC hanged(object sender,

{
}
p riv ate void cukor_C heckedC hanged(object sender,
{
}
p riv ate void citrom _C heckedC hanged(object sender,
{
p riv a te void b u tto n 2 _ C lic k (o b je c t sender, E v e n t A r g s e)

{
o s s z e g s t r i n g . T e x t = 11 " ;
c s o k i . Checked = f a l s e ;
tea.C hecked = f a ls e ;
k av e.C h eck ed = f a l s e ;
capu.C hecked = f a l s e ;
tej.C h ec k ed = fa ls e ;
142
c i t r o m . Checked = false;
}
}
A szoftverfejlesztésben az évek során több projektmenedzsment modell alakult ki

azért, hogy egy keretrendszer vázat alkossanak a fejlesztés folyamatáról. Ezt
útmutatóként lehet használni a hatékony és átgondolt fejlesztéseknél, ahol adott az
egyes folyamatlépések sorrendje, elvégzésük módja és ideje.
A szoftverfejlesztési modellek történeti fejlődése során több modell is kialakult,
melyek közül az iteratív modellel ismerkedünk meg.
Ez a modell kockázatvezérelt szoftverfejlesztési módszeren alapul. Olyan
iterációkból áll, melyek folyamatosan ismétlődnek a munka során. Egy iteráció
négy fő részből áll. A termék fejlődése során többször is ismétlődik egy-egy
részfeladat, így a problémák hamar felismerhetők.
Ezen iterációk során a rendszer kibővül, de nem lesz bonyolultabb. Nagyon fontos,
hogy a megrendelő folyamatosan be legyen vonva vonva a fejlesztési tevékenységek
során.
Nézzük mindezt a gyakorlatban.

Tegyük fel, hogy az előző feladatot egy valós megrendelés alapján kell elkészíteni.
Leegyszerűsítve a szoftverfejlesztési részt az alábbi módon járhatunk el.
Iteratív programfejlesztésnél a felhasználóval történő előzetes egyeztetés után
elkészítjük a program dizájn részét, de kódot még nem írunk hozzá.
Ha megfelel a megrendelőnek, akkor folytathatjuk a munkát, ha nem, akkor meg
beszéljük min kell változtatni.
Ebben az esetben például bővíthető (vagy csökkenthető) az italok, vagy a
hozzávalók listája. Ez a kódolást még nem érinti csak a megjelenést. De módosulhat
ezáltal például az is, hogy melyik italhoz milyen hozzávaló tartozhat. Ez viszont
már a program kódolását is befolyásolja.
Ha mindennel kész vagyunk jöhet a tesztelés és ha ekkor sincs probléma, akkor a
feladatot sikeresen megoldottuk.
Természetesen, ha például a programban rögzített árak bármikor változnak - és ezt
jelzi a megrendelő - akkor ezt módosítani kell a megrendelő igényei szerint.
Ennek megfelelően a fenti feladatot is módosíthatjuk szükség szerint.
Jelenleg ha a teát kijelöljük az italok közül, akkor a tej le van tiltva. Gyakorlásképpen
módosítsuk úgy a programot, hogy a teához tejet is kérhessenek!
A T extB ox
143
60. feladat:
Készítsünk egy egyszerű számológépet, amely két szám között megjelenít egy
alapműveletet ( a / egyikét) és ennek megfelelően számítja ki az eredményt!
A műveleti jeleket egy legördülő listából (ComboBox) lehessen kiválasztani! Ha a
számokhoz nem írunk semmit, azt tekintse a program nullának! A ComboBoxban
alapesetben a „+” legyen látható!
Név: Formfeladató
Megoldás:
B8 Debug Daba Format Took window Help
JkàïàMAjL^àJl.. 3 bul«* - i J 1j X' S J • í

.
S ^ fa ge Forml.cs [Des*»] Forces
P Solution ,Formteladat6’(1 project)

B 23 Formfdadatb
m iiy Properties
m M References
S3 • 2^ Resources
oy bmp
J l gyok.bmp
8 a Forwl.es
m
IU Cemboßox
Forml.Desig
U Forml.resx
Program.es
?$j ContextMenuStríp
p OataGridView
igg DataSet
H DateTimePfcter
J 30 OrectoryEntry
5 OrectorySearcher
Propertfes - * X
\ LS OomahUpOown
Forml System.Windows.Forms.Form $\
0 ErrorProvider
g§ Eventtog HRffll
Jp FüeSystemWatcher RightToteft
'•* FlowUyoutPanel RightTourftlayout False
1
Q0 FontOîalog
Showlcon True
rv ; QroupBox v.j SfceGnpStyle Auto

Error list -r 9 X StertPosition WindowsDefaultLocati
. Tag
:J1S Í á S S
Description
lit) 0 Messages
File line Column Project
Text
TopHost
Alapműveletek
False
IL TransparencyKey ....□.... .. «
jveletek ¡g fip ll A program megírásához szükség van

ComboBox vezérlőelemre, amely
egy lenyíló lista. Ezt a listát a fel
használó nem tudja bővíteni. Elemeit
Com boBox Tasks a programozó rögzíti.
B Use data bound items
A ComboBoxot a két TextBox között
Unbound M ode
hozzuk létre, amelyekbe majd a szá
Edit Items
Törlés
mok kerülnek.
A ComboBoxot kijelölve a felső ré
szén megjelenő jobbra mutató nyílra
kattintva, a legördülő menüből az Edit Items String Collection Editorba kell bírni
a megfelelő műveleti jeleket egymás alá enterrel.
W in d o w s fo r m a p p l ic a t io n
144
A program:
nam espace F orm feladat6
{
p u b lic p artia l class Form l : Form
{
p u b lic F o r m l ()
{
I n i t i a l i z e C o m p o n e n t () ;
}
p riv ate v o id F orm l_L oad(object sender, E v e n t A r g s e)

{
p r iv a te void b u tto n l_ C lic k (o b je c t sender, E v e n t A r g s e)

{
double a = 0, b = 0, c = 0;
if ( a S tr in g . Text = = "") asz .T ex t = "0";
if (b S trin g . Text = = "") b sz.T ex t = "0";
a = C o n v ert.T o D o u b le(aS trin g .T ex t);
b = C o n v e r t. T o D o u b le ( b S trin g . Text) ;
if (jel.T ex t = = " + " ) c =a + b ;
if (jel.T ex t = = " - " ) c =a - b ;
if (j e l . T e x t = = "*")c =a * b ;
if (jel.T ex t = = " / " ) c =a / b ;
c S trin g .T e x t = C o n v ert.T oS tring(c) ;
}
p r iv a te void b u tto n 2 _ C lic k (o b je c t sender, E v e n t A r g s e)

{
aS trin g .T e x t =
b S trin g .T e x t =
V! T? .
c S trin g .T e x t =
jel.T e x t =
A T extB ox
145
p r iv a te void aS trin g _ T ex tC h an g ed (o b ject sender,

{
Az if (aString.Text = = ””) aString.Text = ”0”; rész valósítja meg a feladatkiírásban

leírt esetet, amely szerint ha nincs semmi a TextBoxban azt tekintsük nullának.
61. feladat:
Készítsünk egy egyszerű számológépet, amely az alapműveletek mellett számol
gyököt és köbgyököt! A számológépekhez hasonlóan egy C jelű gomb segítségével
töröljük szükség esetén a textbox tartalmát! A számológép működjön egérrel és
billentyűvel egyaránt! (kivéve a gyök és köbgyök esetén, itt csak egérrel)
Név: Formfeladat7
Megoldás:

Debug Data Format Tods Window
Ü
Toofcox Forml.cs [Design]
I* Pointer
w
® Button
0 ChedSox
0 0 0 0 GO
me
p DataGridVtew
3 DataSet 0 0 0 0 0
Ü DateTimePictter
{JQ DirectoryEntry
DiectorySearcher □ 0 0 □ E
C.I DomaMJpDown
ÜI ErrorProvider
iU Eventtog
0 00 0 0 RightToleft No
M FfeSystemWatcher RightToleftley» False
Showlcon True
m*
.^FontDiabg
wDiateg ShowInTaskbar True
3 Sse 443; 369
Qs StartPosfeon WndowsDefault
m Imagetist
A Label
à LinHabel
S j ..
146
A gyök és a köbgyök gombok Backgroundlmage részébe a Select Resource segít

ségével illesszük be a megfelelő háttérképet, amelyet valamilyen képszerkesztővel
már elkészítettünk. Ezt a gombokhoz tartozó Properties részben tehetjük meg.
A program:
using System ;
using S y stem .C o l le c t i o n s .G eneric;
using S y s te m . Com ponentM odel;
using S ystem .D ata;
using S y s te m .D raw ing;
using S y ste m .Linq;
using S y stem .T e x t;
using S y ste m .W in d o w s. Form s;
nam espace Form feladat7

{
p u b lic p artia l class Forrni : Form
{
p ublic F o r r n i ()
{
In itia liz e C o m p o n e n t();
}
d o u b l e szam = 0, e r e d m e n y = 0;
strin g je l =
s tr in g szöveg =
i n t v e s s z ő = 0;
p r iv a te void s a ja t( o b je c t sender, E ventA rgs e)
{
b u t t o n 5 . E nabled = tr u e ;
sz a m S trin g . F o c u s();
eredm eny = C o n v e rt. T o D o u b le (sz a m S trin g . T e x t ) ;
}
p riv a te void b u tto n 5 _ C lic k (o b je c t sender, E v e n t A r g s e)
{
if (jel == " + ")
{
szam = C o n v e r t . T o D o u b l e ( s z a m S t r i n g . T e x t ) ;
e r e d m e n y += s z a m ;
}
if (jel == "-")
A T extB ox
147
{
szám = C o n v e r t . T o D o u b l e ( s z a m S t r i n g . T e x t ) ;
ered m en y -= szam;
}
if (jel == "*")
{
e r e d m e n y *= s z a m ;
}
if (jel == "/")
{
if ( s z a m S t r i n g . T e x t == " 0 M | | s z a m S t r i n g . T e x t == " " )
{
s z a m S t r i n g . T e x t = " N u l l á v a l nem l e h e t o s z t a n i ! " ;
}
else
{
ered m en y /= szam;
sza m S trin g . Text = S t r i n g . F o rm at(C o n v ert.

T o S trin g (e re d m e n y ));
sz a m S trin g .S e le c t(s z a m S trin g . T e x t. L ength, 1);
s z a m S trin g . F o c u s();
e r e d m e n y = 0;
v e s s z o = 0;
}
p r iv a te void szam S tring_T extC hanged(object sender,
{
i n t u=0;
b u t t o n l .E nabled = tr u e ;
b u t t o n 2 .E nabled = tr u e ;
b u t t o n l 7 .E nabled = tr u e ;
b u tto n 2 0 .E nabled = tr u e ;
i f ( s z a m S t r i n g . T e x t != " " )
{
szoveg = C o n v e rt. T o S trin g (s z a m S trin g . T e x t);
148
u = s z ö v e g . L e n g t h - 1;
if (szoveg[u == i | szöveg[u] == V' 11
\ _ r
szöveg[u] == '+ ' 11 szöveg[u] == 11
s z ö v e g [ u ] == ' c ' )
;i
sza m S trin g . Text =
}
else
y r
if ( s z ö v e g ! [u] ! = && s z o v e g [ u ] != r &&
'1 ' &&
O
szöveg[u] szoveg[u] !=
II &&
'3 '
CM
szöveg[u] szoveg[u] !=
ta
II
ScSc
&
szöveg[u] szoveg[u] != '5 '
II
szöveg[u] szoveg[u] != '7 ' &&

II
szoveg[u] ! = ' 8 ' && s z o v e g [ u ] != A9 ' )

{
i f ( s z a m S t r i n g . T e x t == " N i n c s v a l ó s m e g o l d á s " )
s z a m S trin g .T e x t = "Nincs v a ló s m egoldás";
else
s z a m S t r i n g . T e x t = "nem s z á m " ;
v e s s z ő = 0;
p r iv á té void b u tto n l_ C lic k (o b je c t sender, E v e n t A r g s e)

{
sajat(n u ll, n u ll);
j e l = "+";
szam S trin g .T ex t = "";
v e s s z ő = 0;
}
p riv á té void b u tto n 2 _ C lic k (o b je c t sender, E v e n t A r g s e)
{
s a ja t (null, n u l l ) ;
jel =
szam S trin g .T ex t = "";
v e s s z ő = 0;
}
p r iv á té void b u tto n 3 _ C lic k (o b je c t sender, E v e n t A r g s e)
{
sajat(n u ll, n u ll);
j e l = "*";
A T extB ox
149

v e s s z ő = 0;
}
{
s a ja t (null, n u l l ) ;
je l = "/";
v e s s z ő = 0;
}
{
b u tto n 5 . E nabled = tr u e ;
sza m S trin g . Text = "";
s z a m S t r i n g . F o c u s () ;
v e s s z ő = 0;
}
p r iv a te void b u tto n l7 _ C lic k (o b je c t sender, E v e n t A r g s e)
{
b u tt o n 5 . E nabled = f a ls e ;
szam = C o n v e r t . T o D o u b l e ( s z a m S t r i n g . T ex t) ;
i f ( s z a m < 0) s z a m S t r i n g . T e x t = " N i n c s v a l ó s
m egoldás";
else
{
eredm eny = M ath . S q rt (szárad
s z amSt r i n g . T e x t = S t r i n g . F o r m a t ( C o n v e r t .
s z a m S tr in g . S e l e c t ( s z a m S tr in g . T e x t . Length, 1);
v e s s z ő = 0;
}
}
p riv ate void Form l_L oad(object sender, E ventA rgs e)
{
}
p r i v a t e v o id Form l_Show n(object se n d e r, E v e n t A r g s e)
{
b u t t o n l .E nabled = f a ls e ;
150
b u tto n 2 .E nabled = f a ls e ;
b u t t o n 3 . E nabled = f a l s e ;
b u t t o n l 7 .E nabled = f a ls e ;
b u tto n 2 0 .E nabled = f a ls e ;
}
{
s z a m S t r i n g . T e x t += " 0 " ;
s z a m S trin g . S e le c t( s z a m S tr in g . T e x t. L ength, 1 );// az
u to ls ó k a ra k te r után á l l a kurzor
}
{
s z a m S t r i n g . T e x t += " 1 " ;
s z a m S tr in g .S e le c t( s z a m S tr in g . T e x t. L ength, 1);
}
{
s z a m S t r i n g . T e x t += " 2 " ;
s z a m S tr in g .S e le c t( s z a m S tr in g .T e x t. L ength, 1);
}
{
s z a m S t r i n g . T e x t += " 3 " ;
s z a m S trin g . S e l e c t ( s z a m S tr in g . T e x t. L ength, 1);
}
p r iv a te void b u tto n lO _ C lick (o b je ct sender, E v e n t A r g s e)
{
s z a m S t r i n g . T e x t += " 4 " ;
s z a m S tr in g .S e le c t( s z a m S tr in g . T e x t. L ength, 1);
}
p riv a te void b u tto n ll_ C lic k (o b je c t sender, E v e n t A r g s e)
{
s z a m S t r i n g . T e x t += " 5 " ;
A T extB ox
151
s z a m S t r i n g . S e l e c t (s z a m S t r i n g . T e x t . L e n g th , 1);
}
{
s z a m S t r i n g . T e x t += " 6 " ;
sza m S trin g .S ele ct(sza m S trin g .T e x t.L en g th , 1);
}
private void b u tto n 7 _ C lick (o b ject sender, E v e n t A r g s e)
{
s z a m S t r i n g . T e x t += " 7 " ;
s z a m S trin g . S e l e c t ( s z a m S t r i n g . T e x t . L ength, 1);
}
private void b u tto n 8 _ C lic k (o b je c t sender, E v e n t A r g s e)
{
s z a m S t r i n g . T e x t += " 8 " ;
s z a m S trin g . S e l e c t ( s z a m S tr in g . T e x t . Length, 1);
}
private void b u tto n 9 _ C lic k (o b je c t sender, E v e n t A r g s e)
{
s z a m S t r i n g . T e x t += " 9 " ;
s z a m S trin g . S e l e c t ( s z a m S tr in g . T e x t . Length, 1);
}
{
s z a m S t r i n g . T e x t +=
s z a m S t r i n g .S e l e c t ( s z a m S t r i n g .T e x t . L ength, 1);
vesszo++;
i f ( v e s s z o > 1) s z a m S t r i n g . T e x t = " n e m s z a m " ;
}
p riv ate void szam S tring_K eyP ress(object sender,
K e y P r e s s E v e n t A r g s e)
{
if ( e . K e y C h a r == 1 3 ) b u t t o n 5 . P e r f o r m C l i c k ( ) ; / /
enter
i f ( e . K e y C h a r == 4 3 ) b u t t o n l . P e r f o r m C l i c k () ; / / +
i f ( e . K e y C h a r == 4 5 ) b u t t o n 2 . P e r f o r m C l i c k () ; / / -
152
i f ( e . K e y C h a r == 4 2 ) b u t t o n 3 . P e r f o r m C l i c k ( ) ; / / *
if ( e . K e y C h a r == 4 7 ) b u t t o n 4 _ C l i c k ( n u l l , n u l l ) ;
// per
if ( e . K e y C h a r == 99) b u t t o n 6 _ C l i c k ( n u l l , n u l l ) ;
// c
i f ( e . K e y C h a r == 4 4 ) v e s s z o + + ;
i f ( e . K e y C h a r == 44 && v e s s z ő > 1) s z a m S t r i n g .
T e x t = "nem s z á m " ;
}
{
s z a m S tr in g . Focus ();
s z a m S t r i n g . T e x t = S t r i n g . F o r m a t ( C o n v e r t . T o S t r i n g (-
szam ));
s z a m S trin g . S e le c t( s z a m S tr in g . T e x t . Length, 1);
v e s s z ő = 0;
}
p riv a te void bu tto n 2 0 _ C lick (o b ject sender, E v e n t A r g s e)
{
e r e d m e n y = M a t h . S i g n (szam) * M a t h . P o w ( M a th .
A bs(szam ), (1 /3 .0 ));
sza m S trin g .T e x t = S t r i n g . F o rm at(C o n v ert.
s z a m S tr in g .S e le c t( s z a m S tr in g . T e x t . L ength, 1);
v e s s z ő = 0;
A szám gombokhoz tartozó alprogramokba be kell írni a programban szereplő egyet

len TextBox aktuális értékét. A TextBox neve szamString.Text. Az értékadáshoz a
+= operátort célszerű használni, amely egyenértékű a szamString.Text = szamString.
Text + ’’valami” művelettel, ahol a valami az adott gombhoz tartozó számérték.
A szamString.Focus(); a szamString.textBoxba fókuszálja, állítja a kurzort.
A szamString.Select(szamString.Text.Length, 1); pedig a TextBox sorában az
utolsó karakterre állítja a kurzort.
A T extB ox
153
A priváté void Forrni _Shown részben a program indulása után azonnal a TextBoxba
állítjuk a kurzort és inaktívvá tesszük a műveletek és az egyenlőség gombjait.
A Forrni Shown részbe viszont csak akkor tudunk írni, ha előtte a Forml-hez tar
tozó Properties ablakban a sárga villám jelre kattintunk, és ott megkeressük a Shown
sort. Erre kettőt kattintva bemásolódik a megfelelő rész a program szövegébe.
Hasonlóképpen érhetjük el a szamString TextChanged és KeyPress eseményeit is,
ahol az előbbi a szövegdoboz tartalmának változásakor aktivizálódik, az utóbbi pedig
a szövegdobozban történő billentyűleütéskor fut le. A két esemény nem ugyanaz, mert
a szövegdoboz tartalma változhat billentyűleütéssel, vagy a számgombra kattintva is.
A szamString TextChanged-bzn aktívvá tesszük a műveletek gombjait, majd ha a
szamString. Text - azaz a szövegdoboz - már nem üres, akkor ebből konvertálunk
egy szöveg nevű sztringet, amelynek mindig az utolsó karakterét vizsgáljuk meg.
Ha ez az utolsó karakter egy műveletijei vagy a C billentyű, akkor a szövegdoboz
tartalmát töröljük.
Ha viszont a szövegdoboz még üres, akkor megvizsgáljuk, hogy milyen billentyű
vagy gomb került leütésre, ill. lenyomásra és csak a decimális számjegyeket, a
vesszőt és a negatív előjelet fogadjuk el.
Ha nem jó értéket kapunk kiírjuk, hogy a beírt érték nem szám. A ’’nincs valós
megoldás” csak gyökvonás esetén léphet fel, ha negatív számból próbálunk négy
zetgyököt vonni. A vessző változó értékét pedig lenullázzuk, ha elhagyjuk a szö
vegdobozt. Ezt azért kell elvégezni, mert egy szám beírásakor csak egy vesszőt
használhatunk, ha viszont újabb számot írunk a szövegdobozba, akkor újból hasz
nálhatunk egy vesszőt, de többet nem.
Az operátor gomboknál meghívjuk a sajat nevű függvényt, amely a button5, vagy
is az egyenlő gombot teszi aktívvá (inaktívvá pedig a gyök és köbgyök műveletek
során válhat, mivel ekkor az egyenlő gombra értelemszerűen nem kattinthatunk).
Továbbá itt fókuszáljuk a kurzort a szövegdobozba, előállítjuk a szamString.Text-
ből az eredményt, mint számot, és beállítjuk a je l értékét.
A button5-ben az egyenlő gomb eseményvezérlőjében a műveleti jelektől függően
kiszámoljuk az eredményt, és a String.Form at segítségével megjelenítjük a
TextBox-bm.
A buttonl8-bdL\\ a vesszőt, mint karaktert adjuk hozzá a szöveghez és számoljuk is,
hogy hány vessző van a szövegdobozban. Ha egynél több, akkor az már nem szám
és ezt ki is íratjuk.
A button79-ben a szám változó értékét szorozzuk —1-el, és ki is írjuk a szamString.
Text segítségével.
A négyzetgyökvonás a buttonl 7-ben történik. Ha a szám negatív, akkor nincs meg
oldás a valós számok halmazán, egyébként viszont kiszámoljuk és kiíratjuk a gyököt.
154
Köbgyök estén egyszerűbb a dolog, itt nem kell figyelni a negatív értékre, mivel
köbgyöke negatív számnak is van. Fontos azonban a köbgyök kiszámítási módja:
a Math.Sign(szam) a szám előjelétől függően 1 vagy -1 (signum függvény) a
Math.Pow hatványoz.
Itt kell egy alap és egy kitevő. Az alapot vehetjük pozitívnak, mert a végeredmény
helyes előjeléről a signum függvény gondoskodik. A kitevő tört lesz, és nem vélet
lenül van 1/3.0 írva. Ha csak 1/3 lenne, akkor egész osztásnak venné a C# és 1/3
egész része az nulla lenne, ami esetünkben helytelen. Az 1/3.0 viszont valóban egy
tizedestört formát ad, így már az alap a megfelelő kitevőre lesz emelve.
A szamString.KeyPress-ben az adott billentyűkódhoz van hozzárendelve a megfe
lelő gomb, amelyet két módon is elérhetünk. A PerformClick-kel, vagy a Click-kel,
de utóbbinál kötelező két paramétert megadni a függvényhívás miatt.
A C# nyelv széleskörű alkalmazásának csupán a töredéke az, amit eddig sikerült
bemutatni. Kezdő lépésként azonban ez a segédlet megfelelő alapot nyújt minden
ki számára, hogy ezzel a programozási nyelvvel megismerkedjen, és a továbbiak
ban bátran használja informatikai problémák megoldásában. A mai modem, tech
nikailag rohamosan fejlődő világunkban természetes, hogy ez nyelv is változik, és
változni is fog, de nagy valószínűséggel még - informatikai téren sokáig - évekig
használható a C# nyelv.
155
8. WINDOWS PRESENTATION
FOUNDATION
A Windows Presentation Foundation (WPF) a Microsoft keretrendszere, amellyel

asztali alkalmazások grafikus felhasználói felületét és működését készíthetjük el a
webfejlesztésre jellemző szemlélet szerint. A WPF alapvetően épít a Windows
Forms-nál megismert elemekre, de annál több. A keretrendszer segítségével a lát
ványtervezők és programozók az XAML (Extensible Application Markup
Language) bővíthető alkalmazás-jelölőnyelv és az ezt támogató eszközökkel zök
kenőmentesen és nagy hatásfokkal fejleszthetnek együtt. Szintén nagy segítség,
hogy a rendszer támogatja a multimédiás anyagok elhelyezését az alkalmazások
ban. A WPF a vektorgrafikus rendszert használja, ennek minden előnyével együtt.
(PL: átméretezhető grafikák minőségromlás nélkül, stb.)
Ez a fejezet egy nagyon rövid betekintést ad a WPF keretrendszerről. A segédlet
célja néhány lehetőség bemutatása a teljesség igénye nélkül, illetve az érdeklődés
felkeltése.
8.1. A W PF használata
Ha WPF-t szeretnénk használni, akkor a New Project után a WPF App (.NET
Framework) segítségével megadjuk a Project nevét és kiválasztjuk a helyet. Ekkor
az előttünk megjelenő képernyő úgy, vagy ahhoz nagyon hasonlóan néz ki, mint a
következő ábrán.
A Windows Form és WPF ablak része nem igazán tér el első ránézésre. Ami újdon
ság, az a középen alul megjelenő rész, amely a HTML-re emlékezteti azokat, akik
már foglalkoztak weblapkészítéssel.
Mint láthatjuk, itt a felül megjelenő ablak tulajdonságai, többek között a mérete
jelenik meg. Ezek a tulajdonságok a Formnál is megtalálhatók, de itt azonnal lát
ható. A ToolBox, a Solution Explorer és az Error List sem tér el jelentősen a
Windows Formnál megszokottól. A Properties viszont már csak „nyomokban”
W in d o w s P r e s e n t a t io n F o u n d a t io n
156
emlékeztet a Form ugyanezen részére, mivel jónéhány tulajdonságot megtalálunk

itt is, de több olyan is van, amely csak a WPF-re jellemző.
i apvj QuickUunch (Cüfc-Ofr
Rk Erfít View Pioject Bt»ki Debug Team Design Format Topfe Test Analyze Window Help
m
o - % I ♦ Ss u j*jo » o* .j, - ^ ■>-1 m 2 2 1_
1_____
Q3 Solution *WpfAppV(1 project)

H Border
- 0 WpfAppI
CJ Button
(✓ ] CKeckBox
Ű App.config
> £3 Appjcaml
► O MainWindow.)
□ Rectangle
Il StackPand
—- TabControl
(U TextBlock
►
All WPFControls
Arrangefay:Category ’
E3Window • p i Window
1 E <Window x :C la ss = "W p fA p p l.M a in W in d o w " li
this group. Drag an 2 x m ln s= “h t t p : / / s c h e m a s .m i c r o s o f t . c o m /w in f x /2 0 0 6 / x a m l/p r e s e n t a tio n " -f
itemonto this text
to add it to the 3 x m ln s:x = ”h t t p : / / s c h e m a s .m i c r o s o f t . com /w in fx /2 0 0 6 /x a m l"
4 x m ln s:d = “h t t p : / / s c h e m a s . m ic r o s o ft .c o m / e x p r e s s io n / b le n d / 2 0 0 8 “
5 x m ln s :mc=”h t t p : / /s c h e m a s . o p e n x m lfo r m a ts.o r g / m a r k u p - c o m p a t i b i li t y / 2006“ |
6 x m ln s : l o c a l = “c lr -n a m e s p a c e :W p fA p p l"
7 m c :Ig n o r a b le = “d"
8 T i t l e = “MainW indow ” H e ig h t = “2 8 6 .6 5 9 ” W id t h s "4 7 8 .7 1 2 “>
9 ¡0 3; < G rid >
18
11 < /G r id >
12 </Window>
....
ü l .... v1 3 ....... . ........ .... . .... . ... ..... .. . .
A különböző vezérlőelemeknél eltérő, hogy milyen tulajdonságok módosíthatók a

Formokhoz hasonlóan és melyek térnek el, illetve bővült is a lehetőségek sora.
Csak az érdekesség kedvéért WPF-ben nagyon egyszerű a különböző vezérlőele
mek elforgatása a Properties-Transform-Rotate segítségével, ahol a szöget adhat
juk meg. Ugyanitt a Rotate melletti Scale az x és y irányú átméretezést teszi lehe
tővé egyszerű módon.
Megemlítendő, hogy a Formoknál megszokott módtól eltérően itt nem lesz auto
matikusan ellátva névvel az adott elem. Nekünk kell nevet adni mindennek, ha ez
a programozáshoz szükséges.
A Properties könnyebb használata miatt néhány fontosabb tulajdonság beállítását

soroljuk fel az alábbiakban a teljesség igénye nélkül:
• Brush: a vezérlőelemek háttér- és betűszíne módosítható.

• Layout: a szélesség, magasság, az igazítás és a margók beállítása.
• Text: betűtípus és méret, valamint stílus. Pl: félkövér.
• Appearance: átlátszóság, láthatóság, keretek.
A B utton
157
• Common: a leggyakrabban használt tulajdonság a Content, amellyel a tartalom

módosítható.
• Transform: a korábban említetten kívül az eltolás és döntés is könnyen módo
sítható.
A Layout komponens használata a különböző vezérlőelemek esetén nagyon hason

lít a word-ben található elrendezési lehetőségekhez. A fent említett tulajdonságok
beállítása pedig a HTML-ben használt módon történik.
Például egy téglalap beállítása az alábbi módon történhet a Layout komponens
segítségével:
< R e c ta n g le x:N am e="nev" H e ig h t= " 2 0 0 " W idth= "100"

H orizo n talA lig n m en t= "C en ter" V e rticalA lig n m en t= "C en ter"
M argin= "0,0 , 0 , 0"> < /R ectangle>
A téglalap neve után megadjuk a magasságot, a szélességet, vízszintes és függőle

ges igazítás és a margók értékeit.
A Windows Formok ismerete után a programozás tekintetében nagyon sok hason

lóságot fogunk tapasztalni, de természetesen bonyolultabb programoknál jelentős
eltérés is lehet a Form és a WPF között.
Ő.2. A Button
A Button használata itt is egyszerű. Nézzük meg egy konkrét példán keresztül.
62. feladat:
Készítsünk alkalmazást, amely gombra kattintva kiírja: Első WPF-es programom.
Egy másikgombra kattintva pedig kilép!
Név: WPF1
A Windows Formhoz hasonlóan itt is az adott gombra kettőt kattintva megjelenik a
gomb click eseménye esetén lefutó alprogam kódja, ahová be kell írni, az alábbi kódot:
label.Content = "Első WPF-es programom";
158
»4j «feoWPF*MkrowftVwiiiStüd» ggj¡$?gQutcklUunch(CüHQ)

fcft Vfc* Pwject B«i« Otbus Twn Oe«* tornát Took Test Ar*fc*e Vön**. Help
O-.. ;&>&H#| ' Vrföebug:¡Í^u“ ~ .:•.!** V*
Ez viszont csak akkor fog működni, ha előtte létrhoztunk egy lábéit, amelynek a
hátterét ugyanolyanra állítjuk, mint az ablakét, így nem látszik a helye és a tartal
ma. Utóbbi csak akkor, ha az OK gombra kattintunk.
AKilép-re kattintva kettőt, írjükbe a F ormoknál már megismert t h i s . C l o s e () ;
utasítást.
Láthatjuk, hogy ami a Formnál a label.Text az a WPF-ben a label.Content.
Természetesen módosíthatjuk tetszés szerint a MainWindow.xaml alatti Window
részben az ablak, vagy a vezérlőelemek méreteit. A Margin, a Width, a Height,
vagy a FontSize utáni értékek módosítása után megfigyelhetjük a változásokat.
< B u tto n x :N am e= "button" Content="O K "
H o r i z o n t a l A l i g n m e n t =,,L e f t " M a r g i n = " 1 1 8 , 2 0 3 , 0 , 0 "
V e r t i c a l A l i g n m e n t = " T o p " W i d t h = " 104" H e i g h t = " 39"
F o n t S i z e = " 18" C l i c k = " b u t t o n C l i c k " / >
8.3. A TextBox
A TextBox használata sem fog sok újdonsággal szolgálni. Fontos lesz azonban az
elnevezésekre odafigyelni, amit a Properties Name részben tehetünk meg, mivel a
program során ezeket használni fogjuk.
A T extB ox
159
63. feladat:
Készítsünk alkalmazást, amely az alábbi forma szerint épül fel és kiszámolja egy
alap és kitevő megadása esetén a hatványt!
Név: WPF2
p riv á té void b u tto n _ C lic k (o b je c t sender, R o u t e d E v e n t A r g s e)

{
double alap = C o n v e r t. T o D o u b l e ( a l a p S t r i n g . Text) ;
double kitevő = C o n v ert.T o D o u b le(k itev o S trin g .T ex t) ;
double eredmeny = M a th .P o w ( a la p ,k ite v ő ) ;
ered m en y S trin g . Text = e r e d m e n y . T o S t r i n g () ;
A fenti kódsorokat beírva - a Kiléphez a this.Close(); -t elhelyezve - a kívánt mű

ködést kapjuk.
Láhatjuk, hogy a változódeklarácó, a konvertálás és a TextBoxra történő hivatko
zás is a megszokott módon történik. Itt azonban a szövegdoboz tartalmára való
hivkozást továbbra is a Text valósítja meg és nem Content, mint a button, vagy a
label esetén.
64. feladat:
Készítsünk alkalmazást, amely alábbi forma szerint épül fel és kiszámolja, majd
kiírja a másodfokú egyenlet együtthatóinak ismeretében a gyököket!
Név: WPF3
160
p riv a te void b u tto n _ C lick (o b je ct sender, R o u t e d E v e n t A r g s e)

{
d o u b l e x l = 0 , x2 = 0 , a = 0 , b = 0 , c = 0, d = 0 ;
s t r i n g s z ö v e g = 11" ;
a = C onvert.T oD ouble(aS tring.T ext);
b = C o n v ert.T o D o u b le(b S trin g .T ex t);
c = C onvert.T oD ouble(cS tring.T ext);
d = b * b - 4 * a * c ;
i f (d >= 0)
{
x l = ( - b + M a t h . S q r t (d) ) / (2 * a ) ;
x l = M a t h . R o u n d ( x l * 100) / 1 00;
x2 = ( - b - M a t h . S q r t (d) ) / (2 * a ) ;
x2 = M a t h . R o u n d ( x 2 * 1 0 0) / 1 0 0 ;
s z ö v e g = x l . T o S t r i n g () ;
x lS tr in g .C o n te n t = szöveg;
szöveg = x 2 . T o S tr in g ();
x 2 S trin g .C o n ten t = szöveg;
}
else n in csG y o k S trin g .V isib ility = V isib ility .V isib le ;
A Formnál már látott kódsort változtatás nélkül be lehet másolni és már működik
is a WPF-es program.
De hogy mégse legyen ugyanaz a megoldás, itt a gyökök nem létezése esetén a
nincsGyokString labelünknek nem az értékét változtatjuk meg, mint a Formnál,
hanem a láthatóságát.
A z Im age
161
<Label x:Name="nincsGyokString" Visibility-'Hidden" Grid.ColumnSpan="3"

Content="Nincs gyök" HorizontalAlignment="Left" Margin=" 119,366,0,0"
VerticalAlignment="Top"/>
A fenti kódrészletben látható, hogy a címke tartalma kezdettől fogva a Content
utáni rész lesz, de a láthatósága tiltva van. Ezt megtehetjük a Properties-
Appearance-Visibility Hidden-re állításával, de a programban is megvalósíthattuk
volna így:
p u b lic MainW indowO

{
I n i t i a l i z e C o m p o n e n t () ;
n in csG y o k S trin g .V i s i b i l i t y = V i s i b i l i t y . H idden;
}
8.4. Az Im age
Az Image használata lehet egyszerű, de bonyolult is, attól függően, hogy mit szeret
nénk megvalósítani a program futása során. Képet több módon is elhelyezhetünk az
ablakba, vagy akár gomb, esetleg más vezérlőelem háttereként. Ha gomb hátterébe
helyezzük el, akkor a Solution Explorer részben célszerű egy pl.: image könyvtárt
létrehozni és az abban elhelyezett képeket erőforrásként hozzáadni a programhoz,
így a kép megjelenik a gomb hátterében, de ha az egeret fölé visszük, akkor sajnos
a kép eltűnik. Ez kezdő programozóknak problémát jelent, mivel az alapbeállítást
kell megváltoztatni a gomb viselkedését illetően, ami nem egyszerű feladat.
Nézzünk most egy egyszerű, de közismert játék megvalósítását WPF-ben.
65. feladat:
Készítsünk alkalmazást, amellyel a kő, papír, olló játékot lehet játszani a számító
gép ellen!
Tegyük fel,hogy többen is szeretik ezt a játékot egy családban és mindig annak a
képe jelenik meg, aki éppen játszik.
Az egyszerűség kedvéért legyen két felhasználó, de természetesen a program köny-
nyen bővíthető, több felhasználó is használja a programot.
A képek alatti gombra kattintva eltűnik az éppen nem játszó felhasználók képe és
megjelennek a játékhoz szükséges vezérlőelemek. Ehhez az alábbi elrendezést
célszerű kialakítani.
162
Név: WPF4
A XAML rész:
<Wi ndow X : N a me = ,fw i n d o w lf x : C l a s s = " W P F 4 . M a i n W i n d o w "
x m l n s = ,fh t t p : / / s c h e m a s . m i c r o s o f t . c o m / w i n f x / 2 0 0 6 / x a m l /
presentation"
x m ln s:x="h t t p : / /s c h e m a s .m ic r o s o f t. com /w infx/2006/
x a m l 11
x m ln s:d="h t t p : / / s c h e m a s .m ic r o s o f t. co m /ex p ressio n /
blend/2008"
xm lns:m c="h t t p : / / s c h e m a s . o p e n x m lfo rm a ts . o rg /m a rk u p -
co m patibility/2006"
x m l n s : l o c a l = " c l r - n a m e s p a c e : WPF4"
me : I g n o r a b l e = " d "
T itle = " K ő P a p ir O lló " H eig h t= "8 0 0 " W idth="1200"
MaxW i d t h = " 1 2 0 0"
M a x H e i g h t = " 8 0 0 " M i n W i d t h = " 1 2 0 0 " M i n H e i g h t = "8 0 " >
<Grid>
< B u tto n x :Name="m anolButton" C o n te n t= "M a n ó l"
H o riz o n ta lA lig n m en t= "L eft" M argin= "259,3 6 7 ,0 ,0 "
V e rtic a lA lig n m e n t= " T o p " W idth="100" C lic k = " B u tto n _
C lick" R enderT ransform O rigin= "2.5 6 5 ,3 .9 7 9 "
H e i g h t = " 30" F o n t S i z e = " 1 6 " />
< B u tto n x :Name="mano2Button" C o n te n t= "M a n o 2 "
V e rtic a lA lig n m e n t= " T o p " W idth="100"
C lick="m ano2B utton_C lick" R enderT ransform O rig
i n = " l .3 4 4 ,2 .8 4 4 " H eight="30" F o n tS ize = "1 6 "/>
<Image x :Name="manol" H o r i z o n t a l A l i g n m e n t = " C e n t e r "
M arg in = "7 9 ,67,654,388" S ource= "m anol. jpg"
S t r e t c h = " F i l l " M in W id th = "192" M i n H e i g h t = " 192"
V e r t i c a l A l i g n m e n t = " C e n t e r " M axW idth="192"
M axHeight="192" S c r o l l V i e w e r . V e r t i c a l S c r o l l B a r V i s i b i
lity = " A u to " S tretchD irection= "D ow nO nly"
S crollV iew er.H orizo n talS cro llB arV isib ility = "A u to ">
<Im age. R enderTransform >
<Transform Group>
< S caleT ransform />
<SkewTransform/>
< R otateT ransform A ngle="0"/>
< T ranslateT ransform />
</Transform G roup>
< /Im a g e . R enderTransform >
A z Im a g e
163
</Im age>
< Image x:Name="mano2" M a r g i n = " 3 5 5 , 6 7 , 4 3 9 , 3 7 5 "
Source="m ano2. j p g ” S t r e t c h = " F i l l ”
H o r i z o n t a l A l i g n m e n t = " C e n t e r ” M axW idth="124"
M axH eight="205” V e r tic a lA lig n m e n t= " C e n te r "
S crollV iew er.H o rizontalS crollB arV isibility= "A uto"
S cro llV iew e r.V ertica lS cro llB arV isib ility = "A u tó "
M in W id th = "124" M i n H e i g h t = " 2 0 5 " / >
< L ab el x:Name="j a t e k " C o n t e n t = " J á t é k "
H orizo n talA lig n m en t= "L eft" M argin= "844,174 ,0 ,0 "
V erticalA lig n m en t= "T o p " F ontS ize= "20" R e n d erT ran sfo r
m O rigin= "2.253,2.589"/>
< L ab el x:Name="gep" C o n te n t= " "
V erticalA lignm ent= "T op" R enderT ransform O rig
i n = " 0 .0 2 8 ,0 . 1 9 4 " Background="#FFFlE6CD"
FontS ize= "20"/>
< B u tto n x :Name="buttonKo" C o n ten t= "K ő "
V e r t i c a l A l i g n m e n t = " T o p " W i d t h = " 75" F o n t S i z e = " 20"
C lick = "b u tto n K o _ C lick " R enderT ransform O rig
in = "2 .1 5 5 ,3 .4 2 8 "/>
<B utton x :N a m e= "b u tto n P ap ir" C o n te n t= " P a p ir"
V e rtic a lA lig n m e n t= "T o p " W idth="75" F o n tS ize = "2 0 "
C lick = "b u tto n P ap ir_ C lick "/>
< B u tto n x :N am e="button011o" C o n ten t= "0 1 1 ó "
H orizo n talA lig n m en t= "L eft" M argin= "984,33 3 ,0 ,0 "
V e rtic a lA lig n m e n t= "T o p " W idth="75" F o n tS ize = "2 0 "
C lick= "button011o_C lick"/>
< B u t t o n x : Name="ok" C o n t e n t = " O K "
H orizo n talA lig n m en t= "L eft" M argin= "823,40 6 ,0 ,0 "
V e rtic a lA lig n m e n t= "T o p " W idth="75" FontW eight="B old"
F ontS ize="20" C lic k = "o k _ C lic k " />
CLabel x :Name="gepPontLabel" C ontent="G ép p o n t s z á
ma: " H o r i z o n t a l A l i g n m e n t = " L e f t " M a r g i n = " 3 3 5 , 4 6 2 , 0 , 0 "
V e rtic a lA lig n m e n t= "T o p " F ontW eight="B old"
F ontS ize= "22"/>
<Label x :N a m e = "ja te k o so n tla b e l" C o n te n t= "Já té k o s
p o n t s z á m a :" H o r i z o n t a l A l i g n m e n t = " L e f t "
M argin= "299,5 3 6 ,0 ,0 " V erticalA lignm ent= "T op"
FontW eight="B old" F o n tS iz e = " 2 2 " />
< L a b e l x : N a m e = " g e p P o n t " C o n t e n t = " 0"
164
H o riz o n ta lA lig n m e n t= ”L e f t ” M argin=”5 8 2 ,4 6 2 , 0 ,0 ”

V e rtic a lA lig n m e n t= "T o p ” F o n tS iz e = ”22"/>
< L a b e l x : N a m e = " j a t e k o s P o n t ” C o n t e n t = " 0"
H o r i z o n t a l A l i g n m e n t = f,L e f t ” M a r g i n = ” 5 8 2 , 5 3 6 , 0 , 0 ”
V e r t i c a l A l i g n m e n t = ” Top" F o n t S i z e = ” 2 2 " / >
< B u t t o n x : N a m e = " u j J á t é k ” C o n t e n t = ” Új j á t é k ”
H o r i z o n t a l A l i g n m e n t = " L e f t ” M a rg in = ” 605, 6 2 8 , 0 , 0 "
V e r tic a lA lig n m e n t= ”Top” W idth=” 125”
F o n t F a m i l y = ” Y e l l o w t a i l " H e i g h t = ” 5 5 ” F o n t S i z e = ” 36"
C lic k = "u j J a t e k _ C l i c k ”/>
< / G rid>
</Window>
Természetesen nem kell a fenti értékeket (szélesség, magasság, margók, stb.) pon
tosan így beállítani, mivel a program ettől eltérő értékek esetén is helyesen fog
működni. A képek helyére is tetszőleges figurák, arcok tehetők be, csupán a mére
tekre kell odafigyelni. Az elrendezés és a színek is módosíthatók, a lényeg, hogy
jól láthatók legyenek az elemek a program futása során.
j* Properties
■■ References
Ö App.config
ű App.xaml
MainWíndowjcaml
@ mano1.jpg
@ mano2.jpg
A r r a n g e b y : C a t e g o iy ~
* la y o u t
W id th 11200 jS S «
H e ig h t ' ¡8 0 0 {» »
M in W id th 11200 !■ !
M in H e ig h t |« > N
H o r á o n t a iA li.. f=7
i »1
H o riz o n ta le © ... | § r ] 3 ? ^ |= j 1] a
V e r tic e iC o n te — f f f | t t : i l 1 H a
V ertica lA S g n ... n iïT ¥ I Î Î D | í a
L eft 1 A u to _____ k
H a l-fo S
«r?zi«iEZ¡
T op j A u to 1°
♦ I ® Window (window)
A
Lass="WPF4.MainWindow" M a x W id th 11200 !•
as.microsoft.com/winfx/2006/xaml/presentation" M a x H e ig h t 800 11
amas.microsoft.com/winfx/2006/xaml" S cro tIV Iew er« - [D is a b le d
S cro iiV iew er.V ... | V isib le • N
R o w D ir e c tio n f L eftT o R ig h t "N
G rtd J sS h a red « . □ Q
A felhasználókat Manói és Manó2 néven láthatjuk a fenti ábrán. Az átméretezhe-

tőség megakadályozása érdekében a Properties részben az 1200x800-as méreteket
ajánlott beállítani alapként és ugyanezeket az értékeket a maximális és minimális
méretekhez is.
A z Im a g e
165
A program kódja:
using System ;
using S y stem .C o llectio n s.G en eric;
using S ystem .L inq;
using S y stem .T ex t;
using S ystem .T h read in g .T ask s;
using S y s te m . Windows;
using S ystem .W indow s.C ontrols;
using S ystem .W indow s. D ata;
using S y ste m .W in d o w s. Documents;
using S ystem .W indow s. I n p u t;
using S ystem .W indow s.M edia;
using S ystem .W indow s.M edia. Im aging;
using S ystem .W indow s.N avigation;
using S ystem .W indow s. S hapes;
n a m e s p a c e WPF4
{
I I I <summary>
I I I I n t e r a c t i o n l o g i c f o r MainWindow.xaml
I I I </summary>
p u b l i c p a r t i a l c l a s s M a i n W i n d o w : Wi ndow
{
public M a i n W i n d o w ()
{
In itia liz e C o m p o n e n t();
ja te k .V is ib ility = V isib ility .H id d e n ;
g e p .V is ib ility = V isib ility .H id d e n ;
b u t t o n K o . V i s i b i l i t y = V i s i b i l i t y . Hidden;
b u tto n P a p ir.V is ib ility = V isib ility .H id d e n ;
b u tto n O llo .V is ib ility = V isib ility .H id d e n ;
o k . V i s i b i l i t y = V i s i b i l i t y . Hidden;
g e p P o n tL a b e l.V i s i b i l i t y = V i s i b i l i t y . Hidden;
j atek o so n tlab e l.V isib ility = V isib ility .H id d e n ;
g e p P o n t . V i s i b i l i t y = V i s i b i l i t y . Hidden;
j a t e k o s P o n t .V is i b i l it y = V i s i b i l i t y . H idden;
u j J a t e k . V i s i b i l i t y = V i s i b i l i t y . Hidden;
}
p riv ate bool ko = f a l s e , papir = false, olio = false;

166
p riv ate in t geppont = 0, e m b e r p o n t = 0;
p r iv a te void butto n K o _ C lick (o b ject sender,

R outedEventA rgs e )
{
ko = t r u e ;
papir = false;
o lio = false;
b u tto n K o . Background = B ru sh es.R ed ;
b u t t o n K o . C o n t e n t = "Ko";
b u t t o n P a p i r . B ackground = B r u s h e s . Gray;
b u t t o n O l l o . B ackground = B r u s h e s . Gray;
}
p r iv a te void b u tto n P a p ir_ C lic k (o b je c t sender,

{
papir = true;
ko = f a l s e ;
o lio = false;
b u t t o n P a p i r . Background = B ru sh es.R ed ;
b u t t o n P a p ir . C ontent = " P a p ir";
b u t t o n K o . B ackground = B r u s h e s . Gray;
b u t t o n O l l o . B ackground = B r u s h e s . Gray;
}
p r iv a te void b u tto n 0 1 1 o _ C lick (o b je ct sender,

{
o lio = tru e;
ko = f a l s e ;
papir = false;
b u t t o n O l l o . B a c k g ro u n d = B r u s h e s . Red;
b u t t o n O l lo . C ontent = "0116";
b u t t o n K o . B ackground = B r u s h e s . Gray;
b u t t o n P a p i r . B ackground = B r u s h e s . Gray;
}
p r iv a te void u jJ a te k _ C lic k (o b je c t sender,

{
A z Im a g e
167
g e p p o n t = 0;
e m b e r p o n t = 0;
g ep P o n t. C ontent = C o n v e rt. T o S trin g (g e p p o n t);
j a t e k o s P o n t . C ontent = C o n v e rt. T o S trin g (e m b e rp o n t);
p r iv a te void B u tto n _ C lic k (o b je c t sender,

{
m an o 2 .V isib ility = V isib ility .H id d e n ;
m a n o 2 B u t t o n . V i s i b i l i t y = V i s i b i l i t y . Hidden;
ja te k .V is ib ility = V isib ility .V isib le ;
g ep .V isib ility = V isib ility .V isib le ;
b u tto n K o .V isib ility = V is ib ility .V is ib le ;
b u tto n P a p ir.V isib ility = V isib ility .V isib le ;
b u tto n O llo .V isib ility = V isib ility .V isib le ;
o k .V isib ility = V isib ility .V isib le ;
gep P o n tL ab el.V isib ility = V is ib ility .V is ib le ;
j a te k o so n tlab e l.V isib ility = V isib ility .V isib le ;
g ep P o n t.V isib ility = V is ib ility .V is ib le ;
jatek o sP o n t.V isib ility = V isib ility .V isib le ;
u jJa te k .V isib ility = V isib ility .V isib le ;
}
p r iv a te void m ano2B utton_C lick(object sender,

R outedE ventA rgs e )
{
m a n o l.V isib ility = V isib ility .H id d e n ;
m a n o l B u t t o n . V i s i b i l i t y = V i s i b i l i t y . Hidden;
ja te k .V isib ility = V isib ility .V isib le ;
g ep .V isib ility = V isib ility .V isib le ;
b u tto n K o .V isib ility = V is ib ility .V is ib le ;
b u tto n P a p ir.V isib ility = V isib ility .V isib le ;
b u tto n O llo .V isib ility = V isib ility .V isib le ;
o k .V isib ility = V isib ility .V isib le ;
g ep P o n tL ab el.V isib ility = V is ib ility .V is ib le ;
j a te k o so n tlab e l.V isib ility = V isib ility .V isib le ;
g ep P o n t.V isib ility = V is ib ility .V is ib le ;
jatek o sP o n t.V isib ility = V isib ility .V isib le ;
u jJa te k .V isib ility = V isib ility .V isib le ;
168
p r iv a te void ok_ C lick (o b ject sender, R o u t e d E v e n t A r g s e)

{
R an do m v s z = n ew R a n d o m O ;
i n t szam;
szám = v s z . N e x t ( 3 ) ;
i f ( s z á m == 0)
{
g e p . C o n t e n t = "Kő";
i f ( p a p i r == t r u e ) e m b e r p o n t + t ;
i f ( o l i o == t r u e ) g e p p o n t + + ;
}
if ( s z a m == 1)
{
gep.C ontent = "P ap ir";
i f (k o == t r u e ) g e p p o n t + + ;
i f ( o l i o == t r u e ) e m b e r p o n t + + ;
}
if ( s z a m == 2)
{
g ep .C o n ten t = "O lló";
i f ( p a p i r == t r u e ) g e p p o n t + + ;
i f (k o == t r u e ) e m b e r p o n t ++;
}
g e p P o n t. C ontent = C o n v e rt. T o S trin g (g e p p o n t);
ja te k o s P o n t. C ontent = C o n v e rt. T o S tr in g (em berpont);
A láthatóság alapból a leírtaknak megfelelően van beállítva és a Manói, vagy

Manó2 gombra kattintva változik meg.
A program lényegi része a véletlenszerűen előállított szám sgítségével valósul
meg, amely 3 értéket vehet fel:
0-kő , 1-papír , 2-olló.
A játékos által kijelölt gomb és a gép által véletlenszerűen adott értékek eltérése a
játék szabályainak megfelelően pontot ad a játékosnak, vagy a számítógépnek. Ha
egyezik a két érték, akkor nem jár pont egyik félnek sem, mivel az if nem tartalmaz
else részt sehol.
Megemlíthető még a b u t t o n O l l o . B a c k g r o u n d = B r u s h e s . R e d ; kód
rész, ahol a gomb hátterének változtatása látható a programon belül.
A T im e r
169
Látható, hogy néhány változó private-ként az alprogramokon kívül került elhelye

zésre, mivel azokat több eseménynél is használni kell.
A képeket célszerű a programunk könyvtárában elhelyezeni. A window részbe
pedig egyszerűen másolás-beillesztés után a megfelelő méret beállításával fixen
rögzíthetjük. Itt is ajánlott az alapértékek megtartása a maximális és minimális
szélesség és magasság beállításánál.
8.5. A Timer
WPF-ben is lehetőség van arra, hogy a program futása során eltelt időt figyeljük,
lekérdezzük és az értéket szükség szerint felhasználjuk. Mindezt a következő példa
megoldása során láthatjuk a gyakorlatban is.
66. feladat:
Készítsünk alkalmazást, amelyben egy mozgó labdát kell visszaütni egy vízszinte
sen mozgó ütő segítségével! Minden visszaütés 1 pontot ér,a játékban és az ütőt
egérmozgatással vezéreljük! A labda pattanjon vissza a játéktér határairól, kivéve
alul! Az elért pontszámot írjuk ki a képernyőre!
A visszaütés után a labda sebessége növekedjen, vagy ugyanannyi maradjon és az
iránya is változzon kis mértékben! A játék végén jelenjen meg az újrakezdéshez és
a kilépéshez szükséges információ! A játékból az Escape billentyűvel bármikor ki
tudjon lépni a felhasználó!
Név: WPF5
A XAML rész:
<Window x : C lass= "W P F 5 . MainWindow"
x m ln s= "h t t p : / / s c h e m a s . m i c r o s o f t . c o m /w in f x /2 0 0 6 /x a m l/
p re s e n ta tio n ”
x m ln s :x = ”h t t p : / / s c h e m a s . m i c r o s o f t . c o m /w in fx /2 0 0 6 /
x a m l”
x m ln s : d = ”h t t p : / / s c h e m a s . m i c r o s o f t . c o m /e x p r e s s io n /
b l e n d /2 0 0 8 ”
x m ln s:m c= ”h t t p : / / s c h e m a s . o p e n x m lf o r m a ts . o r g /m a r k u p -
c o m p a tib ility /2 0 0 6 "
x m ln s : l o c a l = ” c l r - n a m e s p a c e : WPF5”
m c :I g n o r a b le = ”d"
T i t l e = ”T e n i s z ” KeyDown=”Window_KeyDown" W id th = "1 0 0 0 ff
170
He i g h t = " 6 0 0 " M a x W i d t h = " 1 0 0 0 " MaxHe i g h t = " 6 0 0 "

M inW idth="1000" M inH eight= "600" >
< G r id W id th = " 1 0 0 0 " H e ig h t = " 6 0 0 " M a r g i n = " 0 , 0 , 0 , 0">
<Canvas H o r i z o n ta lA lig n m e n t= " L e f t"
B a c k g r o u n d = " # 4 4 f f0000" N a m e = " ja te k te r "
V e r t i c a l A l i g n m e n t = " T o p " W i d t h = " 1 0 0 0 " H e i g h t = " 600"
M in W id th = "1000" M i n H e i g h t = " 600" M axW idth="1000"
M a x H e ig h t= " 600" M a r g in = " 0 , 0 , 0 , 0">
< R e c ta n g le x:Nam e="uto" H e ig h t= "2 0 " W idth="100"
F ill= " B la c k " C a n v as.L eft= "6 0 0 " C anvas.Top="550"
M argin="0, 0 , 0 , 0 "> < /R e c ta n g le >
< E l l i p s e N ame="labda" W idth="30" H e ig h t= " 3 0 "
F ill= " g re e n " H o rizontalA lignm ent= "C enter"
V e rtic a lA lig n m e n t= " C e n te r" C an v as. L eft= "500"
C anvas.T op= "400"X /E llipse>
<Label x:N am e= "labelP ont" C ontent= "0" Canvas.
L e f t = " 67" C a n v a s . T o p = " 10" H e i g h t = " 43" W i d t h = " 59"
F ontS ize= "20"/>
< T e x t B l o c k x :N am e= "v eg e " C a n v a s . L e f t = " 606"
TextW rapping="W rap" C a n v a s . Top="175" H e ig h t= " 1 5 4 "
W idth="129" F o n tS iz e = " 2 0 " F o ntW eight= "B old"
T extA lignm ent= "C enter"X R un T ext="V ege"/><LineB rea
k /X R u n /X L in e B re a k /X R u n T ext="Fl - uj ja te k " /> <
L in e B re a k /X R u n /X L in e B r e a k /X R u n Text="Esc -
K ilep "/x /T ex tB lo ck >
< L a b el x : N a m e = " l a b e ll " C o n t e n t = " P o n t :" C an v as.
Top="10" H e ig h t= "4 5 " W idth="58" F o n tS iz e = " 2 0 " />
</C anvas>
</G rid>
</Window>
A felületen 2 label van, amelyből az elsőnek nincs különösebb jelentősége, mivel

a programban nem hivatkozunk rá, csak a tartalma fontos számunkra. („Pont”)
A labelPont címke már lényeges lesz, csakúgy mint a vege TexBlock, amelyekre a
programban hivatkozunk majd.
A labda egy Ellipse, az ütő pedig egy Rectangle segítségével jön létre. Célszerű a
Canvas („vászon”) és a Grid(„rács”) margó értékeit 0-ra, valamint a méreteket
egyformára állítani. A játék könnyebb, ha az ütő szélesebb, és nehezebb, ha keske
nyebb. Ha ennek érdekében az ütő szélességét módosítjuk, akkor a programban
több helyen is módosítani kell az értékeket.
A T im e r
171
i f ( X p o s i t i o n U t o > 885) X p o s i t i o n U t o = 885;

i f ( C a n v a s . G e t T o p ( l a b d a ) >= 5 2 0 && X p o s i t i o n U t o - 15 <
C an v as. G e tL e f t (labda) && X p o s i t i o n U t o + 85 > C a n v a s .
G etL eft(lab d a))
A 8 8 5 é s a 85 v á l t o z t a t á s á v a l t e h e t j ü k m e g e z t .
A program kó d ja:
u s i n g Systemb
us ing S y stem .C o l l e c t i o n s . G eneric;
u s in g S y stem .L in q ;
u sin g S y stem .T ex t;
u sin g S y stem .T h read in g .T ask s;
u s i n g System .W indow s ;
u s in g S ystem .W indow s. C o n t r o l s ;
u s in g S ystem .W indow s. D ata;
u s i n g S y ste m .W in d o w s. D ocum ents;
u s in g S ystem .W indow s. I n p u t;
u s in g S ystem .W indow s.M edia;
u s in g S ystem .W in d o w s.M ed ia. Im aging;
u s in g S y stem .W indow s.N avigation;
u s in g S ystem .W indow s. S h ap es;
u s in g S ystem .W indow s. T h re a d in g ;
nam espace WPF5

{
III <summary>
172
I I I I n t e r a c t i o n l o g i c f o r M ainW indow. xam l

I I I </sum mary>
p u b l i c p a r t i a l c l a s s M ainW indow : Window
{
public M a i n W i n d o w ()
{
I n itia liz e C o m p o n e n t();
v e g e . V i s i b i l i t y = V i s i b i l i t y . H idden;
D i s p a t c h e r T i m e r i d o = new D i s p a t c h e r T i m e r ( ) ;
i d o . I n t e r v a l = T i m e S p a n . F r o m M i l l i s e c o n d s (1) ;
i d o . T i c k += i d o L e p e s ;
i d o . S t a r t () ;
}
p r i v a t e Random v s z = new R a n d o m ( ) ;
p r i v a t e i n t sebessegX = 1 , sebessegY=2 , p o n t = 0 ,
x=200 , y=200;
p r i v a t e v o i d W indow _K eyD ow n(object s e n d e r ,
K e y E v e n t A r g s e)
{
if (e.K ey == K e y . E s c a p e ) t h i s . C lo s e ();
if (e.K ey == K e y . F I )
{
s e b e s s e g X = 1;
s e b e s s e g Y = 1;
p o n t = 0;
x = 200;
y = 200;
veg e.V is ib ility = V i s i b i l i t y . H idden;
}
p riv ate void ido L ep es(o b ject sender, E ventA rgs e)

{
if (v e g e .V isib ility == V i s i b i l i t y . H i d d e n )
{
P o in t p o s itio n = M ouse. G e t P o s i t i o n ( j a t e k t e r ) ;
i n t X positionU to = C o n v ert. T o In t3 2 (p o s itio n .X );
i f (X positionU to < 0) X p o s i t i o n U t o = 0 ;
i f (X positionU to > 885) X p o s i t i o n U t o = 8 8 5 ;
A T im e r
173
Canvas. S etL eft(u to , X positionU to);

x += s e b e s s e g X ;
y += s e b e s s e g Y ;
C anvas. S e t L e f t (labda, x ) ;
C anvas. S etT o p (labda, y ) ;
i f ( C a n v a s . G e t T o p ( l a b d a ) >= 5 2 0 &&
X p o s i t i o n U t o - 15 < C a n v a s . G e t L e f t ( l a b d a ) &&
X p o s i t i o n U t o + 85 > C a n v a s . G e t L e f t ( l a b d a ) )
{
sebessegY = -sebessegY ;
i f ( s e b e s s e g X <= 0) s e b e s s e g X - = v s z . N e x t ( 2 ) ;
i f ( s e b e s s e g Y <= 0) s e b e s s e g Y - = v s z . N e x t ( 2 ) ;
p o n t += 1 ;
l a b e l P o n t . C o n ten t = p o n t . T o S t r i n g ();
}
i f ( C a n v a s . G e t L e f t ( l a b d a ) <= 0) s e b e s s e g X =
-sebessegX ;
i f ( C a n v a s . G e t L e f t ( l a b d a ) >= 9 5 5 ) s e b e s s e g X =
-sebessegX ;
i f ( C a n v a s . G e t T o p ( l a b d a ) <= 0) s e b e s s e g Y =
-sebessegY ;
i f ( C a n v a s . G e t T o p ( l a b d a ) > 523)
{
vege.V isib ility = V isib ility .V isib le ;
v s e b e s s e g X = 0;
v s e b e s s e g Y = 0;
v}
}
}
A labda folyamatos mozgásához szükségünk van egy időzítőre, amit WPF-ben az

alábbi módon tehetünk meg:
D ispatcherT im er idő = new D i s p a t c h e r T i m e r ( ) ;
id ő .In te rv al = T i m e S p a n . F r o m M i l l i s e c o n d s (1) ;
id o .T ick += i d o L e p e s ;
i d ő . S t a r t () ;
174
Az első sorban létrehozzuk az időzítőt és ellátjuk névvel, (idő)

A második sorban megadjuk a léptetés időintervallumát. Ez lehetne nap, óra, perc,
másodperc is, ha a feladat ezt igényelné.
Az i d ő . T i c k += i d o L e p e s ; megadja annak az alprogramnak a nevét, ahol
az időzítőt szeretnénk használni.
Végül az utolsó sor elindítja a léptetést.
Fontos, hogy az időzítő csak akkor működik ha a usingok között ott van a u s i n g
S ystem .W indow s. T h re a d in g ;
A P o in t p o s itio n = M o u s e . G e t P o s i t i o n ( j a t e k t e r ) ; segítségével
le tudjuk kérdezni az egér pozícióját. Most csak az x irányú koordináta érdekes
számunkra, amit konvertálni kell szám típusú adattá.
AkülönbözőelemekhelyénekbaállításaCanvas . S e t L e f t ( e l e m , p o z i c i ó ) ;
metódust használhatjuk az elem helyének lekérdezéséhez pedig a C a n v a s .
G e t T o p ( e l e m ) ; használható.
Az x és y irányú sebesség véletlenszerűen változhat a labda visszaütése során,
mivel a vsz.Next(2) miatt vagy nő a sebesség eggyel, vagy változatlanul marad.
A p r i v á t é v o i d W i n d o w _ K e y D o w n segítségével beavatkozhatunk, hogy
billentyűlenyomás esetén mi történjen.
Most az Escape és az FI billentyűhöz rendelünk eseményeket, illetve értékeket
állítunk vissza alapra.
A program csupán ízelitő abból, hogy WPF-ben néhány soros programmal egysze
rű, de szép játékot hozhatunk létre.
Ezzel a feladattal és a könyv létrehozásával is elsősorban az volt a célunk, hogy
megmutassuk a programozásban rejlő lehetőségeket, szépségeket és a programo
zást egyre többen kedvelt időtöltésnek tekintsék a továbbiakban. Ha sikerült meg
szerettetnünk az olvasóval a számítógépes programozást, akkor elértük a célunkat.
175
FELHASZNÁLT IRODALOM
Benkő Tiborné-Tóth Bertalan: Együtt könnyebb a programozás C#

Kiadó: COMPUTERBOOKS Kiadás éve: 2008 Budapest
Reiter István: C# devPortal.hu gondozásában
D k Kovács Emőd-Hernyák Zoltán-Radványi Tibor -Király Roland:
A C# programozási nyelv a felsőoktatásban
Copyright © 2005 Eszterházy Károly Főiskola
Zsakó László: Programozási feladatok I.-II. Kossuth Kiadó, 1997 Budapest
Christopher Bennage, Rob Eisenberg: Tanuljuk meg a WPF használatát 24 óra alatt
www.prog.hu
www.nefmi.gov.hu
www.csharp.lap.hu
176
UJ SZAKKIFEJEZESEK
azonosító, 12 Label, 130

bool típus, 29 long típus, 37
Button, 131 operátor, 22
char ciklus, 51 string típus, 39
do ciklus, 51 szemantika, 14
for ciklus, 51 szintaktika, 14
goto utasítás, 51 szövegkonstans, 17
konvertálás, 24 Textbox, 143
kulcsszó, 12 változó, 13
Ez a könyv a magas szintű, objektumorientált programozási nyelv, a C#
segítségével igyekszik bevezetni olvasóját a programozás világába. A prog
ramozás elméletével nem foglalkozik, viszont az egyes feladatok megol
dásához szükséges fontos fogalmakat tisztázza. Az elsősorban kezdőknek
ajánlott könyv lépésről lépésre haladva vezeti be olvasóját a C# programo
zási nyelv világába. Megkönnyíti az elsajátítást az is, hogy a C# program
az internetről letölthető ingyenesen a Microsoft honlapjáról.
A könyv használatával könnyebben fel lehet készülni az emeltszintű infor
matikai érettségi programozási feladataira is.
TM-11205
ISBN 978-963-275-124-5
789632"751245"
ni«

Láposi Zoltán, Kiss Tibor - C# Programozási Segédlet

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Láposi Zoltán, Kiss Tibor - C# Programozási Segédlet

Uploaded by

Copyright:

Available Formats

Láposi Zoltán —Kiss Tibor

Szakmai lektor: Bacskó Sándor

Nyomta és kötötte Érdi Rózsa Nyomda

Az összeállítás magas szintű, objektumorientált programozási nyelv, a C# segítsé­

A Microsoft.NET Framework egy keretrendszer, amely programcsomagként mű­

1.1. A programozás szintjei és a C# nyelv

A programozási nyelvek csoportosítása sokféleképpen történhet. A kezdeti idő­

Pascal kidolgozásában szerzett elévülhetetlen érdemeket. A C#, a C++-ra épülő

A program az internetről letölthető ingyenesen a Microsoft honlapjáról.

A programozás során konkrét feladatot/feladatokat oldunk meg. Nézzünk egy

< b<-° >

tett szövegszerkesztő segítségével írhatunk programot. Ez a szövegszerkesztő kü­

Javaslat az azonosítók elnevezésére:

• változóknál és metódusoknál (függvényeknél) összetett szavak esetén az

Az értéket hozzárendelhetjük a változóhoz:

Ha elindítjuk Start-Programokból a C#-ot, akkor célszerű a File-New Project me­

csoljuk be. Ugyanitt célszerű beállítani a program alatt megjelenő hibalistát, az

2.2. Kiíró utasítások

C o n so le.W riteL in e("A z első C# p r o g r a m o m " ) ;

Ha a ConsoleWrite-ot használnánk, akkor a kiírás után a kurzor közvetlenül a kiírt

nam espace E lső

A programot mentsük el! A legegyszerűbb, ha az ikonok közül a Savé All (három

Vegyük észre a C# szövegszerkesztő azon segítségét, hogy különböző színekkel

static void M a i n ( s t r i n g [] args)

Az eddigi ismereteink alapján melyik az a 3 utasítás, amelyiknél a függvényhez

2.3. Változó értékének kiíratása

Ahhoz, hogy egy változót használhassunk a programban, először deklarálni kell.

Típus neve Értéktartomány A szám típusa

Néhány példa szám típus deklarációjára

A változókat célszerű kezdőértékkel ellátni, már a deklarációnál.

Ezek után nézzünk egy konkrét feladatot.

static void M a i n ( s t r i n g [] args)

double a = 3.45, b = 2.345;

2.4. Kifejezések és műveletek

A programozás során nagyon sokszor az adatokkal valamilyen műveletet kell vé­

Az előző táblázat néhány operátora további magyarázatra szolgál. Kezdjük az ér­

2.4.1. A kifejezések kiértékelése

A kifejezés kiértékelése lépésről-lépésre történik, mindig ’belülről kifelé’. Az utol­

Néhány példa az operátorok használatára:

1. Ha int i = 1, i++=..............., ha int j = - 1, j - - = ................,

2.5. Beolvasás billentyűről

Az adatbevitel egyik leggyakrabban használt módja a billentyűről történő beolva­

static void M a i n ( s t r i n g [] args)

2.7. Matematikai függvények

Néhány fontos matematikai függvényt meg kell említeni, amelyek a számításokat

static void M a i n ( s t r i n g [] args)

static void M a i n ( s t r i n g [] args)

Bankjegy (Ft) Példa 1 (db) Példa 2 (db)

Feladat száma Változó neve Változó típusa Matematikai függvény

Feltételes utasítás végrehajtása

• Az if- else utasítás alakja:

A feltételes utasításnak 2 alapvető alkalmazása van és C#-ban ez így valósul meg:

a = C o n v ert. T o In t3 2 (C o n so le.R eadL ine());

2.9. Logikai műveletek

2.10. Véletlen szám ok előállítása

Az életben előforduló esetek szimulálására gyakran használunk véletlen számokat.

Mindkét esetben veletlenSzam a [-50, 50] intervallumból vesz fel értéket.

Példa: Állítsunk elő egész számokat véletlenszerűen az [l,60]-ból!

1. Állítsunk elő egész számokat véletlenszerűen a [0,60]-ból!

2. Állítsunk elő egész számokat véletlenszerűen a [-100,100]-ból!

4. Állítsunk elő egész számokat véletlenszerűen a [-15,-5]-ból!

A ciklusok feladata, hogy a program valamely pontján ugyanazokat az utasításokat

A fejben vagy a magban lehetnek az ismétlődésre vonatkozó információk. A mag­

Az összeállítás magas szintű, objektumorientált programozási nyelv, a C# segítsé

A Microsoft.NET Framework egy keretrendszer, amely programcsomagként mű

A programozási nyelvek csoportosítása sokféleképpen történhet. A kezdeti idő

tett szövegszerkesztő segítségével írhatunk programot. Ez a szövegszerkesztő kü

Ha elindítjuk Start-Programokból a C#-ot, akkor célszerű a File-New Project me

A programozás során nagyon sokszor az adatokkal valamilyen műveletet kell vé

Az előző táblázat néhány operátora további magyarázatra szolgál. Kezdjük az ér

A kifejezés kiértékelése lépésről-lépésre történik, mindig ’belülről kifelé’. Az utol

Az adatbevitel egyik leggyakrabban használt módja a billentyűről történő beolva

A fejben vagy a magban lehetnek az ismétlődésre vonatkozó információk. A mag

A következő feladatban a program helytelen adatokkal való működését akadályoz

A programozási tételek olyan algoritmusok, amelyeket gyakran használunk a prog

Rendezéskor az elemeket valamilyen tulajdonságuk alapján sorba rendezzük. Álta

A módszer lényege, hogy egy hátultesztelő ciklusban addig végezzük a szomszé

írjunk programot, amely beolvassa az adatokat egy 6 elemű szövegtömbbe soron

Az olvas logikai fájlt összerendeljük a fajl.txt fizikaival, majd a ciklusban beol