Newsgroup: it.comp.lang.visual-basic
Titolo: ActiveX e istanze multiple

Salve a tutto il NG. Vorrei sapere se qualcuno č in grado di darmi una
soluzione al mio problema:
sto sviluppando un programma che tramite DLL esterne (scritte anch'esse in
VB) gestisce delle apparecchiature seriali. Queste apparecchiature sono di
tipo diverso (relč, lettori, stampanti ecc..) per cui voglio creare tante
DLL quanti sono i tipi di apparecchiature da gestire. In questo modo ogni
DLL dialoga con il programma principale per mezzo di una interfaccia, ed
ogni DLL gestisce in maniera appropriata il proprio tipo di periferica. Il
problema č che la seriale dove arrivano/invio i dati č unica, e non posso
permettere che ogni DLL tenti l'apertura della COM1. Per cui vorrei
sviluppare un'ulteriore DLL per la gestione della seriale. In pratica vorrei
costrutire un qualcosa che ha una struttura del tipo:
----------------------------------
           PROGRAMMA
----------------------------------
   |               |             |
  \/              \/            \/
-------   -------    -------
 DLL1    DLL2     DLL3
-------   -------    -------
   |               |             |
  \/              \/            \/
---------------------------------
              DLL SERIALE
---------------------------------
Il problema č che la prima DLL che viene istanziata da PROGRAMMA (DLL1) crea
la sua istanza di DLL SERIALE e lo stesso fanno DLL2 e DLL3, generandomi un
errore di apertura porta COM1 dato che č giŕ aperta dall'istanza DLL SERIALE
di DLL1. Dovrei quindi da DLL2 e DLL3 riuscire a beccare il riferimento a
DLL SERIALE di DLL1. Ho provato con l'istruzione GetObject di VB ma non mi
funziona in nessun caso mentre la CreateObject mi crea per ogni DLL(1,2,3)
una nuova istanza della DLL SERIALE che tentando di aprire COM1 si inchioda.
Siamo punto e a capo.
Vorrei quindi creare una istanza della DLL SERIALE all'interno della prima
DLL istanziata da PROGRAMMA (DLL1) ma che poi abbia una vita sua (tanto che
se tiro giů l'instanza di DLL1 la DLL SERIALE rimanga sů) e che sia
referenziabile da tutte le altre DLL(2,3) instanziate da PROGRAMMA.
La soluzione sarebbe che PROGRAMMA istanzia DLL SERIALE e le altre DLL1,
DLL2, DLL3, passando a quest'ultime il riferimento a DLL SERIALE. Il
problema č che il sistema deve essere aperto, nel senso che in futuro
verranno sviluppate altre DLL (delle quali ancora non conosco la struttura
nč il funzionamento) e quindi non posso prevedere tutte le necessitŕ che
queste future DLL disporranno; mi devo cioč semplicemente limitare a
istanziare un primo livello di DLL (una per ogni tipo di apparecchiatura in
rete); eventualmente se queste DLL necessitano di altre DLL o librerie
saranno libere di caricarsele e gestirsele, ma non devono passare per
PROGRAMMA per rendere visibile a tutte le altre un oggetto creato in una DLL
di primo livello.
L'obiettivo č quello di creare un oggetto in una DLL (DLL1) e di renderlo
autonomo, disponibile e visibile anche alle altre DLL, che viva di una vita
sua.
Spero di esser stato chiaro.
Grazie a tutti, Massimo.

 alle altre DLL, che viva di una vita sua.
Permettimi una premessa. Io mi occupo proprio di sistemi
reattivi, e pertanto credo di essermi fatto una discreta
esperienza. Quindi sono più che convinto che il VB *non* sia
il linguaggio adatto e che tu ti stia andando ad impelagare in
una grana (sperando con tutto il cuore di sbagliarmi), e
neppure tanto piccola. Detto questo, la soluzione sta nel creare
un activeX *non* in-process (dll) ma out-of-process (exe), che
pertanto vive di vita propria.
Ciao.
-- 
BSD is for UNIX lovers -- linux is for Windows haters.

...

Scartabellando ieri sera tra esempi internet e MSDN ho trovato la
soluzione, è come dici tu, creare un Exe Active out of process che ha
1 classe, (StartUp) di tipo Multiuse, ed un modulo (modMain) dove ho
le mie variabili globali. Ogni nuova DLL che vorrà utilizzare il mio
Exe ActiveX genererà una nuova istanza della StartUp alla quale
passerà in qualche modo il riferimento di se stessa e la nuova istanza
di StartUp memorizzerà tale riferimento in una collection dichiarata
Global nel modulo modMain. In questo modo, mi par di capire, che il
modulo gode di vita sua mentre la classe StartUp viene creata e
distrutta dalle DLL che istanziano l'Exe ActiveX. In risposta agli
eventi OnComm il modulo può alzare un evento a tutti i riferimenti
presenti nella Collection ed informare le DLL "collegate" che è stato
ricevuto un pacchetto di dati dalla seriale. Ogni DLL poi saprà come
gestire o scartare tale pacchetto. L'Exe ActiveX deve essere del tipo
"Pool di threed (1 threed)" ma ho visto che funziona anche "Threed per
oggetto". Saresti in grado di spiegarmi cosa significano queste due
impostazioni e perchè la classe StartUp deve essere proprio del tipo
Multiuse e non Global Multiuse o Public Non Creatable o SingleUse...
Tu dici che con VB non si arriverà lontano.. beh, probabilmente se sei
un programmatore Delphi posso darti tutti le ragioni; se sei un
programmatore Java posso dirti che finirò il lavoro in metà del tuo
tempo; se sei un programmatore C ti consiglio di non metterti neppure
all'opera. Sono un "piccolo esperto di VB" per cui non ho pensieri
riguardo al fatto di riuscire a raggiungere l'obiettivo, sempre che VB
mi consenta di farlo. Questo tipo di infrastruttura non l'avevo mai
affrontato e non sapevo appunto se VB permetteva di farlo o meno. Ora
che ho trovato la soluzione procederò con i miei test di solidità e
velocità.
Grazie per il suggerimento, Massimo.