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/.

Sommario

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"

Esempi di utilizzo

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

Elenco dei file

 

Panoramica delle modifiche al modello apartment-threading

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.

Limiti dell'edizione Control Creation, versione 5.0

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.

 

Selezione di un modello di threading per il progetto

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

  1. Scegliere Proprietà di <progetto> dal menu Progetto per visualizzare la finestra di dialogo Proprietà progetto.
  2. Nella scheda Generale selezionare le opzioni desiderate nella casella Modello di threading.

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.

Service Pack 2 ed esecuzione invisibile all'utente

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.

 

Limiti del modello apartment-threading

I limiti descritti di seguito si riferiscono a tutte le edizioni di Visual Basic.

 

Conversione di progetti esistenti

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.

Utilizzo forzato di controlli a thread singolo

È 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.

Considerazioni sulla progettazione di progetti per controlli e DLL ActiveX

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.

Considerazioni sulla progettazione di progetti Exe ActiveX

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.

 

Modifiche alla documentazione 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.

 

Modifiche a "Il modello Apartment-threading in Visual Basic"

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.

Dove utilizzare il threading

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.

Reentrancy

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.

 

Modifiche a "Sviluppo di DLL sicure per l'utilizzo di thread multipli"

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.

 

Modifiche a "Sviluppo di componenti out-of-process a thread multipli"

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.

 

Esempi di utilizzo

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

 

Controlli con apartment-threading per Internet Explorer 4.0

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.

La maggior parte dei controlli ActiveX forniti con Visual Basic sono stati aggiornati

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.

Controlli ActiveX creati con Visual Basic

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.

 

Creazione di DLL thread-safe con form

È 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.

  • Nella scheda Generale della finestra di dialogo Proprietà progetto, selezionare Sub Main nella casella Oggetto di avvio, selezionare Thread per oggetto nella casella Modello di threading e immettere un valore univoco per il nome del progetto. Il nome del progetto determina il nome della libreria dei tipi. Possono verificarsi dei problemi se due applicazioni hanno lo stesso nome di libreria dei tipi. "ThreadDemo" è il nome di progetto utilizzato nell'esempio seguente. Nella scheda Componente, selezionare Autonoma nella casella Modalità avvio.
  • Aggiungere un form, assegnargli il nome frmProcess e impostare le proprietà Visible e ControlBox su False. Questo form funziona come una finestra nascosta, che verrà utilizzata dalla routine Sub Main per identificare il thread principale per il progetto. Per questo form non è necessario del codice.
  • Aggiungere un modulo standard al progetto. In questo modulo inserire le dichiarazioni, la routine Sub Main e la routine EnumThreadWndMain indicata di seguito. Come descritto nel testo e nei commenti nel codice, la routine Sub Main verrà eseguita all'avvio dell'applicazione e ogni volta che si crea un nuovo thread. Il codice di esempio della routine Sub Main dimostra come identificare il primo thread in modo che sia possibile sapere quando creare MainApp.
  • Aggiungere un form ed assegnargli il nome frmMTMain. Questo form fornisce l'interfaccia utente principale per l'applicazione di prova. Aggiungere la dichiarazione singola e l'evento Form_Unload immediatamente prima del titolo "Istanze multiple dell'applicazione di prova".
  • Nella routine di eventi Class_Initialize per MainApp, aggiungere codice per visualizzare frmMTMain. Il codice necessario è disponibile di seguito.
  • Per creare thread di prova aggiuntivi, è necessario che per almeno una classe del progetto la proprietà Instancing sia impostata su MultiUse. Aggiungere un modulo di classe e un form e inserire il codice fornito nella sezione "Creazione di nuovi thread". Dato che per questo progetto è stata selezionata l'opzione Thread per oggetto, ogni oggetto pubblico creato esternamente verrà avviato su un nuovo thread. Ciò significa che è possibile creare un nuovo thread utilizzando la funzione CreateObject per creare un'istanza della classe MultiUse in base all'ID programmatico corrispondente (ProgID), come descritto nel testo relativo.
  • Aggiungere codice in frmMTMain per creare nuovi thread mediante la creazione di istanze delle classi MultiUse definite. Nell'esempio seguente fare riferimento al codice nella sezione "Creazione di nuovi thread".
  • L'ambiente di sviluppo non supporta il multithreading. Se si preme F5 per eseguire il progetto, tutti gli oggetti verranno creati sullo stesso thread. Per poter verificare il funzionamento a thread multipli, è necessario compilare il progetto EXE ActiveX ed eseguire l'eseguibile risultante.
  • 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.

    Determinazione del thread principale durante la Sub Main

    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

    Istanze multiple dell'applicazione di prova

    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.

    Proprietà utili per l'apartment-threading

    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.

    Creazione di nuovi thread

    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.

    Riferimenti agli oggetti sui thread

    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.

    I metodi Friend non possono essere utilizzati tra thread

    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.

    Reentrancy

    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:

    Task asincroni

    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.

    Utilizzo dell'applicazione di prova a thread multipli

    È 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.

     

    Note sui controlli ActiveX protetti da script

    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:

     

    Elenco dei file

    I seguenti file sono inclusi in Visual Basic versione 5.0 Service Pack 2: 

    comct232.ocx
    comct232.dep
    comctl32.ocx
    comctl32.dep
    comdlg32.ocx
    comdlg32.dep
    dbgrid32.ocx
    dbgrid32.dep
    dblist32.ocx
    dblist32.dep
    mci32.ocx
    mci32.dep
    mscomm32.ocx
    mscomm32.dep
    msflxgrd.ocx
    msflxgrd.dep
    msinet.ocx
    msinet.dep
    msmapi32.ocx
    msmapi32.dep

    msmask32.ocx
    msmask32.dep msrdc20.ocx
    msrdc20.dep
    msrdo20.dll
    msrdo20.dep
    msstkprp.dll
    mswinsck.ocx
    mswinsck.dep
    picclp32.ocx
    picclp32.dep
    richtx32.ocx
    richtx32.dep
    sysinfo.ocx
    sysinfo.dep
    tabctl32.ocx
    tabctl32.dep
    vb5.exe
    vba5.dll
    vb5ide.dll

    msvbvm50.dll
    c2.exe
    asycfilt.dll
    oleaut32.dll
    olepro32.dll
    stdole2.tlb
    setupwiz.exe
    vb5dep.ini
    setup1.bas
    setup1.exe
    vb5sp2.htm
    vb5sp2.wri
    mscdrun.dll
    mscdrun.dep
    mscondes.dll
    cmctlit.dll
    cmdlgit.dll
    flxgdit.dll
    msprpit.dll
    vb5it.dll

    readme.wri