A Delphi programozási nyelv

Windows technológiák

Standard dialógusok

Előnyei:

Hátrányai:

A dialógusablakok tervezési időben egy kis négyzettel vannak szemléltetve, amelyek futási időben nem látszódnak. A dialógusablakot az Execute metódussal lehet megnyitni. Ez a metódus true értéket ad vissza, ha a felhasználó az OK gombbal zárta be, és false értéket, ha a Cancel gombbal vagy a jobb felső sarokban levő X-szel lépett ki. A PrinterSetupDialog kivételével mindegyik dialógusnak van Options tulajdonsága, amely több altulajdonságból áll.

OpenDialog, SaveDialog

E két dialógus fájl, fájlok kiválasztására szolgálnak megnyitáshoz illetve mentéshez.

Tulajdonságaik:

Események:

Metódusok:

Példa:

OpenPictureDialog, SavePictureDialog

Hasonló az előzőhöz, de a dialógusablak része a kép előnézetét mutató felület is. Ezt az előnézetet azonban csak akkor láthatjuk, ha a képet felismeri a TPicture osztály, tehát ha a kép .bmp, .ico, .wmf vagy .emf kiterjesztésű.

FontDialog

Ez a dialógusablak biztosan mindenki számára ismerős a szövegszerkesztő programokból.

Tulajdonságai:

Események:

Metódusok:

Példa:

ColorDialog

Tulajdonságai:

PrinterSetupDialog, PrintDialog

A PrinterSetupDialog a nyomtató beállításait megjelenítő dialógusablakot nyit meg. Ennek nincs semmi különösebb eseménye vagy tulajdonsága. Amit ezzel a dialógusablakkal kapcsolatban szükséges megemlítenünk, az csak annyi, hogy az Execute metódussal nyitható meg. A dialógusablak formája szorosan összefügg a felinstallált nyomtató típusával. A PrintDialog komponensnek már van néhány paramétere. Be lehet állítani kezdeti értékeket vagy ki lehet olvasni beállíott értékeket, melyek megadhatják például: a másolatok számát (Copies tulajdonság), a leválogatás módját (Collage tulajdonság). Továbbá korlátozható a kinyomtatandó oldalak száma (MinPage, MaxPage).

FindDialog, ReplaceDialog

A FindDialog és ReplaceDialog kizárólag az adatok bevitelére szolgálnak, magát a keresést, cserét sajnos nekünk kell teljes mértékben implementálnunk. A szöveget, amelyet keresnünk kell, a FindText tulajdonságban adhatjuk meg. A ReplaceDialognak van még egy ReplaceText tulajdonsága is.

Az Options tulajdonság lehetőségei:

Események:

Metódusok:

DDE technológia

A DDE (Dynamic Data Exchange) a Microsoft által kifejlesztett protokol. A DDE ma már egy kicsit elavult technológia, az újabb alkalmazásokban már helyette főleg az OLE automatizálást vagy más COM-on alapuló technológiát használnak. Ennek ellenére elsősorban az egyszerűsége végett érdemes a DDE-vel megismerkednünk.

A DDE szerver az az alkalmazás, amely információt nyújt más alkalmazásoknak. A DDE kliens ezeket az információkat használja, szükség esetén kéri az adatokat a szervertől. Egy DDE szerver több kliens részére is szolgáltathat információkat, és hasonlóan egy DDE kliens-alkalmazás több szervertől is kaphat információkat. A DDE kliens felelős a kapcsolat kialakításáért, majd kérvényt küld a szervernek az adatokért, esetleg valamilyen parancs végrehajtását kéri a szervertől.

Ahhoz, hogy megmutathassuk, hogyan alakíthatunk ki kapcsolatot két alkalmazás között, mindenekelőtt fontos megértenünk az alábbi három fogalmat:

Míg a kliens mindig a konkrét szerverrel kommunikál (ismeri a szervert), a szerver a konkrét klienseket nem ismeri. A szerver csak üzeneteket küld a klienseknek, az adatok a megosztott memórián keresztül vannak továbbítva a kliensek felé.

A Delphiben a DDE-vel való munkához négy komponens létezik. Szerver létrehozásakor ezek közül a két szerver komponenst, kliens létrehozásakor a kliens komponenseket használjuk. Mind a négy komponens a System kategória alatt található:

A kapcsolat létrehozása után amilyen adatot a szerver beír a DdeServerItem1.Text tulajdonságba, az automatikusan benne lesz a kliens DdeClientItem.Text tulajdonságában is. Fontos, hogy a kapcsolat kialakításakor a szolgáltatás, téma és elem nevét pontosan úgy adjuk meg a kliensen, ahogy a szerveren szerepel. Itt fontos a kis- és nagybetű is!

OLE technológia

Az OLE (Object Linking and Embedding = objektum csatolása és beszúrása) egy érdekes technológia, melyet a Microsoft fejlesztett ki. Ennek segítségével megjeleníthetünk, sőt szerkeszthetünk bitmapeket a programunkban anélkül, hogy ezt külön be kéne programoznunk. Valójában ezt a technológiát használjuk ki akkor is, amikor például a MS Wordben írt dokumentumba egy Paintben rajzolt képet vagy egy MS Excelben elkészített táblázatot rakunk be. Ha az ilyen objektumra duplán rákattintunk, akkor az megnyílik szerkeszthető formában a Paint, ill. MS Excel programban. Jelenleg az OLE 2-es verziója használt a gyakorlatban.

Történelem

    OLE 1.0

    OLE 2.0

Az OLE technológia a munkájához OLE szervereket használ. Az OLE szerverek a saját gépünkben futó alkalmazások, melyek más alkalmazások (nevezzük ezeket OLE klienseknek) részére felkínálják a szolgáltatásaikat és működésüket. Az alkalmazás (OLE kliens) kihasználhatja valamelyik, a számítógépen elérhető OLE szervert olyan tevékenységek elvégzésére, melyre saját maga nem képes. Ha van például MS Word szerverünk, amely felkínálja „DOC formátumú dokumentumok megjelenítését”, akkor a mi alkalmazásunkból ezt a szervert meghívhatjuk és így a saját alkalmazásunkban Word dokumentumot jeleníthetünk meg anélkül, hogy a programunkban ezt saját magunk implementáltuk volna. Az OLE tehát egy olyan mechanizmus, amely lehetőséget ad az alkalmazásunkban elhelyezni olyan objektumot, amely egy másik alkalmazásban van definiálva. Ez lehetőséget ad tehát más alkalmazásban definiált objektum megjelenítésére a saját programunkban.

Az OLE-val való munkánk során megkülönböztetünk:

A Delphi és az OLE

Az OLE-vel való munkánk alapkomponense a System palettán található OleContainer. Ez a komponens jelképezi az OLE szervereket a Delphiben létrehozott alkalmazásokban. Az OleContainer lehetőséget ad bármilyen OLE objektum kiválasztására és elhelyezésére vagy csatolására (linkelésére) az alkalmazásunkban. Az objektumok száma, melyek közül választhatunk, a számítógépen telepített programoktól függ.

Az OleContainer komponenssel való munkánk során mindenekelőtt el kell helyezni a formon egy ilyen komponenst, melyben a kiválasztott objektum fog megjelenni. Ez után meghívhatjuk az InsertObjectDialog metódust, amely egy dialógusablakot nyit meg, melyben a felhasználó kiválaszthatja a számítógépen levő összes elérhető OLE objektum közül a megfelelőt.

Ha az objektumot a programból, tehát nem dialógusablak segítségével szeretnénk beszúrni vagy linkelni, akkor a beszúráshoz az OleContainer komponens CreateObject, CreateObjectFromFile vagy CreateObjectFromInfo metódusai közül választhatunk, csatoláshoz pedig a CreateLinkToFile metódust használhatjuk.

Ha csatolunk egy objektumot (pl. MS Word dokumentumot), akkor az megjelenik az OLEContainerben. De ekkor hiányzik a MS Word főmenüje a dokumentum szerkesztésekor. Ezt nagyon egyszerűen javítható. Elég, ha az alkalmazásunkra elhelyezünk egy MainMenu komponenst. Így ebben a komponensben automatikusan megjelenik majd a MS Word menüje az OLE objektum aktiválásakor.

Megfigyelhető, hogy bármilyen dokumentumot (Word,Paint, ...) helyezünk el az OLE konténerben, aktiváláskor mindig az alkalmazásunk ablakában jelenik meg. Sokszor kényelmesebb és praktikusabb is lenne, ha a kiválasztott objektum egy új ablakban jelenne meg. Ez úgy vitelezhető ki, hogy az OleContainer AllowInPlace tulajdonságát false-ra állítjuk. Ezután már a dokumentumunkat máris új ablakban szerkeszthetjük.

Az OLEContainer tulajdonságai

Az AllowInPlace tulajdonság segítségével beállíthatjuk, hogy az objektum szerkesztését az alkalmazásunk OLE konténerén belül (true) vagy külön ablakban (false) szeretnénk elvégezni. Ha a szerkesztést új ablakban végezzük el, akkor külön ablakban megnyílik az objektumhoz tartozó alkalmazás, melyben az objektumon történő változtatások azonnal megjelennek az alkalmazásunk ablakában (OleContainerben) is.

A SizeMode tulajdonság segítségével megadhatjuk, hogyan jelenjen meg az objektumunk az OLE konténerben.
Lehetséges értékek:

Az OleContainer State tulajdonságának kiolvasásával megtudhatjuk, hogy az OLE objektum éppen milyen állapotban van. Lehetséges értékek:

Kulcsszavak lekérdezése és végrehajtása

Ha meg szeretnénk tudni, milyen kulcsszavakat támogat az OLE konténerben levő objektum, használhatjuk az ObjectVerbs tulajdonságot. Ezeket a kulcsszavakat mint szöveget kapjuk meg, így tartalmazhatnak & jelet is, melyek a gyors billentyűelérést jelölik.

Például:

OLE objektum beolvasása és mentése

Például:

Az első nyomógombnál a CreateObjectFromFile segítségével beolvassuk a Word dokumentumot a konténerbe. Ha a teszt.doc állományban valóban Word dokumentum van, akkor ez hiba nélkül végrehajtódik. A paraméterben az ExpandFileName függvényt azért kellett használnunk, mivel ennek a metódusnak az állomány nevét a teljes útvonallal együtt kell átadnunk. A metódus második paramétere azt adja meg, hogy az objektum csak ikon formájában jelenjen meg (true) vagy látható legyen a tartalma (false).

Ha a "teszt.doc" állományban nem Word dokumentum van, hanem OLE objektum, akkor azt csak a LoadFromFile metódus segítségével tudjuk beolvasni. Az OLE konténerben megjelenített objektumot a SaveToFile segítségével menthetjük el úgy, mint Word típusú OLE objektum.

A SaveAsDocument metódussal az objektumot elmenthetjük mint Word dokumentum. Lehet, hogy egy kicsit furcsának tűnik, miért van ilyen nagy különbség a hagyományos állomány (Word dokumentum, bitmap,...) között és az OLE objektumot tartalmazó állomány formátuma között, amikor az első példánkban minden gond nélkül be tudtunk olvasni dokumentumot az OLE konténerbe. Ez azért volt, mivel ott a beolvasást az InsertObjectDialog metódus segítségével hajtottuk végre, amely automatikusan elvégezte a dokumentum átalakítását OLE objektummá.

Menük összekapcsolása

Korábban láthattuk, hogy ha elhelyezünk egy MainMenu komponenst a formon, akkor az objektum szerkesztésekor ebben megjelennek az OLE szerverhez tartozó menüpontok. De mi van akkor, ha az alkalmazásunkban is szeretnénk saját menüt kialakítani?

Hozzunk létre egy új alkalmazást, melyre helyezzünk el egy Panel komponenst, arra egy nyomógombot, amely az objektum beolvasására fog szolgálni. Továbbá tegyünk a formra egy OleContainer és egy MainMenu komponenst. Állítsuk be a komponensek tulajdonságait, majd alakítsunk ki egy menüszerkezetet. Ha most elindítjuk a programunkat és beszúrunk valamilyen objektumot, majd duplán rákattintunk a szerkesztéshez, akkor a mi menünk is megmarad és az objektum OLE szerverének menüje is elérhető lesz. Ez gyakran nem kényelmes, hiszen előfordulhat, hogy ugyanazzal a Captionnel több menüelem is szerepel.

Ezzel a problémával a Delphiben könnyen boldogulhatunk. A menüpontoknak ugyanis van GroupIndex tulajdonságuk. Most ennek a tulajdonságnak egy felhasználásával ismerkedhetünk meg. A GroupIndex segítségével azt is befolyásolhatjuk, hogy a menük összekapcsolásakor melyik menüpontunk legyen látható és melyik nem:

Hasonlóan a menükhöz, az eszköztárak is összekapcsolhatók. Alapértelmezett beállításoknál az OLE szerver eszköztára felülírja az alkalmazásunk eszköztárát. Ha ezt el szeretnénk kerülni, állítsuk be az alkalmazásunk eszköztárának Locked tulajdonságát True értékre.

OLE Automation

Az OLE Automation olyan technológia, amely lehetőséget ad egy alkalmazás képességeit kihasználni egy másik alkalmazásból. Az OLE Automation a Microsoft által bevezetett Component Object Modelt (COM) használja ki. Az OLE Automatizálást felhasználva lehetőségünk van objektumokat használó alkalmazásokat létrehozni és az alkalmazás objektumait egy másik alkalmazás segítségével irányítani.

MS Word irányítása Delphiből

A programunk öt nyomógombot fog tartalmazni. Az első nyomógomb elindítja a Microsoft Word alkalmazást, a második létrehoz egy új dokumentumot, a harmadik ebbe az üres dokumentumba beír két sort, a negyedik elmenti ezt a dokumentumot "level.doc" néven (mivel útvonalat nem adunk meg, ezért az alapértelmezett mappába – a Dokumentumok-ba menti), az ötödik nyomógomb pedig bezárja a Microsoft Word alkalmazást.

Fontos:

Mielőtt áttekintenénk az alkalmazásunk nyomógombjaihoz tartozó programkódot, ismerkedjünk meg a variant típus használatával, mellyel eddig még nem találkoztunk. A variant (variáns) típus felrúgja az Object Pascal nyelv típusosságát, ugyanis egy variant típusú változóban tetszőleges típusú adatot tárolhatunk, a rekord, halmaz, statikus tömb, állomány, osztály, osztályhivatkozás, mutató és int64 típusok kivételével. A variáns típus bevezetésének elsődleges célja a Microsoft által kifejlesztett objektummodellhez (COM) való csatlakozás volt. A variáns változók használata kényelmes, hiszen bizonyos típusok közti átalakítások automatikusan végbemennek, azonban a szokásosnál több memóriát igényelnek, továbbá a variáns típusok alkalmazása lassítja a program működését. Ezért próbáljuk ezek használatát kizárólag a COM objektummodellek programozására szűkíteni! A variáns típusú változó akkor is tartalmaz információt, ha nincs értéke (unassigned), illetve ha értéke semmilyen típussal nem azonosítható (null). A fenti állapotok tesztelésére a VarIsEmpty(), illetve a VarIsNull() logikai függvényeket használhatjuk. A VarType() függvény segítségével azonosíthatjuk a variáns változóban tárolt adat típusát.

procedure TForm1.StartClick(Sender: TObject); begin   if VarIsEmpty(w) then   begin     w := CreateOleObject('Word.Application');     w.Visible := true;     w.Caption := 'Delphi-ből megnyitott Word';   end; end; procedure TForm1.CreateClick(Sender: TObject); begin   if not VarIsEmpty(w) then w.Documents.Add; end; procedure TForm1.InsertDataClick(Sender: TObject); begin   if (not VarIsEmpty(w)) and (w.Documents.Count>0) then   begin     w.Selection.TypeText('Ez egy egyszerű dokumentum, ');     w.Selection.TypeParagraph;     w.Selection.Font.Size := 14;     w.Selection.TypeText('melyet ');     w.Selection.Font.Bold := true;     w.Selection.TypeText('Delphi');     w.Selection.Font.Bold := false;     w.Selection.TypeText('-ből hoztunk létre.');     w.Selection.TypeParagraph;   end; end; procedure TForm1.SaveClick(Sender: TObject); begin   if (not VarIsEmpty(w)) and (w.Documents.Count>0) then   begin     w.ActiveDocument.SaveAs('level.doc');   end; end; procedure TForm1.CloseClick(Sender: TObject); begin   if not VarIsEmpty(w) then   begin     w.Quit(false); { false = kilepeskor a 'Menti a valtozasokat?' kerdesre a valasz nem }     w := Unassigned;   end; end;

A form létrehozásakor beállítottuk a FormStyle tulajdonságát fsStayOnTop értékre, mellyel elértük, hogy a Word megnyitása után is a mi alkalmazásunk lesz felül (látható marad). A Word objektumainak tulajdonságairól és metódusairól, melyeket a fenti példában használtunk, bővebb információt az MS Word súgójának Visual Basic részében olvashatunk. Ha szeretnénk valamilyen műveletet végrehajtani Delphiből Wordben az OLE Automatizálás segítségével, de nem tudjuk pontosan, hogy a Word melyik objektumait, metódusait használhatjuk ehhez, akkor nagy segítség lehet a Word makrója is. Elég, ha a makró segítségével eljátsszuk az adott műveletet, majd megnézzük a makró Visual Basicben írt forráskódját – így megtudhatjuk, milyen objektum melyik tulajdonságát kell megváltoztatnunk, melyet utána egy kis szintaxisátírással a Delphiből is megtehetünk.

DLL-ek

A Windowsban kétféle futtatható állomány létezik: programok (EXE fájlok) és dinamikus csatolású könyvtárak (Dynamic Link Libraries = DLL fájlok). Bár a DLL fájlok közvetlenül nem futtathatók, mégis tartalmaznak programkódot (függvényeket, eljárásokat), továbbá tartalmazhatnak erőforrásokat (képeket, hangokat, szövegtáblákat), akárcsak a programok. Amikor egy Delphi alkalmazást írunk, akkor egy programfájlt készítünk. Ez a programfájl felhasználhatja a DLL-ekben található függvényeket, eljárásokat, erőforrásokat.

De miért is jó, ha nem mindent egy programfájlba rakunk, hanem DLL-be is, és mikor érdemes DLL-eket használni?
Ehhez nézzük meg a DLL-ek felhasználhatóságát és azok főbb előnyeit:

DLL készítése

Ha dinamikus csatolású könyvtárat szeretnénk létrehozni, válasszuk ki a Delphi fejlesztőkörnyezetében a File – New – Other menüpontot. A megnyíló ablakban válasszuk a Delphi Projects kategória alatt a DLL Wizardot, majd klikkeljünk az OK gombra. Ekkor megjelenik egy üres dinamikus csatolású könyvtár forráskódja. Ebbe írhatjuk bele azokat a függvényeket és eljárásokat, melyeket szeretnénk, ha a DLL-ünk tartalmazna.

Készítsünk most egy olyan dinamikus csatolású könyvtárat, amely tartalmaz egy függvényt két szám legnagyobb közös osztójának meghatározására (lko), egyet pedig a legkisebb közös többszörös meghatározására (lkt). Továbbá tartalmazzon még egy paraméter nélküli függvényt, amelynek meghívásával megkapjuk a Fibonacci számsor (1, 1, 2, 3, 5, 8, 13, 21, ..) következő elemét (fibo), és egy paraméter nélküli eljárást, amelynek segítségével a Fibonacci számok generálását az elejére állítjuk (fiboinit). Az egyes eljárások és függvények megírása után fontos, hogy azokat a függvényeket és eljárásokat, melyeket kívülről (a programokból, melyek a DLL-t használni fogják) is meg kívánunk hívni, felsoroljuk az exports záradék után. Itt adhatunk a függvényeknek és eljárásoknak más nevet is (ahogy ezt tesszük a fibo-nál és fiboinit-nél), vagy hagyhatjuk azt a nevet, melyen a DLL-ben a függvényt megírtuk. Ha új nevet adunk, akkor az alkalmazásokból, melyekben a DLL-függvényt vagy eljárást használni akarjuk, az új néven érhetjük majd el. Ha más fejlesztői rendszerből is el szeretnénk érni a DLL exportált eljárásait és függvényeit, akkor a Delphiben alapértelmezett register paraméterátadási mód helyett a stdcall szabványos Win32 paraméterátadási módot kell használnunk.

Nézzük most meg, hogyan is néz ki a könyvtár forráskódja:

library dll_pelda; uses SysUtils, Classes, Math; {$R *.res} {ket szam legnagyobb kozos osztoja} function lko(a,b: integer): integer; stdcall; var   i: integer; begin   i := min(a,b);   while (a mod i > 0) or (b mod i > 0) do dec(i);   result := i; end; {ket szam legkisebb kozos tobbszorose} function lkt(a,b: integer): integer; stdcall; var   i: integer; begin   i := max(a,b);   while (i mod a > 0) or (i mod b > 0) do inc(i);   result := i; end;
{Fibonacci szamok} var   a1, a2, ssz: int64;
{a Fibonacci szamsor kovetkezo eleme} function fibo: int64; stdcall; begin   if ssz<=2 then result := 1   else begin   result := a1 + a2;   a1 := a2;   a2 := result; end;   inc(ssz); end; {a Fibonacci szamgenerator inicializalasa} procedure fiboinit; stdcall; begin   a1 := 1;   a2 := 1;   ssz := 1; end; {exportalando alprogramok listaja} exports   lko, lkt,   fibo name 'Fibonacci',   fiboinit name 'StartFibonacci';
{a DLL inicializalasa} begin   fiboinit;   beep(); end.

A forráskód végén a begin és end között történik a DLL inicializálása. Az ide leírt program csak egyszer fut le, mielőtt bármelyik függvényt használnánk. A mi programunkban itt inicializáljuk a Fibonacci számgenerátort, majd a beep függvénnyel megszólaltatjuk a hangszórót – így majd halljuk mikor fut le az alkalmazásunkban ez az inicializációs rész. A megírt forráskódot a Project – Compile (Ctrl+F9) menüpont segítségével tudjuk lefordítani és így létrehozni a DLL kiterjesztésű fájlt. Ha már megírtuk volna azt az alkalmazást, amely a dinamikus csatolású könyvtárat használja, akkor azt futtatva tesztelhetjük a DLL futását is a közvetlenül a Delphiből. Ehhez elég a DLL mappájába (ahova elmentettük) átmásolnunk a lefordított EXE fájlt és a Run – Parameters menüpontot kiválasztva a Host application alatt megadni ezt az alkalmazást. Ezután a DLL-t tesztelhetjük a beállított alkalmazásunk segítségével (pl. Run – Run menüponttal).

A DLL felhasználása alkalmazásunkban

Ahhoz, hogy a kész dinamikus csatolású könyvtár függvényeit és eljárásait fel tudjuk használni alkalmazásainkban, a lefordított DLL állományt MS Windows XP rendszer esetében az alábbi alkönyvtárak valamelyikében kell elhelyeznünk:

A legegyszerűbb a lefordított DLL állományt oda átmásolni, ahova az alkalmazásunkat menteni fogjuk, azaz ahol létrejön majd az alkalmazásunk EXE fájlja. Ha a kész alkalmazásunkat majd hordozni szeretnénk, akkor az EXE állománnyal együtt a DLL állományt is vinnünk kell, mivel a nélkül a programunk nem fog működni.

De nézzük meg, hogyan is tudjuk az alkalmazásunkban felhasználni a megírt dinamikus csatolású könyvtárat. Példaként a korábban bemutatott dll_pelda.dll fájlt használjuk. Ahhoz, hogy a DLL-ben definiált alprogramokat elérhetővé tegyük, importálnunk kell őket. Minden DLL-ben található rutin külső definíció a programunk számára (external). A Delphiben az importálás lehet:

Ezek után az lko és LegkKozTobb függvényeket bárhol felhasználhatjuk a programunkban. A fenti két példa esetében fontos, hogy az lko és lkt nevek szerepeljenek a dll_pelda modul exports részében!

Statikus és dinamikus importálás

A DLL eljárásaink és függvényeink importálását statikus és dinamikus módon is elvégezhetjük. Az eddigiek során a statikus importálást használtuk. A statikus importálás esetén a rendszer a dinamikus csatolású könyvtárat akkor tölti be a memóriába, amikor az azt használó program első példánya elindul. Minden további a könyvtárra hivatkozó alkalmazás a már betöltött könyvtár alprogramjait használja. A dinamikus importálás esetén az alkalmazás futása során saját magunk töltjük be a memóriába a dinamikus csatolású könyvtárat. Ha a könyvtárra már nincs szükségünk, akkor egyszerűen felszabadítjuk azt. A betöltés és felszabadítás műveletéhez a Windows API-függvényeket használjuk, melyek a Windows unitban találhatók. A dinamikus importálás első lépése a könyvtár betöltése a memóriába. Ezt a LoadLibrary() függvény segítségével tehetjük meg, pl. function LoadLibrary(KonyvtarNeve: PAnsiChar): HModule; A függvény paramétereként csak a könyvtár nevét kell megadni elérési útvonal nélkül. Ha a függvény 0 (nulla) értékkel tér vissza, akkor sikertelen volt a betöltés, egyébként a betöltött modul azonosítóját kapjuk vissza. Ha a DLL-t sikerült betöltenünk a memóriába, akkor hivatkozhatunk a DLL-ben tárolt függvényekre és eljárásokra. A hivatkozáshoz azonban meg kell tudnunk a DLL-függvény vagy eljárás belépési pontjának címét. A cím lekérdezéséhez a GetProcAddress() függvényt használhatjuk, pl. function GetProcAddress(hLibModule: HModule; AlprogNeve: LPCStr): FARProc; A függvény paramétereként meg kell adnunk az előző függvény visszatérési értékeként kapott DLL modul azonosítóját és az alprogram (DLL-függvény vagy eljárás) nevét. A függvény visszatérési értékeként megkapjuk a paraméterben megadott alprogram címét. Ha nincs ilyen alprogram a DLL-ben, akkor visszatérési értékként nil-t kapunk. Ha már nincs szükségünk az alkalmazásban a betöltött dinamikus csatolású könyvtárra, akkor azt a FreeLibrary() függvény meghívásával szabadíthatjuk fel a memóriából, pl. function FreeLibrary(hLibModule: HModule): Bool; Paraméterként a LoadLibrary() függvény meghívásakor kapott azonosítót kell megadnunk.

A DLL és a memória

A dinamikus csatolású könyvtárak alaphelyzetben nem támogatják a hosszú sztringek paraméterként, illetve függvényértékként való átadását. Amennyiben erre szükség van, mind a DLL, mind pedig az alkalmazás uses részében az első helyen meg kell adnunk a ShareMem unitot, a lefordított programhoz pedig csatolnunk kell a memóriakezelést végző borlndmm.dll könyvtárat. Egyszerűbb megoldáshoz jutunk, ha az AnsiString (String) típus helyett a PChar (nullvégű string) vagy ShortString (max. 255 hosszú string) típust használjuk. A nullvégű sztring használata különbözik a megszokott „string” típustól. A ShortString típus használata hasonló, a különbség csupán az, hogy ebben a típusban maximum 255 karakter hosszú stringet tárolhatunk.