Verwendung der frühen und späten Bindung in der Automatisierung

SPRACHE AUSWÄHLEN SPRACHE AUSWÄHLEN
Artikel-ID: 245115 - Produkte anzeigen, auf die sich dieser Artikel bezieht
Dieser Artikel ist eine Übersetzung des folgenden englischsprachigen Artikels der Microsoft Knowledge Base:
245115 Using early binding and late binding in Automation
Bitte beachten Sie: Bei diesem Artikel handelt es sich um eine Übersetzung aus dem Englischen. Es ist möglich, dass nachträgliche Änderungen bzw. Ergänzungen im englischen Originalartikel in dieser Übersetzung nicht berücksichtigt sind. Die in diesem Artikel enthaltenen Informationen basieren auf der/den englischsprachigen Produktversion(en). Die Richtigkeit dieser Informationen in Zusammenhang mit anderssprachigen Produktversionen wurde im Rahmen dieser Übersetzung nicht getestet. Microsoft stellt diese Informationen ohne Gewähr für Richtigkeit bzw. Funktionalität zur Verfügung und übernimmt auch keine Gewährleistung bezüglich der Vollständigkeit oder Richtigkeit der Übersetzung.
Alles erweitern | Alles schließen

Auf dieser Seite

Zusammenfassung

Die von Ihnen für die Bindung an den Automatisierungsserver gewählte Bindungsart kann sich auf viele Aspekte Ihres Programms auswirken, zum Beispiel auf die Leistung, die Flexibilität und die Wartungsfreundlichkeit.

Dieser Artikel erläutert die für Automatisierungsclients verfügbaren Bindungsarten und stellt die Vor- und Nachteile dar.

Weitere Informationen

Automatisierung ist ein Prozess, bei dem eine Softwarekomponente über das Microsoft Component Object Model (COM) mit einer anderen Softwarekomponente kommuniziert bzw. bei dem eine Softwarekomponente eine andere Softwarekomponente über COM steuern kann. Sie bildet die Grundlage für einen Großteil der in Sprachen wie Visual Basic oder Visual Basic für Applikationen eingesetzten komponentenübergreifenden Kommunikation und ist zu einem normalen Bestandteil der meisten Programme geworden.

Bisher hat man unter einem Automatisierungsobjekt ein beliebiges Objekt verstanden, das die IDispatch-Schnittstelle unterstützt. Diese Schnittstelle ermöglicht es Clients, Methoden und Eigenschaften zur Laufzeit aufzurufen. Dabei muss das genaue Objekt, mit dem zur Entwurfszeit kommuniziert wird, nicht bekannt sein. Dieser Prozess wird auch als späte Bindung bezeichnet. Heute lässt sich der Begriff Automatisierungsobjekt jedoch auf nahezu jedes COM-Objekt anwenden. Dies gilt auch für jene Objekte, die die IDispatch-Schnittstelle nicht unterstützen (und für die daher keine späte Bindung erfolgen kann). In diesem Artikel wird angenommen, dass das zu automatisierende Objekt beide Bindungsarten unterstützt.

Was bedeutet Bindung?

Bindung ist ein Vorgang, bei dem vom Programmierer erstellte Funktionsaufrufe dem tatsächlichen (internen oder externen) Code zugewiesen werden, der die Funktion implementiert. Dieser Vorgang erfolgt beim Kompilieren der Anwendung. Alle im Code aufgerufenen Funktionen müssen gebunden werden, bevor der Code ausgeführt werden kann.

Zum besseren Verständnis dieses Vorgangs kann die Bindung am Beispiel der Veröffentlichung eines Buches veranschaulicht werden. Stellen Sie sich vor, Ihr Code ist der Text eines Buches. In einem bestimmten Absatz dieses Textes steht zum Beispiel der Hinweis "weitere Informationen finden Sie in Kapitel 12 auf Seite x". Sie wissen jedoch erst nach Fertigstellung des Buches, wie die Seitennummer lauten wird. Bevor der Absatz wie beabsichtigt gelesen werden kann, müssen alle Seiten des Buches gebunden und der Absatz mit der richtigen Seitennummer versehen sein. Sie warten also, bis das Buch "gebunden" ist, bevor Sie auf andere Abschnitte des Buchs verweisen können.

Die Bindung von Software erfolgt auf ähnliche Weise. Ihr Code besteht aus einzelnen Teilen, die verknüpft werden müssen, bevor der Code "gelesen" werden kann. Die Bindung ist der Vorgang des Ersetzens von Funktionsnamen durch die Speicheradressen (oder genauer gesagt, die Speicher-Offsets), zu denen der Code beim Aufruf der Funktion "springt". Bei COM-Objekten ist diese Adresse ein Speicher-Offset in einer Tabelle von Zeigern (auch als V-Tabelle bezeichnet), die vom Objekt verwaltet werden. COM-Funktionen werden über die V-Tabelle gebunden.

Die Struktur eines COM-Objekts ist einfach. Wenn der Code einen Verweis auf ein Objekt enthält, dann enthält er auch einen indirekten Zeiger zum Anfang der V-Tabelle. Die V-Tabelle ist ein Array von Speicheradressen. Jeder Eintrag dieser Tabelle entspricht einer anderen Funktion, die für dieses Objekt aufgerufen werden kann. Um die dritte Funktion für ein COM-Objekt aufzurufen, springen Sie drei Einträge in der Tabelle nach unten und anschließend zur dort angegebenen Speicheradresse. Hierdurch wird der Code für die Funktion ausgeführt. Nach Abschluss dieses Vorgangs kehren Sie zum Ausgangspunkt zurück, um die nächste Codezeile auszuführen.

+-[Code]------------+  +.................................[COM Object]...+
|                   |  : +-------------+                                :
|Set obj = Nothing -|--->| obj pointer |                                :
|                   |  : +-|-----------+                                :
+-------------------+  :   |   +-----------------+                      :
                       :   +-->| v-table pointer |                      :
                       :       +--|--------------+                      :
                       :          |                                     :
                       :          |  +----------------------------+     :
                       :  (3rd)   |  | Function 1 Address pointer |     :
                       : (Offset) |  +----------------------------+     :
                       :          |  | Function 2 Address pointer |     :
                       :          |  +----------------------------+     :
                       :          +->| Function 3 Address pointer |     :
                       :             +----------------------------+     :
                       +................................................+

				
Das Beispiel oben veranschaulicht, was bei der Freigabe eines COM-Objekts geschieht. Da alle COM-Objekte von IUnknown erben, sind die ersten drei Einträge in der Tabelle die Methoden zu IUnknown. Wenn Sie ein Objekt freigeben, ruft der Code die dritte Funktion in der V-Tabelle (IUnknown::Release) auf.

Diese Aufgaben übernimmt Visual Basic sozusagen hinter den Kulissen. Als Visual Basic-Programmierer müssen Sie V-Tabellen nie direkt bearbeiten. Da jedoch alle COM-Objekte anhand dieser Struktur gebunden werden, müssen Sie wissen, was unter Bindung zu verstehen ist.

Frühe Bindung

Das Beispiel oben veranschaulicht die sogenannte frühe Bindung (auch als V-Tabellenbindung bezeichnet). Diese Art der Bindung erfolgt für alle COM-Objekte, wenn die IUnknown-Schnittstelle eines COM-Objekts aufgerufen wird. Aber was passiert mit den anderen Funktionen des Objekts? Wie rufen Sie die Refresh-Methode oder die Parent-Eigenschaft des Objekts auf? Es handelt sich dabei um benutzerdefinierte Funktionen, die in der Regel eindeutig für ein Objekt sind. Wenn keine Annahme über ihren Standort in der V-Tabelle getroffen werden kann, wie finden Sie dann die zum Aufrufen dieser Funktionen erforderlichen Funktionsadressen?

Die Antwort ist natürlich davon abhängig, ob Sie im Voraus wissen, wie die V-Tabelle des Objekts aussieht. Wenn Sie das Aussehen der V-Tabelle kennen, können Sie für die benutzerdefinierten Methoden des Objekts dasselbe frühe Bindungsverfahren wie für die IUnknown-Methoden ausführen. Dies wird im Allgemeinen als "frühe Bindung" bezeichnet.

Um die frühe Bindung für ein Objekt verwenden zu können, müssen Sie wissen, wie die V-Tabelle dieses Objekts aussieht. In Visual Basic können Sie zu diesem Zweck einen Verweis auf eine Typbibliothek hinzufügen, die das Objekt, seine Schnittstelle (V-Tabelle) und alle Funktionen beschreibt, die für das Objekt aufgerufen werden können. Wenn dies erfolgt ist, können Sie ein Objekt eines bestimmten Objekttyps deklarieren. Anschließend können Sie dieses Objekt festlegen und mithilfe der V-Tabelle verwenden. Wenn Sie Microsoft Office Excel beispielsweise mithilfe der frühen Bindung automatisieren möchten, würden Sie im Dialogfeld "Projekt"|"Verweise" einen Verweis auf die "Microsoft Excel 8.0-Objektbibliothek" hinzufügen und die Variable anschließend als Variable des Typs "Excel.Application." deklarieren. Ab diesem Zeitpunkt wären alle Aufrufe der Objektvariablen früh gebunden:
' Set reference to 'Microsoft Excel 8.0 Object Library' in
' the Project|References dialog (or Tools|References for VB4 or VBA).

' Declare the object as an early-bound object
  Dim oExcel As Excel.Application

  Set oExcel = CreateObject("Excel.Application")

' The Visible property is called via the v-table
  oExcel.Visible = True
				
Diese Methode funktioniert in den meisten Fällen gut. Was passiert jedoch, wenn Sie das genaue Objekt, das Sie zur Entwurfszeit verwenden möchten, nicht kennen? Was geschieht beispielsweise, wenn Sie mit verschiedenen Versionen von Excel oder einem möglicherweise vollständig "unbekannten" Objekt kommunizieren müssen?

Späte Bindung

COM beinhaltet die IDispatch-Schnittstelle. Objekte, die die IDispatch-Schnittstelle implementieren, werden auch als Objekte mit Dispinterface-Schnittstelle (wenn dies die einzige von den Objekten unterstützte Schnittstelle ist) oder als Objekte mit dualer Schnittstelle (wenn die Objekte auch über eine benutzerdefinierte Schnittstelle verfügen, an die Sie eine frühe Bindung durchführen können) bezeichnet. Clients, die an die IDispatch-Schnittstelle binden, werden auch als "spät gebunden" bezeichnet, weil die Bestimmung der genauen Eigenschaft oder Methode, die von ihnen aufgerufen wird, zur Laufzeit erfolgt. Zum Auffinden der jeweiligen Eigenschaft oder Methode werden die Methoden von IDispatch verwendet. Vergleicht man diesen Vorgang erneut mit dem oben genannten Beispiel der Veröffentlichung eines Buches, wäre dies wie eine Fußnote, die auf das Inhaltsverzeichnis verweist, in dem Sie die Seitennummer sozusagen "während des Lesevorgangs" suchen, anstatt die Seitennummer bereits in den Text einzufügen.

Die Funktionalität der Schnittstelle wird durch zwei Funktionen gesteuert: GetIDsOfNames und Invoke. Die erste Funktion ordnet Funktionsnamen (Zeichenfolgen) einer ID (auch als Dispid bezeichnet) zu, die die Funktion darstellt. Sobald Sie die ID für die aufzurufende Funktion kennen, können Sie die Funktion mithilfe der Funktion "Invoke" aufrufen. Diese Art des Methodenaufrufs wird als "späte Bindung" bezeichnet.

In Visual Basic wird die Bindungsart des Objekts durch Ihre Objektdeklaration festgelegt. Wenn Sie eine Objektvariable als "Objekt" deklarieren, weisen Sie Visual Basic dazu an, IDispatch und damit die späte Bindung zu verwenden:
' No reference to a type library is needed to use late binding.
' As long as the object supports IDispatch, the method can 
' be dynamically located and invoked at run-time.

' Declare the object as a late-bound object
  Dim oExcel As Object

  Set oExcel = CreateObject("Excel.Application")

' The Visible property is called via IDispatch
  oExcel.Visible = True
				
Wie Sie sehen können, ist der Rest Ihres Codes identisch. Der einzige Unterschied zwischen der frühen und der späten Bindung (was den von Ihnen erstellten Code angeht) besteht in der Variablendeklaration.

Wichtig ist dabei, dass sich die "späte Bindung" auf die aufgerufene Funktion und nicht auf die Art und Weise ihres Aufrufs bezieht. Wie in den allgemeinen Ausführungen zur Bindung weiter oben erläutert, ist IDispatch selbst "früh gebunden", das heißt, Visual Basic führt den Aufruf zum Festlegen der Visible-Eigenschaft wie einen beliebigen COM-Aufruf über einen V-Tabelleneintrag (IDispatch::Invoke) aus. Das COM-Objekt selbst ist für die Weiterleitung des Aufrufs an die richtige Funktion verantwortlich, um Excel sichtbar zu machen. Dieser Umweg erlaubt zwar die Kompilierung des Visual Basic-Clients (d. h. das Binden an eine gültige Funktionsadresse), jedoch ist dem Client die genaue Funktion, die den Vorgang ausführen wird, weiterhin unbekannt.

Dispid-Bindung

Einige Automatisierungsclients (vornehmlich MFC und Visual Basic 3.0, jedoch auch Visual Basic 5.0 und 6.0 in Bezug auf ActiveX-Steuerelemente) verwenden eine Hybridform der späten Bindung, die auch als Dispid-Bindung bezeichnet wird. Wenn das COM-Objekt zur Entwurfszeit bekannt ist, können die Dispids für die aufgerufenen Funktionen zwischengespeichert und direkt an IDispatch::Invoke übergeben werden, ohne GetIDsOfNames zur Laufzeit aufzurufen. Dies kann die Leistungsfähigkeit deutlich steigern, da anstelle von zwei COM-Aufrufen pro Funktion nur ein COM-Aufruf ausgeführt werden muss.

Die Dispid-Bindung steht in Visual Basic 5.0 oder 6.0 normalerweise nicht als Option zur Verfügung. Sie wird für Objekte verwendet, die in einer Typbibliothek referenziert sind, aber keine benutzerdefinierte Schnittstelle beinhalten (also nur für Objekte mit Dispinterface). Außerdem wird sie für zusammengesetzte ActiveX-Steuerelemente genutzt. Im Allgemeinen verwendet Visual Basic die frühe Bindung jedoch überall dort, wo Sie normalerweise die Dispid-Bindung verwenden würden.

Welche Art der Bindung sollte ich verwenden?

Die Antwort auf diese Frage hängt in gleichem Maße von der Gestaltung Ihres Projekts wie von anderen Faktoren ab. Microsoft empfiehlt in fast allen Fällen die frühe Bindung. Unter Umständen ist jedoch die Verwendung der späten Bindung begründet.

Die frühe Bindung ist das bevorzugte Verfahren. Es bietet die höchste Leistungsfähigkeit, da Ihre Anwendung direkt an die Adresse der aufgerufenen Funktion bindet und kein zusätzlicher Aufwand durch die Suche der Funktion zur Laufzeit entsteht. Im Hinblick auf die allgemeine Ausführungsgeschwindigkeit ist dieses Verfahren mindestens doppelt so schnell wie die späte Bindung.

Die frühe Bindung bietet außerdem Typsicherheit. Wenn Sie einen Verweis auf die Typbibliothek der Komponente gesetzt haben, unterstützt Sie Visual Basic mit dem IntelliSense-Feature beim korrekten Codieren der einzelnen Funktionen. Visual Basic warnt Sie außerdem, wenn der Datentyp eines Parameters oder Rückgabewertes nicht korrekt ist. Auf diese Weise sparen Sie viel Zeit beim Erstellen und Debuggen von Code.

Die Verwendung der späten Bindung bleibt jedoch in Situationen sinnvoll, in denen die genaue Schnittstelle eines Objekts zur Entwurfszeit nicht bekannt ist. Wenn Ihre Anwendung mit mehreren unbekannten Servern kommunizieren oder Funktionen mit ihrem Namen aufrufen soll (beispielsweise mithilfe der Visual Basic 6.0-Funktion CallByName), müssen Sie die späte Bindung verwenden. Die späte Bindung ist auch hilfreich, wenn Sie Kompatibilitätsprobleme zwischen mehreren Versionen einer Komponente umgehen möchten, deren Schnittstelle nicht ordnungsgemäß für die einzelnen Versionen angepasst ist.

Die Vorteile der frühen Bindung machen diese Bindungsart jedoch zur Methode der ersten Wahl, sofern ihr Einsatz möglich ist.

Gewährleisten der versionsübergreifenden Kompatibilität

Wenn Sie eine Komponente verwenden, die Sie nicht mit Ihrem Setuppaket weiterverteilen möchten, und Ihnen die genaue Version, mit der zur Laufzeit kommuniziert werden soll, nicht bekannt ist, sollten Sie eine frühe Bindung an eine Schnittstelle bevorzugen, die mit allen Versionen der Komponente kompatibel ist. Anderenfalls (in bestimmten Fällen) sollten Sie die späte Bindung zum Aufrufen einer Methode verwenden, die möglicherweise nur in einer bestimmten Version existiert. Falls diese Methode in der auf dem Clientsystem installierten Version nicht vorhanden ist, wird der Vorgang fehlerfrei beendet.

Microsoft Office-Anwendungen sind ein gutes Beispiel für solche COM-Server. Office-Anwendungen erweitern ihre Schnittstellen in der Regel, um neue Funktionen hinzuzufügen oder frühere Unzulänglichkeiten zwischen den Versionen auszugleichen. Wenn Sie eine Office-Anwendung automatisieren, empfiehlt sich eine frühe Bindung an die früheste Version des Produkts, die wahrscheinlich auf dem Clientsystem installiert ist. Wenn Sie beispielsweise Excel 95, Excel 97, Excel 2000 und Excel 2002 automatisieren möchten, sollten Sie die Typbibliothek für Excel 95 (XL5en32.olb) verwenden, um die Kompatibilität mit allen drei Versionen zu gewährleisten.

Bei Office-Anwendungen zeigt sich außerdem, dass es im Zusammenhang mit Objektmodellen mit umfangreichen dualen Schnittstellen auf einigen Plattformen zu Einschränkungen beim Marshalling kommen kann. Verwenden Sie daher IDispatch, damit Ihr Code plattformübergreifend optimal funktioniert. Weitere Informationen dazu, wie Sie die Kompatibilität bei der Arbeit mit Office-Anwendungen gewährleisten, finden Sie im folgenden Artikel der Microsoft Knowledge Base:
247579 INFO: verwenden Sie DISPID, Sie binden, dass Sie Office-Anwendungen nach Möglichkeit automatisieren möchten

Informationsquellen

Weitere Informationen zum Component Object Model (COM), zu V-Tabellen und zur Automatisierung finden Sie in den folgenden Publikationen:
Rogerson, Dale, Inside COM, MSPRESS, ISBN: 1-57231-349-8.

Curland, Matt, Advanced Visual Basic 6, DevelopMentor, 0201707128.

Eigenschaften

Artikel-ID: 245115 - Geändert am: Freitag, 23. November 2007 - Version: 7.1
Die Informationen in diesem Artikel beziehen sich auf:
  • Microsoft Office Ultimate 2007
  • Microsoft Office Enterprise 2007
  • Microsoft Office Professional 2007
  • Microsoft Office Professional Plus 2007
  • Microsoft Office Standard 2007
  • Microsoft Office Home and Student 2007
  • Microsoft Office Basic 2007
  • Microsoft Office Standard Edition 2003
  • Microsoft Office XP Developer Edition
  • Microsoft Office 2000 Developer Edition
  • Microsoft Visual Basic 5.0 Professional Edition
  • Microsoft Visual Basic 6.0 Professional Edition
  • Microsoft Visual Basic 5.0 Enterprise Edition
  • Microsoft Visual Basic 6.0 Enterprise Edition
Keywords: 
kbinfo kbautomation KB245115
Microsoft stellt Ihnen die in der Knowledge Base angebotenen Artikel und Informationen als Service-Leistung zur Verfügung. Microsoft übernimmt keinerlei Gewährleistung dafür, dass die angebotenen Artikel und Informationen auch in Ihrer Einsatzumgebung die erwünschten Ergebnisse erzielen. Die Entscheidung darüber, ob und in welcher Form Sie die angebotenen Artikel und Informationen nutzen, liegt daher allein bei Ihnen. Mit Ausnahme der gesetzlichen Haftung für Vorsatz ist jede Haftung von Microsoft im Zusammenhang mit Ihrer Nutzung dieser Artikel oder Informationen ausgeschlossen.

Ihr Feedback an uns

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com