Anmerkungen zu dieser Version von Microsoft Visual Basic 5.0 Service Pack 2

 

© 1996-1997 Microsoft Corporation

Visual Basic 5.0 Service Pack 2 ist ein Update zu Visual Basic Professional, Enterprise und Control Creation Edition. Es unterstützt das Threading nach dem Apartment-Modell für Visual Basic-Projekte, die Benutzeroberflächenelemente, wie z.B. Formulare und Steuerelemente, enthalten. Es behebt auch mehrere Programmfehler, die in Visual Basic 5.0 aufgetreten sind. (Suchen Sie auf der Website der Knowledge Base unter http://www.microsoft.com/kb/default.asp) nach VB5FixListSP.)

Durch die Verwendung von Visual Basic 5.0 Service Pack 2 mit Ihrer lizenzierten Kopie von Visual Basic können Sie ActiveX&trade-Steuerelemente und -Dokumente erstellen, die in Multithread-Clients wie dem Internet Explorer 4.0 gut funktionieren. Wenn Sie die Professional oder Enterprise Edition von Visual Basic verwenden, können Sie außerdem folgende Elemente erstellen:

Diese Erweiterung auf das Threading nach dem Apartment-Modell ist das einzige Funktionsmerkmal von Visual Basic 5.0 Service Pack 2.

Diese Anmerkungen enthalten Informationen, die die Hilfe und Online-Dokumentation zu Microsoft® Visual Basic™ 5.0 ergänzen. Weitere Informationen finden Sie auf der Microsoft Visual Basic Website unter http://www.microsoft.com/vbasic/.

Inhaltsverzeichnis

Überblick über die Änderungen am Threading nach dem Apartment-Modell

Auswählen eines Threading-Modells für Ihr Projekt
Einschränkungen beim Threading nach dem Apartment-Modell
Konvertieren vorhandener Projekte

Änderungen in der Visual Basic 5.0-Dokumentation

Änderungen in "Threading nach dem Apartment-Modell in Visual Basic"
Änderungen in "Entwerfen von Thread-sicheren DLLs"
Änderungen in "Entwerfen von prozeßexternen Multithread-Komponenten"

Einsatzszenarien

Steuerelemente mit Threading nach dem Apartment-Modell für Internet Explorer 4.0
Erstellen einer thread-sicheren DLL mit Formularen
Erstellen einer Multithread-Testanwendung

Ein Hinweis zur sicheren Skriptenerstellung für ActiveX-Steuerelemente

Liste zum Inhalt des Pakets

 

Überblick über die Änderungen am Threading nach dem Apartment-Modell

Mit Visual Basic 5.0 Service Pack 2 verfaßte Projekte können Threading nach dem Apartment-Modell nutzen, ohne auf visuelle Elemente wie z.B. Formulare und Steuerelemente zu verzichten. Durch die Ausführung des Visual Basic 5.0 Service Pack 2 können Formulare, benutzerdefinierte Steuerelemente, benutzerdefinierte Dokumente und ActiveX-Designer sicher auf Threads (thread-sicher) ausgeführt werden. Das Visual Basic 5.0 Service Pack 2 enthält:

Anmerkung   Der Unterstützungs-Code für ActiveX-Designer kann jetzt sicher auf Threads im Apartment-Modell ausgeführt werden. Dies ist aber keine Garantie dafür, daß ein bestimmter Designer thread-sicher ist. Wenn Sie einen Designer eines Drittherstellers verwenden, müssen Sie beim Händler nachfragen.

Einschränkungen der Control Creation Edition, Version 5.0

Nur die Teile dieses Dokuments, die sich auf thread-sichere ActiveX-Steuerelementprojekte auswirken, beziehen sich auf die Control Creation Edition.

Wenn Sie die Control Creation Edition zum Erstellen von ActiveX-Steuerelementen mit Threading nach dem Apartment-Modell verwenden, müssen Sie zum Testen des Verhaltens solcher Steuerelemente einen Multithread-Client wie z.B. Internet Explorer 4.0 verwenden. Mit der Control Creation Edition können keine Test-Clients erstellt werden, die Multithreading unterstützen.

 

Auswählen eines Threading-Modells für Ihr Projekt

Visual Basic 5.0 Service Pack 2 ändert die Optionen auf der Registerkarte Allgemein des Dialogfeldes Projekteigenschaften. Nach der Ausführung des Visual Basic 5.0 Service Pack 2 ist die Option Unbeaufsichtigte Ausführung nicht mehr mit dem Threading-Modell Ihres Projekts gekoppelt. Sie können jetzt für das Threading-Modell eine Einstellung wählen, ohne das Projekt für Unbeaufsichtigte Ausführung zu markieren.

So legen Sie ein Threading-Modell für ein ActiveX-DLL-, ActiveX-Exe- oder ActiveX-Steuerelementprojekt fest

  1. Klicken Sie im Menü Projekt auf Eigenschaften von <Projekt>, um das Dialogfeld Projekteigenschaften zu öffnen.
  2. Wählen Sie auf der Registerkarte Allgemein die gewünschten Optionen im Feld für das Threading-Modell.

Für ActiveX-DLL- und ActiveX-Steuerelementprojekte können Sie Apartment-threaded oder Single-threaded wählen..

Für ActiveX-Exe-Projekte können Sie entweder festlegen, daß jedes neu erstellte Objekt als neuer Thread (Thread pro Objekt) erstellt wird, oder Ihre Komponente auf einen festen Pool von Threads beschränken. Durch eine Thread-Pool-Größe von eins (1) wird das Projekt zu einem Projekt mit einem Thread; durch einen größeren Pool zu einem Projekt mit Threading nach dem Apartment-Modell.

Anmerkung   WWenn Sie das Threading-Modell für ein existierendes Projekt ändern, tritt ein Fehler auf, wenn das Projekt ActiveX-Steuerelemente mit einem Thread verwendet. Visual Basic verhindert die Verwendung von Steuerelementen mit einem Thread in Projekten mit Threading nach dem Apartment-Modell (siehe dazu Konvertieren vorhandener Projekte).

Anmerkung   Wenn Sie für ein ActiveX-Exe-Projekt Thread pro Objekt (oder einen Thread-Pool größer als 1) festlegen, werden auf neuen Threads nur externe Objekte erstellt. (Siehe Entwerfen von prozeßexternen Multithread-Komponenten in der Online-Dokumentation.) Thread pro Objekt und Thread Pool stehen für ActiveX-DLL- und ActiveX-Steuerelementprojekte nicht zur Verfügung, weil die Thread-Erstellung von der Client-Anwendung gesteuert wird.

Wichtig   Für Benutzer der Professional und Enterprise Edition werden die Auswirkungen der Auswahl von Thread pro Objekt und Thread Pool ausführlich in Entwerfen von prozeßexternen Multithread-Komponenten in der Online-Dokumentation erläutert.

Visual Basic 5.0 Service Pack 2 und unbeaufsichtigte Ausführung

Visual Basic 5.0 Service Pack 2 ändert die Funktionsweise der Option Unbeaufsichtigte Ausführung nicht. Unbeaufsichtigte Ausführung ermöglicht auch weiterhin die Erstellung von Komponenten, die auf Netzwerk-Servern ohne Operatoreingriff ausgeführt werden können. Die einzige von Visual Basic 5.0 Service Pack 2 vorgenommene Änderung besteht darin, daß sich die Auswahl von Unbeaufsichtigte Ausführung nicht auf das Threading-Modell Ihrer Komponente auswirkt.

 

Einschränkungen beim Threading nach dem Apartment-Modell

Die folgenden Einschränkungen gelten für alle Editionen von Visual Basic.

 

Konvertieren vorhandener Projekte

Nachdem Sie Visual Basic 5.0 Service Pack 2 angewandt haben, können Sie Ihren existierenden Projekten Apartment-Threading hinzufügen, indem Sie die Option für das Threading-Modell wie unter Auswählen eines Threading-Modells für Ihr Projekt beschrieben ändern und das Projekt neu kompilieren. Bei vielen Projekten brauchen Sie sonst nichts zu tun.

Wenn ein existierendes ActiveX-DLL-, ActiveX-EXE- oder ActiveX-Steuerelementprojekt konstituierende Steuerelemente mit einem Thread verwendet, führt das Ändern von des Threading-Modells zu Apartment-threaded zu einem Fehler. Aufgrund des häufigen Auftretens und der Schwere von Problemen, die ActiveX-Steuerelementen mit einem Thread für Multithread-Clients verursachen, gestattet Visual Basic ihre Verwendung in ActiveX-Komponentenprojekten nicht.

Wenn ein existierendes Projekt ein Steuerelement mit einem Thread verwendet, wenden Sie sich an den Hersteller, um herauszufinden, ob eine Version mit Threading nach dem Apartment-Modell erhältlich ist.

Erzwingen des Einsatzes von Steuerelementen mit einem einzelnen Thread

Durch Bearbeiten der .vbp-Datei können Sie veranlassen, daß Visual Basic in einem Projekt mit Threading nach dem Apartment-Modell ein Steuerelement mit einem einzelnen Thread verwendet. Dies sollten Sie allerdings unterlassen. Bei ActiveX-Steuerelementen mit einem Thread kann es zu folgenden Fehlern kommen:

Wichtig   Steuerelemente mit einem Thread können diese und andere Probleme in beliebigen Multithread-Komponenten oder Anwendungen, die Sie unter Verwendung von Visual Basic oder einem anderen Entwicklungsprogramm erstellen, verursachen.

Design-Überlegungen für Projekte zum Erstellen von ActiveX-DLLs und ActiveX-Steuerelementen

Von prozeßinternen Komponenten zur Verfügung gestellte Objekte werden auf Client-Threads erstellt. Eine von Ihnen erstellte DLL- oder OCX-Datei kann keine eigenen Threads erstellen. Wenn ein Client-Thread zum erstenmal eine Instanz eines von Ihrer Komponente bereitgestellten Objekts erstellt, wird für diesen Thread ein neues "Apartment" erstellt, und Ihre Sub Main wird für dieses Apartment ausgeführt. Alle Objekte, die Ihre Komponente für diesen Client-Thread zur Verfügung stellt, befinden sich im gleichen Apartment.

Wenn Sie Ihre Komponenten so entworfen haben, daß alle Instanzen einer Klasse einige häufige globale Daten gemeinsam nutzen, werden die Daten jetzt nur von den Objekten auf dem gleichen Thread gemeinsam benutzt. Wenn es globalen Code gibt, der auf eine Datenbank zugreift, findet der Zugriff jetzt auf jedem Thread separat statt.

Angenommen, ein Multithread-Client zeigt eine Instanz Ihres Widget-Steuerlements auf einem Formular auf Thread A und zwei weitere Instanzen auf einem Formular auf Thread B. Die Steuerelementinstanzen befinden sich dann in zwei Apartments, wobei jedes eine Kopie Ihrer globalen Variablen enthält. Sub Main wird pro Apartment einmal ausgeführt. Die beiden Steuerelemente auf Thread B haben einen gemeinsamen globalen Zustand, während das Steuerelement in Thread A einen anderen globalen Zustand hat.

Weitere Design-Überlegungen werden unter Änderungen in "Threading nach dem Apartment-Modell in Visual Basic" und Änderungen in "Entwerfen von Thread-sicheren DLLs" in diesem Dokument und in den entsprechenden Themen der Online-Dokumentation von Visual Basic 5.0 erläutert.

Design-Überlegungen für ActiveX-EXE-Projekte

Der wichtigste Unterschied zwischen Komponenten mit einem Thread und prozeßexternen Komponenten mit Threading nach dem Apartment-Modell besteht darin, daß alle globalen Daten (einschließlich der Eigenschaften des App-Objekts) für jeden Thread repliziert werden. Dies hat u.a. zur Folge, daß Sub Main jedesmal ausgeführt wird, wenn ein neuer Thread erstellt wird.

Andere Design-Überlegungen für prozeßexterne Komponenten werden unter Änderungen in "Threading nach dem Apartment-Modell in Visual Basic" und Änderungen in "Entwerfen von prozeßexternen Multithread-Komponenten" in diesem Dokument und in den entsprechenden Themen der Online-Dokumentation von Visual Basic 5.0 erläutert.

 

Änderungen in der Visual Basic 5.0-Dokumentation

Die folgenden Themen beschreiben spezifische Änderungen in den angegebenen Themen in der Online-Dokumentation von Visual Basic 5.0:

Änderungen in "Threading nach dem Apartment-Modell in Visual Basic"
Änderungen in "Entwerfen von Thread-sicheren DLLs"
Änderungen in "Entwerfen von prozeßexternen Multithread-Komponenten"

Wenn Sie die Professional oder Enterprise Edition von Visual Basic verwenden, können Sie diese Themen mit Hilfe des Inhaltsfensters der Online-Dokumentation finden:

Handbuch zur KomponentenentwicklungComponent Tools Guide
  Erstellen von ActiveX-Komponenten
    Erstellen von Code-Komponenten
      Skalierbarkeit und Multithreading

Anmerkung   In der Control Creation Edition gibt es für die Online-Dokumentation keinen Browser. Die oben aufgeführten Themen sind nicht in den Teilen der Visual Basic 5.0-Dokumentation enthalten, die zur Verwendung mit der Control Creation Edition heruntergeladen werden können. Das in den folgenden beiden Themen enthaltene Material über den Wiedereintritt (Reentrancy) und das Entwerfen thread-sicherer DLLs ist aber für Benutzer der Control Creation Edition interessant.

 

Änderungen in "Threading nach dem Apartment-Modell in Visual Basic"

Im Originalthema in der Online-Dokumentation wird erklärt, daß Visual Basic für jeden Thread eine separate Kopie von globalen Daten verwaltet. Dies hat den (in der Online-Dokumentation nicht erwähnten) Nebeneffekt, daß Sub Main für jedes neue Apartment (d.h. für jeden neuen Thread) ausgeführt wird. Andernfalls könnten die globalen Daten für den Thread nicht initialisiert werden. Dies wird weiter unten unter Änderungen in "Entwerfen von Thread-sicheren DLLs" und Änderungen in "Entwerfen von prozeßexternen Multithread-Komponenten", erläutert.

Wo Sie Threading verwenden können

Es trifft nicht mehr zu, daß Komponenten für die Unbeaufsichtigte Ausführung markiert werden müssen, damit Apartment-Threading verwendet werden kann. Unbeaufsichtigte Ausführung stellt jetzt auf der Registerkarte Allgemein des Dialogfeldes Projekteigenschaften eine separate Option dar (siehe Auswählen eines Threading-Modells für Ihr Projekt, weiter oben).

Wiedereintritt

Laut Originalthema wird bei der Durchführung eines thread-übergreifenden Aufrufs verhindert, daß die aufgerufene Methode nochmals ausgeführt wird, solange die Methode die Steuerung nicht wieder abgibt (z.B. durch Aufrufen von DoEvents). Beachten Sie bitte, daß eine Methode die Steuerung auch abgeben kann, indem sie einen eigenen thread- oder prozeßübergreifenden Methodenaufruf ausführt oder ein Formular anzeigt.

 

Änderungen in "Entwerfen von Thread-sicheren DLLs"

Das Thema der Online-Dokumentation gilt jetzt sowohl für ActiveX-Steuerelemente als auch für ActiveX-DLL-Projekte.

Die Prozedur, mit der ein ActiveX-DLL-Projekt mit Threading nach dem Apartment-Modell ausgeführt wird, hat sich geändert (siehe Auswählen eines Threading-Modells für Ihr Projekt weiter oben). Es ist nicht mehr notwendig, alle Benutzerinteraktionen zu unterdrücken (mit der Option Unbeaufsichtigte Ausführung), um eine DLL mit Threading nach dem Apartment-Modell zu erstellen.

Wenn Sie zur Laufzeit eine Instanz eines Formulars erstellt haben, befolgt Visual Basic die gleichen Regeln, die auch für andere private Objekte verwendet werden, d.h. das neue Formular wird auf dem Thread an der Stelle erstellt, an der New-Operator ausgeführt wird. Wenn Sie ein Formular implizit erstellen (z.B. durch Zugreifen auf eine Formulareigenschaft unter Verwendung einer Variablen, die als As New Form1 deklariert wurde), wird das Formular an der Stelle auf dem Thread erstellt, an der der Code ausgeführt wurde.

Amerkung   Ein Sonderfall der implizierten Formulare besteht in der vordeklarierten ID (z.B. Form1), einer verborgenen, globalen Formularvariablen, die Visual Basic für jede Formularklasse verwaltet. Da Visual Basic globale Daten für jedes Apartment dupliziert, gibt es für jeden Thread ein separates Form1. Um Verwirrung zu vermeiden, kann es hilfreich sein, die Verwendung vordeklarierter IDs in Komponenten mit Threading nach dem Apartment-Modell zu vermeiden, indem Sie Ihre eigenen Formularvariablen ausdrücklich deklarieren.

Anmerkung   Duplizierte globale Daten bedeuten, daß eine als öffentlich deklarierte Variable in einem Standardmodul nur für den Thread global ist, d.h. jeder Thread hat eine Instanz der Variablen. Dies bedeutet auch, daß die Eigenschaften des App-Objekts, z.B. App.ThreadID, für jeden Thread separate Instanzen haben.

Im Gegensatz zu Formularen handelt es sich bei ActiveX-Steuerelementen um öffentliche Objekte, die von Client-Formularen erstellt und verwendet werden können. Eine Instanz eines ActiveX-Steuerelements befindet sich immer auf dem gleichen Thread wie das Client-Formular, von dem sie verwendet wird.

Wichtig   Bei einer Apartment-Modell-DLL wird für jeden Client-Thread, der von der DLL zur Verfügung gestellte Objekte anfordert, ein neues Apartment erstellt. Wenn ein Client zum ersten Mal ein solches Objekt anfordert, wird Sub Main für das neue Apartment ausgeführt. Eine DLL kann keine eigenen Threads erstellen.

 

Änderungen in "Entwerfen von prozeßexternen Multithread-Komponenten"

Das Unterdrücken jeglichen Benutzereingriffs (durch die Option Unbeaufsichtigte Ausführung) ist nicht länger notwendig, um eine Multithread-Exe zu erstellen. Die Beschreibungen von Thread pro Objekt und Round-Robin Thread Pool bleiben gleich.

Sie können ein ActiveX-Exe-Projekt mit Threading nach dem Apartment-Modell erstellen, indem Sie die Registerkarte Allgemein des Dialogfeldes Projekteigenschaften öffnen und entweder Thread pro Objekt oder Thread Pool wählen und eine Pool-Größe größer als 1 festlegen.

Wie andere private Objekte residieren Formulare auf dem Thread, auf dem sie erstellt wurden. Private Objekte können nicht mit der CreateObject-Funktion erstellt werden, d.h. sie können nicht zum Starten neuer Threads verwendet werden.

Wichtig   In einer Multithread-Exe wird Sub Main für jeden neuen Thread unabhängig ausgeführt. In Visual Basic gibt es keine Möglichkeit festzustellen, welcher Thread zuerst erstellt wurde.

 

Einsatzszenarien

Die folgenden Themen beschreiben Szenarien, in denen es sinnvoll sein kann, Threading nach dem Apartment-Modell zu verwenden.

Steuerelemente mit Threading nach dem Apartment-Modell für Internet Explorer 4.0
Erstellen einer thread-sicheren DLL mit Formularen
Erstellen einer Multithread-Testanwendung

 

Steuerelemente mit Threading nach dem Apartment-Modell für Internet Explorer 4.0

Internet Explorer 4.0 zeigt Fenster unter Verwendung mehrerer Ausführungs-Threads an. Wenn zwei unterschiedliche Fenster in Internet Explorer 4.0 Instanzen des gleichen ActiveX-Steuerelements anzeigen, muß das OCX für jeden Thread eine Instanz bereitstellen. Wenn beide Instanzen vom gleichen Apartment im OCX (wie das bei Visual Basic 5.0 der Fall ist) bereitgestellt werden, kommt es bei einer Steuerelementinstanz aufgrund des thread-übergreifenden Marshaling zu einer Leistungsverminderung.

Neben der Leistungsverminderung kann ein Steuerelement mit einem Thread bei der Verwendung in einer Multithread-Anwendung Probleme mit dem Fokus, dem Einsatz der Tabulatortaste und den Zugriffstasten verursachen.

Durch Kompilieren Ihres OCX mit Visual Basic 5.0 Service Pack 2 werden die Leistung verbessert und diese Probleme beseitigt. Jede vom Internet Explorer 4.0 verwendete Steuerelementinstanz wird auf dem gleichen Thread ausgeführt wie das Fenster, in dem das Steuerelement angezeigt wird, da das OCX für jeden Client-Thread ein separates Apartment unterstützen kann.

Die meisten zum Lieferumfang von Visual Basic gehörenden ActiveX-Steuerelemente wurden aktualisiert

Visual Basic 5.0 Service Pack 2 enthält neue Versionen der meisten zum Lieferumfang von Visual Basic 5.0 gehörenden ActiveX-Steuerelemente. Die aktualisierten Steuerelemente folgen jetzt dem Threading nach dem Apartment-Modell und funktionieren bei Clients mit einem Thread oder bei Multithread-Clients gleich gut. Folgende Steuerelemente haben auch weiterhin einen Thread: DBTabelle (DBGrid), MSChart sowie die alten Steuerelemente, die im Verzeichnis Tools von Visual Basic 5.0 enthalten sind.

Mit Visual Basic verfaßte ActiveX-Steuerelemente

Nach der Installation von Visual Basic 5.0 Service Pack 2 verwenden neue ActiveX-Steuerelementprojekte automatisch das Threading nach dem Apartment-Modell. Sie können ein existierendes ActiveX-Steuerelementprojekt auf das Threading nach dem Apartment-Modell umstellen, indem Sie das Threading-Modell wie unter Auswählen eines Threading-Modells für Ihr Projekt beschrieben ändern und das Projekt neu kompilieren. Bei vielen ActiveX-Steuerelementprojekten brauchen Sie nichts weiter zu tun.

Wenn Ihr ActiveX-Steuerelementprojekt konstituierende Steuerelemente mit einem Thread verwendet, führt der Versuch, das Threading-Modell zu Apartment-threaded zu ändern, zu einem Fehler. Aufgrund des häufigen Auftretens und der Schwere von Problemen, die von ActiveX-Steuerelementen mit einem Thread in Multithread-Clients verursacht werden, gestattet Visual Basic ihre Verwendung als Bestandteile von ActiveX-Komponenten mit Threading nach dem Apartment-Modell nicht. Siehe dazu Konvertieren vorhandener Projekte.

Wenn vorhandene ActiveX-Steuerelemente konstituierende Steuerelemente mit einem Thread verwenden, wenden Sie sich an den Hersteller des Steuerelements mit einem Thread, um herauszufinden, ob eine Version mit Threading nach dem Apartment-Modell erhältlich ist.

Weitere Design-Überlegungen für ActiveX-Steuerelemente mit Threading nach dem Apartment-Modell werden unter Konvertieren vorhandener Projekteerläutert.

 

Erstellen einer thread-sicheren DLL mit Formularen

Die Option Thread Modell kann jetzt in ActiveX-DLL-Projekten, die Formulare enthalten, auf Apartment-threaded eingestellt werden.

DLLs mit Threading nach dem Apartment-Modell können keine eigenen Threads erstellen. Wenn ein Client-Thread zum erstenmal ein von Ihrer DLL zur Verfügung gestelltes Objekt anfordert, wird ein neues Apartment erstellt und Sub Main für dieses Apartment ausgeführt. Alle von diesem Client angeforderten öffentlichen Objekte befinden sich im gleichen Apartment und verwenden globale Daten gemeinsam. Private Objekte (einschließlich Formulare), die von den öffentlichen Objekten erstellt werden, befinden sich ebenfalls in dem Apartment.

Visual Basic bietet keine Möglichkeit, Apartments aufeinander aufmerksam zu machen. Ein Multithread-Client könnte aber einen Verweis auf ein Objekt auf Thread A erhalten und diesen Verweis an ein Objekt auf Thread B weitergeben. Wenn Ihre DLL dies gestattet, sollten Sie die Informationen zum Wiedereintritt unter Threading nach dem Apartment-Modell in Visual Basic in der Online-Dokumentation und unter Änderungen in "Threading nach dem Apartment-Modell in Visual Basic" in diesem Dokument lesen.

Wichtig   Von einem Thread angezeigte gebundene Formulare blockieren die Ausführung von Code auf anderen Threads nicht und sind für Formulare auf anderen Threads nicht gebunden. Durch das Anzeigen eines Formulars wird ebenso wie durch das Aufrufen von DoEvents die Steuerung abgegeben, was zur Folge haben kann, daß der Code in einem Objekt nochmals ausgeführt wird.

 

Erstellen einer Multithread-Testanwendung

Das Installieren von Visual Basic 5.0 Service Pack 2 für die Professional und Enterprise Edition von Visual Basic ermöglicht die Erstellung von Multithread-Testanweisungen zum Ausführen Ihrer Multithread-Steuerelemente. Zum Erstellen einer einfachen Multithread-Anwendung sind folgende Schritte erforderlich:

  1. Öffnen Sie ein neues ActiveX-EXE-Projekt, und nennen Sie das Standard-Klassenmodul MainApp. Setzen Sie die Instancing-Eigenschaft für MainApp auf PublicNotCreatable. Ein MainApp-Objekt nimmt den ersten Thread der Anwendung ein und zeigt die Hauptbenutzeroberfläche an.
  2. Wählen Sie im Dialogfeld Projekteigenschaften auf der Registerkarte Allgemein im Feld Startobjekt den Eintrag Sub Main, wählen Sie dann im Bereich für das Threading-Modell Thread pro Objekt, und geben Sie einen eindeutigen Wert für den Projektnamen ein. (Projektname bestimmt den Namen der Klassenbibliothek. Wenn zwei Anwendungen den gleichen Klassenbibliotheksnamen haben, können Probleme auftreten.) Im folgenden Beispiel wird der Projektname "ThreadDemo" verwendet. Wählen Sie auf der Registerkarte Komponente im Feld Startmodus die Option Eigenständig.
  3. Fügen Sie ein Formular hinzu, nennen Sie es "frmProcess", und setzen Sie die Eigenschaften Visible und ControlBox auf False. Dieses Formular funktioniert als verborgenes Fenster, das Sub Main zum Identifizieren des Haupt-Threads des Prozesses verwendet. Für dieses Formular wird kein Code benötigt.
  4. Fügen Sie dem Projekt ein Standardmodul hinzu, und fügen Sie die Deklarationen, die Sub Main-Prozedur und die unten gezeigte EnumThreadWndMain-Prozedur in das Modul ein. Wie in den zugehörigen Text- und Code-Kommentaren erklärt, wird Sub Main beim Starten Ihrer Anwendung und beim Erstellen eines neuen Threads ausgeführt. Der Sub Main-Beispiel-Code zeigt, wie Sie den ersten Thread identifizieren, damit Sie wissen, wann MainApp erstellt werden muß.
  5. Fügen Sie ein Formular hinzu, und nennen Sie es "frmMTMain". Dieses Formular stellt die Hauptbenutzeroberfläche der Testanwendung zur Verfügung. Fügen Sie ihm die einzelne Deklaration und das Form_Unload-Ereignis hinzu, die/das weiter unten unmittelbar oberhalb der Überschrift "Mehrere Instanzen der Testanwendung" aufgeführt sind.
  6. Fügen Sie in der Class_Initialize-Ereignisprozedur für MainApp Code hinzu, um frmMTMain anzuzeigen. Den dazu notwendigen Code finden Sie weiter unten.
  7. Um weitere Test-Threads zu erstellen, muß es in Ihrem Projekt mindestens eine Klasse geben, deren Instancing-Eigenschaft auf MultiUse eingestellt ist. Fügen Sie ein Klassenmodul und ein Formular hinzu sowie den unter der Überschrift "Erstellen neuer Threads" angegebenen Code. Da Sie für dieses Projekt Thread pro Objekt aktiviert haben, wird jedes extern erstellte öffentliche Objekt auf einem neuen Thread gestartet, d.h. Sie können mit Hilfe der CreateObject-Funktion einen neuen Thread erstellen, um wie im zugehörigen Text erläutert eine Instanz der MultiUse-Klasse aus der Ressource-ID (ProgID), zu erstellen.
  8. Fügen Sie frmMTMain Code hinzu, um neue Threads durch Erstellen von Instanzen der von Ihnen definierten MultiUse-Klassen zu erstellen. Im untenstehenden Beispiel wird der Code unter der Überschrift "Erstellen neuer Threads" angezeigt.
  9. Multithreading wird in der Entwicklungsumgebung nicht unterstützt. Wenn Sie zum Ausführen des Projekts F5 drücken, werden alle Objekte auf dem gleichen Thread erstellt. Um das Multithread-Verhalten zu testen, müssen Sie das ActiveX-EXE-Projekt kompilieren und die resultierende ausführbare Datei ausführen.

Wichtig   Um sicherzustellen, daß jedes neue MultiUse-Objekt einen neuen Thread startet, müssen Sie Thread pro Objekt statt Thread Pool verwenden.

Bestimmen des Haupt-Threads während der Ausführung von Sub Main

Sub Main wird für jeden neuen Thread ausgeführt. Grund dafür ist, daß Visual Basic für jeden Thread (jedes Apartment) eine separate Kopie Ihrer globalen Daten verwaltet. Um globale Daten für den Thread zu initialisieren, muß Sub Main ausgeführt werden, d.h. wenn Ihre Sub Main ein verborgenes Formular lädt oder die Hauptbenutzeroberfläche Ihrer Anwendung anzeigt, werden für jeden von Ihnen erstellten Thread neue Kopien dieser Formulare geladen.

Der folgende Code bestimmt, ob Sub Main im ersten Thread ausgeführt wird oder nicht, damit Sie das ausgeblendete Formular nur einmal zu laden und die Hauptbenutzeroberfläche der Testanwendung nur einmal anzuzeigen brauchen.

' Stammwert für Beschriftung des verborgenen Fensters
Public Const PROC_CAPTION = "ApartmentDemoProcessWindow"

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

' Fensterzugriffsnummer von EnumThreadWindows abgerufen.
Private mhwndVB As Long
' Verborgenes Formular zum Identifizieren des Haupt-Threads verwendet.
Private mfrmProcess As New frmProcess
' Prozeß-ID.
Private mlngProcessID As Long

Sub Main()
    Dim ma As MainApp

    ' Eine Fensterzugriffsnummer zum Erhalten einer Prozeß-ID
    '   einlesen (siehe EnumThreadWndMain-Rückruf weiter unten).
    Call EnumThreadWindows(App.ThreadID, AddressOf EnumThreadWndMain, 0&)
    If mhwndVB = 0 Then
        Err.Raise ERR_InternalStartup + vbObjectError, , "Interner Fehler beim Starten des Thread"
    Else
        Call GetWindowThreadProcessId(mhwndVB, mlngProcessID)
        ' Die Prozeß-ID macht die verborgene Fensterbeschriftung eindeutig.
        If 0 = FindWindow(vbNullString, PROC_CAPTION & CStr(mlngProcessID)) Then
            ' Das Fenster wurde nicht gefunden; daher ist dies der erste Thread.
            If App.StartMode = vbSModeStandalone Then
                ' Verborgenes Formular mit eindeutiger Beschriftung erstellen. 
                mfrmProcess.Caption = PROC_CAPTION & CStr(mlngProcessID)
                ' Das Initialize-Ereignis von MainApp (Instancing =
                '   PublicNotCreatable) zeigt die Hauptbenutzeroberfläche.
                Set ma = New MainApp
                ' (Das Herunterfahren der Anwendung ist einfacher, wenn es
                '   keinen globalen Verweis auf MainApp gibt; MainApp sollte
                '   statt dessen Me an das Hauptbenutzerformular weitergeben,
                '   so daß das Formular ein Beenden von MainApp verhindert.)
            Else
                Err.Raise ERR_NoAutomation + vbObjectError, , _
                    "Anwendung kann nicht mit Automatisierung gestartet werden"
            End If
        End If
    End If
End Sub

' Rückruf-Funktion von EnumThreadWindows verwendet.
Public Function EnumThreadWndMain(ByVal hwnd As Long, ByVal lParam As Long) As Long
    ' Fensterzugriffsnummer speichern.
    mhwndVB = hwnd
    ' Nur das erste Fenster wird benötigt.
    ' Die Wiederholung beenden, sobald das Fenster gefunden wurde.
    EnumThreadWndMain = ENUM_STOP
End Function

' MainApp ruft diese Sub-Prozedur in seinem Terminate-Ereignis auf;
'   andernfalls verhindert das verborgene Formular  
'   ein Schließen der Anwendung.
Public Sub FreeProcessWindow()
    Unload mfrmProcess
    Set mfrmProcess = Nothing
End Sub

Wichtig   Diese Methode zum Identifizieren des ersten Threads funktioniert in künftigen Versionen von Visual Basic möglicherweise nicht.

Wie Sie sehen, führt Sub Main für auf den ersten Thread folgende Threads keine Aktionen aus. Wenn Sie Code hinzufügen, der MultiUse-Objekte erstellt (um nachfolgende Threads zu starten), müssen Sie Code zum Initialisieren dieser Objekte hinzufügen.

EnumThreadWindows wird mit einem Rückruf, EnumThreadWndMain, verwendet, um eines der verborgenen Fenster zu finden, die Visual Basic zur internen Verwendung erstellt. Die Fensterzugriffsnummer dieses verborgenen Fensters wird an GetWindowThreadProcessId weitergeleitet, welches die Prozeß-ID zurückgibt. Die Prozeß-ID wird dann zum Erstellen einer eindeutigen Legende für das verborgene Fenster (frmProcess), das von Sub Main geladen wird, verwendet. Nachfolgende Threads entdecken dieses Fenster und erkennen somit, daß sie das MainApp-Objekt nicht zu erstellen brauchen. Diese Umwege sind notwendig, weil Visual Basic keine Möglichkeit zum Identifizieren des Haupt-Threads der Anwendung bietet.

Die MainApp-Klasse zeigt in ihrem Initialize-Ereignis das Hauptformular der Testanwendung an. MainApp muß seinen Me-Verweis an das Hauptformular weitergeben, damit das Formular ein Beenden von MainApp verhindert. Sie können alle nachfolgenden Threads über die Hauptbenutzeroberfläche erstellen. Durch Einstellen der Instancing-Eigenschaft für MainApp auf PublicNotCreatable wird das Anzeigen von zwei Hauptbenutzeroberflächen-Formularen vermieden.

Ein einfaches Beispiel der MainApp-Klasse und des zugehörigen Formulars (Schritt 5 und 6 weiter oben) könnte z.B. so aussehen:

' Code für eine MainApp-Klasse.
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()
    ' Das verborgene Fenster freigeben.
    Call FreeProcessWindow
End Sub

' Code für das Formular frmMTMain.
Public MainApp As MainApp

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

Mehrere Instanzen der Testanwendung

Durch Aufnahme der Prozeß-ID in der Beschriftung des verborgenen Fensters ist es möglich, mehrere Instanzen der Testanwendung auszuführen, ohne daß diese miteinander in Konflikt geraten.

Beim Aufrufen von CreateObject befindet sich die Instanz der von Ihnen erstellten öffentlichen Klasse auf einem Thread in der aktuellen Instanz der Anwendung. Ursache dafür ist, daß CreateObject immer versucht, ein Objekt in der aktuellen Anwendung zu erstellen, bevor es nach anderen ausgeführten Komponenten von Exe-Dateien sucht, die das Objekt möglicherweise bereitstellen.

Nützliche Eigenschaften für das Apartment

Es kann nützlich sein, die Prozeß-ID als schreibgeschützte Eigenschaft des Moduls offenzulegen, das Sub Main enthält:

'Dieser Code wird nicht für die Testanwendung benötigt
Public Property Get ProcessID() As Long
    ProcessID = mlngProcessID
End Property

Damit kann jedes Objekt auf dem Thread die Prozeß-ID durch Aufrufen der nicht näher angegebenen ProcessID-Eigenschaft ermitteln. Es kann auch nützlich sein, eine boolesche IsMainThread-Eigenschaft auf diese Art und Weise offenzulegen.

Erstellen neuer Threads

Die Option Thread pro Objekt führt zur externen Erstellung aller öffentlichen Objekte, d.h. sie werden unter Verwendung der CreateObject-Funktion erstellt, um einen neuen Thread zu starten. Um einen neuen Thread zu erstellen, verwenden Sie einfach die Ressource-ID (ProgID) einer Ihrer MultiUse-Klassen:

'Dieser Code gehört nicht zur Testanwendung
Dim tw As ThreadedWindow
Set tw = CreateObject("ThreadDemo.ThreadedWindow")

Die Variable tw enthält jetzt einen Verweis auf ein Objekt auf einem neuen Thread. Alle Aufrufe an die Eigenschaften und Methoden dieses Objekts, die unter Verwendung von tw gemacht werden, unterliegen dem zusätzlichen Aufwand des thread-übergreifenden Marshaling.

Anmerkung   Ein mit dem New-Operator erstelltes Objekt wird nicht auf einem neuen Thread erstellt. Es befindet sich auf dem gleichen Thread, in dem der New-Operator ausgeführt wurde. Siehe Entwerfen von prozeßexternen Multithread-Komponenten und Funktionsweise der Objekterstellung in Visual Basic-Komponenten in der Online-Dokumentation.

Um zu gewährleisten, daß MainApp erst beendet wird, wenn alle anderen Threads abgeschlossen sind, können Sie jede öffentliche Klasse mit einer MainApp-Eigenschaft versehen. Wenn ein Objekt ein MultiUse-Objekt auf einem neuen Thread erstellt, kann es als Teil des Initialisierungsprozesses einen Verweis auf das MainApp-Objekt an das neue Objekt übergeben. (Sie können MainApp auch als Verweis auf das neue Objekt weitergeben, damit MainApp über eine Auflistung der Bezüge auf alle Objekte verfügt, die Threads steuern. Denken Sie aber daran, daß dadurch Zirkelbezüge erstellt werden. Siehe Umgang mit Zirkelbezügen in der Online-Dokumentation.)

Wenn Sie eine Klasse benötigen, die einen Thread steuert, um ein Formular anzuzeigen, müssen Sie ihr eine Initialize-Methode (die nicht mit einem Initialize-Ereignis verwechselt werden sollte) oder eine Show-Methode, die das Formular anzeigt, zur Verfügung stellen. Zeigen Sie das Formular nicht in der Class_Initialize-Ereignisprozedur an, denn dies kann beim Erstellen von Instanzen der Klasse zu Fehlern im zeitlichen Ablauf führen. In einem sehr vereinfachten Fall könnte der Code für eine ThreadedWindow-Klasse mit der Einstellung MultiUse und ihr Formular frmThreadedWindow folgendermaßen aussehen:

'Code für eine MultiUse ThreadedWindow-Klasse.
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 für das Formular frmThreadedWindow.
Public ThreadedWindow As ThreadedWindow

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

Der folgende Code-Auszug zeigt, wie Sie das ThreadedWindow-Objekt initialisieren können:

'Code für das Hauptformular (frmMTMain) der Testanwendung.
Private Sub mnuFileNewTW_Click()
    Dim tw As ThreadedWindow
    Set tw = CreateObject("ThreadDemo.ThreadedWindow")
    ' Das neue Objekt anweisen, sein Formular anzuzeigen,
    '   und einen Verweis auf das Haupt-
    '   anwendungsobjekt weitergeben.
    Call tw.Initialize(Me.MainApp)
End Sub

Wenn Sie über eine Reihe von Klassen verfügen, die Threads steuern können, können Sie Ihren Code allgemeiner gestalten, indem Sie eine IApartment-Schnittstelle definieren, die die Initialize-Methode enthält. Wenn Sie IApartment in jeder Klasse implementieren, können Sie für diese Klasse den entsprechenden Code der Initialize-Methode zur Verfügung stellen. Der Code zum Erstellen des Threads könnte folgendermaßen aussehen:

'Dieser Code wird nicht für die Testanwendung benötigt
Private Sub mnuFileNewObject_Click(Index As Integer)
    Dim iapt As IApartment
    Select Case Index
      Case otThreadedWindow
        Set iapt = CreateObject("ThreadDemo.ThreadedWindow")
      ' (andere Fälle…)
    End Select
    ' Gemeinsamer Code zum Initialisieren von Objekten.
    Call iapt.Initialize(MainApp)
End Sub

Anmerkung   Sie können eine IXxxxApartment-Schnittstelle erstellen, die nur der Multithread-Anwendung bekannt ist, indem Sie die Schnittstelle in einer separaten Klassenbibliothek erstellen. Legen Sie im ActiveX-Exe-Projekt einen Verweis auf die Klassenbibliothek fest.

Verwaltung der Verweise auf Thread-Objekte

Um ein ordnungsgemäßes Herunterfahren einer Multithread-Anwendung zu gewährleisten, müssen Sie den Überblick über alle Verweise auf MultiUse-Objekte behalten, die Sie zum Erstellen und Steuern von Threads verwenden.

Definieren Sie die Ziele für die Lebensdauer von Objekten deutlich. Nehmen Sie z.B. ein MultiUse-Objekt, das ein Formular zeigt. Die einfachste Methode zum Verwalten der Objektlebensdauer besteht darin, über das Objekt einen Me-Verweis an das Formular zu übergeben; das Formular sorgt dann dafür, daß das Objekt weiter ausgeführt wird. Wenn der Benutzer das Formular schließt, muß das Unload-Ereignis alle Verweise auf das MultiUse-Objekt auf Nothing setzen, damit das Objekt beendet werden kann, und seinerseits den Verweis auf das Formular zurücksetzen. (Es ist möglicherweise nützlich, dem MultiUse-Objekt eine Friend-Methode zur Verfügung zu stellen, die den Verweis auf das Formular sowie alle anderen internen Objektverweise zurücksetzt; diese Methode kann vom Unload-Ereignis des Formulars aufgerufen werden.)

Wenn das Objekt, das einen Thread steuert, zusätzliche Objekte auf dem Thread erstellt, stellen Sie mit Hilfe des New-Operators sicher, daß alle Verweise auf diese Objekte zurückgesetzt werden. Der Thread kann erst geschlossen werden, wenn alle Verweise auf Objekte, die auf dem Thread erstellt wurden, freigegeben wurden. Geöffnete Threads beanspruchen Systemressourcen.

Friend-Methoden können nicht thread-übergreifend verwendet werden

Da Friend-Eigenschaften und -Methoden nicht zur öffentlichen Schnittstelle einer Klasse gehören, können Sie sie nicht aus einem anderen Thread aufrufen. Thread-übergreifende Aufrufe zwischen Objekten sind auf Eigenschaften und Methoden beschränkt, die als öffentlich deklariert werden.

Wiedereintritt

Wenn eine Methode eines Objekts die Steuerung durch Aufrufen von DoEvents, das Anzeigen eines gebundenen Formulars oder das Durchführen eines zweiten Aufrufs eines Objekts auf einem anderen Thread zurückgibt, kann der Code in der Methode durch eine zweite aufrufende Routine ausgeführt werden, bevor der erste Aufruf abgeschlossen ist. Wenn eine solche Methode Eigenschaftswerte oder Variablen auf Modulebene verwendet oder ändert, kann der interne Zustand des Objekts ungültig werden. Sie können den Wiedereintritt folgendermaßen verhindern:

Asynchrone Vorgänge

Visual Basic bietet keine Möglichkeit, die Ausführung zu verzweigen, d.h. daß ein Thread einen Methodenruf auf einem neuen Thread initiiert und sofort die Verarbeitung des Original-Threads wieder aufnimmt. Sie können dieses Verhalten in Ihrer Testanwendung simulieren, indem Sie den ursprünglichen Methodenaufruf zum Aktivieren eines Zeitgebers und zur sofortigen Rückkehr veranlassen. Wenn das Zeitgeberereignis auftritt, können Sie den Zeitgeber ausschalten und die asynchrone Verarbeitung vornehmen. Diese Methode wird unter Asynchrone Rückrufe und Ereignisse in der Online-Dokumentation erläutert und in dieser (siehe Erstellen einer ActiveX-EXE-Komponente) sowie in der Coffee-Beispielanwendung demonstriert.

Verwenden der Multithread-Testanwendung

Sie müssen die Multithread-Testanwendung kompilieren, um Ihre Komponente mit Threading nach dem Apartment-Modell testen zu können, da die Entwicklungsumgebung von Visual Basic die Ausführung mehrerer Threads zur Zeit nicht unterstützt. Wenn Sie über Microsoft Visual Studio verfügen, ist es möglicherweise hilfreich, die Testanwendung mit Testinformationen für systemeigenen Code zu kompilieren, damit Sie den Visual Studio-Debugger verwenden können.

 

Ein Hinweis zur sicheren Skriptausführung für ActiveX-Steuerelemente

Zwei der in Visual Basic 5.0 Service Pack 2 enthaltenen Steuerelemente mit Threading nach dem Apartment-Modell, das Standarddialog-Steuerelement (CommonDialog) und das Symbolleiste-Steuerelement (Toolbar), unterstützen jetzt die ActiveX-IObjectSafety-Schnittstelle. Wenn diese Steuerelemente in einer Umgebung verwendet werden, in der die sichere Skriptausführung überprüft wird, wie z.B. beim Internet Explorer, werden sie als Sicher für Skriptenerstellung markiert. Damit diese Steuerelemente als für die Skriptausführung sicher zertifiziert werden können, werden allerdings einige ihrer Funktionen deaktiviert:

 

Liste zum Inhalt des Pakets

Visual Basic 5.0 Service Pack 2 enthält folgende Dateien:: 

asycfilt.dll
c2.exe
cmctlde.dll
cmdlgde.dll
comct232.dep
comct232.ocx
comctl32.dep
comctl32.ocx
comdlg32.dep
comdlg32.ocx
dbgrid32.dep
dbgrid32.ocx
dblist32.dep
dblist32.ocx
flxgdde.dll
mci32.dep
mci32.ocx
mscdrun.dep
mscdrun.dll
mscomm32.dep
mscomm32.ocx
mscondes.dll
msflxgrd.dep
msflxgrd.ocx
msinet.dep

msinet.ocx
msmapi32.dep
msmapi32.ocx
msmask32.dep
msmask32.ocx
msprpde.dll
msrdc20.dep
msrdc20.ocx
msrdo20.dep
msrdo20.dll
msstkprp.dll
msvbvm50.dll
mswinsck.dep
mswinsck.ocx
oleaut32.dll
olepro32.dll
picclp32.dep
picclp32.ocx
readme.wri
richtx32.dep
richtx32.ocx

setup1.bas
setup1.exe
setupwiz.exe
stdole2.tlb
sysinfo.dep
sysinfo.ocx
tabctl32.dep
tabctl32.ocx
vb5.exe
vb5de.dll
vb5dep.ini
vb5ide.dll
vb5sp2.htm
vb5sp2.wri
vba332me.dll
vba5.dll

 

Nur Alpha-Systeme:
adme.dll
dtccm.dll
dtctrace.dll
dtcutil.dll
msdtcprx.dll