Dipendenza componente personalizzata inferno

Question

Sto provando a creare un pacchetto per un componente personalizzato che ho creato. Si basa su diverse librerie, tra cui Graphics32, GraphicEx e CCR.Exif.

ho creato un progetto pacchetto, ha scritto l'unità compresa la procedura di Registrazione, aggiunto alcune referenze in più Delphi mi ha notificato per la richiede sezione (tra cui dbrtl.dcp, inet.dcp, soaprtl.dcp, vclimg. dcp, xmlrtl.dcp e dclGraphicEx140.dcp) e aggiunto molte unità allo contiene la sezione per evitare che gli avvisi si verifichino implicitamente. Il progetto viene compilato e può essere installato e utilizzato sulla mia macchina senza problemi. Tuttavia, quando voglio installarlo su un'altra macchina, iniziano i problemi. Alla fine, ho dovuto copiare tutti i DCU di tutti i componenti di terze parti che ho usato, oltre a DCP e BPL di GraphicEx, che ho dovuto installare anche.

Fornire un sacco di file è un fiasco, ma sormontabile, ma dover installare anche altri pacchetti è un no. Potrei sbarazzarmi di quel DCP e BPL mettendo ancora più unità nella sezione contenente, ma ciò ha provocato messaggi di errore sul mio computer in cui GraphicEx è effettivamente installato. Questo mi confonde, perché con Graphics32 non succede nulla del genere ...

Ad ogni modo, come posso mantenere la mia distribuzione al minimo ed evitare tali situazioni? Voglio che altri sviluppatori del mio team siano in grado di utilizzare il pacchetto senza preoccuparsi di ciò che ho usato per costruirlo. Per cominciare, non tutte le unità di terze parti possono essere compilate nella mia DCU?

Answer 1

Sommario

non hanno l'uso Delphi per un po ', ma, ha fatto sviluppare le mie controlli visivi personalizzati (Ultimo lavoro versione ero Delphi 6).

Ci sono 2 problemi quando si ha a che fare con le dipendenze dei pacchetti. Uno si sta installando nell'ambiente Delphi, facendo apparire i controlli sulla tavolozza dei componenti, oltre agli editor di componenti &.

E un altro quando si distribuiscono i pacchetti compilati nelle macchine clienti.

Dipende anche da quale versione su Delphi è in esecuzione.

fase di progettazione

Quando si sviluppa un pacchetto personalizzato, v'è una scheda per opzioni del pacchetto, che indica le cartelle di destinazione.

I manuali di solito dicono agli sviluppatori di lasciare vuote quelle caselle di testo. A volte funziona, a volte no. Scrivo esplicitamente ogni percorso di cartella, nella rispettiva casella di testo.

C'è un percorso di casella di testo per i file ".dcp", altro per " .dcu" e così via.

Se si dispone di controlli visivi e cose come editor di proprietà o editor di componenti, è meglio dividere il codice in 2 pacchetti ("Runtime" & "Designtime").

Solitamente inserisco i progetti delphi (pacchetti) al di fuori della cartella di installazione delphi.

Run Time

Di solito, il modo veloce è quello di mettere i "* .bpl" "i file in Windows (32)/cartella di sistema, o simili "" .dcp cartella DLL" finestre.

---

Pacchetti struttura delle cartelle del codice sorgente di suggerimento

Gestione dei pacchetti può essere difficile. Non so quanto sia cambiato il processo di installazione con Embarcadero e le versioni più recenti di Delphi. Il seguente grafico, è un esempio su come organizzare il codice sorgente. Spero che sia d'aiuto.

[-]--+--c: 
.....| 
.....+--[-]--+--software 
.............| 
.............+--[+]-----java 
.............| 
.............+--[+]-----php 
.............| 
.............+--[-]--+--delphi (not the delphi folder in program files) 
.....................| 
.....................+--[+]-----apps (source code for delphi programs) 
.....................| 
.....................+--[+]-----other 
.....................| 
.....................+--[-]--+--packages (all delphi packages source code here) 
.............................| 
.............................+--[+]-----lib (a single package for non visual controls, libraries) 
.............................| 
.............................+--[+]-----tools (package pair for non visual tcomponent descendants) 
.............................| 
.............................+--[+]-----json (example) 
.............................| 
.............................+--[+]-----xml (example) 
.............................| 
.............................+--[-]--+--mycontrols (folder custom visual controls) 
.............................|.......| 
.............................|.......+--[-]--+--delphi40 (folder for delphi40 version of "mycontrols") 
.............................|.......|.......| 
.............................|.......|.......+----------dsgvclctrls40.dpk (design-time package "mycontrols") 
.............................|.......|.......| 
.............................|.......|.......+----------runvclctrls40.dpk (run-time package "mycontrols") 
.............................|.......|.......| 
.............................|.......|.......+--[+]--+--demos (individual example for each "mycontrol") 
.............................|.......|.......| 
.............................|.......|.......+--[+]--+--design ("*.pas" component editors destination folder) 
.............................|.......|.......| 
.............................|.......|.......+--[+]--+--sources ("*.pas" source code destination folder) 
.............................|.......|.......| 
.............................|.......|.......+--[+]--+--bin ("*.dcu" destination folder) 
.............................|.......|........ 
.............................|.......+--[+]--+--delphi50 (folder for delphi50 version of "mycontrols") 
.............................|.......|........ 
.............................|.......+--[+]--+--delphi60 (folder for delphi60 version of "mycontrols") 
.............................|.......|........ 
.............................|.......+--[+]--+--delphi70 (folder for delphi70 version of "mycontrols") 
.............................|................ 
.............................+--[-]-----etc... 

---

applausi.

Answer 2

Thijs, non puoi farlo solo con un pacchetto. Lo sviluppatore di destinazione richiederà quasi tutto ciò che hai aggiunto al pacchetto. Ma c'è un modo alternativo di fare ciò che vuoi: costruisci una DLL con tutti i componenti/librerie che stai usando nel tuo componente e avvolgi tutti quei componenti/librerie esterni in un codice che esporterai dalla DLL. Quindi crea il componente senza utilizzare direttamente i componenti esterni, ma la DLL che hai creato. Non è possibile nel componente "utilizzare" alcuna unità degli altri componenti/librerie esterne. Devi creare una nuova unità con tutti i tipi di dati e la dichiarazione richiesta per qualsiasi cosa tu esporti dalla tua DLL. Tutto ciò funziona perfettamente ma diventerà rapidamente molto complesso per un gran numero di componenti o librerie esterne.

Answer 3

Quello che hai vissuto è una cosa normale per quelli che scrivono componenti. La distribuzione è sempre così. I pacchetti non portano altri pacchetti, ma li fanno riferimento. È nella loro natura.

Per superare una situazione del genere, tratta sempre i miei componenti nello stesso modo in cui lo farei se fossero un prodotto da vendere: costruisco un wizard di installazione che distribuisce e registra tutto ciò di cui ha bisogno il pacchetto.

Nel mio caso InnoSetup funziona molto bene (http://www.jrsoftware.org/isinfo.php).

Answer 4

Penso che AlexSC abbia la risposta migliore, ma penso che potrebbe esserci un'alternativa se si deve assolutamente avere un componente personalizzato che non ha dipendenze.

Mi sono imbattuto nelle frustrazioni di dipendenza Delphi un po 'di tempo fa cercando di creare un componente interno per i nostri sviluppatori. Il mio suggerimento:

1. Disinstalla tutte le dipendenze il componente utilizza

2. Nel vostro pacchetto di componenti, togliere il DCP sopra dalla richiede sezione dalla confezione.

3. Copiare i file di origine delle vostre dipendenze per i componenti

Quando si distribuisce il componente, dovrete distibute con il codice delle dependecies richieste

Correrete in problemi se si desidera utilizzare le dipendenze separatamente poiché Delphi non consente di avere nomi di unità duplicati nei pacchetti installati.

Inoltre, il motivo per cui non si desidera utilizzare DCU è il fatto che le DCU sono compilate per una piattaforma e un compilatore specifici. Quindi, a meno che tu non sia sicuro che tutti i devolpers si trovano sullo stesso annuncio della piattaforma che utilizza la stessa versione di Delphi, il codice di dipendenza deve essere ricompilato.

Ancora una volta, AlexSC ha la migliore risposta e InnoStudio è un ottimo piccolo strumento.