Newsgroup: it.comp.lang.visual-basic
Titolo: Meglio i Moduli o le DLL?

Moreno
Ne avra' fatto un uomo oggetto ;-)
ciao, hal

memoria ?
Dunque, i moduli si differenziano dalle
dll per il salvataggio delle info al loro interno; quindi più che pensare
quale è più veloce, io penseserei a come devi usare le tue funzioni.
Un
modulo/modulo di classe, se inserito in un progetto, va a far parte dell'
exe una volta che questo viene compilato, quindi, il tuo modulo  lo carichi
per intero appena lanci il programma, e te lo porti dietre anche se poi non
fai nessuna chiamata a funzioni al suo interno, lo scarichi dalla memoria
solo quando termini l' applicazione. Un modulo quindi esiste per tutto il
ciclo di vita della tua applicazione.
Una dll invece, essendo un oggetto
che va istanziato, a differenza del modulo, puoi includerlo in un progetto,
avere un riferimento al file .dll ma non caricarla mai in memoria se non
solo quando crei fisicamente (set pippo = new class1) un istanza alla tua
dll. Un oggetto istanziato quindi, ha validità limita all' interno di un
progetto, nasce quando tu lo crei, e lo scarichi dalla memria quando lo
setti a nothing (set pippo = nothing).
Ora, se la tua funzione è un
qualcosa che usi parecchie volte nel tuo programma, e che non ha senso
farla vivere come oggetto assestante, invece che istanziare 100 volte un
oggetto per fare tre istruzioni di somma, lasciala nel modulo. Se invece il
tuo progetto prevede la risoluzione di più cose, sparo a casa, che
so...equazioni, fattoriali etc etc, puoi creare tante dll per ogni
funzione, aggiungere tanti riferimenti al tuo progetto quante sono le dll,
e creare di volta in volta solo l' oggetto funione_matematica che ti serve.
Ti sconsiglio vivamente però il proliferale di tante librerie, perchè
ognuna va registrata...
Potresti fare un altra cosa...creare un unica
libreria di funzioni matematiche e poi richiamare il metodo (somma,
sottrazione, fattoriale...) che ti serve. A questo punto però ti chiedo,
una dll di questo genere, non è come un modulo??
Come puoi quindi vedere
stà a te decidere in base a quello che devi fare, scegliere una via o un
altra. In termini di velocità non so quale dei due possa essere meglio, in
termini di risorse è meglio la dll perchè occupa memoria solo quando viene
realmente usata.
Saluti...
--------------------------------
Inviato via 
http://usenet.iol.it
 

Sto facendo un Programma di matematica/fisica. Cosa è meglio usare per le
funzioni ? Cioè, in termini di velocità, chi è più veloce e occupa meno
memoria ?
THANX

 wrote:

Se per DLL intendi quelle fatte con VB, in termini di velocità
è molto meglio utilizzare i moduli (BAS), quindi solo codice.
Questo pechè le DLL create con VB non sono vere e proprie DLL
standard ma degli ActiveX camuffati, quindi la loro esecuzione è
a parità di funzionalità molto più lenta sia di una DLL
standard (creata per esempio in C) sia del codice sorgente presente
in un BAS, in una Classe, in una form o in qualsiasi altra parte
del progetto VB.
Ciao
Roberto


Se e' early-bound bene o male non dovresti notare differenze tra una DLL ed
un modulo; se invece e' late-bound la  ricerca dell'interfaccia puo'
rallentarti un po'.
Ciaotutti,
[Star]


Il MOLTO pero' me lo devi spiegare :)
L'overhead e' la chiamata ad un metodo virtuale di un componente nello
stesso spazio di indirizzamento, non e' poi cosi' pesante...
Ciaotutti,
Alessandro

 ha scritto nel messaggio
news:LR3s6.43866$yl2.1...@news1.tin.it...


Chiamate COM?
Salve
            Dbg
*Alessandro* ha scritto nel messaggio


 ha scritto nel messaggio
news:LR3s6.43866$yl2.1...@news1.tin.it...

Se sei interessato unicamene alla velocità probabilmente ne l'uno ne l'altro
ma metti tutto il codice in linea, se però sei a questo punto forse è meglio
creare una libreria in C
Ciao VB


Una DLL ActiveX, come qualsiasi altro oggetto COM, non viene
chiamato direttamente ma, il sistema operativo, prima di eseguire
una qualsiasi routine presente in uno di questi componenti,
deve, ricercare nel registro la classe di appartenenza,
individuare il file, aprire una sessione OLE, controllare l'esattezza
della chiamata fatta (controllando che gli oggetti instanziati, i
metodi e le proprietà utilizzate esistano), quindi chiamare la
routine voluta (sempre ovviamente attraverso un, non proprio
semplice, meccanismo OLE).
Nel caso di una DLL standard, il file (dll) da utilizzare viene
specificato nella chiamata, così come il nome della routine da
utilizzare e i suoi parametri comprensivi di tipo, infine
l'accesso al file avviene in maniera diretta, nel senso che il
sistema deve solamente leggere nella DLL l'indirizzo di ingresso
della routine voluta.
E' possibile quindi affermare che, le DLL ole sono
indubbiamente comode e utilizzabili in maniera più semplice e coerente con
la programmazione ad oggetti, però certamente non si può dire
siano veloci. Per controllare quanto sto dicendo è sufficiente
realizzare una DLL ActiveX e una DLL conteneti le stesse
procedure (a livello di funzionalità), cronometrare le operazioni
svolte, certamente la DLL standard sarà sempre più rapida.
Ciao :)
Roberto 

On Thu, 15 Mar 2001 14:36:24 GMT, 
sku...@libero.it
 (skunk) wrote:
[MEGA CLIP]
Che hai fatto, ultimamente ti sei chiuso in ascensore con Deborah Kurata??? ;-PPP
Bravo! :-P
Ciao,
Moreno
#sirri#@#morenosoft#.com
(togliete "#" dall'indirizzo)
Moreno Sirri VB Site - 
http://www.morenosoft.com/MSVBSite/
---------------------------------------------------------------------------
Le risposte alle tue domande le trovi sul Sito Comune di questo NewsGroup:
 
http://www.murialdo.it/it_lang_vb
---------------------------------------------------------------------------


Ed e' la stessa cosa che succede con i componenti. L'overhead del COM si
verifica quando istanzi l'oggetto, non quando ne richiami dei metodi.
Devo riguardarmi le specifiche ma sono ragionevolmente sicuro.
Ciaotutti,
Alessandro