|
Note di rilascio Microsoft Visual Basic versione 5.0 Service Pack 2 |
|
© 1996-1997 Microsoft Corporation
Visual Basic versione 5.0 Service Pack 2 è un aggiornamento delle edizioni Professional, Enterprise e Control Creation di Visual Basic che rende disponibile il modello apartment-threading per i progetti di Visual Basic che includono elementi di interfaccia, come form e controlli. L'aggiornamento all'edizione Control Creation ha il proprio programma di installazione; inoltre, questa edizione č solo disponibile in lingua inglese. In questo aggiornamento sono stati corretti vari problemi segnalati per Visual Basic 5.0. (Cercare VB5FixListSP nel sito Web Knowledge Base all'indirizzo
http://www.microsoft.com/kb/default.asp).L'integrazione del Service Pack 2 nella copia in licenza di Visual Basic consente di creare controlli e documenti ActiveX&trade con buone prestazioni in client a thread multipli come Internet Explorer 4.0. Se è disponibile l'edizione Professional o Enterprise di Visual Basic, è inoltre possibile creare:
Questo aggiornamento del modello apartment-threading è l'unica caratteristica di Visual Basic versione 5.0 Service Pack 2.
In questo documento vengono fornite informazioni supplementari rispetto alla documentazione di Microsoft® Visual Basic® 5.0 disponibile nella Guida e nella Documentazione in linea. Per ulteriori informazioni, visitare il sito Web di Microsoft Visual Basic all'indirizzo
http://www.microsoft.com/italy/vbasic/.Panoramica delle modifiche al modello apartment-threading
Selezione di un modello di threading per il progetto
Limiti del modello apartment-threading
Conversione di progetti esistenti
Modifiche alla documentazione di Visual Basic 5.0
Modifiche a "Il modello Apartment-threading in Visual Basic"
Modifiche a "Sviluppo di DLL sicure per l'utilizzo di thread multipli"
Modifiche a "Sviluppo di componenti out-of-process a thread multipli"
Controlli con apartment-threading per Internet Explorer 4.0
Creazione di DLL thread-safe con form
Creazione di un'applicazione di prova a thread multipli
Note sui controlli ActiveX protetti da script
Nei progetti creati con Visual Basic versione 5.0 Service Pack 2 sarà possibile sfruttare le caratteristiche dell'apartment-threading senza dover eliminare elementi visivi come form e controlli. L'utilizzo del Service Pack 2 rende thread-safe i form, i controlli utente, i documenti utente e le finestre di progettazione ActiveX. Il Service Pack 2 include:
Nota Il codice di supporto per le finestre di progettazione ActiveX è ora thread-safe per il modello apartment-threading ma ciò non garantisce che una finestra di progettazione particolare sia thread-safe. Se si utilizza una finestra di progettazione di terze parti, è consigliabile controllare con il fornitore.
Le uniche sezioni di questo documento che riguardano l'edizione Control Creation sono quelle relative ai progetti per controlli ActiveX thread-safe.
Se si utilizza l'edizione Control Creation per creare controlli ActiveX con il modello apartment-threading, è necessario utilizzare un client a thread multipli come Internet Explorer 4.0 per verificare la funzionalità in multithreading dei controlli. Non è possibile utilizzare l'edizione Control Creation per creare un client di prova a thread multipli.
Con il Service Pack 2 vengono modificate le opzioni disponibili nella scheda Generale della finestra di dialogo Proprietà progetto. Dopo aver integrato il Service Pack 2, l'opzione Esecuzione invisibile all'utente non è più abbinata al modello di threading del progetto. È possibile selezionare un'impostazione per l'opzione Modello di threading senza impostare l'esecuzione invisibile all'utente per il progetto.
Per impostare il modello di threading per un progetto per DLL, Exe o controlli ActiveX
Per i progetti per DLL e controlli ActiveX sono disponibili le opzioni Con Apartment-threading o A thread singolo.
Per i progetti Exe ActiveX, è possibile specificare che ogni nuovo oggetto venga creato su un nuovo thread (Thread per oggetto) oppure limitare il componente a un pool di thread fisso. L'impostazione di (1) come dimensione del pool di thread imposta un progetto a thread singolo; un pool di dimensioni maggiori imposta un progetto per il modello apartment-threading.
Nota Quando si modifica il modello di threading per un progetto esistente, verrà generato un errore se il progetto utilizza controlli ActiveX a thread singolo. Visual Basic non consente di utilizzare controlli a thread singolo in progetti con apartment-threading, come descritto in Conversione di progetti esistenti.
Nota Quando si imposta l'opzione Thread per oggetto (o un pool di thread maggiore di uno) per un progetto Exe ActiveX, sui nuovi thread vengono creati solo gli oggetti creati esternamente. (Vedere "Sviluppo di componenti out-of-process a thread multipli" nella Documentazione in linea). Le opzioni Thread per oggetto e Pool di thread non sono disponibili per i progetti per DLL e controlli ActiveX, perché la creazione dei thread è controllata dall'applicazione client.
Importante Gli effetti della selezione delle opzioni Thread per oggetto o Pool di thread nelle edizioni Professional e Enterprise sono descritte in dettaglio in "Sviluppo di componenti out-of-process a thread multipli" nella Documentazione in linea.
Il Service Pack 2 non influisce sulla funzionalità dell'opzione Esecuzione invisibile all'utente. Questa opzione consente ancora di creare componenti eseguibili senza l'intervento dell'utente in server di rete. L'unica modifica del Service Pack 2 si riferisce al fatto che la selezione dell'opzione Esecuzione invisibile all'utente non è collegata al modello di threading del componente.
I limiti descritti di seguito si riferiscono a tutte le edizioni di Visual Basic.
Dopo aver installato Visual Basic versione 5.0 Service Pack 2, è possibile aggiungere l'apartment-threading nei progetti esistenti modificando l'opzione Modello di threading come descritto in
Selezione di un modello di threading per il progetto e ricompilando il progetto. Per la maggior parte dei progetti saranno le uniche operazioni necessarie.Se un progetto per DLL, Exe o controlli ActiveX utilizza controlli costitutivi a thread singolo, il tentativo di impostazione del modello apartment-threading genererà un errore. Considerate la quantità e la serietà dei problemi che i controlli ActiveX a thread singolo causano nei client a thread multipli, in Visual Basic non è consentito utilizzare controlli ActiveX a thread singolo nei progetti per componenti ActiveX.
Se un progetto esistente utilizza un controllo a thread singolo, rivolgersi al fornitore per verificare se è disponibile una versione per apartment-threading.
È possibile "ingannare" Visual Basic ed utilizzare un controllo a thread singolo in un progetto con apartment-threading, modificando manualmente il file .vbp. Si tratta di un'operazione sconsigliata. Di seguito alcuni dei problemi che possono essere causati da controlli ActiveX a thread singolo:
Importante I controlli a thread singolo possono causare questi ed altri problemi in qualsiasi componente o applicazione a thread multipli, creati utilizzando Visual Basic o qualsiasi altro strumento di sviluppo.
Gli oggetti forniti da componenti in-process vengono creati sui thread del client. La DLL o l'OCX non possono creare thread in modo autonomo. Quando il thread del client crea la prima istanza dell'oggetto fornito dal componente, verrà creato un nuovo apartment per tale thread e verrà eseguita la routine Sub Main per il nuovo apartment. Tutti gli oggetti forniti dal componente per tale thread del client risiederanno nello stesso apartment.
Se il componente è stato progettato in modo che tutte le istanze di una classe condividano alcuni dati globali, tali dati verranno condivisi solo dagli oggetti che si trovano sullo stesso thread. In presenza di codice globale per l'accesso a un database, tale accesso verrà eseguito separatamente per ogni thread.
Si supponga, ad esempio, che un client a thread multipli visualizzi un'istanza del controllo Strumento su un form nel thread A e altre due istanze in un form nel thread B. Le istanze del controllo si troveranno in due apartment, ognuno dei quali con una copia delle variabili globali. La routine Sub Main verrà eseguita una volta per ogni apartment. I due controlli sul thread B condivideranno lo stato globale, distinto dallo stato globale del controllo sul thread A.
Altre considerazioni sulla progettazione sono disponibili in
Modifiche a "Il modello Apartment-threading in Visual Basic" e in Modifiche a "Sviluppo di DLL sicure per l'utilizzo di thread multipli" in questo documento e negli argomenti corrispondenti nella Documentazione in linea di Visual Basic 5.0.La differenza più importante tra i componenti out-of-process a thread singolo o con apartment-threading consiste nel fatto che tutti i dati globali (incluse le proprietà dell'oggetto App) vengono replicati per ogni thread. Una delle implicazioni è che la routine Sub Main verrà eseguita ogni volta che viene creato un nuovo thread.
Altre considerazioni sulla progettazione dei componenti out-of-process sono disponibili in
Modifiche a "Il modello Apartment-threading in Visual Basic" e in Modifiche a "Sviluppo di componenti out-of-process a thread multipli" in questo documento e negli argomenti corrispondenti nella Documentazione in linea di Visual Basic 5.0.
Nelle sezioni seguenti vengono descritte modifiche specifiche degli argomenti indicati della Documentazione in linea di Visual Basic 5.0:
Modifiche a "Il modello Apartment-threading in Visual Basic"
Modifiche a "Sviluppo di DLL sicure per l'utilizzo di thread multipli"
Modifiche a "Sviluppo di componenti out-of-process a thread multipli"
Se è disponibile l'edizione Professional o Enterprise di Visual Basic, è possibile trovare questi argomenti nella Documentazione in linea utilizzando il riquadro Sommario:
Guida ai componenti
Creazione di componenti ActiveX
Progettazione di componenti di codice
Scalabilità e multithreading
Nota Il browser della Documentazione in linea non è disponibile nell'edizione Control Creation. Gli argomenti sopra indicati non sono inclusi nella documentazione di Visual Basic 5.0 scaricabile per l'utilizzo con l'edizione Control Creation. Tuttavia, le informazioni sulla reentrancy e sulla progettazione di DLL thread-safe disponibili nelle due sezioni seguenti interessano anche gli utenti dell'edizione Control Creation.
Nell'argomento originale della Documentazione in linea si spiega che Visual Basic mantiene una copia distinta dei dati globali per ogni thread. Un effetto collaterale di questa funzionalità, non menzionato nella Documentazione in linea, è che la routine Sub Main viene eseguita per ogni nuovo apartment, ovvero per ogni nuovo thread. In caso contrario non esisterebbe un modo per inizializzare i dati globali per il thread. Questo argomento viene discusso in maggiore dettaglio in
Modifiche a "Sviluppo di DLL sicure per l'utilizzo di thread multipli" e Modifiche a "Sviluppo di componenti out-of-process a thread multipli", di seguito.Non è più vero che i componenti devono essere impostati per l'esecuzione invisibile all'utente per utilizzare l'apartment-threading. L'opzione Esecuzione invisibile all'utente è ora un'opzione indipendente nella scheda Generale della finestra di dialogo Proprietà progetto, come descritto in
Selezione di un modello di threading per il progetto, più indietro.Nell'argomento originale si afferma che quando si esegue una chiamata tra thread, il metodo che si sta chiamando è protetto dalla reentrancy fino a quando non cede il controllo, ad esempio richiamando DoEvents. È importante notare che un metodo può cedere il controllo anche eseguendo autonomamente una chiamata tra thread o tra processi oppure visualizzando un form.
L'argomento della Documentazione in linea ora si riferisce ai progetti per controlli ActiveX ed anche ai progetti per DLL ActiveX.
La procedura per impostare il modello apartment-threading per un progetto per DLL ActiveX è stata modificata, come descritto in
Selezione di un modello di threading per il progetto (più indietro). Non è più necessario disattivare tutte le interazioni con l'utente (opzione Esecuzione invisibile all'utente) per ottenere una DLL con apartment-threading.Quando si crea un'istanza di un form in fase di esecuzione, Visual Basic segue le stesse regole valide per gli oggetti privati. Ovvero, il nuovo form viene creato sul thread in cui viene eseguito l'operatore New. Se si crea un form in modo implicito, ad esempio accedendo ad una proprietà del form con una variabile dichiarata As New Form1), il form viene creato sul thread in cui era in esecuzione il codice.
Nota Un caso particolare di creazione implicita di form è l'ID predichiarato, ad esempio Form1, ovvero una variabile del form globale e nascosta che Visual Basic crea per ogni classe di form. Poichè Visual Basic duplica i dati globali per ogni apartment, esiste un Form1 distinto per ogni thread. Per evitare confusione può essere utile evitare di utilizzare ID predichiarati in componenti con apartment-threading ricorrendo alla dichiarazione esplicita delle variabili dei form.
Nota Dati globali duplicati significa che una variabile dichiarata Public in un modulo standard è globale solo per il thread. Ogni thread ha un'istanza della variabile. Significa inoltre che per le proprietà dell'oggetto App, come App.ThreadID, esistono istanze separate per ogni thread.
A differenza dei form, i controlli ActiveX sono oggetti pubblici che possono essere creati e utilizzati dai form client. Un'istanza di un controllo ActiveX risiede sempre nello stesso thread del form client che lo utilizza.
Importante In una DLL con apartment-threading, viene creato un nuovo apartment per ogni thread del client che richiede gli oggetti forniti dalla DLL. Alla prima richiesta di un oggetto da parte del thread del client, viene eseguita la routine Sub Main per il nuovo apartment. Una DLL non può creare thread autonomamente.
Non è più necessario disattivare le interazioni con l'utente (opzione Esecuzione invisibile all'utente) per ottenere un Exe a thread multipli. Le descrizioni delle opzioni Thread per oggetto e Pool di thread (thread di tipo round-robin) sono ancora valide.
Per impostare un progetto Exe ActiveX per l'apartment-threading, aprire la scheda Generale della finestra di dialogo Proprietà progetto e selezionare Thread per oggetto o Pool di thread ed impostare una dimensione di pool maggiore di uno.
Come altri oggetti privati, i form risiedono nel thread in cui sono stati creati. Gli oggetti privati non possono essere creati con la funzione CreateObject e pertanto non possono essere utilizzati per avviare nuovi thread.
Importante In un eseguibile a thread multipli, la routine Sub Main viene eseguita in modo indipendente per ogni nuovo thread. In Visual Basic non è disponibile un metodo per determinare il thread che è stato creato per primo.
Nelle sezioni successive vengono descritti esempi di utilizzo del modello apartment-threading.
Controlli con apartment-threading per Internet Explorer 4.0
Creazione di DLL thread-safe con form
Creazione di un'applicazione di prova a thread multipli
Internet Explorer 4.0 visualizza le finestre utilizzando thread multipli di esecuzione. Quando due diverse finestre in Internet Explorer 4.0 visualizzano istanze dello stesso controllo ActiveX, l'OCX deve fornire un'istanza a ogni thread. Se entrambe le istanze vengono fornite dallo stesso apartment nell'OCX (come nel caso di Visual Basic 5.0), una delle istanze del controllo avrà prestazioni inferiori a causa del marshaling tra thread.
Oltre a una riduzione delle prestazioni, l'utilizzo di un controllo a thread singolo in un'applicazione a thread multipli può causare problemi con lo stato attivo, l'utilizzo di TAB e i tasti di accesso.
La compilazione dell'OCX con Visual Basic versione 5.0 Service Pack 2 migliora le prestazioni ed elimina questi problemi. Ogni istanza del controllo utilizzata da Internet Explorer 4.0 viene eseguita sullo stesso thread della finestra che visualizza il controllo, perché l'OCX supporta un apartment distinto per ogni thread del client.
Visual Basic versione 5.0 Service Pack 2 include nuove versioni della maggior parte dei controlli ActiveX forniti con Visual Basic 5.0. I controlli aggiornati supportano ora il modello apartment-threading e avranno prestazioni uguali sia in client a thread singolo che in client a thread multipli. Tra i controlli che sono ancora a thread singolo vi sono i controlli DBGrid, MSChart e i controlli forniti nella directory Tools di Visual Basic 5.0 per compatibilità con le versioni precedenti.
Dopo aver installato Visual Basic versione 5.0 Service Pack 2, l'impostazione predefinita per i nuovi progetti per controlli ActiveX sarà il modello apartment-threading. È possibile impostare il modello apartment-threading per un progetto esistente per controlli ActiveX modificando l'impostazione del modello di threading, come descritto in
Selezione di un modello di threading per il progetto e ricompilando il progetto. Per la maggior parte dei progetti per controlli ActiveX si tratta delle uniche operazioni da eseguire.Se un progetto per controlli ActiveX utilizza controlli costitutivi a thread singolo, il tentativo di impostazione del modello apartment-threading genererà un errore. Considerate la quantità e la serietà dei problemi che i controlli ActiveX a thread singolo causano nei client a thread multipli, in Visual Basic non è consentito utilizzare controlli ActiveX a thread singolo come elementi costitutivi di controlli ActiveX con apartment-threading. Per ulteriori informazioni vedere
Conversione di progetti esistenti.In presenza di controlli ActiveX esistenti che utilizzano controlli costitutivi a thread singolo, rivolgersi al fornitore del controllo a thread singolo per verificare se è disponibile una versione dello stesso controllo per il modello apartment-threading.
Altre considerazioni sulla progettazione di controlli ActiveX per apartment-threading sono disponibili in
Conversione di progetti esistenti.
È ora possibile impostare il modello apartment-threading in progetti per DLL ActiveX che contengono form.
Le DLL con apartment-threading non possono creare thread autonomamente. Quando il thread del client invia la prima richiesta di un oggetto fornito dalla DLL, viene creato un nuovo apartment e la to MainApp occuperà il primo thread dell'applicazione e visualizzerà l'interfaccia utente principale.
Importante Per essere sicuri che ogni nuovo oggetto MultiUse venga avviato come nuovo thread, è necessario utilizzare l'opzione Thread per oggetto anziché Pool di thread.
La routine Sub Main viene eseguita per ogni nuovo thread. Il motivo è che Visual Basic conserva una copia separata dei dati globali per ogni thread (ogni apartment). Per inizializzare i dati globali per il thread, è necessario eseguire la routine Sub Main. Ciò significa che se la routine Sub Main carica un form nascosto o visualizza l'interfaccia utente principale dell'applicazione, verranno caricate nuove copie di tali form ogni volta che si crea un nuovo thread.
Il codice seguente determina se la routine Sub Main è o meno in esecuzione nel primo thread, in modo che sia possibile caricare il form nascosto una sola volta e visualizzare l'interfaccia utente principale dell'applicazione di prova una sola volta.
' Valore radice per la didascalia della finestra nascosta
Public Const PROC_CAPTION = "FinestraProcessoDemoApartment"
Public Const ERR_InternalStartup = &H600
Public Const ERR_NoAutomation = &H601
Public Const ENUM_STOP = 0
Public Const ENUM_CONTINUE = 1
Declare Function FindWindow Lib "user32" Alias "FindWindowA" (ByVal lpClassName As String, ByVal lpWindowName As String) As Long
Declare Function GetWindowThreadProcessId Lib "user32" (ByVal hwnd As Long, lpdwProcessId As Long) As Long
Declare Function EnumThreadWindows Lib "user32" (ByVal dwThreadId As Long, ByVal lpfn As Long, ByVal lParam As Long) As Long
' Handle della finestra recuperato da EnumThreadWindows.
Private mhwndVB As Long
' Form nascosto utilizzato per identificare il thread principale.
Private mfrmProcess As New frmProcess
' ID di processo.
Private mlngProcessID As Long
Sub Main()
Dim ma As MainApp
' Prende in prestito un handle di finestra da utilizzare per ottenere
' l'ID di processo (vedi call-back EnumThreadWndMain di seguito).
Call EnumThreadWindows(App.ThreadID, AddressOf EnumThreadWndMain, 0&)
If mhwndVB = 0 Then
Err.Raise ERR_InternalStartup + vbObjectError, , "Errore interno durante l'avvio del thread"
Else
Call GetWindowThreadProcessId(mhwndVB, mlngProcessID)
' L'ID di processo rende univoca la didascalia della finestra.
If 0 = FindWindow(vbNullString, PROC_CAPTION & CStr(mlngProcessID)) Then
' La finestra non è stata trovata, per cui questo è il primo thread.
If App.StartMode = vbSModeStandalone Then
' Crea il form nascosto con la didascalia univoca.
mfrmProcess.Caption = PROC_CAPTION & CStr(mlngProcessID)
' L'evento Initialize di MainApp (Instancing =
' PublicNotCreatable) mostra l'interfaccia utente
' principale.
Set ma = New MainApp
' (La chiusura dell'applicazione è più semplice se
' non c'è un riferimento globale a MainApp; MainApp
' dovrebbe invece passare Me al form utente principale
' in modo che il form impedisca la terminazione di
' MainApp).
Else
Err.Raise ERR_NoAutomation + vbObjectError, , _
"Impossibile avviare l'applicazione con l'automazione"
End If
End If
End If
End Sub
' Funzione call-back utilizzata da EnumThreadWindows.
Public Function EnumThreadWndMain(ByVal hwnd As Long, ByVal lParam As Long) As Long
' Salva l'handle della finestra.
mhwndVB = hwnd
' La prima finestra è l'unica necessaria.
' Interrompe l'iterazione non appena si trova una finestra.
EnumThreadWndMain = ENUM_STOP
End Function
' MainApp richiama questa Sub e il relativo evento Terminate;
' in caso contrario il form nascosto impedirebbe
' la chiusura dell'applicazione.
Public Sub FreeProcessWindow()
Unload mfrmProcess
Set mfrmProcess = Nothing
End Sub
Importante
Questa tecnica per l'identificazione del primo thread potrebbe non funzionare nelle versioni future di Visual Basic.Si noti che la Sub Main non esegue alcuna azione per nessun thread dopo il primo. Quando si aggiunge codice per la creazione di oggetti MultiUse (per avviare thread successivi) assicurarsi di includere codice per l'inizializzazione di tali oggetti.
EnumThreadWindows viene utilizzato con una funzione call-back, EnumThreadWndMain, per individuare una delle finestre nascoste che Visual Basic crea per utilizzo interno. L'handle di questa finestra nascosta viene passato a GetWindowThreadProcessId, che restituisce l'ID di processo. L'ID di processo viene quindi utilizzato per creare una didascalia univoca per la finestra nascosta (frmProcess) caricata da Sub Main. I thread successivi individuano questa finestra e in questo modo sanno che non è necessario creare l'oggetto MainApp. Queste operazioni sono necessarie perché Visual Basic non fornisce un metodo per identificare il thread principale dell'applicazione.
La classe MainApp, nell'evento Initialize, visualizza il form principale dell'applicazione di prova. MainApp dovrebbe passare il riferimento Me al form principale in modo da impedire la terminazione di MainApp. Dall'interfaccia utente principale è possibile creare tutti i thread successivi. L'impostazione della proprietà Instancing di MainApp su PublicNotCreatable consente di evitare la visualizzazione di due form di interfaccia utente principali.
Un esempio semplice di classe MainApp e del form associato (passaggi 5 e 6 più indietro) potrebbe essere simile al seguente:
' Codice per una classe MainApp.
Private mfrmMTMain As New frmMTMain
Private Sub Class_Initialize()
Set mfrmMTMain.MainApp = Me
mfrmMTMain.Caption = mfrmMTMain.Caption & " (" & App.ThreadID & ")"
mfrmMTMain.Show
End Sub
Friend Sub Closing()
Set mfrmMTMain = Nothing
End Sub
Private Sub Class_Terminate()
' Rilascia la finestra nascosta.
Call FreeProcessWindow
End Sub
' Codice per il form frmMTMain.
Public MainApp As MainApp
Private Sub Form_Unload(Cancel As Integer)
Call MainApp.Closing
Set MainApp = Nothing
End Sub
L'inserimento dell'ID di processo nella didascalia della finestra nascosta consente di eseguire istanze multiple dell'applicazione di prova senza interferenze.
Quando si richiama CreateObject, l'istanza della classe pubblica creata sarà su un thread nell'istanza corrente dell'applicazione. Ciò è dovuto al fatto che CreateObject cerca sempre di creare un oggetto nell'applicazione corrente prima di cercare altri componenti Exe in esecuzione che potrebbero fornire l'oggetto.
Potrebbe risultare utile esporre l'ID di processo come proprietà di sola lettura del modulo che contiene la Sub Main:
'Codice non necessario per l'applicazione di prova
Public Property Get ProcessID() As Long
ProcessID = mlngProcessID
End Property
Ciò consente a qualsiasi oggetto sul thread di ottenere l'ID di processo richiamando la proprietà ProcessID non qualificata. Potrebbe inoltre risultare utile esporre una proprietà IsMainThread booleana in questo modo.
Se si imposta l'opzione Thread per oggetto, ogni oggetto pubblico creato esternamente, ovvero creato utilizzando la funzione CreateObject, viene avviato su un nuovo thread. Per creare un nuovo thread, è sufficiente utilizzare semplicemente l'ID programmatico (ProgID) di una delle classi MultiUse:
'Codice non incluso nell'applicazione di prova
Dim tw As ThreadedWindow
Set tw = CreateObject("ThreadDemo.ThreadedWindow")
La variabile tw include ora un riferimento a un oggetto su un nuovo thread. Tutte le chiamate alle proprietà e ai metodi di questo oggetto effettuate utilizzando tw saranno soggette all'overhead aggiuntivo del marshaling tra thread.
Nota Un oggetto creato con l'operatore New non viene creato su un nuovo thread, ma risiede nello stesso thread in cui è stato eseguito l'operatore New. Vedere "Sviluppo di componenti out-of-process a thread multipli" e "Modalità di creazione di oggetti in componenti Visual Basic" nella Documentazione in linea.
Per assicurarsi che MainApp non venga terminata fino a quando non sono finiti tutti gli altri thread, è possibile inserire una proprietà MainApp in ogni classe pubblica. Quando un oggetto crea un oggetto MultiUse su un nuovo thread, passa al nuovo oggetto un riferimento all'oggetto MainApp come parte del processo di inizializzazione. È inoltre possibile passare a MainApp un riferimento al nuovo oggetto, in modo che MainApp abbia un insieme di riferimenti a tutti gli oggetti che controllano i thread. Si ricordi, tuttavia, che in questo modo verranno creati dei riferimenti circolari. Vedere "Gestione di riferimenti circolari" nella Documentazione in linea.
Se si desidera che una classe che controlla un thread visualizzi un form, è necessario includere un metodo Initialize (da non confondere con l'evento Initialize) o un metodo Show per la visualizzazione del form. Non visualizzare il form nella routine di eventi Class_Initialize, poiché si potrebbero creare errori di temporizzazione quando si creano istanze della classe. In un esempio molto semplice, il codice per una classe ThreadedWindow MultiUse e per il relativo form, frmThreadedWindow, potrebbe essere simile al seguente:
'Codice per una classe ThreadedWindow MultiUse.
Private mMainApp As MainApp
Private mfrm As New frmThreadedWindow
Public Sub Initialize(ByVal ma As MainApp)
Set mMainApp = ma
Set mfrm.ThreadedWindow = Me
mfrm.Caption = mfrm.Caption & " (" & App.ThreadID & ")"
mfrm.Show
End Sub
Friend Sub Closing()
Set mfrm = Nothing
End Sub
'Codice per il form frmThreadedWindow.
Public ThreadedWindow As ThreadedWindow
Private Sub Form_Unload(Cancel As Integer)
Call ThreadedWindow.Closing
Set ThreadedWindow = Nothing
End Sub
La seguente parte di codice mostra come potrebbe essere inizializzato l'oggetto ThreadedWindow:
'Codice per il form principale dell'applicazione di prova (frmMTMain).
Private Sub mnuFileNewTW_Click()
Dim tw As ThreadedWindow
Set tw = CreateObject("ThreadDemo.ThreadedWindow")
' Indica al nuovo oggetto di visualizzare il form
' corrispondente e di passare un riferimento
' all'oggetto dell'applicazione principale.
Call tw.Initialize(Me.MainApp)
End Sub
Se sono disponibili varie classi che controllano i thread, è possibile rendere il codice più generico definendo un'interfaccia IApartment che include il metodo Initialize. Quando si implementa IApartment in ogni classe è possibile fornire il codice appropriato del metodo Initialize per tale classe. Il codice per la creazione di thread potrebbe essere simile al seguente:
'Codice non necessario per l'applicazione di prova
Private Sub mnuFileNewObject_Click(Index As Integer)
Dim iapt As IApartment
Select Case Index
Case otThreadedWindow
Set iapt = CreateObject("ThreadDemo.ThreadedWindow")
' (altri casi…)
End Select
' Codice comune per l'inizializzazione di oggetti.
Call iapt.Initialize(MainApp)
End Sub
Nota
È possibile creare un'interfaccia IXxxxApartment nota solo all'applicazione a thread multipli, definendo l'interfaccia in una libreria dei tipi distinta. In un progetto Exe ActiveX, impostare un riferimento alla libreria dei tipi.Per garantire una chiusura corretta di un'applicazione a thread multipli, è necessario tenere traccia accuratamente di tutti i riferimenti agli oggetti MultiUse utilizzati per creare e controllare i thread.
Definire chiaramente il ciclo di vita previsto per l'oggetto. Si consideri, ad esempio, il caso di un oggetto MultiUse che visualizza un form. Il sistema più semplice per gestire il ciclo di vita dell'oggetto consiste nel fare in modo che l'oggetto passi al form un riferimento Me. In questo modo il form mantiene attivo l'oggetto. Quando l'utente chiude il form, l'evento Unload del form deve impostare tutti i riferimenti all'oggetto MultiUse su Nothing, in modo che l'oggetto possa essere terminato e vengano rilasciati i riferimenti al form. Potrebbe essere utile assegnare all'oggetto MultiUse un metodo Friend per il rilascio del riferimento al form e di tutti gli altri riferimenti interni all'oggetto. Il metodo può essere richiamato dall'evento Unload del form.
Se l'oggetto che controlla un thread crea oggetti aggiuntivi sul thread utilizzando l'operatore New, assicurarsi di eliminare i riferimenti a tali oggetti. Il thread non potrà essere chiuso fino a quando non vengono rilasciati tutti i riferimenti agli oggetti creati sul thread. I thread aperti consumano risorse di sistema.
Dato che le proprietà e i metodi Friend non fanno parte dell'interfaccia pubblica di una classe, non è possibile richiamarli da un altro thread. Le chiamate tra thread tra oggetti sono limitate alle proprietà e ai metodi dichiarati Public.
Se un metodo di un oggetto cede il controllo richiamando DoEvents, visualizzando un form a scelta obbligatoria o eseguendo una chiamata secondaria a un oggetto su un altro thread, è possibile che un secondo chiamante entri nel codice del metodo prima del completamento della prima chiamata. Se un metodo di questo tipo utilizza o modifica i valori di proprietà o variabili a livello di modulo, il risultato potrebbe essere uno stato interno non valido per l'oggetto. Per attivare la protezione dalla reentrancy, è possibile:
In Visual Basic non è disponibile un metodo per la biforcazione dell'esecuzione, ovvero per fare in modo che un thread inizializzi una chiamata di un metodo su un nuovo thread e che quindi riprenda l'elaborazione sul thread originale. È possibile simulare questa funzionalità nell'applicazione di prova, facendo in modo che la chiamata originale del metodo attivi un timer e quindi restituisca il controllo immediatamente. Quando viene generato l'evento timer, è possibile disattivare il timer ed eseguire l'elaborazione asincrona. Questa tecnica viene descritta in "Eventi e funzioni call-back asincrone" nella Documentazione in linea. È inoltre disponibile una dimostrazione nella Documentazione in linea (vedere "Creazione di componenti Exe ActiveX") e nell'applicazione di esempio Coffee.
È necessario compilare l'applicazione di prova a thread multipli per eseguire le prove funzionali del componente con apartment-threading, perché l'ambiente di sviluppo Visual Basic attualmente non supporta thread multipli di esecuzione. Se è disponibile Visual Studio, potrebbe risultare utile compilare l'applicazione di prova con informazioni di debug per il debug in codice nativo, in modo che sia possibile utilizzare il debugger di Visual Studio.
Due dei controlli con apartment-threading inclusi in Visual Basic versione 5.0 Service Pack 2, il controllo finestre di dialogo comuni (Common Dialog) e il controllo barra degli strumenti (Toolbar) ora supportano l'interfaccia IObjectSafety ActiveX. Quando questi controlli vengono utilizzati in un ambiente in cui sono attive le funzioni per la protezione da script, come in Internet Explorer, verranno contrassegnati come Protetti da script. Tuttavia, alcune funzioni di questi controlli verranno disattivate per qualificarli come protetti da script:
I seguenti file sono inclusi in Visual Basic versione 5.0 Service Pack 2:
|
comct232.ocx |
msmask32.ocx |
msvbvm50.dll |
readme.wri |