Met behulp van vroege binding en late binding in automatisering

Vertaalde artikelen Vertaalde artikelen
Artikel ID: 245115 - Bekijk de producten waarop dit artikel van toepassing is.
Alles uitklappen | Alles samenvouwen

Op deze pagina

Samenvatting

Hoe u koppelt aan een automatiseringsserver kan invloed hebben op veel dingen in het programma, zoals prestaties, flexibiliteit en onderhoud.

In dit artikel wordt uitgelegd welke bindings beschikbaar Automatisering-clients, en weegt beide zijden van elke methode.

Meer informatie

Auto mat ion is een proces waarbij een software onderdeel communiceert en/of een ander onderdeel van de software met behulp van Microsoft beheert Component objectmodel (COM). Het is de basis voor de meeste cross-component communicatie in talen als Visual Basic of Visual Basic for gebruikt Toepassingen, en een normaal onderdeel van de meeste toepassingen is geworden.

In het verleden is een automatiseringsobject een object dat het IDispatch ondersteunt interface. Deze interface kunt u methoden en eigenschappen aanroepen in runtime-clients tijd zonder te weten de exacte object communiceren met op ontwerp tijd; een proces genaamd late binding. Vandaag, echter, de termAutomatiseringsobjectkan worden toegepast op vrijwel elke COM-object, zelfs wanneer die handelingen geen ondersteuning voor IDispatch (en daarom mag laat gebonden). In dit artikel het object dat u wilt automatiseren ondersteunt beide methoden binding aangenomen.

Wat is binding?

Binding is een proces dat overeenkomt met de functieaanroepen die zijn geschreven door de programmeur naar de werkelijke code (intern of extern) die u implementeert de functie. Dit gebeurt wanneer de toepassing is gecompileerd en alle functies genoemd in de code moet worden gebonden voordat de code kan worden uitgevoerd.

Om te begrijpen het proces, het verzetten van "binding" in termen van een uitgave. Stel uw code is vergelijkbaar met de tekst van het boek waar in een bepaalde alinea u hebt geschreven iets als "Zie hoofd stuk 12, pagina x voor meer informatie." U weet wat u het paginanummer zich tot het boek klaar is, dus voordat het lid kan worden Lees de bedoeling, alle pagina's van het boek moeten worden gebonden samen en de juiste paginanummer in de paragraaf ingevoegd. Wachten op het boek worden "gekoppeld" voordat u kunt verwijzen naar andere delen van het boek.

Binding software is vergelijkbaar. De code bestaat uit onderdelen die moeten worden opgehaald samen voordat de code kan worden "gelezen." Is de handeling van het vervangen van binding functie namen met geheugen adressen (of geheugen verschuivingen nauwkeuriger) waar wordt de code "springen" wanneer de functie wordt aangeroepen. Voor COM-objecten, de adres is een verschuiving van geheugen in een tabel van aanwijzers (de v-tabel genoemd) aangehouden door het object. Een COM-functie afhankelijk is, is gebonden door de v-tabel.

De structuur van een COM-object is eenvoudig. Wanneer uw code bevat een verwijzing naar een object, hij een indirecte verwijzing naar de bovenkant van de v-tabel. De v-tabel is een matrix met geheugen adressen waarbij elke vermelding een andere functie die op dat object kan worden aangeroepen. De derde aanroepen functie op een COM-object, springt u naar beneden drie posten in de tabel en vervolgens de geheugen locatie die er gaan. Die wordt uitgevoerd met de code voor de functie en wanneer hebt voltooid, geeft u weer gereed voor het uitvoeren van de volgende regel code.

+-[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 |     :
                       :             +----------------------------+     :
                       +................................................+

				
In het bovenstaande voorbeeld ziet u wat er gebeurt wanneer het vrij geven van een COM-object. Omdat alle COM-objecten overnemen IUnknown, de eerste drie vermeldingen in de tabel worden de methoden IUnknown. Wanneer u een object code vrij moet de derde functie oproepen in de v-tabel (IUnknown::Release).

Gelukkig is dit werk achter de schermen gedaan door Visual Basic. Als een visuele Basic programmeur, u hoeft nooit rechtstreeks omgaan met een v-tabel. Maar, dit de structuur is hoe alle COM-objecten zijn gekoppeld en het is belangrijk dat u bent Als u bekend bent met het begrijpen welke binding is.

Vroege binding

In het bovenstaande voorbeeld is wat is bekend als vroeg (of v-tabel) binding. Voor alle COM-objecten deze vorm van binding vindt plaats wanneer een COM-object IUnknown-interface wordt aangeroepen. Maar hoe zit het met de andere functies van het object? Hoe noemt u de vernieuwings methode of de bovenliggende eigenschap? Dit zijn aangepast functies die meestal uniek voor een object zijn. Als de locaties in de v-tabel kan niet worden aangenomen, hoe u de functie adressen nodig om te zoeken Noem ze?

Het antwoord natuurlijk afhankelijk of u weet van tevoren hoe het object v-tabel eruitziet. Als u dit doet, voert u de aangepaste methoden van het object als u dezelfde early binding proces heeft om haar IUnknown-methoden. Dit is wat meestal wordt bedoeld met "vroege binding."

Vroege binding gebruiken op een object, moet u weten wat de v-tabel eruit ziet. In Visual Basic kunt u dit doen door een verwijzing naar een type toevoegen Beschrijving van het object, de interface (v-tabel) en alle bibliotheek de functies die kunnen worden aangeroepen op het object. Zodra u dat hebt gedaan, kunt u declareren een object als een bepaald type wordt vervolgens ingesteld en dat object via de v-tabel. Bijvoorbeeld, als u Microsoft Office Excel automatiseren met behulp van vroeg binding, zou u een verwijzing naar 'Microsoft Excel 8. 0 Object Library' toevoegen vanuit het project |Dialoog venster verwijzingen en declareert u de variabele als het type "Application". Daarna alle oproepen naar uw object variabele zou early binding:
' 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
				
Deze methode werkt prima de meeste van de tijd, maar wat als u niet weet de exacte object die u tijdens het ontwerpen gebruiken wilt? Bijvoorbeeld, als u moet spreken om meerdere versies van Excel, of eventueel een "Onbekend" object helemaal?

Laat binden

COM bevat IDispatch. Objecten die implementeren van IDispatch genoemd verzendinterface (als deze de enige interface die wordt ondersteund is) of dual interface (als ze ook beschikken over een aangepaste interface u vroeg kunt binden). Clients die afhankelijk maakt van IDispatch ' late binding ' genoemd omdat de exacte eigenschap of methode die ze belt wordt tijdens runtime met behulp van de methoden bepaald van IDispatch te vinden. Teruggaan naar het rapport voorbeeld eerder, beschouwen Als het wordt als een voet noot, waarin wordt verwezen naar de tabel van de inhoud waar u "opzoeken" het paginanummer bij"lezen" in plaats van deze al hebben er in de tekst afgedrukt.

De magie van de interface wordt beheerd. door twee functies: GetIDsOfNames en Invoke. De eerste functie namen toegewezen (reeksen) aan een id (ook wel een dispid genoemd) die de functie voorstelt. Eenmaal u weet dat de ID voor de functie die u wilt bellen, kunt u bellen met de Functie aanroepen. Deze vorm van de methode aanroep heet ''late binding'.

Nogmaals, in Visual Basic de manier waarop u opgeeft hoe het object is gekoppeld is uw object aangifte. Als u een object variabele als "Object declareren" u, in feite vertellen Visual Basic gebruiken IDispatch, en daarom laat binding:
' 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
				
Zoals u ziet, is de rest van uw code hetzelfde. Het enige verschil tussen binding vroege en late binding (in termen van de code die u schrijft) is in de declaratie van de variabele.

Het is belangrijk te weten wat is "late gebonden"de functie wordt aangeroepen en de manier waarop wordt genoemd. Uit de eerdere discussie binden in het algemeen moet u merkt dat IDispatch zelf is "early binding:" dat wil zeggen dat Visual Basic kunt u het gesprek instellen de eigenschap Visible via een v-tabel vermelding (IDispatch::Invoke) zoals deze zou de COM-aanroep. Het COM-object zelf is verantwoordelijk voor het doorsturen van de aanroep de juiste functie Excel zichtbaar maken. Op die manier kan de Visual Basis client opgesteld (die is gekoppeld aan een geldige functie adres), maar nog steeds niet weet wat de exacte functie die eigenlijk het werk doet.

DISPID binding

Sommige automatiseringsclients (de meeste merkbaar MFC en Visual Basic 3. 0, maar ook Visual Basic 5. 0 en 6. 0 met betrekking tot ActiveX-besturingselementen) gebruiken een hybride formulier late binding genoemd dispid binding. Als het COM-object bekend is tijdens de ontwerpfase, de DISPID's voor de functies die worden genoemd kunnen worden opgeslagen en rechtstreeks doorgegeven zonder te hoeven aanroepen van GetIDsOfNames in IDispatch::Invoke bewerkings tijd. Hierdoor kan de prestaties aanzienlijk toenemen omdat in plaats van twee COM-aanroepen per functie, hoeft u alleen één.

DISPID binding geen optie normaal kunt u in Visual Basic 5. 0 of 6. 0. Het wordt gebruikt voor objecten die in een typebibliotheek worden verwezen, maar hebben niet een aangepaste interface (dat wil zeggen voor objecten die alleen een verzendinterface) en ActiveX-besturingselementen samengevoegd, maar in het algemeen early binding in Visual Basic wordt gebruikt elke plaats u normaal gebruikt dispid binding.

Welke vorm van binding moet ik gebruiken?

Het antwoord op deze vraag is afhankelijk van zo veel op het ontwerp van uw project als iets anders. Microsoft adviseert early binding in bijna alle gevallen. Wel kunnen er redenen voor het kiezen van late binding.

Vroeg binding verdient de voorkeur. Het is de beste prestaties omdat uw toepassing wordt gebonden rechtstreeks naar het adres van de functie wordt aangeroepen en Er is geen extra overhead in een runtime-zoekbewerking wordt uitgevoerd. Algemene uitvoering snelheid, is het ten minste tweemaal zo snel laat binden.

Vroeg binding bovendien type beveiliging. Wanneer er een verwijzing naar de de component typebibliotheek, Visual Basic biedt IntelliSense-ondersteuning voor u code elke functie correct. Visual Basic ook waarschuwt u als het gegevens type van een parameter of een retour waarde is onjuist, het opslaan van veel tijd bij het schrijven en fout opsporing.

'Late binding is nog steeds nuttig in situaties waarin de exacte interface van een object niet bekend is op ontwerp tijd. Als uw toepassing te praten met meerdere servers onbekend of nodig heeft om op te roepen functies op naam (met de Visual Basic 6. 0CallByNamevoorbeeld functie) en vervolgens moet u late binding gebruiken. Laat binding is ook handig om compatibiliteitsproblemen tussen meerdere omzeilen versies van een onderdeel dat niet goed gewijzigd of aangepast zijn interface tussen versies.

Het voordeel dat vroege binding maken de beste zo veel mogelijk.

Compatibiliteit behouden voor de verschillende versies

Als u gebruikmaakt van een onderdeel dat u niet opnieuw distribueren met het installatie pakket en niet zeker dat de exacte versie u communiceert tijdens runtime, u moet speciale aandacht besteden aan vroege binding een interface die compatibel is met alle versies van de component of (in Soms) 'late binding gebruiken voor het aanroepen van een methode die zich in een bepaald voordoen kan versie en probleemloos als deze methode niet aanwezig in de versie is mislukt op het client systeem zijn geïnstalleerd.

Microsoft Office-toepassingen bieden een goed voorbeeld van dergelijke COM-servers. Office-toepassingen wordt doorgaans uitvouwen hun interfaces voor het toevoegen van nieuwe functionaliteit of het juiste vorige tekortkomingen tussen versies. Als u een Office-toepassing te automatiseren, is aanbevolen dat u vroeg aan de oudste versie van het product dat u binden verwacht kan worden geïnstalleerd op de client computer. Als u bijvoorbeeld kunnen automatiseren van Excel 95, Excel 97, Excel 2000 en Excel 2002, moet u de typebibliotheek voor Excel 95 (XL5en32.olb) gebruiken voor compatibiliteit met alle drie versies.

Office-toepassingen ook aantonen dat object modellen met grote dual interfaces kunnen verslechteren in "marshall ing" op bepaalde beperkingen platforms. De code is geschikt voor alle platforms gebruik IDispatch.Voor meer informatie aan de instandhouding van compatibiliteit bij het werken met Office toepassingen, klikt u op het volgende artikelnummer in de Microsoft Knowledge Base:
247579DISPID binding gebruiken voor het automatiseren van Office-toepassingen waar mogelijk

Referenties

Voor meer informatie over COM, v-tabellen en met Automatisering, raadpleegt u de volgende boeken:
Rogerson, Dale,Inside COMMSPRESS, ISBN: 1-57231-349-8.

Curland, mat,Ervaren Visual Basic 6DevelopMentor, 0201707128.

Eigenschappen

Artikel ID: 245115 - Laatste beoordeling: dinsdag 1 maart 2011 - Wijziging: 2.0
De informatie in dit artikel is van toepassing op:
  • 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 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
Trefwoorden: 
kbautomation kbinfo kbmt KB245115 KbMtnl
Automatisch vertaald artikel
BELANGRIJK: Dit artikel is vertaald door de vertaalmachine software van Microsoft in plaats van door een professionele vertaler. Microsoft biedt u professioneel vertaalde artikelen en artikelen vertaald door de vertaalmachine, zodat u toegang heeft tot al onze knowledge base artikelen in uw eigen taal. Artikelen vertaald door de vertaalmachine zijn niet altijd perfect vertaald. Deze artikelen kunnen fouten bevatten in de vocabulaire, zinsopbouw en grammatica en kunnen lijken op hoe een anderstalige de taal spreekt en schrijft. Microsoft is niet verantwoordelijk voor onnauwkeurigheden, fouten en schade ontstaan door een incorrecte vertaling van de content of het gebruik ervan door onze klanten. Microsoft past continue de kwaliteit van de vertaalmachine software aan door deze te updaten.
De Engelstalige versie van dit artikel is de volgende:245115

Geef ons feedback

 

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