Struttura di un Progetto
In questo capitolo vorrei spendere due parole su un argomento che probabilmente qualcun altro avrebbe spiegato all’inizio. Ma ho deciso di affrontarlo ora non perché sia complicato, tutt’altro, ma perché probabilmente con quello che abbiamo imparato fino a ora risulterà più semplice capire come effettivamente è strutturato un progetto in Delphi. Per prima cosa diamo uno sguardo al padre di Delphi, così aiutiamo quelli di voi che hanno studiato il Pascal a scuola.
Il Pascal puro conosce essenzialmente due tipi di file:
Il file Program con l’estensione “.pas”
E le Unit anch’esse con estensione “.pas”
Il file Program contiene il codice del programma scritto ed è strutturato in questo modo:
PROGRAM nomeprogramma;
USES dichiarazioni unit;
VAR dichiarazioni variabili;
BEGIN
codice
END.
Tra begin ed end si scrive il codice che eventualmente può richiamare anche procedure e funzioni da scrivere esternamente al blocco principale, subito dopo le dichiarazioni.
Ecco un esempio:
PROGRAM nomeprogramma;
USES dichiarazioni unit;
VAR dichiarazioni variabili;
PROCEDURE PrimaProc;
Begin
codice
End;
FUNCTION PrimaFunc (lista var) : risultato;
Begin
codice
End;
BEGIN
codice
PrimaProc;
PrimaFunc(lista var);
END.
Dove PrimaProc e PrimaFunc sono costrutti di fantasia, giusto per far capire come funziona la cosa. Si nota subito la chiarezza della struttura e la sintassi rigorosa: nome del programma, dichiarazioni, i “;” per indicare che un comando o un blocco è finito e il punto finale a indicare che il programma termina li.
Le Unit invece sono una raccolta di costrutti (procedure e funzioni) richiamabili dal programma, a patto che questi la dichiari nell’apposita sezione (USES). La struttura è questa:
UNIT nomeunit;
INTERFACE
USES dichiarazioni unit;
lista nomi delle funzioni e procedure contenute
IMPLEMENTATION
Implementazione delle procedure e delle funzioni dichiarate
END.
Come si nota la Unit è molto diversa da un programma e sostanzialmente divisa in due sezioni, l’Interface dove vengono dichiarate tutte le procedure e le funzioni contenute in essa e quindi richiamabili da un programma, e l’Implementation dove le procedure vengono scritte e dove c’è il codice.
Facciamo un esempio con costrutti di fantasia:
UNIT nomeunit;
INTERFACE
USES dichiarazioni unit;
PROCEDURE ProcFinta1;
PROCEDURE ProcFinta2(S1 : String) : Integer;
IMPLEMENTATION
PROCEDURE ProcFinta1;
Begin
codice
End;
PROCEDURE ProcFinta2(S1 : String) : Integer;
Begin
codice
End;
END.
Come si capisce, il codice di programma si trova nella sezione Implementation mentre nella parte Interface vengono scritti solo i nomi. Tutto le procedure e funzioni dichiarate in Interface sono visibile dall’esterno, se nella parte Implementation vengono scritte procedure o funzioni senza che i loro nomi compaiano in Interface, queste non possono essere chiamate dall’esterno.
Ora faremo un esempio completo di una Unit che viene chiamata da un programma.
La nostra prima Unit con una sola procedura, ne potrebbe contenere molte di più non cambierebbe niente.
UNIT PrimaUnit;
INTERFACE
USES SysUtils;//questa unit di sistema contiene la procedura “Beep”
PROCEDURE Suona;
IMPLEMENTATION
PROCEDURE Suona;
Begin
Beep;
End;
END.
Questo è il programma in Pascal che usa la nostra Unit, si noti che è stata dichiarata nella sezione USES.
PROGRAM PrimoProg;
USES PrimaUnit;
PROCEDURE PrimaProc;
Begin
codice
End;
FUNCTION PrimaFunc (lista var) : risultato;
Begin
codice
End;
BEGIN
codice
PrimaProc;
PrimaFunc(lista var);
Suona;
END.
Si noti come il nome della procedura “Suona” contenuta nella Unit venga chiamata come se fosse scritta nel programma stesso, questo perché l’abbiamo dichiarata all’inizio. Questa breve spiegazione serve solo a farvi capire come è architettato un progetto in Pascal, in Delphi le cose sono un poco diverse.
Quando creiamo un progetto in Delphi in effetti vengono creati più file, ognuno che asserve un compito ben preciso, in fase di compilazione del progetto il compiler (la parte di Delphi che si occupa di trasformare il nostro codice in un programma eseguibile) raccoglie tutte queste informazioni e le tramuta in un file unico eseguibile stand alone.
In Delphi il file “Program” rimane ma ha l’estensione “.dpr”. Questo è il file che darà il nome al nostro eseguibile e che assume in questo contesto l’autorità di “File Progetto”. Al suo interno la struttura non cambia, tra begin ed end troveremo la chiamata alle nostre form che creiamo più alcuni comandi, tutto gestito da Delphi, noi questo file potremmo anche non toccarlo mai. Ogni volta che si aggiunge una form al progetto viene creata una Unit che contiene tutto il codice che la gestisce (questo lo abbiamo già visto), mentre il file “.dfm” associata alla Unit descrive la struttura della finestra e dei suoi componenti.
Oltre a questi file principali ci sono altri che riguardano il salvataggio della configurazione del desktop “.dsk” e del progetto “.cfg”, e poi c’è il file di risorse “.res” dove sono salvate le risorse del progetto (immagini, icone ecc...). Con le ultime release si sono aggiunti altri file:
“.bdsproj” dove vengono salvate tutt le informazioni del nostro progetto in formato UML (per saperne di più http://www.uml.org)
“.identcache” archivio dove viene salvata la lista dei file che appartengono al progetto
“bdsproj.local” della stessa natura della prima voce, ma salva i file che appartengono al progetto
Tutti questi file di contorno che Delphi crea automaticamente per il salvataggio delle impostazioni del nostro progetto, non vanno toccati, essi infatti vengono gestiti direttamente dall’ambiente di sviluppo.