|  | ||||||||
|  | ||||||||
| | ||||||||
| | ||||||||
 |
kategória |  |
||||||||
|
|
||||||||||
 |
 |
|
|
|
|
|
||
|
|
Amikor az Office-t programozzuk, általában valamilyen objektummal dolgozunk, annak tulajdonságait és metódusait (eljárásait) használjuk . Objektumnak tekinthető egy Excel munkalap, egy Word dokumentumban lévő szövegdoboz, de maguk az alkalmazások is. Egy Word dokumentum tulajdonságai például a lapméret vagy a bekezdések száma, egy metódusa pedig a dokumentum bezárását végrehajtó utasítás-sorozat. Legtöbb esetben a gyárilag elkészített objektumokat használjuk, de természetesen mi magunk is készíthetünk ilyet.
Egy egyszerű hétköznapi példa a könnyebb megértés kedvéért: tekintsünk objektumnak egy mikrohullámú sütőt. Ebben az esetben az objektum tulajdonsága a színe, súlya, térfogata, ára. stb. A különböző mikrohullámú sütők különböző módszereket használnak a behelyezett étel felmelegítésére, ez a folyamat a melegítés metódusa (eljárása).
A fenti példák egy fontos részben különböznek egymástól, nevezetesen az utóbbinak nem, vagy 232e48c csak nagyon nehezen lehet változtatni a tulajdonságain (a metódusán pláne nem), míg az Office '97 objektumtulajdonságait gyakorlatilag tetszés szerint alakíthatjuk át.
Az objektumokat egy előre elkészített minta alapján lehet létrehozni. Ebből a mintából veszi az újonnal létrehozott objektum a saját tulajdonságait és metódusait. Ezt a mintát az objektum osztályának nevezzük.
Gyakran fordul elő, hogy több objektumot is hozunk létre ugyanabból a mintából (osztályból). Ilyenkor az adott objektumok gyűjteményéről beszélünk. Például Excelben a munkafüzet egyetlen lapja egy objektumnak tekinthető, az összes lap viszont már gyűjtemény.
Elmondhatjuk tehát, hogy az Office alkalmazások programozása során az előre elkészített objektumok lehetőségeit használjuk annak érdekében, hogy a mindennapi munka során felmerülő feladatokat automatizálhassuk. Minél több objektumot, illetve annak tulajdonságait, viselkedését ismerünk meg, annál nagyobb gyakorlatot szerzünk az alkalmazások programozásában.
Egy objektumra, illetve azon belül annak valamilyen tulajdonságára vagy metódusára a következő szintaxis szerint hivatkozhatunk:
objektumnév.tulajdonságnév
vagy
objektumnév.metódusnév([paraméterek])
Minden esetben a "pont" az elválasztó karakter. A "paraméterek" szögletes zárójelbe tétele azt jelenti, hogy nem minden metódusnak vannak paraméterei, valamint a paraméterek közül nem mindegyik lehet kötelező.
Például Wordben az aktív dokumentum első bekezdésére az
ActiveDocument.Paragraphs(1)
utasítással lehet hivatkozni. Ha a zárójeleket és az 1-est elhagytuk volna, akkor a dokumentumban lévő összes bekezdés gyűjteményére hivatkozunk, így azonban csak a gyűjtemény első elemére.
A fent említett bekezdésnek a stílusát az
ActiveDocument.Paragraphs(1).Style
utasítással lehet lekérdezni vagy módosítani.
A következőben egy metódusra hivatkozunk. A C: meghajtó gyökérkönyvtárában lévő Irat.doc fájlt az
Application.Documents.Open("C:\Irat.doc")
utasítással nyithatjuk meg. Itt a metódus az Open, paramétere pedig a megnyitandó dokumentum teljes elérési útvonala.
Elemezzük a következő példát:
Bekezdés = ActiveDocument.Paragraphs(1)
Itt egy értékadásra láthatunk példát. A Bekezdés nevű változó egy objektumnak a változója, amely objektum a Paragraphs (Bekezdések) gyűjtemény első eleme. Innentől kezdve az első bekezdés stílusára a következőképpen is hivatkozhatunk:
Bekezdés.Style
A előző fejezetben említettem több olyan fogalmat is, amely egy kezdő programozó számára idegennek tűnhet. E jegyzet terjedelme nem engedi meg, hogy teljes részletességgel ismertessem meg a hallgatóval a programozás alapfogalmait, de röviden tekintsük át a legfontosabbakat.
A programok futása során sokszor előfordul, hogy bizonyos értékeket le kell tárolnunk újbóli felhasználás miatt. Erre a célra valók a változók. Mivel az adatokat többféleképpen kódolhatjuk, ezért a változóknak is többféle típusa van. Akkor van egyértelműen definiálva egy változó, ha a neve mellett az adattípusa is meg van adva. A VBA nyelvben kétféleképpen adhatunk meg változót: implicit és explicit módon. Implicit megadás esetén a használatba vételt nem előzi meg deklaráció, pontosabban maga a használatba vétel egyben deklaráció is.
Sub Gyökvonás()
Gyok=Sqr(9)
B=Gyok * 2
Cells(1, 1).Value = B
End Sub
Itt éppen 9 négyzetgyökének az értékét tároltuk le a "Gyok" nevű változóba, ennek értékét használjuk fel a B értékadásához végül az eredményt az aktív Excel munkalap A1-es cellájában tároljuk. Ez a fajta változóhasználat megnehezítheti a nagyobb programokban a hibakeresést. Pl. ha a B kiszámításakor "Gyok" helyett például "Gyök"-öt írtunk volna, B értéke 0 lenne, hiszen semelyik új változónak nincs értéke.
Az explicit deklaráció esetében használatba vétel előtt deklaráljuk a változó nevét és adattípusát is.
Option Explicit
Dim Gyok As Double
Dim B As Long
Sub Gyökvonás()
Gyok = Sqr(9)
B = Gyok * 2
Cells(1, 1).Value = B
End Sub
Így már minden egyértelműen meg van adva, és ha véletlenül elírjuk egy változó nevét (vagy deklarálni elfelejtettük), hibaüzenetet kapunk.
A változókat több helyen is definiálhatjuk: eljáráson belül és kívül. A különböző eljárásokban definiált változók egymástól függetlenek lesznek, értékük nem látható más eljárás számára.
Sub Egyik()
Dim Szöveg1 As String
Szöveg1="Ez egy szöveges változó"
MsgBox Szöveg2
End Sub
Sub Másik()
Dim Szöveg2 As String
Szöveg2="Másik szöveg"
MsgBox Szöveg1
End Sub
Ha mindkét eljárásban "látni" szeretnénk a két változót, akkor kívül kell definiálni:
Dim Szöveg1 As String
Dim Szöveg2 As String
Sub Értékadás()
Szöveg1="Ez egy szöveges változó"
Szöveg2="Másik szöveg"
End Sub
Sub Egyik()
MsgBox Szöveg2
End Sub
Sub Másik()
MsgBox Szöveg1
End Sub
Hosszabb programoknál gyakran előfordul, hogy egy bizonyos érték nem változik, azaz konstans (állandó). Nem célszerű rendszeresen leírni az értéket, hiszen ha valamilyen okból mégis változtatnunk kell rajta, az egész programon keresztül végig kell vezetnünk a változást. Konstanst a következőképpen definiálunk:
Const Állandó As Byte
Az eljárások (szubrutinok) és függvények szerepe az, hogy egy bizonyos utasítássorozatot tároljanak, amely sorozatra azután egy névvel hivatkozhatunk például egy másik eljárásban. A későbbiekben a makrórögzítés során fogunk még a gyakorlatban találkozni eljárással, amikor a rögzítendő makró neve egyben az eljárás neve is lesz. Van olyan eljárás, amely csak statikus utasítások sorát dolgozza fel, de lehet olyat is deklarálni, amely kap valamilyen bemenő adatot is. Nézzünk rá példákat:
Sub Levélvége()
Selection.TypeText "Miskolc, " & Date
End Sub
Az eljárásnak tehát van egy neve, amit megelőz a SUB kulcsszó. Ha nincs paramétere, akkor a név után "üres" zárójelet teszünk. (Ez utóbbit - ha majd a gyakorlatban kipróbáljuk az eljárás-írást - megteszi helyettünk a VB editora). A fenti példa az aktuális Word dokumentumban az aktuális kurzorpozíciótól kezdve kiírja a "Miskolc, AktuálisDátum" szöveget. Ugyanez a feladat egy másik megoldással:
Sub Kiirás()
Levélvége ("yyyy. mmmm dd., dddd")
End Sub
Sub Levélvége(Dátumforma As String)
Selection.TypeText "Miskolc, " & Format(Date, Dátumforma)
End Sub
Ebben az esetben a Levélvége eljárást a Kiirás eljárásból hívjuk meg, ráadásul egy paramétert is átadunk, amely meghatározza majd a kiírandó dátum megjelenési formáját (a példában 2000.október 10., Kedd lesz az eredmény).
Függvényeket is hasonlóképpen definiálhatunk. A különbség az, hogy a nevet a FUNCTION kulcsszó vezeti be. Mivel a függvények szerepe az, hogy valamilyen bemenő adat(ok) ismeretében visszaadjon egy értéket, ezért a függvény adattípusát is meg kell adnunk (ugyanúgy, ahogyan a változókét).
Function NagySzóköz(BejövőSzöveg As String) As String
NagySzóköz = UCase(Trim(BejövőSzöveg))
End Function
A fenti példa a "Nagyszóköz" függvény bemenő paramétereként egy szöveges változót ad meg (Bejövőszöveg), majd ezt felhasználva a szöveg elejéről és végéről levágja a szóközöket (Trim függvény) majd utána nagybetűssé alakítja (Ucase függvény). A "Nagyszóköz" függvény felhasználása a következő lehet:
Sub Próba()
Selection.TypeText NagySzóköz(" ez Itt egy PRóba szÖveg ")
End Sub
Az aktuális kurzorpozícióba beilleszti az "EZ ITT EGY PRÓBA SZÖVEG" szöveget.
Makrórögzítés
felvétellel Első gyakorlati feladatként indítsuk el a Word-öt, és az üres dokumentumba gépeljünk be egy tetszőleges szöveget. Ezután jelöljük ki, majd a Tools - Macros - Record new macro. parancsot válasszuk. A megjelenő párbeszédablakban a Macro name: alatt gépeljük be a rögzítendő makrónk nevét (emlékezzünk, ez egyben egy eljárás neve is lesz), majd OK
Ekkor megjelenik egy eszköztár 
(ne tüntessük el,
szükségünk lesz rá a felvétel leállításához.) Ezután figyeljünk arra, hogy NE
tüntessük el a kijelölést sem, mert ezt a műveletet is rögzítenénk. Formázzuk
meg a szöveget a Format
- Font. menüparanccsal. Álltsuk le a felvételt az imént
megjelent eszköztár 
(Stop) gombjával.
Most éppen az történt, hogy az iménti formázási beállításainkat a makrórögzítő VBA utasítások formájában felvette, és egy eljárásba helyezte. Ezt az eljárást (és a későbbiekben az általunk megírtakat is a VB Editorában (VBE) tekinthetjük meg. Ide többféleképpen léphetünk:
A Tools - Macro - Macros. parancs kiválasztása után jelöljük ki az imént felvett makrónk nevét, majd kattintsunk az Edit gombra.
Üssük le az ALT+F11 billentyűkombinációt!
Ez utóbbi művelet hatására bejutunk a VBE felületére.
Project
Explorer (Projekttallózó) - Itt lehet látni az összes nyitott projektet.
Properties Window (Tulajdonságablak). A kijelölt modul vagy űrlapelem tulajdonságait tartalmazza, de csak azokat, amelyeket tervezési időben módosíthatunk.
Code (Kód) vagy űrlapablak. Itt módosíthatjuk a makrórögzítő által felvett kódrészletet.
Immediate Window (Próba ablak). Ez egy nagyon hasznos része a VBE-nek, hiszen az itt beírt utasításokat azonnal végrehajtja a VB, és meg is lehet tekinteni az eredményt. Későbbiekben sokat használjuk majd.
Ezenkívül látszik egy eszköztár, amelynek leginkább 3 elemét használjuk majd:
Run Sub/Form -
Az aktuális eljárás/űrlap kódjának végrehajtása
Break (Szünet) -
A végrehajtás felfüggesztése. A Run-nal még folytatható a végrehajtás.
Reset - A
végrehajtás leállítása, projekt változóinak alapállapotba állítása
Egy VBA projekt modulokból épül fel.
Az alkalmazás alapobjektumaira mutató modul.
Form-modul. Felhasználói űrlapokat és a hozzá tartozó eseménykódokat tárol
Kód modul. Általában globális eljárásokat, változókat, konstansokat tárolunk itt.
Osztály modul. Ennek segítségével új objektumokat hozhatunk létre.
Az alábbi ábrán egy üres Word dokumentum és Excel munkafüzet projektfelépítése látható a VBE-n belül, hierarchikus ábrázolásban.
A gyakran használt "ThisDocument" az adott dokumentumra utaló objektumhivatkozás. Tehát például a
Név = ThisDocument.Name
az
adott dokumentum éppen aktuális nevét (fájlnevét) adja meg. Ezt a hosszú
hivatkozásnevet természetesen lerövidíthetjük a Properties ablakban, a
Name tulajdonság
megváltoztatásával pl. "td"-re. Ezt az ablakot és a Project Exploret gyakran
fogjuk használni a VBE-n belül.
Az előző fejezetben csináltunk egy példát, amely egy szövegformázás lépéseit rögzítette makrónyelven. De hova is kerülnek ezek az utasítás-sorozatok? Először is azt kell megmondani - még a rögzítés megkezdése előtt -, hogy melyik munkafüzetben, vagy sablonban, azaz melyik projektállományban tárolja le a rendszer a kódot. Ezt a már látott párbeszédablak Store in: listájában tehetjük meg (8. o). Esetünkben ez most a Normal.dot sablonfájl volt. Ha a rögzítésnek vége, az ALT+F11-gyel léptünk át a VBE felületre. Itt a projekttallózóban nyissuk ki a Normal ágat, majd a Modules-t. Itt találunk egy NewMacros elemet, ha erre duplán kattintunk, megjelennek az itt tárolt eljárások.
Az általam alkalmazott formázási beállítások a következőek voltak ( a Format - Font. után):
fékövér
12-es méret
kiskapitális
Ennek hatására a következő eljárást generálta a Word makrórögzítője:
Sub Szövegformázás()
' Szövegformázás Macro
' Macro recorded 01.02.14 by Pazár András
With Selection.Font
.Name = "Times New Roman"
.Size = 12
.Bold = True
.Italic = False
.Underline = wdUnderlineNone
.StrikeThrough = False
.DoubleStrikeThrough = False
.Outline = False
.Emboss = False
.Shadow = False
.Hidden = False
.SmallCaps = True
.AllCaps = False
.ColorIndex = wdAuto
.Engrave = False
.Superscript = False
.Subscript = False
.Spacing = 0
.Scaling = 100
.Position = 0
.Kerning = 0
.Animation = wdAnimationNone
End With
End Sub
A fenti kódsorozatból látható, hogy a makrórögzítő a kijelölt szöveg jellemzői közül (Selection.Font) olyan tulajdonságokat is beállított, amelyeket én a formázás során nem is alkalmaztam. Ha csak a szürkén kiemelt sorokat hagynánk meg az eljáráson belül, ugyanazt a hatást érnénk el. Felmerülhet a kérdés: "Miért generált a gép 7-szer annyi kódot, mint amennyire szükség van ?" A választ pontosan nem tudom, de valószínű azért, hogy ezzel a módszerrel minél több objektum és tevékenység minél több alapértelmezett eljárását és tulajdonságát ismerhessük meg.
Pl. adott a feladat: Word dokumentumba programozás útján hozzunk létre táblázatot. Ezt nehézkes lenne csak a belső helpből kihalászni. Ezért érdemes a makrórögzítést alkalmazni (Tools - Macro - Record new macro), majd a Table - Insert table. parancs kiadása után (és persze a felvétel megállítása után) megnézni a generált kódot :
ActiveDocument.Tables.Add Range:=Selection.Range, NumRows:=2,_ NumColumns:=4
Érdemes minél több helyen módosítani, kísérletezni a generált kódban, mert így lehet eljutni majd arra a szintre, hogy egyre kevesebbszer kell a makrórögzítést használni, és egyre bonyolultabb feladatokat tudunk majd megoldani önálló programírással is.
Egy klasszikusnak mondható iskolapéldán keresztül nézzük meg az önálló makróírás lépéseit. A feladatot Excelben oldjuk meg. Kiindulásként legyen elég 5 cellába beírni egy húzás eredményét. Fejlesztve a feladatot, egy másik munkalap egy cellájába írt értékétől függően generál X húzást a program. És végül egy húzás eredményét felhasználói űrlapon jelenítsük meg.
Nézzük milyen változókra lesz szükségünk:
Szamok : logikai elemekből álló tömb, elemszám 90. Feladata lesz tárolni, hogy a 90 számból melyiket húzta ki már a gép
KihuzottSzam : Byte típusú változó. Feladata tárolni az aktuálisan kihúzott szám értékét
I : ciklusváltozó
Tehát az Excelen belül üssük le az ALT+F11-et, majd pl. a ThisWorkbook elemen duplán kattintva írjuk be az alábbi kódot: (az '-lel kezdődő sorok megjegyzések, természetesen nem kötelező beírni)
Sub Lottóhúzás()
' Igaz-Hamis értékeket tároló tömb
' Igaz az elem értéke = kihúzott a szám
' Hamis az elem értéke = nincs kihúzva a szám
Dim Szamok(1 To 90) As Boolean
' Az éppen aktuálisan kihúzott szám
' Értéket véletlenszám-generátorral adunk neki
Dim KihuzottSzam As Byte
' Ciklusváltozó
Dim i As Integer
' Az elején egyik szám sincs kihúzva ...
For i = 1 To 90
' ... ezért minden elemét hamisra állítjuk
Szamok(i) = False
Next
For i = 1 To 5
' Ez a ciklus addig megy ...
Do
' "Kihúzunk" egy számot
KihuzottSzam = Int(Rnd * 90 + 1)
' ... amíg nem találunk olyan számot,
' ami még nincs kihúzva
Loop Until Szamok(KihuzottSzam) = False
' Ha megtaláltuk, igazra állítjuk a
' megfelelő tömbelemet
Szamok(KihuzottSzam) = True
' Az aktuális munkalap i. sorának 1 oszlopába
' írjuk be a kihúzott számot
Cells(i, 1) = KihuzottSzam
' következő szám húzása
Next
' Az első számra állunk ...
Cells(1, 1).Select
' ... majd növekvő sorrendbe állítjuk a számokat
Selection.Sort Range("A1"), xlAscending
End Sub
A programba elhelyezett kommentek mellé egy kis magyarázat: az Rnd függvény önmagában egy 0 és 1 közé eső véletlenszámot generál. Ezért kell megszorozni 90-nel és egész számra alakítani (Int függvény).
A Do - Loop Until ciklusnak akkor lesz vége, amikor az Until után írt feltétel igazzá válik. Másik változata a Do - Loop While, amikor is a ciklusmag addig fut, amíg a While utáni feltétel igaz marad. Tehát a ciklus így is kinézhetne:
Do
' "Kihúzunk" egy számot
KihuzottSzam = Int(Rnd * 90 + 1)
' ... amíg nem találunk olyan számot,
' ami még nincs kihúzva
Loop While Not Szamok(KihuzottSzam) = False
A Cells(sor,oszlop) gyűjtemény gyakorlatilag egy mátrix (kétdimenziós tömb), ami önmagában az aktív munkalap celláira mutat. Ha egy meghatározott munkalap celláira akarunk hivatkozást (pl. a Sheets3 lapra), akkor a következő formában kell alkalmazni:
Sheets("Sheet3").Cells(sor,oszlop)
A számok sorbarendezését végrehajtó kódot makrórögzítő segítségével generáltam (az itt lévő változat már le van egyszerűsítve).
Gyakorlatilag megvalósítottuk a feladat első részét. Most nézzük a továbbfejlesztést. Csak kis mértékben változtatjuk meg a programot. A húzás eredményeit az első munkalapra tesszük; azt, hogy hány húzás-sorozat legyen egymás után, azt pedig a második munkalap A1-es celláájának tartalmából vesszük. A módosított program (kommentek és a már ismert deklarációk nélkül) a következő:
Dim j As Integer
For j = 1 To Sheets(2).Cells(1, 1)
For i = 1 To 90
Szamok(i) = False
Next
For i = 1 To 5
Do
KihuzottSzam = Int(Rnd * 90 + 1)
Loop While Not Szamok(KihuzottSzam) = False
Szamok(KihuzottSzam) = True
Sheets(1).Cells(i, j) = KihuzottSzam
Next
Sheets(1).Activate
Sheets(1).Range(Cells(1, j), Cells(5, j)).Select
Selection.Sort Range(Cells(1, j), Cells(1, j)), _ xlAscending
Next
End Sub
Annyiban változott a kód, hogy egy új ciklus (For j= .) jelent meg, és a már előbb említett módszerrel hivatkozunk a 2. munkalap egy cellájára. A végén nem egy cellát jelölünk ki a sorbarendezés előtt, hanem 5-öt, hogy a már előzőleg kihúzott 5-ös sorozatokat ne rendezze át.
És végül készítsünk egy felhasználói párbeszédablakot, amelyben egy húzás eredményét fogjuk egy gomb lenyomására ("Sorsolás" felirattal) megjeleníteni. Ehhez lépjünk a VBE felületére, és az aktív munkafüzet valamelyik projektelemére állva (mondjuk ThisWorkbook) válasszuk az Insert - UserForm parancsot. Ennek hatására megjelenik a projektlistában egy UserForm elem, majd a formtervező ablaka is megjelenik.
Ennél a módszernél már tisztábban kell látni az ún. eseményvezérelt programozás területén. E jegyzet keretei erősen meghaladják ennek a témának az ismertetését. Röviden egy pár mondatban: esemény például, ha egy nyomógombra kattintunk (mondjuk egy OK-ra). De esemény az is, ha egy űrlap (továbbiakban form) megynyílik és/vagy aktiválódik. Ezekre az eseményre kell egy kódsorozattal reagálni. Hogy egyáltalán milyen események vannak, ezt a belső help, valamint a kódszerkesztő is nagyszerűen tálalja.
Most nézzük a mi példánkat. Legyen két nyomógomb, az egyik "Sorsolás" a másik "Bezárás" felirattal. Ezért a formtervezőben látható Toolbox eszköztárból válasszuk a CommandButton-t, majd az üres formon kattinsunk egyet. Ezt ismételjük meg még egyszer. Két gomb keletkezett, CommandButton1 ill. CommandButton2 felirattal. Helyezzük el őket vonszolással esztétikusan. Majd változtassuk meg a feliratukat a Properties ablakban látható Caption tulajdonság átírásával. (Először értelemszerűen jelöljük ki a megfelelő gombot)
Ezután helyezzünk el 5 Label vezérlőelemet (ha nem látszik a Toolbox, jelöljük ki a formot) Kb. most így néz ki a formunk:
A tervezési időben látható rácspontok természetesen nem láthatóak futáskor, csak a vezérlőelemek kényelmesebb igazítását szolgálják.
Már most "működik" a form, hiszen ha a VBE eszköztárából megnyomjuk a Run Sub/UserForm-ot, megjelenik a form. A gombokra kattintva nem történik semmi (hiszen még nem írtuk meg az esemény-kódokat). Csak a szabvány Windows-os "X"-szel zárhatjuk le.
Visszatérve a formtervezőbe, kattintsunk duplán a Bezárás gombra, ennek hatására a form kódszerkesztőjébe jutunk, és automatikusan generálódik a vezérlő eseménykódja, ami a kattintásra (click) reagál majd. Írjuk meg eztt a kódot:
Private Sub CommandButton2_Click()
Unload UserForm1
End Sub
Az Unload eljárással bármilyen objektumot (vezérlőt, formot, stb) kitörölhetünk a memóriából. Ez form esetén annak bezárását eredményezi. Most jön a "könnyebbik" feladat: írjuk meg a Sorsolás gomb kódját. Azért könnyebb ez, mert felhasználjuk az előzőleg megírt sorsolás kódot, kis változtatással. Tehát kattinsubk duplán a Sorsolás gombra (aut. generálódott az esemény eljárás neve), majd ha a ThisWorkbook "alá" írtuk meg előbb a kódot, akkor arra duplázzunk. Vágólapon keresztül vigyük át a kódot a Sorsolás gomb esemény-eljárásába. Íme a kód (deklaráció és kommentek nélkül):
For i = 1 To 90
Szamok(i) = False
Next
For i = 1 To 5
Do
KihuzottSzam = Int(Rnd * 90 + 1)
Loop While Not Szamok(KihuzottSzam) = False
Szamok(KihuzottSzam) = True
Select Case i
Case 1
Label1.Caption = KihuzottSzam
Case 2
Label2.Caption = KihuzottSzam
Case 3
Label3.Caption = KihuzottSzam
Case 4
Label4.Caption = KihuzottSzam
Case 5
Label5.Caption = KihuzottSzam
End Select
Next
Itt most I értékétől függően változtattuk a megfelelő vezérlő (Label1-Label5 Caption tulajdonságát futási időben. Tipp: tegyük itt is emelkedő sorrendbe a számokat. Itt érdemes felvenni egy 5 elemű tömböt (Byte típusú elemekkel), és valamilyen egyszerű algoritmussal (mondjuk a "buborék" módszerrel) sorbarendezni az elemeket.
Találat: 1855
