Notes de mise à jour Microsoft Visual Basic 5.0 Service Pack 2

 

© 1996-1997 Microsoft Corporation

Visual Basic 5.0 Service Pack 2 est une mise à jour de Visual Basic Éditions Professionelle, Entreprise et Création de contrôle. Ce programme permet l'utilisation de threads cloisonnées pour les projets Visual Basic contenant des éléments d'interface utilisateur, tels que les feuilles et les contrôles. Plusieurs bogues découverts dans Visual Basic 5.0. ont été corrigés (recherchez VB5FixListSP sur le site Web Knowledge Base à l'adresse suivante http://www.microsoft.com/kb/default.asp).

L'utilisation de Service Pack 2 avec votre version sous licence de Visual Basic vous permet de créer des contrôles et des documents ActiveX™ qui fonctionnent correctement avec des clients multithread comme Internet Explorer 4.0. Si vous possédez l'Édition Professionelle ou Entreprise de Visual Basic, vous pouvez également créer :

La seule caractéristique de Visual Basic 5.0 Service Pack 2 réside dans l'amélioration de la thread cloisonnée.

Ces notes de mise à jour contiennent des informations qui complètent la documentation de l'aide et des manuels en ligne de Microsoft® ; Visual Basic® 5.0. Pour plus d'informations, visitez le site Web de Microsoft Visual Basic à l'adresse suivante http://www.microsoft.com/france/vbasic/.

Table des matières

Modifications apportées à la thread cloisonnée

Sélection d'un modèle de thread pour votre projet
Limitations de la fonction de thread cloisonnée
Conversion des projets existants

Modifications apportées à la documentation Visual Basic 5.0

Modifications apportées à la section «Modèle d'ordonnancement de threads cloisonné dans Visual Basic»
Modifications apportées à la section «Création de DLL à thread sécurisées»
Modifications apportées à la section «Conception de composants Out-of-Process multithread»

Scénarios utilisateur

Contrôles à thread cloisonnée pour Internet Explorer 4.0
Création d'une DLL à thread sécurisée avec des feuilles
Création d'une application test multithread

Remarque au sujet du script sécurisé pour les contrôles ActiveX

Contenu

 

Modifications apportées à la thread cloisonnée

Les projets conçus avec Visual Basic 5.0 Service Pack 2 peuvent bénéficier de la thread cloisonnée, sans avoir à supprimer les éléments visuels tels que les feuilles et les contrôles. Les feuilles, UserControls, UserDocuments, et créateurs ActiveX conçus avec le Service Pack 2 disposent d'une thread sécurisée. Service Pack 2 comprend :

Remarque   Le code de support pour les créateurs ActiveX bénéficie maintenant d'une thread cloisonnée sécurisée ; Cependant cela ne garantit pas qu'un créateur particulier possède une thread sécurisée. Si vous travaillez avec un créateur tiers, vous devez vous en assurer auprès de votre revendeur.

Limitations dans l'Édition Création de contrôle, Version 5.0

Les parties de ce document uniquement consacrées à l'Édition Création de contrôle sont celles concernant les projets de contrôle ActiveX à thread sécurisée.

Si vous utilisez l'Édition Création de contrôle pour concevoir des contrôles ActiveX à thread cloisonnée, vous devez utiliser un client multithread comme Internet Explorer 4.0 pour tester le fonctionnement de vos contrôles multithread. Vous ne pouvez pas utiliser l'Édition Création de contrôle pour concevoir un client multithread test.

 

Sélection d'un modèle de thread pour votre projet

Service Pack 2 modifie les options dans le volet Général de la boîte de dialogue Propriétés du projet. Dès que vous utilisez Service Pack 2, l'option Mode d'exécution n'est plus associée avec le modèle de thread pour votre projet. Vous pouvez sélectionner un paramètre pour l'option Modèle de thread sans choisir Mode d'exécution.

Pour définir le modèle de thread pour un projet DLL ActiveX, Exe ActiveX ou Contrôle ActiveX

  1. Dans le menu Projet, cliquez sur Propriétés du<projet> pour ouvrir la boîte de dialogue Propriétés du projet.
  2. Dans le volet Général, sélectionnez les options dans la zone Modèle de thread.

Pour les projets DLL ActiveX et Contrôle ActiveX, vous pouvez sélectionner Thread cloisonnée ou Thread unique.

Pour les projets Exe ActiveX, vous pouvez soit préciser que chaque nouvel objet est créé à partir d'une nouvelle thread (Thread per Object), ou limiter votre composant à un nombre maximal de threads déterminé. Si le nombre maximal de threads est de un (1) il s'agit d'un projet monothread ; un nombre plus important donne un projet à threads cloisonnées.

Remarque   Lorsque vous modifiez le modèle de thread d'un projet existant, une erreur se produit s'il s'agit d'un projet utilisant des contrôles ActiveX monothread. Visual Basic ne permet pas d'utiliser des contrôles monothread dans les projets à threads cloisonnées, comme cela est indiqué dans la section Conversion des projets existants.

Remarque   Lorsque vous spécifiez Thread per Object (ou un nombre maximal de threads supérieur à un) pour un projet Exe ActiveX, seuls les objets créés en externe sont définis sur de nouvelles threads (voir la section «Conception de composants Out-of-Process multithread» dans les manuels en ligne). Les options Thread per Object et Nb max de thread ne sont pas disponibles pour les projets DLL ActiveX et Contrôle ActiveX car la création de thread est gérée par l'application client.

Important   Pour les utilisateurs des Éditions Professionnelle et Entreprise, la sélection de Thread per Object ou Nb max de threads est expliquée en détails dans la section «Conception de composants Out-of-Process multithread» des manuels en ligne.

Action du Service Pack 2 sur l'option Mode d'exécution

Service Pack 2 ne change pas le fonctionnement de l'option Mode d'exécution. Cette dernière vous permet toujours de créer des composants pouvant être exécutés sans intervention de la part de l'opérateur sur les serveurs de réseau. La seule modification apportée par Service Pack 2 réside dans le fait que la sélection de Mode d'exécution ne change pas le modèle de thread de votre composant.

 

Limitations de la fonction de thread cloisonnée

Les limitations suivantes concernent toutes les éditions de Visual Basic.

 

Conversion des projets existants

Dès que vous avez appliqué Visual Basic 5.0 Service Pack 2, vous pouvez ajouter une thread cloisonnée à vos projets existants en modifiant l'option Modèle de thread (voir Sélection d'un modèle de thread pour votre projet) et en recompilant le projet. C'est aussi simple que cela pour de nombreux projets.

Si un projet DLL ActiveX, Exe ActiveX ou Contrôle ActiveX utilise des contrôles avec des éléments monothread, il se produit une erreur lorsque vous essayez de transformer le modèle de thread en thread cloisonnée. En raison du nombre et de la gravité des problèmes causés par les contrôles ActiveX monothread pour les clients multithread, il est impossible de les utiliser dans des projets de composant AvtiveX avec Visual Basic.

Si votre projet utilise un contrôle monothread, contactez le revendeur pour savoir si une version à thread cloisonnée est disponible.

Utilisation forcée des contrôles monothread

Il est possible de tricher avec Visual Basic et d'utiliser un contrôle monothread dans un projet multithread. Il suffit de modifier le fichier .vbp manuellement. Ceci est fortement déconseillé. Voici certains des problèmes causés par les contrôles ActiveX monothread :

Important   Les contrôles monothread sont susceptibles de provoquer de tels problèmes dans n'importe quel composant multithread ou application conçu avec Visual Basic ou tout autre outil de développement.

Création de projets DLL ActiveX et Contrôle ActiveX

Les objets fournis par des composants in-process sont créés sur des threads client ; votre DLL ou OCX ne peut pas créer de threads seul. La première fois qu'un thread client crée une instance d'objet fourni par votre composant, une nouvelle cloison est définie pour cette thread, et votre procédure Sub Main s'exécute pour la nouvelle cloison. Tous les objets fournis par votre composant pour cette thread client résident dans la même cloison.

Si vous avez créé votre composant de manière à ce que toutes les instances d'une classe partagent quelques données globales en commun, celles-ci sont dorénavant partagées uniquement entre les objets se trouvant sur la même thread. Si vous disposez d'un code global qui permet l'accès à une base de données, cet accès se produira séparément maintenant sur chaque thread.

Supposez par exemple qu'un client multithread affiche une instance de votre contrôle Widget sur une feuille située sur une thread A, et deux autres instances sur une feuille située sur une thread B. Les instances de contrôle seront dans deux cloisons, chacune avec une copie de vos variables globales. La procédure Sub Main s'exécutera une fois pour chaque cloison. Les deux contrôles sur la thread B partageront l'état global, indépendamment de l'état global du contrôle sur la thread A.

D'autres considérations sur la conception sont développées dans les sections Modifications apportées à la section «Modèle d'ordonnancement de threads cloisonné dans Visual Basic» et Modifications apportées à la section «Création de DLL à thread sécurisées» dans ce document et les sections correspondantes des manuels en ligne Visual Basic 5.0.

Création des projets Exe ActiveX

Toutes les données globales (y compris les propriétés pour l'objet App) sont dupliquées pour chaque thread. Cela représente la différence la plus importante entre les composants monothread et à thread cloisonnée qui ne sont pas en cours d'exécution. La procédure Sub Main est alors exécutée chaque fois qu'une nouvelle thread est créée.

D'autres considérations sur les composants qui ne sont pas en cours d'exécution sont développées dans les sections Modifications apportées à la section «Modèle d'ordonnancement de threads cloisonné dans Visual Basic» et Modifications apportées à la section «Conception de composants Out-of-Process multithread» dans ce document et les sections correspondantes des manuels en ligne Visual Basic 5.0.

 

Modifications apportées à la documentation Visual Basic 5.0

Les rubriques suivantes présentent les modifications spécifiques apportées aux sections des manuels en ligne Visual Basic 5.0 :

Modifications apportées à la section «Modèle d'ordonnancement de threads cloisonné dans Visual Basic»
Modifications apportées à la section «Création de DLL à thread sécurisée»
Modifications apportées à la section «Conception de composants Out-of-Process multithread»

Si vous possédez les Éditions Professionnelle ou Entreprise de Visual Basic, vous pouvez trouver ces sections dans les manuels en ligne à partir du volet Sommaire :

Guide des composants outils
  Création de composants ActiveX
    Construction de composants de code
      Évolutivité et traitement multithread

Remarque   L'explorateur des Manuels en ligne n'est pas fourni avec l'Édition Création de contrôle. Les sections présentées ci-dessous ne figurent pas dans les parties de la documentation de Visual Basic 5.0 qui peuvent être téléchargées pour l'Édition Création de contrôle. Cependant, le matériel sur l'invariance et la conception de DLL à thread sécurisée apparaissant dans les deux sections suivantes est intéressant pour les utilisateurs de l'Édition Création de contrôle .

 

Modifications apportées à la section «Modèle d'ordonnancement de threads cloisonné dans Visual Basic»

La section des manuels en ligne explique comment Visual Basic conserve une copie séparée des données globales pour chaque thread. Un problème non mentionné dans les manuels en ligne se produit : la procédure Sub Main est exécutée pour chaque nouvelle cloison (pour chaque nouvelle thread, en fait). Il serait sinon impossible d'initialiser des données globales pour la thread. Pour plus d'informations, reportez-vous aux sections Modifications apportées à la section «Création de DLL à thread sécurisées» et Modifications apportées à la section «Conception de composants Out-of-Process multithread», plus bas.

Enploi des threads

Dorénavant, il n'est plus nécessaire d'appliquer l'option Mode d'exécution aux composants pour pour utiliser des threads cloisonnées. Le mode d'exécution est maintenant une option indépendante sur le volet Général de la boîte de dialogue Propriétés du projet. Pour plus d'informations à ce sujet, reportez-vous à la sectionSélection d'un modèle de thread pour votre projet, plus haut.

Invariance

Dans la première section, lorsque vous effectuez un appel inter-thread, la méthode est protégée contre la réécriture tant que la méthode n'est pas annulée (par DoEvents par exemple). Il est important de savoir qu'une méthode peut également être annulée en effectuant une méthode inter-thread ou interprocess seule ou en affichant une feuille.

 

Modifications apportées à la section «Création de DLL à thread sécurisée»

La section des manuels en ligne s'applique maintenant aussi bien aux projets Contrôle ActiveX qu'aux projets DLL ActiveX.

La procédure de création d'un projet DLL ActiveX à thread cloisonnée a changé. Pour plus d'informations, reportez-vous à la section Sélection d'un modèle de thread pour votre projet (plus haut). Il n'est plus nécessaire de supprimer toute interaction utilisateur (l'option Mode d'exécution) pour obtenir une DLL à thread cloisonnée.

Lorsque vous créez une instance d'une feuille durant l'exécution, Visual Basic suit les mêmes règles que pour d'autres objets privés : la nouvelle feuille est créée sur la thread où l'opérateur New est exécuté. Si vous définissez une feuille de manière implicite (en accédant à une propriété de feuille à l'aide d'une variable déclarée As New Form1), celle-ci est créée sur la thread où le code a été exécuté.

Remarque   L'ID prédéclaré (Form1, par exemple) constitue un cas spécial de création de feuille implicite, une variable de feuille globale cachée que Visual Basic conserve pour chaque classe de feuille. Visual Basic reproduit des données globales pour chaque cloison, par conséquent, il existe une Form1 pour chaque thread. Afin d'éviter toute confusion, il peut être utile de ne pas utiliser d'ID prédéclarés dans les composants à thread cloisonnée, en déclarant de manière explicite vos propres variables de feuille.

Remarque   La duplication de données globales signifie qu'une variable déclarée publique dans un module standard est globale uniquement pour la thread ; chaque thread possède une instance de la variable. Cela signifie également que les propriétés de l'objet App, telles que App.ThreadID, possèdent des instances séparées pour chaque thread.

A la différence des feuilles, les contrôles ActiveX sont des objets publiques qui peuvent être créés et utilisés par des feuilles client. Une instance de contrôle ActiveX réside toujours sur la même thread que la feuille client qui l'utilise.

Important   Dans une DLL à cloison, une nouvelle cloison est définie pour chaque thread client qui nécessite des objets fournis par la DLL. La procédure Sub Main s'exécute pour la nouvelle cloison lors de la première requête d'une thread client pour un tel objet. Une DLL n,a pas la possibilité de créer des threads à elle seule.

 

Modifications apportées à la section «Conception de composants Out-of-Process multithread»

Il n'est plus nécessaire de supprimer toute interaction utilisateur (l'option Mode d'exécution) pour obtenir un Exe multithread. Les descriptions de Thread per Object et Nb max de threads (thread circulaire) demeurent identiques.

Vous pouvez effectuer un projet Exe ActiveX à thread cloisonnée en cliquant sur l'onglet Général de la boîte de dialogue Propriétés du projet, puis en sélectionnant soit Thread per Object, soit Nb max de threads et en choisissant un nombre maximal de threads supérieur à un.

Tout comme les autres objets privés, les feuilles résident sur la thread où elles ont été créées. La fonction CreateObject ne permet pas de créer des objets privés, Ces derniers ne peuvent donc pas être utilisés pour démarrer de nouvelles threads.

Important   Dans un fichier exécutable multithread, la procédure Sub Main s'exécute indépendamment pour chaque nouvelle thread. Il est impossible de déterminer quelle thread a été créée en premier.

 

Scénarios utilisateur

Les scénarios dans lesquels vous pouvez utiliser des threads cloisonnées sont décrits dans les sections suivantes.

Contrôles à thread cloisonnée pour Internet Explorer 4.0
Création d'une DLL à thread sécurisée avec des feuilles
Création d'une application test multithread

 

Contrôles à thread cloisonnée pour Internet Explorer 4.0

Internet Explorer 4.0 affiche des fenêtres qui utilisent plusieurs threads d'exécution. Lorsque deux fenêtres distinctes affichent des instances sur le même contrôle ActiveX dans Internet Explorer 4.0, l'OCX doit fournir une instance pour chaque thread. Si les deux instances sont fournies à partir de la même cloison dans l'OCX (comme c'est le cas avec Visual Basic 5.0), le fonctionnement d'une des instances de contrôle ne sera pas optimal à cause du triage inter-thread.

En outre, des problèmes de focus, de tabulation et de touches d'accès rapide peuvent s'ajouter aux problèmes de fonctionnement lorsqu'un contrôle monothread est utilisé dans une application multithread.

La compilation de votre OCX avec Visual Basic Version 5.0 SP2 améliore les performances et supprime ces problèmes. Chaque instance de contrôle utilisée par Internet Explorer 4.0 s'exécute sur la même thread que la fenêtre qui affiche le contrôle, car l'OCX peut gérer une cloison distincte pour chaque thread client.

Mise à jour des contrôles ActiveX livrés avec Visual Basic

Visual Basic Version 5.0 SP2 comprend de nouvelles versions de la plupart des contrôles ActiveX livrés avec Visual Basic 5.0. Les contrôles mis à jour sont dorénavant à thread cloisonnée et fonctionnent aussi bien sur des clients monothread que sur des clients multithread. Les contrôles qui demeurent monothread sont DBGrid, MSChart et les contrôles légaux figurant dans le répertoire Outils pour Visual Basic 5.0.

Contrôles ActiveX conçus avec Visual Basic

Dès que vous avez appliqué Visual Basic Version 5.0 SP2, les nouveaux projets Contrôle ActiveX deviennent à thread cloisonnée par défaut. Vous pouvez ajouter des threads cloisonnées à un projet Contrôle ActiveX existant en modifiant le modèle de thread (voir Sélection d'un modèle de thread pour votre projet) et en recompilant le projet. Il vous suffit de suivre la même procédure pour de nombeux projets Contrôle ActiveX.

Si votre projet Contrôle ActiveX utilise des éléments de contrôle monothread, une erreur peut se produire en essayant de transformer le modèle de thread en thread cloisonnée. En raison du nombre et de la gravité des problèmes causés par les contrôles ActiveX monothread sur les clients multithread, Visual Basic ne permet pas de les utiliser comme éléments pour les contrôles ActiveX à thread cloisonnée. Pour plus d'informations, reportez-vous à la section Conversion des projets existants.

Si vous possédez des contrôles ActiveX qui utilisent des contrôles avec des éléments monothread, contactez le revendeur des contrôles monothread pour savoir si une version multithread est disponible.

Pour plus d'informations sur la conception des contrôles ActiveX à thread cloisonnée, reportez-vous à la section Conversion des projets existants.

 

Création d'une DLL à thread sécurisée avec des feuilles

Vous pouvez maintenant transformer le modèle de thread en thread cloisonnée dans des projets DLL ActiveX contenant des feuilles.

Les DLL à thread cloisonnée ne peuvent pas créer leurs propres threads ; une nouvelle cloison est créée (pour laquelle Sub Main s'exécute) à chaque première requête effectuée par une thread client pour un objet fourni par votre DLL. Tous les objets publiques requis par ce client résident dans la même cloison et partagent des données globales. Tous les objets privés (feuilles incluses) créés par les objets publiques résident également dans la cloison.

Les cloisons ne peuvent pas se reconnaître mutuellement avec Visual Basic. Cependant, un client multithread peut obtenir la référence d'un objet sur la Thread A et communiquer cette référence à un objet sur la Thread B. S'il est possible de réaliser cette opération avec votre DLL, reportez vous aux informations concernant l'invariance dans la section »Modèle d'ordonnancement de threads cloisonné dans Visual Basic» des manuels en ligne et dans la section Modifications apportées à la section «Modèle d'ordonnancement de threads cloisonnées dans Visual Basic» dans ce document.

Important   Les feuilles modales affichées par une thread ne bloquent pas l'exécution d'un code sur d'autres threads et ne sont pas modales pour les feuilles d'autres threads. L'affichage d'une feuille arrête l'exécution du contrôle, de la même manière que DoEvents. Le code doit alors éventuellement être entré à nouveau dans un objet.

 

Création d'une application test multithread

L'utilisation de Service Pack 2 avec les Éditions Professionnelle et Entreprise de Visual Basic vous permet de créer des applications test multithread pour vos contrôles multithread. Pour créer une application multithread simple, procédez comme suit :

  1. Ouvrez un nouveau projet EXE ActiveX, et attribuez le nom MainApp au module de classe par défaut. Affectez la valeur PublicNotCreatable à MainApp dans la propriété Instancing. Un objet MainApp occupe alors la première thread de l'application et affiche l'interface utilisateur principale.
  2. Dans le volet Général de la boîte de dialogue Propriétés du projet, sélectionnez Sub Main dans la zone Objet Startup, puis Thread per Object dans la zone Modèle de thread et entrez une valeur unique pour le nom du projet (nom de la bibliothèque type). Des problèmes risquent de se produire si deux applications possèdent le même nom de bibliothèque type. «ThreadDemo» est le nom de projet utilisé dans l'exemple présenté ci-dessous. Dans le volet Composant, sélectionnez Autonome dans la zone Mode de Démarrage.
  3. Ajoutez une feuille appelée frmProcess et attribuez la valeur False aux propriétés Visible et ControlBox. Cette feuille fonctionne comme une fenêtre cachée que Sub Main utilise pour identifier la thread principale pour le processus. Aucun code n'est nécessaire pour cette feuille.
  4. Ajoutez un module standard au projet. Placez les déclarations, la procédure Sub Main et la procédure EnumThreadWndMain qui apparaissent ci-dessous dans ce module. Sub Main s'exécute au démarrage de votre application (comme indiqué dans le texte d'accompagnement et dans les commentaires sur les codes) et chaque fois que vous créez une nouvelle thread. L'exemple de code de Sub Main permet d'identifier la première thread. Vous savez ainsi quand créer MainApp.
  5. Ajoutez une feuille et appelez-la frmMTMain. Cette feuille fournit l'interface utilisateur principale pour l'application test. Ajoutez-y la déclaration simple et l'événement Form_Unload juste au-dessus du titre «Instances Multiples de l'application Test».
  6. Dans la procédure événement Class_Initialize pour MainApp, ajoutez le code pour afficher frmMTMain. Ce code vous est indiqué plus bas.
  7. Pour créer des threads test supplémentaires, vous devez posséder au moins une classe dans votre projet avec la valeur MultiUse comme propriété Instancing. Ajoutez un module de classe et de feuille et insérez le code qui apparaît sous le titre «Création de nouvelles threads». Comme vous avez sélectionné Thread per Object pour ce projet, chaque objet publique qui est créé en externe démarre sur une nouvelle thread. Cela signifie que vous pouvez créer une nouvelle thread à l'aide de la fonction CreateObject pour établir une instance de votre classe MultiUse à partir de son ID de programmation (ProgID), comme indiqué dans le texte d'accompagnement.
  8. Ajoutez le code à frmMTMain pour créer de nouvelles threads en établissant des instances des classes MultiUse que vous avez définies. Dans l'exemple présenté plus bas, observez le code situé sous le titre «Création de nouvelles threads.»
  9. L'environnement de développement ne peut pas gérer le traitement multithread. Si vous appuyez sur la touche F5 pour exécuter le projet, tous les objets sont créés sur la même thread. Afin de tester le fonctionnement en mode multithread, vous devez compiler le projet EXE ActiveX et lancer le fichier exécutable que vous obtenez.

Important   Pour vous assurer que chaque nouvel objet MultiUse lance une nouvelle thread, vous devez utiliser l'option Thread per Object au lieu de l'option Nb max de threads.

Détermination du thread principal au cours de la procédure Sub Main

La procédure Sub Main est exécutée pour chaque nouvelle thread. En effet, Visual Basic crée et gère une copie indépendante de vos données globales pour chaque thread (ou cloison). Afin d'initialiser les données globales pour le thread, il est impératif d'exécuter la procédure Sub Main. Si celle-ci a pour effet de charger une feuille cachée ou d'afficher l'interface utilisateur principale de votre application, de nouvelles copies des feuilles seront automatiquement chargées pour chaque nouvelle thread que vous créez.

Le code suivant détermine si la procédure Sub Main est exécutée ou non dans la première thread, de façon à ce que vous puissiez charger la feuille cachée et afficher l'interface utilisateur principale de l'application test une seule fois.

' Valeur initiale de la légende de la fenêtre cachée
Public Const PROC_CAPTION = «FenêtreDémoThreadCloisonnée»

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

' Descripteur de fenêtre extrait par EnumThreadWindows.
Private mhwndVB As Long
' Feuille cachée servant à identifier la thread principale.
Private mfrmProcess As New frmProcess
' ID processus.
Private mlngProcessID As Long

Sub Main()
    Dim ma As MainApp

    ' Emprunte un descripteur de fenêtre pour obtenir le numéro d'identification
    '   (ID) du processus (voir le rappel EnumThreadWndMain ci-après).
    Call EnumThreadWindows(App.ThreadID, AddressOf EnumThreadWndMain, 0&)
    If mhwndVB = 0 Then
        Err.Raise ERR_InternalStartup + vbObjectError, , "Erreur interne de démarrage de la thread"
    Else
        Call GetWindowThreadProcessId(mhwndVB, mlngProcessID)
        ' Légende de la fenêtre cachée unique à cause de l'ID de processus.
        If 0 = FindWindow(vbNullString, PROC_CAPTION & CStr(mlngProcessID)) Then
            ' La fenêtre n'a pas été trouvée. Il s'agit donc de la première thread.
            If App.StartMode = vbSModeStandalone Then
                ' Création d'une feuille cachée possédant une légende unique.
                mfrmProcess.Caption = PROC_CAPTION & CStr(mlngProcessID)
                ' L'événement Initialize de MainApp (Instancing =
                '   PublicNotCreatable) affiche l'interface principale.
                Set ma = New MainApp
                ' (Il est plus facile d'arrêter l'application lorsqu'aucune
                '   référence globale à MainApp n'existe; MainApp doit
                '   transmettre Me à la feuille utilisateur principale pour que
                '   la feuille empêche l'arrêt de MainApp.)
            Else
                Err.Raise ERR_NoAutomation + vbObjectError, , _
                    "Impossible de lancer l'application avec Automation"
            End If
        End If
    End If
End Sub

' Fonction Call-back utilisée par EnumThreadWindows.
Public Function EnumThreadWndMain(ByVal hwnd As Long, ByVal lParam As Long) As Long
    ' Enregistrement du descripteur de fenêtre.
    mhwndVB = hwnd
    ' La première fenêtre est la seule nécessaire.
    ' Arrêt de l'itération dès qu'une fenêtre a été trouvée.
    EnumThreadWndMain = ENUM_STOP
End Function

' MainApp appelle cette sous-procédure dans son événement Terminate;
'   sinon, la feuille cachée empêche l'arrêt de 
'   l'application.
Public Sub FreeProcessWindow()
    Unload mfrmProcess
    Set mfrmProcess = Nothing
End Sub

Important   Il est possible que cette technique d'identification de la première thread ne soit pas adaptée aux prochaines versions de Visual Basic.

Vous pouvez remarquer que la procédure Sub Main n'effectue aucune action pour les threads définies après la première thread. Lorsque vous ajoutez du code permettant de créer des objets MultiUse (afin d'exécuter les threads suivantes), n'oubliez pas d'inclure les instructions nécessaires pour initialiser ces objets.

EnumThreadWindows est utilisé avec une fonction de rappel, EnumThreadWndMain, pour localiser l'une des fenêtres cachées que Visual Basic crée en vue d'un usage interne. Le descripteur de cette fenêtre cachée est transmis à GetWindowThreadProcessId qui retourne l'ID de processus. Cet ID sert à définir une légende unique pour la fenêtre cachée (frmProcess) chargée par la procédure Sub Main. Les threads suivantes détectent cette fenêtre et peuvent alors signaler qu'elles n'ont pas besoin de créer l'objet MainApp. Vous devez procéder de cette façon, car Visual Basic n'offre aucun moyen d'identifier la thread principale de l'application.

La classe MainApp, dans son événement Initialize, affiche la feuille principale de l'application test. MainApp doit transmettre sa référence Me à la feuille principale pour que celle-ci empêche l'arrêt de MainApp. Vous pouvez créer toutes les threads suivantes depuis l'interface utilisateur principale. En affectant la valeur PublicNotCreatable à la propriété Instancing de MainApp, vous évitez d'afficher deux feuilles d'interface utilisateur principale.

Voici un exemple simple de classe MainApp avec la feuille qui lui est associée (étapes 5 et 6 ci-dessus) :

' Code pour une 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()
    ' Nettoyage de la fenêtre cachée.
    Call FreeProcessWindow
End Sub

' Code pour la feuille frmMTMain.
Public MainApp As MainApp

Private Sub Form_Unload(Cancel As Integer)
    Call MainApp.Closing
    Set MainApp = Nothing
End Sub

Instances multiples de l'application test

Le fait d'insérer l'ID de processus dans la légende de la fenêtre cachée permet d'exécuter plusieurs exemplaires de l'application test sans aucune interférence.

Lorsque vous appelez CreateObject, l'instance de la classe publique que vous définissez apparaît sur une thread dans l'instance de l'application active. En effet, CreateObject essaie toujours de créer un objet dans l'application active avant de rechercher d'autres composants Exe en cours d'exécution susceptibles de fournir l'objet.

Propriétés utiles pour la cloison

Il est parfois interessant de définir l'ID de processus comme propriété en lecture seule du module contenant la procédure Sub Main :

'Code facultatif pour l'application test
Public Property Get ProcessID() As Long
    ProcessID = mlngProcessID
End Property

Cela permet aux objets sur la thread d'obtenir l'ID de processus en appelant la propriété ProcessID non qualifiée. Il peut vous sembler utile d'exposer une propriété IsMainThread booléenne de la même façon.

Définition de nouvelles threads

L'option Thread per Object permet de d'exécuter chaque objet public créé de façon externe (par l'intermédiaire de la fonction CreateObject) sur une nouvelle thread. Pour définir une nouvelle thread, il suffit d'utiliser l'ID de programmation (ProgID) de l'une de vos classes MultiUse :

'Code non inséré dans l'application test
Dim tw As ThreadedWindow
Set tw = CreateObject("ThreadDemo.ThreadedWindow")

La variable tw contient à présent une référence à un objet sur une nouvelle thread. Tous les appels aux propriétés et méthodes de cet objet effectués au moyen de la variable tw demandent un temps de traitement supplémentaire de triage inter-thread.

Remarque   Un objet créé avec l'opérateur New n'est pas défini sur une nouvelle thread. Il réside sur la thread à partir de laquelle l'opérateur New a été utilisé. Reportez-vous aux sections « Conception de composants Out-of-Process multithread » et « Fonctionnement de la création d'objets » dans les manuels en ligne de Visual Basic.

Pour éviter que MainApp ne s'arrête avant la fin de l'exécution de toutes les autres threads, affectez une propriété MainApp à chaque classe publique. Lorsqu'un objet crée un objet MultiUse sur une nouvelle thread, il a la possibilité de transmettre au nouvel objet, une référence à l'objet MainApp, au cours du processus d'initialisation. Vous pouvez également transmettre à MainApp une référence au nouvel objet, de façon à ce que MainApp contienne une collection des références à tous les objets contrôlant les threads. Rappelez-vous, cependant, que cela a pour effet de créer des références circulaires. Reportez-vous à la section «Gestion des références circulaires» dans les manuels en ligne.)

Pour définir une classe afin de contrôler une thread destinée à afficher une feuille, servez-vous d'une méthode Initialize (à ne pas confondre avec l'événement Initialize0) ou d'une méthode Show. Ne prévoyez pas d'afficher la feuille dans la procédure d'événement Class_Initialize, car vous risqueriez d'obtenir des erreurs de temporisation au moment de la création des instances de la classe. Voici un exemple très simple de code pour une classe MultiUse ThreadedWindow et sa feuille, frmThreadedWindow :

'Code pour une classe MultiUse ThreadedWindow.
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

'Code pour la feuille frmThreadedWindow.
Public ThreadedWindow As ThreadedWindow

Private Sub Form_Unload(Cancel As Integer)
    Call ThreadedWindow.Closing
    Set ThreadedWindow = Nothing
End Sub

La portion de code suivante montre comment initialiser l'objet ThreadedWindow :

'Code pour la feuille principale de l'application test (frmMTMain).
Private Sub mnuFileNewTW_Click()
    Dim tw As ThreadedWindow
    Set tw = CreateObject("ThreadDemo.ThreadedWindow")
    ' Demande au nouvel objet d'afficher sa feuille et
    '   de lui transmettre une référence à l'objet
    '   principal de l'application.
    Call tw.Initialize(Me.MainApp)
End Sub

Si vous disposez d'un certain nombre de classes pour contrôler les threads, vous pouvez définir un code plus générique en prévoyant une interface IApartment pour la méthode Initialize. Lorsque vous mettez en oeuvre une interface IApartment dans chaque classe, il est possible de fournir le code de méthode Initialize approprié pour cette classe. Voici à quoi pourrait ressembler le code de définition de la thread :

'Code non utile pour l'application test
Private Sub mnuFileNewObject_Click(Index As Integer)
    Dim iapt As IApartment
    Select Case Index
      Case otThreadedWindow
        Set iapt = CreateObject("ThreadDemo.ThreadedWindow")
      ' (autres case…)
    End Select
    ' Code commun pour initialiser les objets.
    Call iapt.Initialize(MainApp)
End Sub

Remarque  Il est possible de créer une interface IXxxxApartment connue uniquement de l'application multithread en définissant l'interface dans une bibliothèque de types indépendante. Dans le projet Exe ActiveX, créez une référence à la bibliothèque de types.

Préservation des références aux objets à thread

Pour vous assurer de l'arrêt correct d'une application multithread, vous devez conserver toutes les références aux objets MultiUse servant à créer et contrôler les threads.

Définissez avec précision vos objectifs en matière de durée de vie des objets. Prenons le cas, par exemple, d'un objet MultiUse destiné à afficher une feuille. Le moyen le plus simple pour gérer la durée de vie de l'objet est de faire en sorte que l'objet transmette à la feuille une référence Me. La feuille maintient alors l'objet en vie. Lorsque l'utilisateur ferme la feuille, l'événement Unload de la feuille doit alors se charger d'affecter la valeur Nothing (rien) à l'emsemble des références à l'objet MultiUse, pour permettre à l'objet de s'arrêter et de supprimer sa référence à la feuille. Il peut être utile d'affecter à l'objet MultiUse une méthode Friend permettant d'éliminer la référence à la feuille ainsi que toutes les autres références internes. L'événement Unload de la feuille a la possibilité de faire appel à cette méthode.

Si l'objet qui contrôle une thread crée d'autres objets sur la thread, assurez-vous, au moyen de l'opérateur New, de supprimer les références à ces objets. Il est impossible de fermer la thread tant que toutes les références aux objets crées sur la thread n'ont pas été éliminées. Les threads ouvertes monopolisent des ressources du système.

Impossibilité d'utiliser les méthodes Friend d'une Thread à l'autre

Etant donné que les propriétés et les méthodes Friend ne font pas partie de l'interface publique d'une classe, vous ne pouvez pas les appeler à partir d'une autre thread. Les appels inter-thread entre les objets sont limités aux propriétés et aux méthodes déclarées publiques.

Invariance

Si une méthode d'un objet arrête l'exécution d'un programme en faisant appel à DoEvents, en affichant une feuille modale ou en effectuant un appel secondaire à un objet sur une autre thread, un deuxième appelant peut alors insérer le code dans la méthode avant que prenne fin le premier appel. Si une telle méthode utilise ou modifie les valeurs de propriété ou les variables au niveau du module, l'état interne de l'objet risque d'être incorrect. Vous pouvez vous protéger contre les problèmes d'invariance en :

Tâches asynchrones

Visual Basic ne permet pas l'exécution en parallèle, c'est-à-dire de faire appel à une méthode sur une nouvelle thread et de reprendre immédiatement le traitement sur la thread d'origine. Vous pouvez, toutefois, simuler ce comportement dans votre application test en activant un compteur à partir de l'appel de méthode initial puis en recommençant immédiatement le traitement. Dès que l'événement de minuterie se produit, vous pouvez désactiver le compteur et procéder au traitement asynchrone. Cette technique est traitée dans la section « Rappels et événements asynchrones» des manuels en ligne et est démontrée dans les manuels en ligne (voir «Création d'un composant Exe ActiveX») et dans l'exemple d'application Coffee.

Utilisation de l'application test multithread

N'oubliez pas de compiler l'application test multithread de manière à vérifier le fonctionnement du composant à thread cloisonnée, car l'environnement de développement Visual Basic ne gère pas actuellement plusieurs threads d'exécution. Si vous possédez Visual Studio, il peut être utile de compiler l'application test avec des informations spéciales pour le débogage du code natif. Cela vous permettra d'utiliser le programme de débogage de Visual Studio.

 

Remarque au sujet du script sécurisé pour les contrôles ActiveX

Deux des contrôles à thread cloisonnée fournis avec Visual Basic Version 5.0 SP2, le contrôle Common Dialog et le contrôle Toolbar, sont compatibles maintenant avec l'interface ActiveX IObjectSafety. Lorsque vous utilisez ces contrôles dans un environnement où le script sécurisé est en vigueur (comme Internet Explorer), ils seront sécurisés pour le script et marqués comme tel. Toutefois, certaines fonctions de ces contrôles seront désactivées pour qu'il soit possible de les sécuriser pour le script :

 

Contenu

Les fichiers suivants font partie de Visual Basic Version 5.0 SP2: 

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
readme.wri
dtctrace.dll
mscdrun.dll
mscdrun.dep
mscondes.dll
cmctlfr.dll
cmdlgfr.dll
flxgdfr.dll
msprpfr.dll
vb5fr.dll