Visual Basic

  1. Változók és kifejezések
  2. Alapvető vezérlési szerkezetek
  3. Eljárások, absztrakt eljárások
  4. Beépített és absztrakt adattípusok
  5. Generic, típussal való paraméterezés
  6. Hibakezelés
  7. Objektum-orientált programozás, öröklődés
  8. Helyességbizonyítás
  9. Párhuzamos végrehajtás
  10. Könyvtárak, egyéb nyelvi elemek
  11. A Visual Basic .NET
  12. Példaprogramok

Változók és kifejezések

Változónevek

A Visual Basic kódban a változónevek használatakor be kell tartanunk néhány szabályt. Ugyanez a szabály érvényes eljárások, konstansok, ablakok és control-ok névadására is. A név tartalmazhat számokat, de nem kezdődhet számjeggyel, maximum 255 karakter hosszú lehet. A Visual Basic a legtöbb programnyelvvel ellentétben lehetővé teszi, hogy az azonosítók nevében ékezetes betűk is szerepeljenek, sőt elfogad bármilyen nem-ASCII karaktert is. A változónév nem tartalmazhat space-t, vesszőt, !, @, &, $ és # jelet.

Foglalt szavak nem lehetnek azonosító nevek. Ilyen foglalt szavak az előredefiniált utasítások (If, Loop ...), függvénynevek (Len, Val ...), metódusok (Show, Move ...) és operátorok (And, Or ...). Ha egy ablak vagy control neve foglalt szó, akkor azt szögletes zárójellel jelölni kell (pl.[Show].Caption). Annak ellenére, hogy ezzel a módszerrel feloldható a névütközés, mégis jobb a foglalt szavak használatát kerülni.

A nyelv nem tesz különbséget az azonosítók kis- és nagybetűvel írt alakjai között, bár a környezet minden előfordulásnál ugyanolyan alakúra változtatja az azonosítókat, arra a formára, ami a deklarációnál szerepel. Ismeri az ékezetes karakterek nagybetűs párjait is.

A Visual Basic-ben a változók deklarációja nem kötelező, a nem deklarált változók első előfordulásakor foglalja le a tárolásukhoz  szükséges memóriaterületet. A létrehozott változó alapértelmezés szerint Variant típusú, de a változó megfelelő elnevezésével egyértelműen is megadhatjuk annak típusát. A nyelv két alternatívát ajánl a változók típusának megadására: a típus-deklarációs karaktereket és a DefType utasításokat.

A típus-deklarációs karaktereket a változó neve mögé írva adjuk meg. (pl. s$, i%)

A típus deklarációs karakterek és a hozzájuk rendelt típusok:

%

 Integer

#

Double

@

 Currency

!

 Single

$

 String

&

 Long

A DefType utasításokkal az egyes típusokhoz megadhatunk egy-egy betűintervallumot. Az utasítás után álló implicit változó deklarációk típusának eldöntésekor a Visual Basic megvizsgálja a változó első karakterét, és ha ez valamely DefType utasítás által definiált betűhalmazba tartozik, akkor az itt megadott típusú változót hozza létre. Az utasítás hatásköre csak arra a programmodulra vonatkozik, amelyben elhelyzekedik.

A DefType gyűjtőnév a DefBool, DefByte, DefInt, DefLng, DefCur, DefSng, DefDbl, DefDec, DefDate, DefStr, DefObj, DefVar utasítások halmazát jelöli.

DefStr A-Q

Message = "Out of stack space"    ' Message String típusú

String literálok

String literálokat "-ek közé írhatunk. Többsoros string literál létrehozására a Chr() függvényt vagy a vbCrLf visual basic konstanst használhatjuk. Figyelem! Ha a string literált több sorban adjuk meg, attól még a string nem tartalmaz sortöréseket!

s$ = "Ez itt " _
& " három sornyi" _
& " szöveg."

Az s$ értéke ekkor: "Ez itt  három sornyi szöveg"

A több sorból álló string helyes megadása:

s$ = "Ez itt " & vbCrLf & " három sornyi" & vbCrLf & " szöveg."

Vezérlőkaraktereket nem helyezhetünk a stringen belülre, különleges jeleket a Chr függvény segítségével készíthetünk. A stringek Visual Basic-ben összehasonlíthatók mind (akár magyar) ábécé szerint, mind a karakterkódjuk alapján. Ezt az Option Compare paranccsal dönthetjük el.

Megjegyzések, számok, utasítások

Megjegyzéseket a ' karakter illetve a Rem kulcsszó után helyezhetünk el a programkódban, és a sor végéig tart. A többsoros megjegyzések készítésére nincs nyelvi eszköz, de a környezet lehetővé teszi, hogy egy kijelölt kódrészt megjegyzéssé, vagy megjegyzésből kóddá alakítsunk.

A Visual Basic a 10-es számrendszer mellett támogatja az oktális és hexadecimális számrendszer használatát is. Az oktális számot &O, a hexadecimálist pedig &H prefixummal kell jelölni.

Az utasításokból általában egy sorban csak egy található. Megengedett több utasítás egy sorba írása is, ekkor ezeket : jellel kell elválasztani egymástól. Ha egy sorban nem fér el egy kifejezés, akkor a sor végére _ karaktert kell írni, így jelezhetjük, hogy a következő sor is az adott kifejezéshez tartozik.

Műveletek

A Visual Basicben található műveletek:

=

 értékadás

&

 karakterláncok összeadása

*

 két numerikus kifejezés szorzása

+

 két kifejezést ad össze, az eredménye a kifejezésektől függően lehet szám, karakterlánc vagy egyéb

-

 két numerikus kifejezés különbsége

/

 két numerikus kifejezés hányadosa. Egészeknél az eredmény single lesz, számtartomány túllépése hibát okoz

\

 két numerikus kifejezés hányadosának egészrésze

^

 hatványozás

AND

 két tetszőleges kifejezés közötti logikai ÉS

EQV

 két tetszőleges kifejezés közötti logikai azonosság (bitenkénti összehasonlításra is jó)

IMP

 két kifejezés közötti logikai implikáció

Is

 két objektumhivatkozás összehasonlítására

Like

 két karaktersorozat összehasonlítására

MOD

 két numerikus kifejezés osztása utáni maradékot adja

NOT

 negáció

OR

 két tetszőleges kifejezés közötti logikai VAGY

XOR

 két tetszőleges kifejezés közötti kizáró VAGY

Relációs műveletek: <, <=, >, >=, =, <>

Műveletek precedenciája

 Aritmetikai

Összehasonlítási

Logikai

^

=

NOT

-

<>

AND

*, /

<

OR

\

>

XOR

MOD

<=

EQV

+, -

>=

IMP

&

Like

Is

Kiértékelés

A Visual Basic a logikai kifejezések teljes kiértékelését elvégzi. Ez azt jelenti hogy például az alábbi kifejezés futás idejű hibát ad, amennyiben az f file nincs megnyitva (és a ReadFirstByte függvény nem nyeli el a fellépő hibát):

if FileIsOpen(f) AND (ReadFirstByte(f) <> 1) Then ... 

Változók érvéyességi köre

A Visual Basicben két féle érvényességi kör van: eljárásszintű és modulszintű.

Alporgramszintű: A változó annak az alprogramnak a sajátja amelyben deklarálva van, kívülről nem érhetjük el. A deklarációs kulcsszó lehet dim vagy static. Az előbbi esetén az alprogram lefutása után a változó megszűnik, az utóbbi esetben pedig nem, azaz a memóriában marad, és az alprogram újbóli hívásánál megmarad az értéke. (Ha az alprogram minden változóját statikussá akarjuk tenni, akkor írjuk az alprogram neve elé a static kulcsszót).

Modulszintű: Itt deklarálhatunk private és protected változókat is. Private esetben a változó csak az őt tartalmazó modulból érhető el, public esetben pedig bárhonnan.

Alapvető vezérlési szerkezetek

Szekvencia

Visual Basicben általában egy sor csak egy utasítást tartalmaz, és az egymást követő sorokban levő utasítások szekvenciája a program. Lehetőség van egy sorba több utasítást is írni, ezeket : jellel kell elválasztani. Az utasítások végét nem kell semmilyen karakterrel jelölni, és a : karakter is csak az utasítások elválasztására szolgál.

Vezérlésátadó utasítások

A Visual Basicben két (gyakran használt) vezérlésátadó utasítás van, a Call és a GoTo (ez már csak hagyománytiszteletből maradt meg a nyelvben). Alkalmazási formájuk:

Eljárásokat hívhatunk a Call kulcsszóval, vagy egyszerűen a nevük leírásával. A paramétereket nem fontos zárójelek közé írni, csak akkor, ha a Call utasítást használjuk. A paramétereket megadhatjuk "param1=érték1 param2=érték2 ..." formában is, ekkor a paraméterek sorrendjét sem kell betartani. Függvények esetében mindig ki kell írni a zárójeleket a paraméterlista elé és után.

A nyelvben maradt néhány struktúra, ami már nem, vagy csak nagyon ritkán használatos. Ezek:

Elágazások

Három elágazásos utasításcsoportot találhatunk a nyelvben:

If feltétel then utasítás

vagy

If feltétel then
    utasítások
EndIf

Ha a feltétel teljesül, akkor végrehajtja az utasításokat. A feltételnek összehasonlításnak vagy numerikusra kiértékelhető kifejezésnek kell lennie.

If feltétel1 then
    utasítások1
Elseif feltétel2 then
    utasítások2
Else     utasítások
EndIf

Ha a feltétel1 teljesül, akkor végrehajtja az utasítások1-ben szereplő utasításokat. Ha nem teljesül, akkor megvizsgálja a feltétel2-t, és így tovább. Azt a Then ágat hajtja végre először, amelyiknél a feltétel teljesül. Ha nincs ilyen, akkor az Else ágat hajtja végre, ha van ilyen.

A Visual Basic az If .. Then .. Else szerkezet alternatívájaként tartalmazza az IIf és a Switch függvényeket. 

IIf(Kifejezés, Érték-1, Érték-2)

Switch(Kifejezés-1, Érték-1[, Kifejezés-2, Érték-2 … [, Kifejezés-n,Érték-n]])

Az IIf függvény a megadott Kifejezés Igaz értéke esetén Érték-1-et, Hamis értéke esetén Érték-2-t adja vissza. A függvény valamennyi paraméterét kiértékeli. (azaz ha például Érték-2 egy függvényhívás eredményeként áll elő, akkor a függvény Kifejezés értékétől függetlenül meghívásra kerül.)

A Switch függvény hasonlóan működik, az első igaz értékű Kifejezés-k-hoz tartozó Érték-et adja vissza. A kiértékelés itt is teljes, minden kifejezés kiértékelésre kerül.

Select Case szelektor
    Case szelektor_lista1
        utasítások1
    Case szelektor_lista2
        utasítások2
    Case Else utasítások
End Select

Kiértékeli a szelektort, és azt az ágat hajtja végre, amelyiknél a szelektor_listában szerepel a kiértékelés eredménye. A szelektor_listában több értéket is felsorolhatunk (ezeket ","-vel kell elválasztani), de megadhatunk intervallumot is (a To kulcsszóval). Ha több illeszkedő Case ág is van, akkor az elsőt hajtja végre csak, a többit nem. A szelektor értékére a szelektor listában az Is kulcsszóval hivatkozhatunk. 

Case 1 To 4, 7 To 9, 11, 13, Is > MaxNumber

Megjegyzés: Az On x Goto cimke1, ..., cimkeN utasítás a Select struktúrával ekvivalens vezérlésátadást tesz lehetővé a Goto és Gosub utasítások használatával. 

Ciklusok

For számláló=tól To ig [Step lépésköz]
    Utasítások
Next [számláló]

A számláló határozza meg, hogy hányszor hajtódnak végre a törzsben levő utasítások. A lépésköz opcionális, az értéke alapértelmezésben 1. A lépésköz lehet negatív is, de ekkor a "tól" értéknek nagyobbnak kell lennie az "ig" értéknél. A számlálónak, valamint a "tól "és "ig" értéknek numerikusnak kell lennie.

For Each element in Group
    Utasítások
Next [element]

A For ciklusnak ez a fajtája akkor hasznos, ha elemek egy csoportjára szeretnénk végrehajtani valamilyen műveletsort, de nem tudjuk pontosan, hogy hány elem tartozik a csoportba. Végigveszi a csoportban található elemeket egyesével, és elvégzi velük a törzsben adott utasításokat. A For Each ciklusban nem okoz fennakadást, ha a ciklusmagban változtatjuk a gyűjtemény tartalmát, kiveszünk elemeket, vagy újakat veszünk hozzá. A ciklus a gyűjteményben levő elemeken fut végig.

Do While felt
    Utasítások
Loop

Do Until felt
    Utasítások
Loop

Do
    Utasítások
Loop Until felt

Do
    Utasítások
Loop While felt

A Do...Loop ciklus a törzset nem előre meghatározott számszor hajtja végre, hanem egy feltétel kiértékelésétől függ, hogy mikor fejezi be a törzs ismételt végrehajtását. Lehet elöl- vagy hátultesztelő is. A ciklusfeltételnek numerikus értékre kiértékelhető kifejezésnek vagy összehasonlításnak kell lennie. A hátultesztelő ciklus használatakor a törzs egyszer mindenképpen végrehajtódik.

While feltétel
    Utasítások
Wend

Mint a Do...Loop ciklus, ez is addig hajtja végre a törzsben szereplő utasításokat, míg a feltétel hamissá nem válik.

Kilépő utasítások

Az Exit utasítással léphetünk ki ciklusokból illetve alprogramokból. Az Exit mindig közvetlenül lép ki a For...Next és Do...Loop ciklusból, valamint a Sub és Function alprogramokból.

Kilépés ciklusból: A For...Next ciklusból az Exit For, a Do...Loop ciklusból az Exit Do utasítással léphetünk ki. Ezeket az utasításokat általában valamilyen feltétel előzi meg, és csak akkor hajtódnak végre, ha a feltétel igaz, és nincsen szükség a ciklus hátralevő részének végrehajtására.

Kilépés alprogramokból: Sub eljárásból az Exit Sub, függvényből pedig az Exit Function utasítással léphetünk ki. Mint a ciklusoknál, az Exit utasítások használata általában az alprogramok esetében is feltételhez kötött.

A With utasítás

A With utasítást akkor használjuk, ha egy objektumon több utasítást szeretnénk végrehajtani egymás után. Használatakor nem kell kiírni az objektum nevét, csak azt a tagját, amire hivatkozunk. Így gyorsíthatjuk a programot, felesleges gépeléstől kíméljük meg magunkat, és a kód is olvashatóbb lesz.

With Font 
 .Name="Arial"
 .Bold=True
 .Size=5
End With

A With utasításblokkok egymásba ágyazhatók, de ilyenkor a belső blokkban a külső blokkban megadott objektum tulajdonságaira csak az objektumnév megadásával hivatkozhatunk.

With MyForm 
 .Caption="Az én űrlapom"
 With .MyTextBox
  .Text="Az én szövegdobozom"
  .Caption="Mégsem az én űrlapom" ' Hibás hivatkozás
 End With
End With

Eljárások, absztrakt eljárások

Bevezetés

Visual Basicben általában eseményvezérelt alkalmazásokat készítünk. Az esemény olyan hatás, amit egy ablak vagy control fogad, és reagál rá egy Visual Basic kódrész végrehajtásával. Minden control előre definiált eseménykészlettel rendelkezik. Ugyanazt az eseményt több objektum is képes felismerni, ezért az eseményt fogadó objektumtól is függ, hogy milyen alprogram hajtódik végre válaszként. Az esemény-eljárást tehát az esemény és az objektum neve együttesen azonosítja. Alapértelmezésként az alkalmazás első ablakához van társítva a Startup Form tulajdonság, ami azt jelenti, hogy az alkalmazás futtatásakor végrehajtódik az ablak Form_Load-hoz tartozó alprogram, majd a Windows várja a beérkező eseményeket. Egy program futása akkor ér véget, ha minden ablaka le van zárva és nincsen már végrehajtható kód. Az End utasítást bárhol kiadva azonnal befejezhetjük az alkalmazás futtatását.

Esemény-eljárások

Ha egy objektum felismeri egy esemény bekövetkeztét, akkor automatikusan meghívja a hozzárendelt alprogramot. Ez egy Sub és End Sub közé zárt végrehajtható kódot tartalmaz. Az esemény-eljárás az esemény és az objektum nevéből áll, melyek "_" karakterrel vannak elválasztva. Ha egy eljárás neve nem egyezik egyik control eljárásának nevével sem, akkor az az ablak általános alprogramja lesz.

Általános alprogramok

Ezek az alprogramok csak akkor hajtódnak végre, ha az alkalmazás egy pontjáról expliciten meghívjuk őket. Lehetnek eljárás vagy függvénytípusúak is. A két típus közt az a különbség, hogy az eljárásnak (Sub) nincsen visszatérési értéke, míg a függvénynek (Function) van. Az alprogramok rekurzív hívása megengedett. Függvények esetén a függvény neve zárójelek nélkül a visszatérési értéket jelenti (még értékadás jobb oldalán is), paraméterlistával együtt a függvény hívásának eredményét.

Eljárás deklarálása

Sub proc_nev (par1, par2, ... As típus1, parx, pary, ... As típus2)
    Utasítások
End Sub

A paraméterek átadása alapértelmezésben hivatkozás szerinti, de ha egy paramétert érték szerint szeretnénk átadni, akkor a neve elé a "ByVal" kulcsszót kiírva megtehetjük. Eljárás hívásakor az argumentumokat nem kell zárójelek közé rakni kivéve, ha a "Call" utasítással hívjuk.

swap A,B
call swap (A,B)

Függvények deklarálása

Function fnev (par1 [As típus1], parx, pary, ... [As típus2]) [As típus]
    Utasítások
End Function

Függvények esetén mindig ki kell írni a zárójeleket az argumentumlistánál. Ha nem adjuk meg az As kulcsszó után a függvény visszatérési értékének típusát, akkor az automatikusan Variant lesz. A visszatérési érték a függvény nevéhez rendelődik hozzá. A függvény törzsében nem kell return utasítást használnunk, de az "fnev = érték" utasításnak szerepelnie kell.

Függvény hívásakor a Visual Basic először az adott ablak- vagy kódmodulban keres, csak ezután keres a többi kód modulban. Az aktuális ablakon kívül nem keres más ablak-modulban. Más ablak-modulok műveleteit csak minősített hivatkozással hívhatjuk meg. Definiálhatunk egy kód modulban private alprogramokat is, ezek lokálisak lesznek az adott modulra nézve.

Paraméterátadás

Az eljárások argumentumai alapértelmezés szerint Variant típusúak, ha expliciten nem adtuk meg a típusukat. A paraméterek átadása alapértelmezés szerint hivatkozás szerint történik. Variant típusú paraméterek átadásakor felléphet a következő probléma:

a függvény:

Function Sor (kar As String, ByVal n As Integer)

hívása:

Dim c As Variant c="Akarmi"
vissza=Sor(c,5)

Ekkor a Visual Basic nem tud mit kezdeni az első paraméterrel, mivel az variant, a függvény viszont String-et vár. Ha egy függvény egy argumentumára valamilyen más típusú adattal szeretnénk hivatkozni, akkor azt jelezni kell.

Ha az argumentumot zárójelbe tesszük, akkor a VB kiértékeli híváskor:

vissza=Sor((c),5)

ByVal kulcsszó használatával deklaráljuk az argumentumot, ekkor ugyanis a változó értékét adjuk át:

Function Sor (ByVal kar As String, ByVal n As Integer)
Dim C As String, k As Variant
C="akarmi" : k="3"
vissza=Sor(c,k)

Az alprogramoknak lehetnek opcionális paraméterei is. Ha ilyet szeretnénk deklarálni, akkor a paraméter neve elé ki kell írni az Optional kulcsszót, és az utána következő paramétereknek is opcionálisnak kell lenniük. Az opcionális paraméterekhez rendelhetünk alapértelmezett értéket is, amit akkor vesznek fel, ha a alprogram hívásakor az paraméterek között nem szerepel az adott paraméterhez tartozó érték.

Sub ListText(x As String, Optional y As Variant = 12345)
    List1.AddItem x
    List1.AddItem y
End Sub

Egy alprogramnak átadható meghatározatlan számú argumentum is, ekkor a ParamArray kulcsszót kell használnunk. Ekkor a For Each...Next ciklus segítségével lépkedhetünk végig az argumentumokon, amelyeket mint halmazt kezelhetjük.

Sub Sum(ParamArray intNums())
    For Each x In intNums
        y = y + x
    Next x
    intSum = y
End Sub

Egy alprogram hívásakor, aktuális paramétereket megfeleltetjük a formális paramétereknek. Ezt megtehetjük úgy is, hogy az alprogram definiciójában megadott sorrendben adjuk meg az aktuális paramétereinket, vagy pedig explicit megmondjuk, hogy melyik formális paraméternek szeretnénk megfeleltetni az aktuálist. Ez a módszer hasznos, ha sok opcionális formális paraméter van. Ez a paraméternév := érték szerkezettel tehetjük meg.

Sub ListText(strName As String, Optional strAddress As String)
    List1.AddItem strName
    List1.AddItem strAddress
End Sub

Private Sub Command1_Click()
    ListText strAddress := "cim", strName := "Név"
End Sub

Külső függvénykönyvtárak használata

A nyelv lehetőséget ad más nyelven megírt programok,programkönyvtárak használatára is. A külső könyvtárban található függvényeket az alábbi módon kell deklarálnunk:

Declare Function <Függvény neve> Lib "<könyvtár neve>" Alias "<Függvény neve a könyvtárban>" [(<Paraméterlista>)] [As <visszatérési érték>]

Declare Sub <Eljárás neve> Lib "<könyvtár neve>" Alias "<Eljárás neve a könyvtárban>" [(<Paraméterlista>)]

Így tetszőleges nyelven megírt, DLL formába lefordított programot használhatunk Visual Basicből. Erre sokszor szükség lehet, például a Windows rendszerfüggvények hívásakor. Bevett gyakorlat, hogy a program kritikus részeit C++ nyelven készítik el, így biztosítva a megfelelő sebességet és stabilitást, és a program többi részét a kényelmes és gyors fejlesztést lehetővé tevő Visual Basic-ben írják meg.

Vigyázni kell azonban a külső függvények hívásakor a típusmegfeleltetésre és a megfelelő paraméteradásra. A következő példában egy függvény C++ és Visual Basic-beli deklarációját vethetjük össze:

Private Declare Function zipOpen Lib "zlib.dll" (ByVal Path As String, ByVal Append As Long) As Long

extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append));

Látható, hogy a C++ szerinti int típus a Visual Basic Long típusának felel meg, valamint hogy a karakter-mutató a karakterlánc érték-szerinti átadásának felel meg. 

A nyelven belül eljárásokat nem adhatunk át paraméterként, de külső függvény paraméterezhető Visual Basic-ben készített függvénnyel, eljárással. Erre szolgál az AddressOf operátor. 

Beépített és absztrakt adattípusok

Alap adattípusok

Visual Basic-ben nem kell a változókat deklarálnunk, azok az első hivatkozásnál jönnek létre. Ez gondot okozhat, mert előfordul, hogy elgépelünk egy változónevet, ami így egy új változót jelent, ami természetesen nem tartalmazza a másik változó értékét. Ennek a problémának a megoldására szolgál az Option Explicit utasítás, ami után minden használt változót explicit módon deklarálnunk kell.

Változókat explicit módon a Dim, Static, Global, Private vagy Public kulcsszóval deklarálhatunk. Ezek a láthatóságban különböznek egymástól. Ha nem adjuk meg a típust, akkor automatikusan variant lesz).

Többszörös deklaráció is lehetséges, ilyenkor a változók nevét ","-vel kell elválasztani.

Explicit deklarálásnál néhány alaptípus esetén nem feltétlenül kell kiírnunk a típus nevét, bizonyos karakterek a változók végén utalnak a változó típusára. Ezek: %: Integer, &: Long, !: Single, #: Double, @: Currency, $: String

Numerikus típusok: A Visual Basicben kétféle egész típus és háromféle valós típust találunk.

Integer: A legkisebb egész típus, 2 bájtos.

Long: Nagy egész számok ábrázolására használható, 4 bájtos.

Currency: Rögzített tizedespontú szám, melyet leggyakrabban a pénzügyi számításokban használnak. Tizenöt számjegyű lehet az egészrész, a törtrész 4 számjegyű. 8 bájton tárolódik.

Single: 4 bájtos lebegőpontos szám.

Double: 8 bájtos lebegőpontos szám.

A lebegőpontos számok értéke ugyan nagyobb korlátok között mozoghat, mint a Currency, de azokat lehet kerekíteni. A lebegőpontos számokat kifejezhetjük normál formában is.

Byte: 1 bájtos nem előjeles szám. Bináris adatok tárolására javasolt a Byte tömb használata. (Pl. string típusú változókban tárolt bináris értékek az ANSI és Unicode formátumok közötti átalakítás során sérülhentek.) A Byte-típusra is érvényesek a Numerikus típosokra definiált aritmetikai műveletek, kivéve a -1-el való szorzást. (ilyenkor a Byteot előjeles Integerre konvertálja)

Boolean: logikai típus értéke a True és a False

String: Karaktersorozat tárolására használható. Alapértelmezésben egy string változó hosszúságú sorozat, azaz a tárolt adattól függően nő vagy csökken a hossza, de deklarálhatunk fix hosszúságú stringet is (String *méret).

Dim nev As String*40

Date/time: Jan 1, 0000 és dec 31, 9999 közötti érték lehet. Megjelenítési formátuma a Windows alapbeállításokhoz kötődik, de ezt a Format függvénnyel módosíthatjuk.

Object: 4 bájtos objektumra mutató pointer, a Set függvénnyel rendelhetünk hozzá értéket. (az objektum lehet pl. Form, Button, Control ...)

Boolean: 2 bájtos, de csak True vagy False értéket vehet fel.

Byte: 1 bájtos szám.

Decimal: 12 bájtos, előjel nélküli szám. Megadható, hogy hány darab jegy legyen a tizedespont jobb oldalán (0-28). Exppliciten nem lehet Decimal típusú változót deklarálni, hanem Variant-ként kell létrehoznunk, majd a Cdec függvénnyel készíthetünk belőle Decimal típust.

Variant: ez az adattípus többféle adatot is tartalmazhat, így használhatjuk pl. dátum, string vagy szám tárolására is. Ha Variant típusú változót használunk egy kifejezésben, akkor a Visual Basic automatikusan elvégzi a típuskonverziókat. Ha egy változót nem deklarálunk expliciten, akkor Variant típusú lesz. A Variant változóhoz tartozik egy belső értékkészlet, és amikor hozzárendelünk egy értéket, akkor a Visual Basic feljegyzi, hogy milyen típusú volt ez az érték, és ennek megfelelően kezeli a jövőben a típuskonverziókat. A Vartype függvénnyel lekérdezhető, hogy a Variant változóhoz éppen milyen típusú érték van rendelve, illetve az IsNumeric függvénnyel megvizsgálhatjuk, hogy számmá konvertálható-e. A Variant változónak két speciális értéke van: 1, Empty - ez lesz a változó értéke kezdetben, és csak akkor változik, ha értéket rendelünk hozzá. 2, Null - általában adatbázis-kezelő alkalmazásokban a hiányzó vagy ismeretlen adatra utal.

Konverziós függvények

Bármilyen valós kifejezést átkonvertálhatunk valamilyen általunk kívánt típusra a konverziós függvények segítségével.

Függvény neve

Milyen típusra konvertál

Cbool

Boolean

Cbyte

Byte

Ccur

Currency

Cdate

Date

Cdbl

Double

Cint

Integer

Clng

Long

Csng

Single

Cstr

String

Cvar

Variant

CVErr

Error

Konstansok

Konstansokat a változók deklarálásához hasonlóan hozhatunk létre azzal a különbséggel, hogy a sor elejére ki kell írni a const kulcsszót.

Összetett típusok

Tömbök: Azonos típusú értékekből tömböt hozhatunk létre, amelyben az egyes elemekre az indexekkel hivatkozhatunk. Bár a tömb elemei azonos típusúak, variant adattípusú tömb esetén az egyes elemek eltérő típusúak is lehetnek. Tömböt készíthetünk saját adattípusból is. A tömb indexe csak Integer lehet, és a tömb számára a memóriaterület a deklaráláskor foglalódik le.

Fix méretű tömök: Globális tömböt a kód modul deklarációs részében a Global tömb(n) As típus utasítással hozhatunk létre. Modul szintű tömböt a Dim utasítással az adott modul deklarációs részében hozhatunk létre. Lokális tömböt a Static vagy Dim utasítással az eljárás deklarációs részében hozhatunk létre. A tömbök sorszámozása alapértelmezésben nullától kezdődik, de ez az Option Base utasítással megváltoztatható (a modul deklarációs részében). A tömb indexében intervallum is megadható a To kulcsszóval.

Többdimenziós tömbök: A Visual Basicben maximum 60 dimenziós tömböket hozhatunk létre, de ez általában bőven elég.

Dim tomb(n,m) As Integer
Dim tomb(n To m, f To g) As Integer

Dinamikus tömbök: Olyan tömbök, amelyeknek futási időben változtatható a méretük, ezzel hatékonyabban kezelhető a memória. Deklarálásuk hasonló a fix méretű tömbökéhez, de a dimenziós listát üresen kell hagyni (pl. Dim tomb() ).A későbbiekben a Redim utasítással adhatjuk meg a dimenziókat illetve az elemek számát. A Redim utasítással változtathatjuk a meglévő dimenziók határait, de adatvesztés nélkül csak a felsőt. Alapértelmezésben a dimenziók számának változtatása adatvesztéssel jár, de a Preserve kulcsszó használatával elérhetjük, hogy megmaradjanak az adataink. Ekkor azonban csak az utolsó dimenzió felső határa módosítható, a többinél hibát kapunk.

A tömbök indexhatárának lekérdezésére a nyelv az Ubound és LBound függvényeket bocsátja a programozók rendelkezésére. Ezek használatával a tömb adott indexének alsó és felső határa kérdezhető le. Komoly hiányossága a nyelvnek, hogy üres tömb esetén a függvények használata futás idejű hibát eredményez. További kellemetlenség a tömbök használatával kapcsolatban, hogy egy dinamikus tömb a Redim utasítással nem állítható vissza üres tömbbé.

Példa: Dinamikus tömb feltöltése előre ismeretlen számú értékkel:

Dim I As Integer
Dim MyArr() As Integer
For i = 1 to X
    On Error Resume Next
    Redim Preserve MyArr(Lbound(MyArr) To UBound(MyArr)+1)
    If Err.Number <> 0 Then
        Redim MyArr(0 To 0)
    End If
    On Error Goto err_handler
    MyArr(Ubound(MyArr))=i
Next i

Huge tömbök: Olyan tömbök, amelyeknek a mérete 64Kbyte-nál nagyobb. Ezeket a tömböket azonban nem használhatjuk bárhogy, vannak megszorítások, melyeket be kell tartanunk:

Collection: ennek segítségével elemek rendezett halmazát hozhatjuk létre, melyekre ezután egy egységként hivatkozhatunk. A halmazhoz tartozó elemek típusa lehet különböző (Deklarálása: pl. Dim x As New Collection). Ezután a halmazhoz az Add utasítással vehetünk hozzá új elemeket, a Remove-val pedig törölhetünk belőle. A halmaz elemein a For Each ... Next utasítással lépkedhetünk végig. Az elemeket az indexükkel is elérhetjük, az indexelés 1-től kezdődik. Egy elemhez hozzárendelhetünk kulcsot is, ekkor kulcson keresztül is elérhetjük, nem csak indexszel. Collection objektum nem tartalmazhat saját típust.

Saját típusok

A Type utasítással struktúrákat hozhatunk létre, de ezt csak kód modul deklarációs részében tehetjük. (Az így létrehozott típusok mindig globálisak).

Type Person
    Nev As String
    Cím As String
    Ber As Currency
End Type

Az új típus tartalmazhat tömböket (dinamikus nem lehet) és saját típusokat is. Saját típus szerepelhet eljárás paramétereként és privát függvény visszatérési értékeként is.

Objektum publikus függvényeinek, eljárásainak paramétereként illetve visszaadott értékeként saját típus nem használható. Amennyiben a rekord átadása elkerülhetlen, a rekordot osztályként kell megvalósítani (az osztály definíciója a rekord típus változóinak megfelelő publikus változókból álljon) amelyet már tetszőleges függvény / eljárás használhat paraméterként vagy visszatérési értékként.

Felsorolási típus

A nyelvben felsorolási típust az Enum kulcsszó segítségével definiálhatunk. 

[Public | Private] Enum name
    membername [= constantexpression]
    membername [= constantexpression]
End Enum
 

Generic, típussal való paraméterezés

A Visual Basicben nincsen generic, nem támogatja a típussal való paraméterezést.

Hibakezelés

Hibakeresés

A Visual Basicnek háromféle működési módja van: tervezési, futási és figyelési mód. A hibafigyelő eszközöket figyelési módban használhatjuk.

A Visual Basic különböző eszközöket kínál futáskövetésre, melyeket érdemes a programunk megírása után felhasználni, azaz a programot ezek igénybevételével lefuttatni. Ezek az eszközök a következők:

Töréspont: a kódban töréspontokat helyezhetünk el, és ha a feldolgozás során a kód ezekhez ér, akkor a program futása felfüggesztődik, és megvizsgálható a program pillanatnyi állapota (változók, jellemzők aktuális értékei, aktív eljárás ...).

Figyelés: ekkor egy megszakítási kifejezés megváltozása vagy igazzá válása esetén belépünk a program-megszakítási módba, ahol ellenőrizhetjük a változók értékeit, illetve meg is változtathatjuk azokat.

Belelépés: lépésenként haladhatunk végig a programon, minden léptetés egy soron következő utasítást hajt végre, majd visszatér megszakítási üzemmódba. Ha egy másik nem védett modulban levő eljárás hívása szerepel az adott sorban, akkor ennek minden utasításán is ugyanígy végiglépkedhetünk. Ha a modul védett, akkor átlépésnek felel meg, azaz az eljárás minden utasítását egy lépésben hajtja végre.

Átlépés: mint a belelépés, de egy eljárás hívásakor a teljes eljárás egyetlen lépésben hajtódik végre.

A Visual Basic akkor lép be megszakítási módba, ha egy utasítás hibát generál, törésponthoz vagy Stop utasításhoz érkezik a végrehajtás, vagy figyelési módban a figyelendő kifejezés értéke igaz lesz vagy megváltozik. A Stop és a töréspont között annyi a különbség, hogy a Stop csak a programsor szerkesztésével távolítható el, míg a töréspont ki/bekapcsolását egy gomb segítségével elvégezhetjük, és a töréspont a project újbóli betöltésekor eltűnik, a Stop viszont megmarad. A Debug rendszerobjektum használatával üzeneteket írathatunk ki a Debug ablakba. (pl. Debug.print "vezeteknev: ";text1.text). Ezeknek a soroknak nincsen semmilyen hatása az .exe fájlban, de azért érdemes őket kitörölni.

Hibák lekezelése

A Visual Basic felismeri a legáltalánosabb hibákat, és az Err objektumban eltárolja a hibakódot. Ennek alapértelmezett jellemzője a Number tag, ezért erre egyszerűen az Err névvel is hivatkozhatunk (nem kell kiírni, hogy Err.Number). A program kódjában mi is kiválthatunk hibát az Error hibakód paranccsal, ami beállítja az Err objektumot és meghívja a hibakezelőt. Ha nincsen ilyen, akkor hibaüzenetet kapunk a hibáról.

Az előre látható hibákat lekezelhetjük az On Error GoTo szerkezettel (a hibakezelés egy címke). Pl.:

Function Valami
    On Error Goto hibakez
    utasítások
    Exit Function
Hibakez:
    Hibakezelő rész
End Function

Ezt a szerkezetet hívják Error trap-nek, és egyszerre csak egy ilyen lehet aktív. Definiálhatunk több alternatív hibakezelőt is, úgy hogy mindig az éppen megfelelőt használjuk.

A Variant típusnak van egy speciális értéke, az Error, amivel azt jelzi, hogy valamilyen hiba történt az eljárásunkban. Ez lehetővé teszi, hogy az alkalmazás alternatívákat hajtson végre a hiba típusától függően. Ha ismerjük a hibakódokat, akkor az Err függvény segítségével könnyen lekezelhetjük a hibákat egy Select Case utasítással. Saját hibakódokat is készíthetünk, ezek Variant típusban lesznek eltárolva Error kódként (pl. rosszérték=CVError(2020)).

A hibakezelő részből többféleképpen léphetünk ki:

Resume: visszatér a hibát okozó utasításra

Resume Next: a hibát okozó utasítás utáni utasításra tér vissza

Resume sorszam: az ugyanazon eljárásban található sorszam címkére ugrik

Error Err: az utolsó hibát újra kiváltja, és a hívási listán másik hibakezelő rutint keres.

Az eljárásból történő kilépés előtt az On Error Goto 0 utasítással minden, az adott eljárásban levő hibakezelő rutin deaktiválható.

Előfordulhat az az eset, hogy hiba lép fel egy eljárásban, és a Visual Basic egy másik eljárásban talál hibakezelő rutint, majd annak végrehajtása után nem tér vissza abba az eljárásba, ahol a hiba bekövetkezett. Ennek elkerülésére a más eljárások által is használt hibakezelő rutinokat úgy kell megírni, hogy eltárolják a hívás helyét.

Lehetőség van a CTRL+BREAK vagy ESC billentyűk letiltására (ezek megszakítják az alkalmazás futását), illetve hatásuk előtt végrehajthatunk bizonyos utasításokat (pl. fájlok lezárása). A letiltás azért nem túl jó ötlet, mert így a felhasználó nem tud kilépni a programból (ezért csak a program bizonyos részein, ideiglenesen tiltsuk le).

Objektum-orientált programozás, öröklődés

Bevezetés

A Visual Basic objektum alapú nyelv, nem objektum orientált, ezért aztán hiányoznak belőle a megszokott eszközök, de az újabb verziókban már lehetőségünk van osztályokat készíteni, amelyekből aztán objektumokat hozhatunk létre. Az alkalmazás során objektumokkal (Form, Control) dolgozunk, amelyekhez létrehozhatunk objektumváltozókat, amelyekkel pl. egy ablaknak több példányát hozhatjuk létre futási időben, illetve módosíthatjuk bármelyik ablakot vagy control-t. Az objektumváltozók láthatósága a deklarálás helyétől függ, mint ahogy a hagyományos változóknál is.

Objektumok és osztálymodulok

Az újabb Visual Basic verziókban már háromfajta modul található: form, standard és osztály. Ez utóbbi a Visual Basic objektum orientált programozásának alapja. Az alkalmazásunk alprogramjai által használt objektumok létrehozására használható, saját objektumokat készíthetünk a segítségével (tulajdonságaikkal és tagfüggvényeikkel együtt). Az osztálymodul tartalmazhat kódot és adatot is.

Egy osztálymodulnak kezdetben két eseménye van: Class_Initialize() és Class_Terminate(). A modul neve lesz az osztály neve, az objektumokat pedig az osztály eljárásain keresztül érhetjük el.

Az osztályban ugyanúgy deklarálhatunk függvényeket, mint más modulokban (a Public és Private kulcsszó hasznlatával).

Eseményeket a "Public Event event_name(...)" utasítással hozhatunk létre, és a "RaiseEvent event_name(...)" utasítással válthatunk ki. Esemény mindig publikus kell legyen, nem lehet opcionális és nem lehet ParamArray argumentuma.

A Visual Basic nem használ öröklődést, a polimorfizmust pedig többszörös interfészen keresztül biztosítja (két osztályban implementálom ugyanazt az interfészt, és ekkor mindkét osztály egyedeire hivatkozhatok ezen az interfészen keresztül, de a megfelelő osztály megfelelő művelete fog végrehajtódni). Interfészt egy külön osztálymodulban kell létrehozni, melyben csak a műveletek fejlécét kell megadni (így ez egy absztrakt osztály lesz), az implementációt pedig abban az osztályban kell megadni, amelyiket ezen az interfészen keresztül szeretnénk elérni (az osztályban szerepelnie kell az Implement interface_name sornak és a megfelelő műveletek deklarációjának). A használathoz létre kell hozni egy interfész típusú változót (Dim iface As Interface_nev), ehhez rendeljük hozzá az adott osztály egy objektumát, és ekkor az interfész műveleteivel érhetjük el az objektum adatait (csak ezeket az alprogramokat látjuk).

Egy osztályban lehet Collection típusú attribútum is, így létrehozható 1-sok kapcsolat osztályok közt.

Objektumváltozók deklarálása

Kód modul deklarációs részében a Global kulcsszóval - globális, az alkalmazás futása alatt él.

Kód modul deklarációs részében a Dim kulcsszóval - modul szintű, az alkalmazás futása alatt él.

Kód modulban a Static kulcsszóval - modul szintű, az alkalmazás futása alatt él.

Form modul deklarációs részében a "Dim" kulcsszóval - az ablakpéldány élettartama alatt él.

Form modulban a Static kulcsszóval - az ablakpéldány élettartama alatt él.

Alprogramon belül a Dim kulcsszóval - az alprogram végrehajtási ideje alatt él.

Objektumváltozót deklarálhatunk általánosnak (ekkor pl. az alkalmazás bármelyik ablakára mutathat), vagy speciálisnak (az objektum egy egyedi típusára hivatkozhat). Három féle általános objektumváltozó van: Form, Control, MDIForm.

A Me taggal a konkrét objektumra hivatkozhatunk. Speciális objektumváltozó lehet az alkalmazás tervezésekor létrehozott objektumok közül valamelyik (Form típusnál valamelyik létező ablak, Control típusnál pedig valamilyen speciális control). Érdemes speciális objektumváltozókat használni, mert ekkor a Visual Basic felismeri az objektumokhoz tartozó metódusokra és tulajdonságokra vonatkozó hivatkozásokat az alkalmazás futásakor, így gyorsabb lesz a programunk.

Objektumváltozókból létrehozhatunk fix méretű vagy dinamikus tömböket, és ekkor is használhatjuk a New kulcsszót.

pl. Dim sajatform(10) As New Form1

Objektumváltozók kezelése

Objektumváltozókat átadhatunk alprogramoknak paraméterként, ekkor az átadás mindig hivatkozás szerinti. Objektumváltozó típusának meghatározásához használhatjuk az If TypeOf .... Is .... then .... [Else ...] szerkezetet.

Objektumváltozókhoz a Set paranccsal rendelhetünk értéket (pl. Set objval={ objkifejezés | New formtípus | Nothing}). Ha egy objektumváltozó nem hivatkozik semmilyen objektumra, akkor az értéke Nothing (ez a kezdeti értéke is inicializálás után). A Set sajatform=Nothing utasítás kiadásakor felszabadul az ablak által lefoglalt memória.

Két objektumváltozó összehasonlításakor az Is parancsot használhatjuk annak eldöntésére, hogy ugyanarra az objektumra mutatnak-e.

Jellemzők

Az osztályokhoz tartozhatnak bizonyos jellemzők (property) is. Ezek úgy viselkednek, mintha adattagok volnának, azzal a különbséggel, hogy ha értéküket kiolvassuk, vagy új értéket kapnak, akkor egy függvény (illetve eljárás) fut le. Gondoljunk csak arra, mennyi mindennek kell történnie, ha egy beviteli mező Text jellemzőjét módosítjuk.

Saját osztályainkhoz is rendelhetünk jellemzőket. Erre mutat példát a következő kódrészlet.

Property Let jellemző (érték)
    kód
End Property

Ennek hatására az osztályunk rendelkezni fog egy jellemző jellemzővel, ami ha értéket kap, akkor a kód-ban leírt utasítások fognak végrehajtódni. Hasonlóan egy Property Set blokkban azt állíthatjuk be, mi történjen, ha a jellemzőhöz új objektumot rendelnek. A Property Get blokkban meghatározott kód akkor fut le, ha a jellemző értékét kiolvassák.

Öröklődés

A szokásos értelemben vett öröklődésről nem beszélhetünk, hiszen nem objektum orientált nyelvről van szó. A Visual Basicben mindössze egy példányosításra hasonlító lehetőségünk van, mégpedig hogy mikor létrehozzuk egy ablak egy másolatát, akkor az örökli az eredeti ablak minden beállítását, s innentől kezdve a másolat az eredetitől teljesen függetlenül kezelhető. Egy egyedi ablak minden példánya ugyanazon a kódon osztozik (műveletek), de az adatokról saját másolata van.

Rendszerobjektumok

A Visual Basic speciális rendszerobjektumot ad, melyek globálisak, és melyek segítségével a környezetről szerezhetünk információkat:

App alkalmazás-specifikus információk
Clipboard az operációs rendszer háttértárjához ad hozzáférést
Debug a Debug ablakba történő nyomtatást támogatja
Printer a nyomtatást segíti
Screen az aktuális ablak, control és egyéb képernyőhöz kapcsolódó adatokat kezel

Helyességbizonyítás

Visual Basicben nincsenek helyességbizonyítást támogató eszközök.

Párhuzamos végrehajtás

Bevezetés

A Visual Basicben eseményvezérelt programokat írhatunk. Egyszerre több ablakot jeleníthetünk meg a képernyőn (ezek mind több control-t is tartalmazhatnak), melyek mindegyike eseményt vár, és ezek között váltogathatunk. Egyszerre mindig csak egy eseményhez tartozó kód fut, ezért a párhuzamosság nem valódi.

Ablakok példányai

A Visual Basicben az objektumváltozók segítségével egy ablaknak több példányát is létrehozhatjuk egy időben. Egy ilyen példány az eredeti ablak másolata lesz, de attól teljesen független, ezért egy alkalmazást egyszerre több példányban is futtathatunk, illetve az alkalmazás valamely ablakából létrehozhatunk több példányt.

Új ablakot a New kulcsszóval hozhatunk létre. pl.:

Sub Form_Click()
Dim Myform As New Form1
    Myform.Show
    Myform.Move(left+300),(top+300)
End Sub

Új ablakot a Load vagy Show paranccsal tölthetünk be. A Show nem csak betölti, hanem láthatóvá is teszi az ablakot. Egy ablaknak a többszörös példányai közösen osztoznak a kódon (műveletek kódján), de az adatokról saját másolatuk van. Amikor egy esemény bekövetkezik egy ablak példányon, akkor a hozzárendelt esemény-eljárás kódja hajtódik végre az adott példány adatainak a felhasználásával. Egy létező ablakot az Unload utasítással szüntethetünk meg. Ha egy ablaknak több példánya létezik, akkor a Me mindig az aktuális ablakra mutat. (ahol éppen a kód fut). Ezért az aktuális ablakot az Unload Me utasítással zárhatjuk be. Nem mindig az aktív ablak az aktuális ugyanis előfordulhat, hogy egy ablak timer control-jának timer eseménye következik be akkor is, ha nem az az aktív ablak.

Ebben a pontban említeném meg a DoEvents utasítást. Ennek hatására a vezérlés átadódik az operációs rendszernek, és mindaddig nem adódik vissza a programnak, amíg az éppen feldolgozás alatti eseménysor feldolgozása, és a SendKeys sor minden billentyűkódjának átküldése be nem fejeződik. A DoEvents utasítással akkor is elég időt biztosíthatunk az operációs rendszernek az események feldolgozására, ha amúgy a programunk túlságosan leterhelné a processzort.

A nyelv alapvetően nem támogatja a párhuzamos programozást, nem hozhatunk létre önálló végrehajtási szálakat. Így például egy hosszabb időt ígénylő művelet elvégzésekor az alkalmazás aktív ablaka nem tudja végrehajtani az újrarajzolási műveleteket, ami elég kiábrándítóan hat a felhasználókra. Ennek elkerülésére használhatjuk a DoEvents utasítást, vagy alternatív megoldásként megírhatjuk a programrészletet egy, a párhuzamos szálak létrehozását támogató programnyelven és külső függvényként meghívhatjuk azt.

Példa az aktív alkalmazásablak karbantartására hosszú művelet végrehajtása közben:

For L=1 to 100000
    Call Szamolj(i)
    DoEvents
Next

Könyvtárak, egyéb nyelvi elemek

Bevezetés

Egy Visual Basic alkalmazás modulokból épül fel. Egy modul 3 típusú lehet: form, standard illetve osztálymodul. A Visual Basic program projectjében fel kell sorolni azokat a modulokat, amelyeknek valamilyen kapcsolata van az alkalmazásunkkal.

Modulok típusai

Form modul: Az alkalmazás minden ablakához tartozik egy form modul (*.frm), amelyik a tulajdonságait tartalmazza. Minden form modul esemény-eljárásokat tartalmaz, amelyekben azok az utasítások szerepelnek, melyeket az adott esemény bekövetkezésekor kell végrehajtani. Ezek a modulok tartalmazzák az ablakon található control-ok és az ablak esemény-eljárásait, illetve tartalmazhatnak általános (objektum nélküli) alprogramokat, melyek csak expliciten hívhatóak meg az eseményvezérlőkből.

Standard modul: A standard modul olyan kódot tartalmaz, ami egyetlen konkrét ablakhoz vagy control-hoz sem kapcsolódik (pl. ha több, különböző objektumokon bekövetkező esemény ugyanazt az utasítássorozatot tartalmazná, akkor azt írhatjuk standard modulba, így nem kell minden eseménykezelőbe bemásolni ugyanazt, és kevesebbet is kell gépelnünk). Itt szerepelnek a globális deklarációk is.

Osztálymodul: A Visual Basic objektum orientált programozásának alapjai az osztálymodulok. Az alkalmazásunk által használt objektumok létrehozására használható. A standard modullal ellentétben, amely csak kódot tartalmaz, az osztálymodul tartalmazhat kódot és adatot is. Úgy is elképzelhető, mint egy control fizikai reprezentáció nélkül.

Modulok felépítése

Mindegyik modul egy deklarációs és egy kódrészből áll. A deklarációs részben a konstansok, változók, típusok és DLL eljárások modul szintű deklarációja adható meg, míg a kódrész a Sub, Function és Property alprogramok kódját tartalmazza.

ActiveX

ActiveX komponensekkel igen hasznos alkalmazásokat készíthetünk (olyan komponenseket hozhatunk létre, melyek módosítás nélkül használhatóak több alkalmazásban). Egy ActiveX komponens olyan újrahasznosítható programrészlet és adathalmaz, amely egy vagy több ActiveX technológiával létrehozott objektumból áll (ilyen felhasználható komponenseket találhatunk a Microsoft Office alkalmazásokban: kód komponensek, ActiveX dokumentumok és ActiveX control-ok).

ActiveX komponensek típusai

Az ActiveX technológiát támogató alkalmazások (Excel, Word, Access) olyan objektumokat biztosítanak, melyek a Visual Basic alkalmazásokból a programkódból módosíthatóak (pl. használhatjuk egy Excel munkalap tulajdonságait, metódusait és eseményeit).

A kód komponensek programozható objektumok könyvtárait biztosítják (pl. gyakran használt Dialog_Box-okat, vagy speciális pénzügyi függvényeket stb.).

Az ActiveX control komponensekkel új szolgáltatásokat kaphatunk (pl. speciális szolgáltatásokat, pl. egy naptár megjelenítése egy ablakon).

Az ActiveX dokumentumokkal interaktív Internetes alkalmazásokat készíthetünk.

Saját ActiveX komponenseket csak a Professional és az Enterprise Edition-ban hozhatunk létre.

Beépített vezérlőelemek

Ikon Vezérlőelem neve Osztálynév Leírás
Parancsgomb CommandButton A felhasználó által választott parancsot vagy műveletet hajtja végre.
Címke Label Felhasználó által nem módosítható szöveg megjelenítésére szolgál
Beviteli mező TextBox Szöveg bevitelére és megjelenítésére alkalmas felület
Lista ListBox Listát jelenít meg, amelyből a felhasználók elemeket választhatnak
Kombinált lista ComboBox A beviteli mező és a lista jellemzőit ötvözi. Segítségével a felhasználó begépelhet szöveget vagy legördülő listáról választhat ki egy elemet.
Jelölőnégyzet CheckBox Igaz/Hamis illetve Igen/Nem értékek megjelenítésére használható.Egy űrlapon egyszerre tetszőleges számú jelölőnégyzet választható ki.
Választógomb OptionButton Több választógombból egy csoportot alakíthatunk ki, amelyeből a felhasználó egyet választhat ki. (Természetesen több csoportot is kialakíthatunk)
Könyvtárlista DirListBox Segítségével a felhasználók könyvtárakat és elérési útvonalakat jelölhetnek ki és jeleníthetnek meg.
Meghajtólista DriveListBox Segítségével a felhasználók érvényes lemezmeghajtókat választhatnak ki és jeleníthetnek meg.
Fájllista FileListBox Segítségével a felhasználók választhatnak a megjelenített fájllistáról.
Keret Frame Vizuális és funkcionális konténert biztosít más vezérlőelemek számára

Vízszintes görgetősáv
Függőleges görgetősáv		 HscrollBar
VscrollBar		 Segítésgükkel a görgetősávokat adhatunk azokhoz a komponensekhez, amelyek alapértelmezett esetben nem tartalmaznak ilyeneket.
Kép Image Bitképek, ikonok vagy Windows metafájlok, JPEG- és GIF fájlok megjelenítésére szolgál. Rákattintva parancsgombként is működik.
Képdoboz PictureBox Bitképek, ikonok vagy Windows metafájlok, JPEG- és GIF fájlok megjelenítésére alkalmas. Szöveg megjelenítésére és már vezérlőelemek vizális konténereként is használható.
Vonal Line Vonalszakaszt vehetünk fel vele az űrlapra.
Alak Shape Téglalapot, négyzetet, kört vagy ellipszist vehetünk fel egy űrlapra, keretbe vagy képdobozba.
Időzítő Timer Eseményeket hajt végre meghatározott időnként.
Adathozzáférési vezérlőelem Data Segítségével adatbázisokhoz kapcsolódhatunk, és az onnan szár,azó információkat jeleníthetünk meg.
OLE-konténer OLE Adatok Visual Basic alkalmazásokba való beágyazására szolgál.

ActiveX komponensek használata

Ha egy ActiveX komponens egy típuskönyvtárat biztosít, akkor a használatához a Visual Basic projecthez hozzá kell venni egy erre a típuskönyvtárra vonatkozó referenciát. Az Object Browser-ben kiválasztva a típuskönyvtár nevét megnézhetjük a benne szereplő objektumokat, illetve azok jellemzőit és metódusait. Ha egy olyan objektumváltozót szeretnénk létrehozni, amely egy ilyen komponensben szereplő objektumra mutat, akkor a deklarálásnál a típuskönyvtárat és az osztály nevét is meg kell adni

pl.: Dim xlchart As Excel.Chart

Ha a New kulcsszót is használjuk a deklarációban, akkor a Visual Basic automatikusan létrehoz egy objektumot, és az első használatkor hozzárendel egy objektum referenciát.

Ha az objektum eseményeit is szeretnénk használni, akkor a deklarálásnál használni kell a WithEvents kulcsszót is.

pl.: Dim WithEvents xlbook As Excel Workbook

Ekkor az objektum eseményeihez ugyanúgy írhatjuk meg a kódot, mint a Control vagy Form objektumok eseményeinél. A WithEvent kulcsszóval deklarált változóra viszont van néhány megszorítás: nem lehet általános objektumváltozó, nem deklarálható As New-ként, nem deklarálható standard modulban, és nem készíthető belőle tömb.

Párbeszédablakok

A Visual Basicben vannak előre definiált párbeszédablakok, amelyeket felhasználhatunk az alkalmazásunkban. Ezeknek a tervezésével és kezelésével már nem kell foglalkoznunk, viszont csak modal típusúak lehetnek. Ezeket a párbeszédablakokat függvények hívásával jeleníthetjük meg:

InputBox: Bemutatja a párbeszédablakot, melyben egy szöveg, egy soreditor és egy gomb lesz látható, visszatérési értéke a felhasználó által begépelt szöveg.

MsgBox (eljárás): Megmutatja a paraméterében megadott üzenetet.

MsgBox (függvény): Megmutatja a paraméterében megadott üzenetet, a visszatérési értéke pedig attól függ, hogy a felhasználó melyik parancsgombot választotta (Ok vagy Mégse)

Ha ezeket az alprogramokat megfelelő paraméterezéssel hívjuk meg, akkor már semmilyen dolgunk nincs velük, a gombok és a beviteli mező kezelését automatikusan végzik. Mi is létrehozhatunk dialógusablakokból álló gyűjteményt, amit a későbbiekben csak át kell paraméterezni a célnak megfelelően.

A Visual Basic .NET

A .NET technológiáról röviden:

A .NET technológia lehetővé teszi alkalmazások, programok, szolgáltatások nyelv-, rendszer- és platformfüggetlen felépítését. A nyelvfüggetlenség nemcsak azt jelenti, hogy az alkalmazást bármely .NET nyelven megírhatjuk, hanem azt is, hogy az alkalmazásunk moduljait különböző .NET nyelveken tudjuk megírni, majd ezeket a modulokat könnyen összekapcsolhatjuk egy alkalmazássá.


A .NET vázlatos felépítése

 

Főbb különbségek a VB6 és a VB.NET között

Alapértelmezett tulajdonságok:

A VB6-ban minden osztálynak lehetett alapértelmezett tulajdonsága. Pl. a TextBox esetében a Text az alapértelmezett tulajdonság.
Legyen két TextBox típusú objektumunk:

Dim a As TextBox
Dim b As TextBox

Ekkor az a = b utasítással a b alapértelmezett tulajdonságát (Text) értékül adja az a alapértelmezett tulajdonságának
Ha azt szeretnénk, hogy az a egy referencia legyen b-re, akkor a következőt kell írni: Set a = b

A VB.NET-ben megszüntették az alapértelmezett tulajdonságot. Az a = b utasítás itt azt jelenti, hogy a legyen b egy referenciája.
Ha b Text tulajdonságát szeretnénk a Text tulajdonságának értékül adni, akkor az a.Text = b.Text utasítást kell írnunk (mint egy tetszőleges publikus tulajdonság esetében).

Az eljárás és függvény hívásnál mindig ki kell tenni a zárójelet:

VB6-ban helyes volt az alábbi eljáráshívas:

foo "bar"
call foo("bar")

VB.NET-ben az alábbi módon helyes:

foo ("bar")
call foo("bar")

Tehát a .NET-ben mindig kell zárójel, akkor is ha nincs visszatési érték. A call kulcsszó megmaradt, de nincs különösebb jelentősége.

Logikai műveletek:

A VB6 az And és az Or logikai művelet kiértékelésénél teljes kiértékelést használ, azaz pl. And esetében ha hamis a kifejezés első tagja, akkor is kiértékeli a másodikat.
Ezt megtartották VB.NET-ben is de bevezettek két új kifejezést az AndAlso-t és az OrElse-t. Ezeket lusta kiértékeléssel értékeli ki.

Deklarációk:

A .NET-ben már van lehetőségünk deklarációkor kezdő értéket adni a változóinknak:
Dim n As Integer = 42

Az alábbi kód esetében mindkét változó Integer típusú lesz, ellenben a VB6-tal, ahol az első Variant.
Dim x, y As Integer

Új operátorok:

Bevezettek új operátorokat:
+=; -=; *=; /=; \=; ^=; &=

Ezek az operátorok ugyanúgy működnek mint ahogy ezt a C/C++ ban megismertük. Az utolsó a string konkatenáció.
A ++ és -- operátorokat nem vezették be, mert a Microsoft szerint rontja a kód olvashatóságát.

Paraméterátadás:

VB.NET-ben az érték szerinti paraméterátadás lett az alapértelmezett. (VB6-ban a címszerinti volt) Cím szerint a ByRef kulcsszóval tudunk átadni paramétert.

Blokkszintű láthatóság:

Lehetőségünk van olyan változókat deklarálni, amik csak egy blokkban láthatóak. Blokknak számít minden olyan programrész, amit az End, Loop, Next kulcsszó zár le. Tehát blokk egy ciklus magja, elágazás egyik ága stb. Az élettartam viszont eljárásszintű maradt.
pl:

While i < 5
    Dim x As Integer
    ...
End While

Ekkor x csak ebben a ciklusban látszik, de a lefoglalt memóriaterület csak akkor szebedul fel, ha a ciklust tartalmazó eljárás vagy függvény lefut.

A while ciklust end while zárja:

A VB6-ban a while ciklust a wend kulcsszó zárta, ezt itt end while-ra cserélték. A .NET-ben while után wend-et írunk, akkor a fejlesztőkörnyezet ezt automatikusan end while-ra cseréli.

Az opcionális argumenteknek kell adni alapértelmezett értéket:

A VB6-ban definiálhattunk olyan eljárásokat, amiknek opcionális argumentjeik voltak, amiknek adhattunk kezdőértéket, de ez nem volt kötelező. Az eljárás törzsében az IsMissing függvénnyel tudtuk eldönteni, hogy az ilyen argumentumoknak az eljárás hívója adott-e értéket.
Az IsMissing függvényt a VB.NET nem támogatja, azonban minden opcionális argumentnek kell adni alapértelmezett értéket.

A static kulcsszó nem kerülhet alprogram neve elé:

Az alábbi kód VB6-ban azt jelentette, hogy az alprogram változói statikusak.
Static Sub foo()
    Dim x As Integer
    Dim y As Integer
    ...
End Sub

VB.NET-ben az alábbi módon tudjuk megírni:

Sub foo()
    Static Dim x As Integer
    Static Dim y As Integer
    ...
End Sub

A RETURN kulcsszó:

A Return kulcsszónál egy alprogram rögtön visszetér az őt hívó alprogramhoz. Föggvények esetében a visszatérési értéket is át lehet vele adni

Egy függvényből való visszatérés VB6-ban:
Sub foo() As Integer
    foo = 42
End Sub

Egy függvényből való visszatérés VB.NET-ben:
Sub foo() As Integer
    return 42
End Sub

Tömbök megadása:

Dim t(2) As Integer
A zárójelben levő szám VB6-ban azt jelentette, hogy a tömb felső indexe 2. (Az alsó alapértelmezett esetben 0.) Így ez egy 3 elemű tömböt jelent. VB.NET-ben pedig azt jelenti, hogy a tömbnek két eleme van. (t(0), t(1))

VB6-ban lehetőség volt megadni egy tömben az alsó indexét is pl.
Dim t(1,3) As Integer
Vagy az Option Base n fordítási direktívával.
Ez a VB.NET-ben nem lehetséges. Itt minden tömb alsó indexe 0. Az Option Base direktíva sincs.

Option Strict:

Ez egy új fordítási direktíva, bekapcsolásával letilthatjuk az összes olyan automatikus típuskonverziót ami adatvesztést eredményezhet.

Az adattípusok változásai:

A Kivételkezelés:

Bár megmaradt a hagyományos hibakezelés is, a VB.NET már támogatja a kivételkezelést is. A kivételkezelés szintakszisa:

Try
    `Normális rész
Catch [ex As Exception]
    `Kivételes rész
Finally
    `Ez a rész normális és kivételes esetben is le fog futni
End Try

Kivételt kiváltani a Throw New Exception("Hibauzenet") utasítással tudunk.

Lehetőségünk van több Catch ágat is használni. Lássuk az alábbi példát:

Try
    x \= y
Catch ex As Exception When Err.Number = 11
    MsgBox("Nullával való osztás")
    Exit Try
Catch ex As Exception
    MsgBox("Más hiba")
Finally
    MsgBox("Finally rész")
End Try

Az első catch ág akkor hajtódik végre, ha a hiba kódja 11. (Ez a nullával való osztás hibakódja) A hibakódot az Err objektum Number adattagja tárolja. A második catch ág pedig minden többi kivételt elkap. (A feldolgozás felülről lefelé történik.) Az Exit Try kulcsszó azt jelenti, hogy ha ilyenre ér a vezérlés, akkor rögtön kilép a blokkból, és nem hajtódik végre a Finallyban megadott kód.

Objektum orientáltság:

Konstruktorok és destruktorok:

A VB.NET-ben konstruktor és destruktor váltja az osztályok Initialize és Terminate eseményeit. A működésük lényegében azonos, egy fontos kivétellel, hogy a konstruktort és a destruktort nem lehet explicit hívni és így biztosan csak egyszer hajtódnak végre. A konstruktor deklarációja Sub New ..., a destruktoré Sub Destruct ...

Névterek:

A névterek segítségével logikailag szétválaszthatjuk a programunkat. Egy névtéren belül alnévteret is definiálhatunk. Vannak beépített névterek pl a System de sajátot is létrehozhatunk, az alábbi módon:

Namespace névtérnév
    ...
End Namespace

Ha sokszor kell használnunk egy névtér objektumait és nem szeretnénk mindig kiírni a minősítést, akkor az Imports névtérnév utasítás kiadása után minősítés nélkül hivatkozhatunk a névtér objeltumaira. pl: Az Imports Sysrem.WinFrorms. kiadása után a Dim x as System.WinForms.Button helyett elés a Dim x as Button utasítást írni.

Túlterhelés:

A VB.NET engedélyezi az alprogramnév túlterhelést, mivel az alprogramot nemcsak a neve, hanem a neve és a paraméterezése azonosítja. Az operátor túlterhelésre azonban nincs lehetőség. Példa a függvénytúlterhelésre:

Overloads Function valami(ByVal s As String) As String
    ...
End Function

Overloads Function valami(ByVal i As Integer) As String
    ...
End Function

Dim str As String
str = valami("hello")
str = valami(42)

Ha túl akarjuk terhelni valamelyik függvényt, akkor explicit ki kell írnunk az Overloads kulcsszót.

Öröklődés:

A VB6-ban csak interfész öröklődésre volt lehetőség, de a VB.NET-ben már osztályokból is származtathatunk gyerekosztályokat. Egy osztályt származtatni az Inherits kulcsszóval tudunk pl:

Public Class Student
    Inherits Person
    ...
End Class

Ha azt szeretnénk, hogy az osztályunkból már ne lehessen tovább származtatni, akkor az alábbi módon kell definiálni:

Public NotInheritable Class Person
    ...
End Class

Ha pedig absztrakt osztályt szeretnénk definiálni, akkor ezt a következő módon tehetjük meg:

Public MustInherit Class Person
    ...
End Class

ilyenkor a Dim p As New Person hibát okoz.

Egy osztály metódusai és tulajdonságai felüldefiniálhatóak is lehetnek. Ekkor a szülő osztályban Overridable kulcsszóval kell definiálnunk őket, a gyerek osztályban pedig az Overrides kulcsszóval mondjuk meg a fordítónak, hogy felüldefiniálásról van szó. Egy osztálynak lehetnek abszrakt metóduasi is, ezeket a MustOverride kulcsszóval vezetjük be.

A VB.NET támogatja a polimorfizmust is. Erre egy példa:

Public MustInherit Class Transportation
    Public MustOverride Function Move() As Boolean
End Class

Public Class Bicycle
    Inherits Transportation
    Overrides Function Move() As Boolean
        `kód
    End Function
End Class

Public Class Tram
    Inherits Transportation
    Overrides Function Move() As Boolean
        `kód
    End Function
End Class

Public Sub PerformMovement(ByVal Vehicle As Transportation)
    Vehicle.Move()
End Sub

Dim MyBike As New Bicycle()
Dim MyTram As New Tram

PerformMovement(MyBike)
PerformMovement(MyTram)

Példaprogramok

Példa eljárásra

Private Sub cmdRemove_Click ()
    Dim Ind As Integer
    Ind = lstClient.ListIndex    ' Get index.
    ' Make sure list item is selected.
    If Ind >= 0 Then
        lstClient.RemoveItem Ind    ' Remove it from list box.
        ' Display number.
        lblDisplay.Caption = lstClient.ListCount
    Else
        Beep    ' If nothing selected, beep.
    End If
End Sub

Példa függvényre és Select Case utasításra

Function RandomString (kind As Integer)
    Dim s As String
    Select Case kind
        Case 0    ' Region.
            Select Case (Rnd * 1000) Mod 5
                Case 0: s = "1. Northwest"
                Case 1: s = "2. Southwest"
                Case 2: s = "3. Midwest"
                Case 3: s = "4. East"
                Case Else: s = "5. Overseas"
            End Select
        Case 1    ' Product.
            Select Case (Rnd * 1000) Mod 5
                Case 0: s = "1. Wahoos"
                Case 1: s = "2. Trinkets"
                Case 2: s = "3. Foobars"
                Case Else: s = "4. Applets"
            End Select
        Case 2    ' Employee.
            Select Case (Rnd * 1000) Mod 4
                Case 0: s = "Mary"
                Case 1: s = "Sarah"
                Case 2: s = "Donna"
                Case Else: s = "Paula"
            End Select
    End Select
    RandomString = s
End Function

Exception kezelés

Function FileExists (filename) As Boolean
    Dim Msg As String
    ' Turn on error trapping so error handler responds
    ' if any error is detected.
    On Error GoTo CheckError    
        FileExists = (Dir(filename) <> "")
        ' Avoid executing error handler if no error
        ' occurs.
        Exit Function
CheckError:            ' Branch here if error occurs.
    ' Define constants to represent intrinsic Visual
    ' Basic error codes.
    Const mnErrDiskNotReady = 71, _
    mnErrDeviceUnavailable = 68
    ' vbExclamation, vbOK, vbCancel, vbCritical, and
    ' vbOKCancel are constants defined in the VBA type
    ' library.
    If (Err.Number = MnErrDiskNotReady) Then
        Msg = "Put a floppy disk in the drive "
        Msg = Msg & "and close the door."
        ' Display message box with an exclamation mark
        ' icon and with OK and Cancel buttons.
        If MsgBox(Msg, vbExclamation & vbOKCancel) = _
        vbOK Then
            Resume
        Else
            Resume Next
        End If
    ElseIf Err.Number = MnErrDeviceUnavailable Then
        Msg = "This drive or path does not exist: "
        Msg = Msg & filename
        MsgBox Msg, vbExclamation
        Resume Next
    Else
        Msg = "Unexpected error #" & Str(Err.Number)
        Msg = Msg & " occurred: " & Err.Description
        ' Display message box with Stop sign icon and
        ' OK button.
        MsgBox Msg, vbCritical
        Stop
    End If
    Resume
End Function

Az oldal a programnyelvek IV. szeminárium óra keretében készült. (Nyékyné Gaizler Judit)
Készítette: Vitéz László, Várnagy Zoltán (2001), Dippold András (2002), Szűgyi Zalán (2004)