Newsgroup: it.comp.lang.delphi
Titolo: I package: utlita' reale o comoda alternativa?

Mi sto chiedendo se i package, che in delphi rappresenterebbero l' evoluzione
delle dll, sono largamente usati oppure molti di noi ancora scelgono di
appoggiarsi alle dll.
Dai post del ng onestamente non mi sembra che si faccia un largo uso dei
package....
Ciao a tutti
-- 
ICLD - Morde. 
(delphi day 2003 ticket)

 ancora scelgono di appoggiarsi alle dll.
Io personalmente non li uso, ma più per disinformazione che per inutilità.
--
Jax
Journeying Artificial Xenomorph

 dei package....
I package di Delphi sono più comodi rispetto alle dll proprio perché
consentono di avere degli oggetti Delphi al loro interno. L'uso è
limitato, probabilmente, perché si preferisce un monolitico exe in
quanto più facilmente distribuibile. Ma questo è vero per applicazioni
semplici, in genere.
Applicazioni più complesse, sviluppate secondo modularità possono
beneficiare dei package soprattutto in fase di patching. Occorre avere
sempre delle accortezze, tuttavia.
ciao
Antonio

 appoggiarsi alle dll.
Bè, questo dipende da cosa realmente vuoi fare....
I package di Delphi permettono di posizionare porzioni di un'applicazione in
moduli
separati, che possono essere condivisi tra più applicazioni.
Si pensi a un package come a una collezione di unit memorizzate in un modulo
separato
di tipo DLL: una libreria Delphi di package (Delphi Package Library) o file
DPL. Un'applicazione
può quindi collegarsi in fase di esecuzione con queste unit "impacchettate",
invece
che in fase di compilazione. Siccome il codice di queste unit risiede in
file DPL, e non
nell'eseguibile EXE o DLL, la dimensione di questi due ultimi (tipi di) file
può essere
molto piccola.
Possono essere creati o usati quattro tipi di package:
1. Package di tipo runtime. Questo tipo di package contiene le unit
richieste da
un'applicazione in fase di esecuzione. Se un'applicazione viene compilata in
modo da farla dipendere in fase di esecuzione da un particolare package
runtime, allora non potrà essere eseguita in sua assenza. Il VCL50.DPL di
Delphi è un esempio di questo tipo di package.
2. Package di tipo design. Questo tipo di package contiene gli elementi
necessari
a un'applicazione in fase di progettazione, quali componenti, editor di
proprietà e di componenti ed expert. Possono essere installati nella
libreria
dei componenti Delphi usando la voce di menu Component/Install Package. I
package DCL*.DPL di Delphi sono esempi di questo tipo di package.
Io, per esempio, ho usato package di questo tipo per creare i miei Pix
Experts; Se vuoi puoi scaricarli da
http://www.salexander.supereva.it/PixExpD6.zip
3. Package di tipo runtime e design. Questi package servono per entrambi gli
scopi elencati ai punti 1 e 2 sopra. Creando questo tipo di package si rende
molto semplice lo sviluppo e la distribuzione di un'applicazione, ma bisogna
considerare che questo tipo di package è meno efficiente perché deve
portarsi
il bagaglio del supporto di progettazione anche nelle applicazioni che
vengono distribuite.
4. Package di tipo né runtime e né design. Questi rari package sono intesi
per
essere usati solo da altri package e non vengono considerati per essere
riferiti direttamente da un'applicazione o usati nell'ambiente di
progettazione.
Rendere un'applicazione abilitata ai package è semplice: basta selezionare
la casella Build
with Runtime Packages del dialogo Project/Options/Packages. Dopo aver
selezionato
questa opzione il build dell'applicazione comporterà il collegamento
dinamico con i
package runtime, invece di un collegamento statico di unit nel file EXE o
DLL. Il risultato
sarà un'applicazione notevolmente più "svelta" (sebbene ci si debba
ricordare di
distribuire anche i package necessari assieme all'applicazione).
I package in genere vengono creati usando il Package Editor, che può essere
invocato
scegliendo la voce di menu File/New/Package. Questo editor genera un file
sorgente di
package Delphi, Delphi Package Source (file DPK), che può essere compilato
in un package.
La sintassi di questo file DPK è abbastanza semplice e segue il formato
seguente:
package PackageName
requires Package1, Package2, ...;
contains Unit1, Unit2, ...;
end.
I package elencati nella clausola requires sono richiesti in modo che questo
package
possa essere caricato. Qui di solito sono elencati i package contenenti unit
usate da unit
elencate nella clausola contains. Le unit elencate nella clausola contains
saranno
compilate in questo package. Si noti che le unit qui elencate non devono
essere elencate
anche nella clausola contains, in nessuno dei package elencati nella
clausola requires.
Si noti inoltre che nessuna unit usata da unit nella clausola contains
saranno inglobate
implicitamente in questo package (a meno che non siano contenute in uno dei
package
richiesti).
Alessandro Storniolo
--------------------------------------------------
Download my Experts for Delphi 6 at
http://www.salexander.supereva.it/PixExpD6.zip

moduli
[CUT]
Grazie per il messaggio esplicativo, l'ho messo in evidenza, e' una mini-faq
che mi tornera' utile :)
Ciao


 un'applicazione in >moduli
Soltanto una precisazione che riguarda il versioning dei BPL (Borland
Package Library). La ricompilazione dell'intera applicazione si rende
necessaria qualora si salti da una versione di Delphi all'altra. Non è
possibile ad esempio avere BPL della versione 6 e eseguibile compilato
con la 7, almeno per quanto ne so ;-) .
Ciao
Antonio


    Via De Gasperi, 14 - 42019
    Scandiano (Reggio Emilia)

 interno non siano state modificate, ma solo l'implementazione. 
Se non ho capito male tu scrivi applicazioni in team e fate uso dei runtime 
package, cioè distribuite non solo l'exe ma anche i bpl che verranno poi 
linkati dinamicamente al programma.
Per fare questo non sei anche costretto a distribuire vcl60.bpl (per Delphi 
6) o sei riuscito a compilare il tuo programma usando parte dei package e 
gli altri lasciandoli fuori?
-- 
Ciao, 
   Stefano 
Una volta che avete conosciuto il volo, camminerete sulla Terra
guardando il cielo, perché là siete stati e là desiderate tornare
(Leonardo da Vinci) 

Delphi č un esempio di questo tipo di package.
Beh questo tipo di package mi interessa particolamrente...
Io finora ho visto del Package solo per i componenti percui contenenti
i sorgenti e simili mai del package da usare come una DLL...
Se io ho una Unit dichiarata cosi
Unit Unit1;
Interface
   Procedure Saluta;
Implementation
   Procedure Saluta;
   Begin
       WriteLn(' Hello World');
   End;
End;
che inserisco in un pakage come hai detto scrivendo il pak
package Package1;
contains Unit1;
end.
ok ora scrivo il dpr
Program Program1;
{$APPTYPE CONSOLE}
Begin
    Saluta;
End.
Ora come faccio a condividere Saluta tra Package1.pak e PRogram1.dpr?
facendo Uses Unit1 si linkerebbe staticamente quest'ultima al'exe e
cmq richiederebbe i sorgenti no?  
altra costa ogni versione di delphi ha un suo modo di scrivere i
package ( la parte binaria ) ? lo chiedo perke tempo fa ho provato a
usare una TPU di una versione diversa del TurboPascal e non funzionava
credo che anche con le DCU sia la stessa cosa ( non ho 2 versioni di
delphi per provare )
Il Razziatore,
The Only Good Windows is an uninstalled Windows
-----------------------------------------------
E-MAILs : IlRazziat...@NOSPAMnetscape.net
ICQ     : 67552596
-----------------------------------------------
Founder of MediaPlayer Project
http://mpp.iwebland.com

 dei package e gli altri lasciandoli fuori?
Diciamo che il vantaggio nell'uso dei package che sfrutto maggiormente è
quello di realizzare, per ogni applicazione, componenti e controlli
visuali in grado di incapsulare alcune delle funzionalità che devono
essere implementate.
Per lo sviluppo in team, la comodità è data dal fatto che ciascuno dei
membri può sviluppare, in base alle proprie capacità, delle funzionalità
incapsulandole in componenti che poi vengono fatti interagire tra di
loro, realizzati ovviamente in base ad accordi presi precedentemente.
Ciascuno non ha bisogno di sapere come sono fatti internamente i
componenti (anche se sarebbe meglio) e il codice dell'applicazione
principale rimane più pulito.
Poi, come hai giustamente precisato, c'è anche il discorso "deployment".
La risposta alla tua domanda è "no": i package per loro natura possono
essere utilizzati da vari eseguibili ed applicazioni, pertanto vengono
compilati in modo da linkarsi dinamicamente ai package da cui dipendono.
Pertanto, devi distribuire anche "vcl60" se il tuo package lo
richiede...e a pensarci bene la ragione è ovvia. Se realizzi
contemporaneamente package e applicazioni che si basano su "vcl60",
entrambi gli elementi devono avere la stessa visibilità del package,
cioè gli elementi binari del package 'vcl60' compilato devono essere
uguali sia per l'applicazione, sia per i package che dipendono da esso.
