Newsgroup: it.comp.lang.visual-basic
Titolo: Problema su DLL in late binding

Spero che qualcuno possa darmi una mano, perche' non so che pesci
pigliare...
Dunque...
Ho sviluppato un sw composto da due DLL e un EXE. Le DLL (create come
ActiveX DLL) esportano delle funzioni, dei metodi e degli user-defined
types (udt), che vengono usati dall'EXE per definire delle variabili.
Se includo le DLL con l'istruzione DIM Pippo AS NEW <Nome della classe>,
e poi imposto le DLL nelle References dell'EXE, tutto fila (piu' o meno)
liscio. Ho pero' il problema di non poter cambiare sotto il naso la DLL
all'EXE, che mi costringe ogni volta che effettuo una correzione a
ricompilare e ridistribuire il tutto.
Se invece utilizzo il Late Binding, definendo un oggetto come Variant, e
poi inizializzandolo con SET Pippo =
CREATEOBJECT("<libreria>.<classe>"), riesco a chiamare lo stesso i
metodi e le funzioni, ma non riesco a vedere gli udt. Ho provato
nell'EXE a definire degli udt identici a quelli presenti nelle DLL, ma
se passo un oggetto di tipo udt ad un metodo di una DLL, mi da' l'errore
"Only public user defined types defined in public object modules can be
used as parameters or return types for public procedures of class
modules or as fields of public user defined types".
Come c#@]!!o si fa a far vedere gli udt all'esterno? O, almeno, ad
evitare l'errore di cui sopra?
Grazie a tutti
Bye by Massimo 8-]

 wrote in message
news:397D6412...@txt.it...


Innanzitutto per poter passare gli UDT e' necessario avere VB6 (non versioni
precedenti), oltre ad una versione recente di COM (in Win98, Win2000,
NT4SP4)
Gli UDT vengono passati tra gli oggetti come Variant, ma , a causa
dell'impossibilita' per le versioni piu' datate di COM di considerare gli
UDT come Variant, non e' possibile usare UDT con il late binding (nello
specifico non e' possibile usare UDT con IDispatch o interfacce duali).
Per cui, se vuoi usare gli UDT, devi proseguire sulla strada iniziale,
referenziando cioe' la Dll nell'EXE.
Il problema a cui stai andando incontro e' un classico della programmazione
COM, per cui, se cambi delle definizioni ai metodi che hai dichiarato nella
DLL, devi poi ricompilare il progetto nell'eseguibile.
Un consiglio (se puo' esserti utile): dedica del tempo alla progettazione
delle interfacce dei tuoi oggetti (cioe' ai metodi ed alle proprieta' che
devono esporre), prima di inziare a scrivere il codice.
Omar

 Omar
Il problema e' che, piu' che la definizione, voglio avere la possibilita'
cambiare il comportamento del metodo, ricompilare la DLL, registrarla sotto il
naso al mio EXE, e vedere l'EXE che funziona come prima.
In particolare, ho un EXE standard, che chiama delle funzioni della DLL che sono
customizzate per i clienti. Ovviamente, ricompilare e distribuire solo la DLL
aggiornata e' meglio di ridistribuire tutto il pacchetto (con due DLL la cosa
puo' essere fattibile, ma con un sistena che arriva a 20/30 DLL la cosa diventa
pesante...).
Grazie cmq per la risposta
Bye by Massimo 8-]

 Il problema e' che, piu' che la definizione, voglio avere la possibilita'
[cut]
Se non ho capito male vorresti fare in maniera che lo stesso metodo
richiamato dall'exe abbia differenti implementazioni a seconda della dll.
Ti consiglierei allora un approccio diverso.
Creare un Active-X Exe.
Creare una classe che dichiari l'interfaccia (es. IAddIn) con i metodi che
vuoi richiamare dalle dll.
Es. IaddIn.cls
Public Function Metodo1(...) as ...
    'solo interfaccia
End Function
....
e cosi' via per gli altri metodi
Creare classi che abbiano come proprieta' i membri degli UDT che vuoi
utilizzare, cosi' non dovrai passare UDT fra l'exe e le dll.
Creare le dll aggiungendo un riferimento all A-X Exe.
Implementare l'interfaccia IAddIn :
Classe1.cls
Implements IAddIn
Private Function IAddIn_Metodo1(...) as ...
    'codice diverso in ogni dll
End Function
....
Cosi' via per gli altri metodi.
A questo punto nell EXE non dovrai fare altro che scrivere
Dim x as IAddIn.
Set x = CreateObject("<libreria>.<Classe1>")
poi
x.Metodo1(...)
Tutto funzionera' senza che tu debba inserire nell'exe il riferimento alla
dll che utilizza.
Ovviamente sara' necessario mantenere sempre la stessa interfaccia nella
classe IAddIn.
Siccome mi rendo conto di non essere stato molto chiaro, se hai dubbi
chiedi.
Ciao.





Ho adottato un sistema consigliatomi da Francesco Balena:
In pratica, creo una DLL d'appoggio con tutti gli UDT, che viene inclusa
nelle references di ogni DLL appartenente al progetto, e nell'EXE.
Le altre librerie vengono linkate in late binding, usando la sintassi
DIM <Oggetto> AS OBJECT
SET <Oggetto> = CreateObject("<NomeLibreria>.<NomeClasse>")
In questo modo, non devo aggiungere nell'EXE delle references a queste DLL,
posso impostarle come NO COMPATIBILITY, e posso cambiarle sotto il naso
all'EXE (ovviamente deregistrando la vecchia versione e registrando la
nuova).
Grazie comunque a tutti per l'aiuto
Bye by Massimo 8-]

 evitare l'errore di cui sopra?
potresti provare passando l'indirizzo della variabile in questo modo:
    Dim MiaVar As MioTipo
    Pippo.NomeFunzione VarPtr(MiaVar)
poi, nella DLL, utilizzi CopyMemory per assegnare ad una variabile MioTipo
il contenuto del puntatore
Ciao      :)
Faber

Sai, mentre la maggior parte della gente quando vede un muro cerca di
scavalcarlo o di aggirarlo, tu non ti poni nemmeno il problema: pigli il
cannone e lo abbatti :-)=
E' un approccio che mi piace :-))
Ciaotutti,
Alessandro


 E' un approccio che mi piace :-))
anche a me   :):):)
Faber