Newsgroup: it.comp.lang.visual-basic
Titolo: Problema con DLL

Ragazzi, ho un problema,
Ho fatto una DLL ActiveX e ho creato un riferimento in un altro mio progetto. Tutto OK.
Quando perň vado ad aggiornare solo la DLL devo per forza ricompilare il progetto altrimenti la mia applicazione non funziona! Perché?
Grazie a tutti
===========================
Andrea Fabbrucci
anfa...@tin.it
www.andreafabbrucci.3000.it
===========================
--
Posted from 
mta01-acc.tin.it
 [212.216.176.32] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

Non ho capito bene.
Sei ancora in fase di test?
Se si, hai creato un gruppo di progetti comprendente il tup PGM e la DLL?
Puoi spiegare un po' meglio?

 wrote in message
news:8ppvtc$o5c$1...@news.flashnet.it...


 Quando però vado ad aggiornare solo la DLL devo per forza ricompilare il
progetto altrimenti la mia applicazione non funziona! Perché?
Dipende dall'aggiornamento!!
Se modifichi solo il codice di una proprietà o metodo la ricompilazione NON
genera dei nuovi GUIDs (IID e CLSID), di conseguenza i Clients che
utilizzano il componente continueranno a funzionare regolarmente.
Le cose cambiano se modifichi l'interfaccia di un componente, cioè
aggiungi/rimuovi una classe, oppure un medoto/proprietà di una singola
classe presente nella DLL o ancora modifichi il numero di parametri o il
loro DataType. In questo caso si verifica una "rottura della compatibilità
binaria" in quanto il compilatore genererà dei nuovi GUIDs.
Il discorso è un po' complesso, soprattutto perché le cose sono cambiate
drasticamente da VB5 a VB6!!
C'è un bellissimo articolo su MSDN all'indirizzo
http://msdn.microsoft.com/library/devprods/vs6/vbasic/vbcon98/vbconeverythin
gyouneedtoknowaboutversioncompatibility.htm
che ti spiega dettagliatamente come VB6 gestisce il versioning dei
componenti COM.
Se le modifiche all'interfaccia del tuo componente sono frequenti (brutta
cosa, significa mancanza di analisi!!), puoi risolvere i tuoi problemi
utilizzando il Late Binding piuttosto che l'Early Binding.
Che parolacce sono?!! ;-)
Niente di più semplice. L'Early Binding consiste nella stipulazione di un
contratto tra Client e Server a Compile Time, facendo una Reference
esplicita al Server; il Late Binding consiste nel stipulare questo contratto
sono a Run Time, quindi senza alcuna Reference ma istanziando semplicemente
la classe con la funzione CreateObject e dichiarando la veriabile oggetto As
Object, andando a ricavare il CLSID dal Registry in maniera dinamica
piuttosto che in maniera statica come nell'Early Binding.
Tutto chiaro?
Penso di no, comunque leggi attentamente l'articolo MSDN che ti ho
segnalato, OK? ;-))
--
Lorenzo Benaglia
24 Ore Personal Finance S.p.A.
Milano
Italy

Il Late Binding non implica la lentezza del codice?

 Il Late Binding non implica la lentezza del codice?
Indubbiamente si, ma a volte bisogna valutare se la flessibilità è di
primaria importanza rispetto alla pura velocità di esecuzione.
Personalmente utilizzo praticamente sempre l'Early Binding, anche perché
ormai è da un paio d'anni che sviluppo esclusivamente su piattadorme NT
Server + MTS e Windows 2000 (e relativo COM+).


Server + MTS e Windows 2000 (e relativo COM+).
Da quello che ho capito l'Early Binding è quando seleziono la dll nei
riferimenti es Word
e faccio :
dim w as word.application
set w= getobject("Word.application")
mentre il Late Binding è quando non includo il riferimento e faccio:
dim w as object
set w = createobject("Word.application")
Correggetemi se erro.....
Ciao
Oz

 set w= getobject("Word.application")
Esatto!!
Ricapitolando, fai una reference alla type library del componente che
intendi utilizzare, poi dichiari la variabile oggetto utilizzando una classe
specifica.
Questo E' SUFFICIENTE per adottare l'Early Binding.
Per quanto riguarda la creazione dell'oggetto puoi procedere in 3 modi
differenti:
- New
- CreateObject
- GetObject
Con la New utilizzi un "particolare tipo" di Early Binding, chiamato VTable
Binding che rappresenta la scelta migliore. Il CLSID della classe viene
letto direttamente dalla type library del componente. Negli altri due casi,
sei costretto a specificare in maniera esplicita il ProgID, cioè
Componente.Classe (es: Word.Application). Questo tipo di  Early Binding
prende il nome di dispID Binding e l'applicazione utilizzerà in fase di
Runtime la funzione API GetCLSIDFromProgID per leggere dal Registry il CLSID
associato al ProgID, con un leggero decadimento di performances.
Nel caso in cui dichiari una variabile As Object, ANCHE SE hai fatto una
Reference ad un componente utilizzerai COMUNQUE un LateBinding, con una
serie di rimpalli di "colloqui" tra applicazione e registry. Come puoi
immaginare il tutto risulterà molto più lento.
Sono concetti piuttosto complessi e risulta difficile riassumerli in poche
righe. Ti consiglio di leggere attentamente la Programmer's Guide di Visual
Basic e alcuni articoli presenti sul sito 
http://msdn.microsoft.com
HTH,


CUT
Ti ringrazio tantissimo, mi hai chiarito tante cose.
Ciao
Oz