DLL- Dynamic Link Library ovvero una libreria a collegamento dinamico che permette di riutilizzare le stesse funzioni in programmi diversi. In realtà è uno strumento piuttosto utile, soprattutto perché una volta scritta una libreria può essere utilizzata in molti programmi. Nella lezione di oggi impareremo come lavorare con dll E ovviamente crearli!
Bene, cominciamo!
Iniziamo creando la nostra prima libreria di collegamenti dinamici! Andiamo a Delfi e salire subito nel menu File -> Nuovo -> Altro.
Davanti a noi appare la seguente finestra:
Selezionare Dynamic-Link Library dall'elenco (nelle versioni precedenti alla 2009 Delfi l'elemento si chiama Creazione guidata DLL).
Di conseguenza, abbiamo solo una finestra con il codice, nota che qui non abbiamo alcun modulo!
Ora inizia il divertimento. Scriviamo le nostre prime procedure nella libreria.
Progetto biblioteca2;
//Probabilmente l'hai già notato invece di program
//quando si crea una DLL, viene utilizzata la libreria di parole.
// Libreria dei significanti.
usi
Sysutil, finestre di dialogo,
classi; // Attenzione! Non dimenticare di includere questi moduli,
// altrimenti il codice non funzionerà
($R*.res)
(QUESTA PARTE INSERIRÀ IL CODICE DLL)
Prima chiamata di procedura; chiamata standard; esportare;
//Stdcall - Questa istruzione inserisce i parametri nello stack
//da destra a sinistra e allineato al valore standard
//Export, in linea di principio, può essere omesso, utilizzato per chiarimenti
//procedura o funzione di esportazione.
Inizio
MostraMessaggio(" La mia prima procedura in dll");
FINE;
DoubleProcedureCall; chiamata standard; esportare;
Inizio
MostraMessaggio(" La mia seconda procedura");
// Richiama il messaggio sullo schermo
FINE;
Esporta FirstCall, DoubleCall;
//Exports contiene un elenco di elementi esportati.
//Che verrà successivamente importato da qualche programma.
inizio
FINE.
Qui è dove ci fermeremo per ora. per un semplice esempio, questo sarà sufficiente. Adesso salviamo il nostro progetto, io personalmente l'ho salvato con il nome Project2.dll e premiamo la combinazione di tasti CTRL+F9 per compilare la libreria. Nella cartella in cui hai salvato il file dpr deve comparire un file con estensione dll, questa è la nostra libreria appena creata. L'ho chiamato Project2.dll
Affrontiamo ora le procedure di chiamata da questa libreria. Creiamo una nuova applicazione secondo lo schema standard. Davanti a noi non c'è niente di insolito, solo una forma. Salviamo la nuova applicazione in una cartella. E nella stessa cartella copiamo quello appena creato libreria dll. Quelli. in questo esempio Project2.dll
Ora devi scegliere come chiamare le funzioni dalla libreria. Esistono due metodi di chiamata in totale.
Metodo numero 1
Forse questo è il metodo più semplice per richiamare le procedure nella libreria.
Ideale per lavorare con una sola libreria.
Eccoci qui...
Dopo la parola chiave di implementazione, scrivi il seguente codice:
Prima chiamata di procedura; chiamata standard; esterno "Progetto2.dll" ;
// Project2.dll può invece avere qualsiasi nome di libreria
DoubleProcedureCall; chiamata standard; esterno "Progetto2.dll" ;
Qui, come avrai intuito, diciamo al programma i nomi delle nostre procedure e diciamo che sono presenti libreria dll, nel mio caso denominato Project2.dll
Adesso, per richiamare queste procedure, dobbiamo solo inserire i loro nomi in un punto qualsiasi del codice, cosa che faremo ora. Inseriamo 2 componenti Button nel modulo dalla scheda Standard e creiamo un gestore eventi OnClick su ciascuno
OnClick del primo pulsante:
Inizio
prima chiamata;
FINE;
OnClick del secondo pulsante:
Inizio
doppia chiamata; // Il nome della procedura contenuta nella dll
FINE;
È tutto!
Metodo numero 2:
Più complicato del primo, ma ha i suoi vantaggi e, soprattutto, è ideale per i plugin.
Per utilizzare questo metodo, dichiariamo prima alcune variabili globali:
Var
LibHandle: HModule; //Collegamento al modulo della libreria
FirstCall: procedura; chiamata standard;
//Nomi delle nostre procedure nella libreria.
DoubleCall: procedura; chiamata standard;
Quindi, dopo la parola chiave di implementazione, scriviamo una procedura che caricherà la nostra libreria:
Carica ProceduraMyLibrary(NomeFile: String);
Inizio
LibHandle:= CaricaLibreria(PWideChar(NomeFile));
//Carica la libreria!
// Attenzione! PChar per le versioni precedenti a Delphi 2009
Se LibHandle = 0 allora inizia
FinestraMessaggio(0,"",0,0);
Uscita;
FINE;
PrimaCall:= GetProcAddress(LibHandle,"FirstCall ");
//Ottiene un puntatore a un oggetto
//1° collegamento del parametro al modulo della libreria
//nome dell'oggetto del 2° parametro nella dll
DoubleCall:= GetProcAddress(LibHandle,"DoubleCall ");
Se @FirstCall = nil allora inizia
FinestraMessaggio(0," Impossibile caricare la libreria",0,0);
Uscita;
FINE;
Se @DoubleCall = nil inizia
//Verifica la presenza di questa funzione nella libreria.
FinestraMessaggio(0," Impossibile caricare la libreria",0,0);
Uscita;
FINE; FINE;
Successivamente, sulla form, creiamo un gestore di eventi OnCreate, nel quale, tramite la procedura appena creata, caricheremo il nostro biblioteca
Procedura TForm1.FormCreate(Sender: TObject);
Inizio
LoadMyLibrary("Progetto2.dll");
FINE;
Anche adesso, per richiamare le procedure necessarie dalla nostra libreria, dobbiamo solo inserire i loro nomi in un punto qualsiasi del codice. Per fare ciò, inseriamo 2 componenti Button nel modulo dalla scheda Standard e creiamo un gestore eventi OnClick su ciascuno
OnClick del primo pulsante:
Procedura TForm1.Button1Click(Sender: TObject);
Inizio
prima chiamata; // Il nome della procedura contenuta nella dll
FINE;
OnClick del secondo pulsante:
Procedura TForm1.Button2Click(Sender: TObject);
Inizio
doppia chiamata; // Il nome della procedura contenuta nella dll
FINE;
Infine, creiamo un gestore di eventi OnDestroy nel modulo in cui scarichiamo libreria dll dalla memoria
Procedura TForm1.FormDestroy(Sender: TObject);
Inizio
Libreria libera(LibHandle);
//Scarica la libreria dalla memoria.
FINE;
È tutto! Il secondo metodo si è rivelato piuttosto macchinoso, ma il suo vantaggio sta nel perfezionare l'oggetto memorizzato nella libreria.
PS Vuoi ricevere prima di tutti gli altri visitatori del sito gli ultimi tutorial video, podcast audio e articoli su Delphi.
Partecipare alle competizioni ed entrare gradualmente a far parte della nostra squadra?!
Allora iscriviti subito alla newsletter multimediale gratuita del sito
Siamo già più di 3500 persone!
A causa del rapido sviluppo delle tecnologie di programmazione, sempre più persone si trovano ad affrontare il problema di aumentare le capacità dei propri programmi. Questo articolo è dedicato a questo problema, ovvero alla programmazione DLL in Borland Delphi. Inoltre, poiché toccheremo le questioni relative all'utilizzo delle DLL, toccheremo anche l'importazione di funzioni da DLL di altre persone (comprese quelle di sistema, ad esempio WinAPI).
Allora, perché sono necessarie le DLL e dove vengono utilizzate?... Ecco solo alcune delle loro aree di applicazione:
Quindi, quali trucchi e funzioni devi utilizzare per lavorare con una DLL? Analizziamo due metodi per importare funzioni dalla libreria:
1 modo.
Associazione di una DLL a un programma. Questo è il metodo più semplice e facile per utilizzare le funzioni importate da una DLL. Tuttavia (e dovresti prestare attenzione a questo) questo metodo presenta uno svantaggio molto significativo: se la libreria utilizzata dal programma non viene trovata, il programma semplicemente non si avvierà, dando un errore e segnalando che la risorsa DLL non è stata trovata. E la libreria verrà cercata: nella directory corrente, nella directory del programma, nella directory WINDOWS\SYSTEM, ecc.
Quindi, per cominciare, la forma generale di questa tecnica:
implementazione
...
funzione NomeFunzione(Par1: Tipo Par1; Par2: Tipo Par2; ...): TipoRitorno; stdcall;
esterno"NOMEDLL.DLL" nome"Nome funzione" indice FuncIndice;
// oppure (se non è una funzione, ma una procedura):
procedura NomeProcedura(Par1: Tipo Par1; Par2: Tipo Par2; ...); stdcall; esterno"NOMEDLL.DLL" nome"nome procedura" indice ProcIndice;
Qui: NomeFunzione(O Nomeprocedura) - il nome della funzione (o procedura) che verrà utilizzata nel programma;
Par1, Par2, ...- nomi di parametri di funzione o procedura;
Tipo Par1, Tipo Par2, ...- tipi di parametri di una funzione o procedura (ad esempio, Numero intero);
tipo di restituzione- tipo di valore restituito (solo per una funzione);
stdcall- una direttiva che deve corrispondere esattamente a quella utilizzata nella DLL stessa;
"DLLNAME.DLL" esterno- una direttiva che specifica il nome della DLL esterna da cui verrà importata la funzione o procedura data (in questo caso - NOMEDLL.DLL);
nome "NomeFunzione" ("NomeProcedura")- una direttiva che specifica il nome esatto di una funzione nella DLL stessa. Si tratta di una direttiva opzionale che permette di utilizzare nel programma una funzione che abbia un nome diverso da quello vero (che ha nella libreria);
indice IndiceFunzione(IndiceProcedura)- una direttiva che specifica il numero ordinale di una funzione o procedura in una DLL. Anche questa è una direttiva facoltativa.
2 vie. Caricamento dinamico della DLL. Questo è un metodo molto più complesso ma anche più elegante. È privo dello svantaggio del primo metodo. L'unica cosa spiacevole è la quantità di codice necessaria per implementare questa tecnica, e la difficoltà è che la funzione importata dalla DLL è disponibile solo quando questa DLL è caricata ed è in memoria... Potete leggere l'esempio qui sotto, ma per ora - una breve descrizione delle funzioni WinAPI utilizzate da questo metodo:
Carica libreria(nomefilelib: PCar) - caricamento della libreria specificata LibFileName in memoria. In caso di successo, la funzione restituisce un handle ( Maniglia)DLL in memoria.
OttieniIndirizzoProc(Modulo: Maniglia; NomeProc: PCar) - legge l'indirizzo della funzione di libreria esportata. In caso di successo, la funzione restituisce un handle ( TFarProc) funzioni nella DLL caricata.
biblioteca gratuita(LibModulo: Maniglia) - invalida il LibModule e libera la memoria ad esso associata. È da notare che dopo aver richiamato questa procedura, le funzioni di questa libreria non sono più disponibili.
Bene, ora è il momento di fornire un paio di esempi dell'uso dei metodi e delle tecniche di cui sopra:
Ora la stessa cosa, ma nel secondo modo - con caricamento dinamico:
|
|
| (... Ecco l'intestazione del file e la definizione del form TForm1 e la sua istanza Form1)
var procedura Button1Click(Mittente: TObject); |
NOTA : Dovresti astenervi dall'utilizzare il tipo stringa nelle funzioni di libreria, perché ci sono problemi con la "condivisione della memoria" durante l'utilizzo. Puoi leggere di più a riguardo (anche se in inglese) nel testo del progetto DLL vuoto creato da Delphi (File -> Nuovo -> DLL). Quindi è meglio usare PChar e poi convertirlo in una stringa con StrPas, se necessario.
Bene, ora analizziamo direttamente la DLL stessa:
In una DLL puoi inserire non solo funzioni, ma anche cursori, immagini, icone, menu, righe di testo. Non ci fermeremo a questo. Noterò solo che per caricare la risorsa è necessario caricare la DLL e quindi, ricevuto il suo descrittore, caricare la risorsa stessa con l'apposita funzione (LoadIcon, LoadCursor, ecc.). In questa sezione, accenneremo solo brevemente al posizionamento delle finestre delle applicazioni (ad esempio i moduli in Delphi) nelle DLL.
Per fare ciò, è necessario creare una nuova DLL e aggiungervi un nuovo modulo (File -> Nuovo -> DLL, quindi File -> Nuovo modulo). Inoltre, se il modulo è una finestra di dialogo (modulo modale (bsDialog)), aggiungi la seguente funzione alla DLL (ad esempio, il modulo si chiama Form1 e la sua classe è TForm1):
Se è necessario inserire un modulo non modale nella DLL, è necessario creare due funzioni: aprire e chiudere il modulo. In questo caso, devi forzare la DLL a ricordare l'handle di questo modulo.
Qui non considereremo i plugin in dettaglio, perché. gli esempi già forniti sopra ti aiuteranno a comprendere facilmente la parte del leone nella programmazione DLL. Permettetemi solo di ricordarvi che il plug-in è un'aggiunta al programma che ne espande le capacità. Allo stesso tempo, il programma stesso deve necessariamente prevedere la presenza di tali integrazioni e consentire loro di raggiungere il loro scopo.
Cioè, ad esempio, per creare un plug-in per un editor grafico che esegua la conversione delle immagini, è necessario fornire almeno due funzioni nel plug-in (e, di conseguenza, chiamare queste funzioni nel programma): una funzione che restituirebbe il nome del plug-in (e/o il suo tipo) per aggiungere questo plug-in al menu (o alla barra degli strumenti), inoltre la funzione principale è inviare e ricevere un'immagine. Quelli. prima il programma cerca i plugin, poi per ciascuno trovato chiama la sua funzione identificativa con un nome rigorosamente definito (ad esempio GetPluginName) e aggiunge la voce desiderata al menu, quindi, se l'utente ha selezionato questa voce, chiama la seconda funzione, che passa l'immagine di input (o il nome del file, contenente questa immagine), e questa funzione, a sua volta, elabora l'immagine e la restituisce in una nuova forma (o un nome di file con una nuova immagine). Questo è il punto centrale del plugin... :-)
Questo articolo mostra gli aspetti principali dell'utilizzo e della creazione di DLL in Borland Delphi. Se avete domande, inviatemele via e-mail: [e-mail protetta], e ancora meglio: scrivi nella conferenza di questo sito in modo che altri utenti possano vedere la tua domanda e provare a rispondere!
Karikh Nikolai. Regione di Mosca, Zhukovsky
Lavorare con le DLL
DLL - Dynamic Link Library ovvero libreria a collegamento dinamico che permette di riutilizzare le stesse funzioni in programmi diversi. In realtà è uno strumento piuttosto utile, soprattutto perché una volta scritta una libreria può essere utilizzata in molti programmi. Nella lezione di oggi impareremo come lavorare con le DLL e, ovviamente, come crearle!
Bene, cominciamo!
Iniziamo creando la nostra prima libreria di collegamenti dinamici! Andiamo su Delphi e saliamo subito nel menu File -> Nuovo -> Altro.
Seleziona Dynamic-Link Library dall'elenco (nelle versioni precedenti a Delphi 2009, l'elemento è chiamato DLL Wizard).
Di conseguenza, abbiamo solo una finestra con il codice, nota che qui non abbiamo alcun modulo!
Ora inizia il divertimento. Scriviamo le nostre prime procedure nella libreria.
| Progetto biblioteca2; //Probabilmente hai già notato che invece di programma //durante la creazione di una DLL, viene utilizzata la parola libreria. // Libreria dei significanti. utilizza SysUtils, Dialoghi, Classi; // Attenzione! Non dimenticare di specificare questi moduli, altrimenti il codice non funzionerà ($R *.res) (QUESTA PARTE E' INSERITA IL CODICE DLL) Procedura FirstCall; chiamata standard; esportare; //Stdcall - Questa istruzione inserisce i parametri nello stack //da destra a sinistra e si allinea al valore standard //Export può in linea di principio essere omesso, utilizzato per perfezionare //export di una procedura o funzione. Begin ShowMessage("La mia prima procedura dll"); //Chiamiamo il messaggio sullo schermo End; DoubleProcedureCall; chiamata standard; esportare; Inizia ShowMessage("La mia seconda procedura"); //Chiamiamo il messaggio sullo schermo End; Esporta FirstCall, DoubleCall; //Exports contiene un elenco di elementi esportati. //Che verrà successivamente importato da qualche programma. inizio Fine. |
Qui è dove ci fermeremo per ora. per un semplice esempio, questo sarà sufficiente. Adesso salviamo il nostro progetto, io personalmente l'ho salvato con il nome Project2.dll e premiamo la combinazione di tasti CTRL+F9 per compilare la libreria. Nella cartella in cui hai salvato il file dpr deve comparire un file con estensione dll, questa è la nostra libreria appena creata. L'ho chiamato Project2.dll
Affrontiamo ora le procedure di chiamata da questa libreria. Creiamo una nuova applicazione secondo lo schema standard. Davanti a noi non c'è niente di insolito, solo una forma. Salviamo la nuova applicazione in una cartella. E nella stessa cartella copiamo la libreria dll appena creata. Quelli. in questo esempio Project2.dll
Ora devi scegliere come chiamare le funzioni dalla libreria. Esistono due metodi di chiamata in totale.
Metodo numero 1
Forse questo è il metodo più semplice per richiamare le procedure nella libreria.
Ideale per lavorare con una sola libreria.
Eccoci qui...
Dopo la parola chiave di implementazione, scrivi il seguente codice:
Qui, come probabilmente avrai intuito, diciamo al programma i nomi delle nostre procedure e diciamo che si trovano in una libreria dll, nel mio caso con il nome Project2.dll
Adesso, per richiamare queste procedure, dobbiamo solo inserire i loro nomi in un punto qualsiasi del codice, cosa che faremo ora. Inseriamo 2 componenti Button nel modulo dalla scheda Standard e creiamo un gestore eventi OnClick su ciascuno
OnClick del primo pulsante:
OnClick del secondo pulsante:
È tutto!
Metodo numero 2:
Più complicato del primo, ma ha i suoi vantaggi e, soprattutto, è ideale per i plugin.
Per utilizzare questo metodo, dichiariamo prima alcune variabili globali:
Quindi, dopo la parola chiave di implementazione, scriviamo una procedura che caricherà la nostra libreria:
| Carica ProceduraMyLibrary(NomeFile: String); Inizio LibHandle:= CaricaLibreria(PWideChar(NomeFile));//Carica la libreria! // Attenzione! PChar per le versioni precedenti alla 2009 Delphi Se LibHandle = 0 inizia MessageBox(0," Impossibile caricare la libreria",0,0); Uscita; FINE; PrimaCall:= GetProcAddress(LibHandle,"FirstCall");//Ottiene un puntatore all'oggetto //il 1° parametro è un collegamento al modulo della libreria //il 2° parametro è il nome dell'oggetto nella dll DoubleCall:= GetProcAddress(LibHandle,"DoubleCall"); Se @FirstCall = nil allora inizia//Verifica la presenza di questa funzione nella libreria. MessageBox(0,"Impossibile caricare la libreria",0,0); Uscita; FINE; Se @DoubleCall = nil inizia//Verifica la presenza di questa funzione nella libreria. MessageBox(0,"Impossibile caricare la libreria",0,0); Uscita; FINE; FINE |
Successivamente, sul form, creiamo un gestore di eventi OnCreate, nel quale, utilizzando la procedura appena creata, caricheremo la nostra libreria
| Procedura TForm1.FormCreate(Sender: TObject); Inizio LoadMyLibrary("Progetto2.dll"); FINE; |
Anche adesso, per richiamare le procedure necessarie dalla nostra libreria, dobbiamo solo inserire i loro nomi in un punto qualsiasi del codice. Per fare ciò, inseriamo 2 componenti Button nel modulo dalla scheda Standard e creiamo un gestore eventi OnClick su ciascuno
OnClick del primo pulsante:
| Procedura TForm1.Button1Click(Sender: TObject); BeginFirstCall; // Il nome della procedura che si trova in dll End; |
OnClick del secondo pulsante:
| Procedura TForm1.Button2Click(Sender: TObject); Inizia DoubleCall; // Il nome della procedura che si trova in dll End; |
Infine, creiamo un gestore di eventi OnDestroy sul form, in cui scarichiamo la libreria dll dalla memoria
È tutto! Il secondo metodo si è rivelato piuttosto macchinoso, ma il suo vantaggio sta nel perfezionare l'oggetto memorizzato nella libreria.
Per creare una nuova DLL in Delphi, seleziona il comando di menu File > Nuovo > Altro. Nel pannello Categorie di articoli finestra Nuovi oggetti seleziona nodo Progetti Delfi, quindi fare doppio clic sull'elemento Libreria di collegamento dinamico nel riquadro destro della finestra.
Maestro Procedura guidata DLL crea un file di codice sorgente DLL principale che sembra quasi identico al codice sorgente generato per una normale applicazione. L'unica differenza è. che questo file inizia con una parola riservata biblioteca, ma no programma.
progetto biblioteca1; (Nota importante sulla gestione della memoria DLL: ShareMem deve essere la prima unità nella clausola USES della libreria E nella clausola USES del progetto (seleziona Project-View Source) se la DLL esporta procedure o funzioni che passano stringhe come parametri o funzioni risultati. Ciò si applica a tutte le stringhe passate da e verso la DLL, anche quelle nidificate in record e classi. ShareMem è l'unità di interfaccia per il gestore della memoria condivisa BORLNDMM.DLL, che deve essere distribuito insieme alla DLL. Per evitare utilizzando BORLNDMM.DLL, passare informazioni sulla stringa utilizzando i parametri PChar o ShortString. ) (Progetto -> Mostra sorgente)) se la DLL esporta procedure o funzioni che passano stringhe come parametri o risultati delle funzioni. Questo vale per tutte le stringhe passate o ricevute dalla DLL e anche per quelle nidificate in record e classi. Il modulo ShareMem è un modulo di interfaccia per il gestore della memoria condivisa BORLNDMM.DLL che devi distribuire con la tua DLL. Per evitare di utilizzare BORLNDMM.DLL, passare le informazioni sulla stringa utilizzando i parametri PChar o ShortString. ) utilizza SysUtils, Classi; ($R *.res) inizio fine.
Tutto quello che devi fare ora è aggiungere una subroutine prima del blocco inizio-fine, È tutto. Questo ti darà una routine interna che può essere utilizzata nella DLL, ma non in applicazioni esterne. Se si desidera richiamare la routine da altre applicazioni e altre DLL, sarà necessario esportarla. Per esportare una routine per nome, aggiungila all'elenco esportazioni. Elenco esportazioni ha la stessa sintassi di una lista usi, ad eccezione di ciò che è nell'elenco esportazioni qualsiasi elemento è una subroutine, non un modulo.
Elenco esportazioni solitamente posizionato immediatamente prima del blocco inizio-fine. Dai un'occhiata al Listato 1, che mostra il codice sorgente per una semplice libreria FirstLib.dll, che esporta una singola funzione.
Listato 1. DLL semplice
BibliotecaPrimaLib; funzione Max3(Num1, Num2, Num3: Intero): Intero; chiamata standard; inizio Risultato:= Num1; se Num2 > Risultato allora Risultato:= Num2; se Num3 > Risultato allora Risultato:= Num3; FINE; ( Esportazione della funzione Max3 ) esporta Max3; inizio fine.
Quando aggiungi una subroutine all'elenco esportazioni, esporterai così la routine con il suo nome. Con la direttiva è anche possibile esportare una subroutine con un nome diverso nome o da un valore ordinale utilizzando la direttiva indice. Applicare comunque la direttiva indice Non consigliato.
Di seguito è riportato un esempio di esportazione di una direttiva con un valore ordinale o con un nome diverso:
Esporta il nome Max3 "MyMax3Function", indice SaySomething 1;
Il caricamento statico è il più semplice dei due modi possibili per caricare una DLL. Il caricamento statico è anche chiamato collegamento dinamico all'avvio ( collegamento dinamico in fase di caricamento) perché le DLL utilizzate vengono caricate automaticamente durante l'avvio dell'applicazione.
Per caricare staticamente una DLL, è necessario copiare la dichiarazione della subroutine e dell'applicazione chiamante e contrassegnarla con la direttiva esterno, che indica al compilatore che la subroutine si trova in un file oggetto o in una DLL.
Quando importi subroutine da una DLL, devi contrassegnarle con la direttiva esterno, seguito dal nome della DLL che contiene l'implementazione della subroutine. Di seguito è riportato un esempio di importazione di una funzione MaxZ dalla biblioteca FirstLib.dll:
Funzione Max3(Num1, Num2, Num3: Intero): Intero; chiamata standard; esterno "FirstLib.dll";
Se lo desideri, puoi anche rinominare la subroutine durante la sua importazione. Per fare ciò è necessario dichiarare la subroutine con un nome diverso e alla fine della dichiarazione specificare il nome originale utilizzando la direttiva nome:
Funzione Max(Num1, Num2, Num3: Intero): Intero; chiamata standard; nome "FirstLib.dll" esterno "Max3";
Puoi anche importare una funzione da una DLL. Per fare ciò, è necessario creare un modulo di importazione e scrivere un'intestazione di subroutine standard nella sezione interfaccia e la sua implementazione esterna - nella sezione implementazione questo modulo. Il listato 2 mostra il codice completo per il modulo di importazione della libreria. FirstLib.dll.
Listato 2. Importatore di librerie FirstLib.dll.
UnitFirstLibInf; funzione interfaccia Max3(Num1, Num2, Num3: Intero): Intero; chiamata standard; implementazione const FirstLib = "FirstLib.dll"; (Al compilatore viene detto che l'implementazione della funzione Max3 è nella libreria FirstLib.dll) function Max3; externalFirstLib; FINE.
Dopo aver creato la DLL e il relativo importatore, testa la DLL per esserne sicuro. che la subroutine funzioni correttamente. Poiché non è possibile eseguire la DLL stessa, è necessario creare un'applicazione di prova che possa accedere alla DLL. Il modo più veloce per farlo è creare un team di progetto aggiungendo un nuovo progetto al progetto corrente. Per fare ciò, è necessario fare clic con il tasto destro del mouse sull'elemento Gruppoprogetto1 nella finestra responsabile del progetto(Gestore Progetto) e selezionare il comando dal menu contestuale Aggiungi nuovo progetto, come mostrato in fig. 1.
Listato 3. Test della routine Max3 importata da FirstLib.dll.
Unità Unità1; l'interfaccia utilizza Windows, Messaggi, SysUtils, Varianti, Classi, Grafica, Controlli, Moduli, Finestre di dialogo, FirstLibInf, StdCtrls; digitare TMainForm = class(TForm) Modifica1: TModifica; Modifica2: TModifica; Modifica3: TModifica; Etichetta1: Etichetta T; Etichetta2: Etichetta T; Etichetta3: Etichetta T; Tasto Max3: Tasto T; procedura Max3ButtonClick(Sender: TObject); private (Dichiarazioni private) public (Dichiarazioni pubbliche) end; var MainForm: TMainForm; procedura di implementazione ($R *.dfm) TMainForm.Max3ButtonClick(Sender: TObject); var LargestNumber: intero; inizio Numeropiùgrande:= Max3(StrToInt(Edit1.Text), StrToInt(Edit2.Text), StrToInt(Edit3.Text)); MessageDlg(Format("Numero più grande: %d.", ), mtInformation, , 0); FINE; FINE.
Riferimenti: Il mondo interiore di Borland Delphi 2006. Ivan Chladni.
