Késői kötés - Late binding
A késői kötés , a dinamikus kötés vagy a dinamikus összekapcsolás - noha nem azonos az importált kódkönyvtárak dinamikus összekapcsolásának folyamatával - olyan számítógépes programozási mechanizmus, amelyben az objektumra hívott metódust vagy az argumentumokkal meghívott függvényt név szerint keresik a futási . Más szavakkal, egy név futáshoz, nem pedig fordításhoz kapcsolódik egy adott művelethez vagy objektumhoz.
A korai kötődés , vagy statikus kötődés , egy objektum-orientált nyelv , összeállításához fázis javít minden típusú változók és kifejezések. Ezt általában a lefordított program eltárolja egy virtuális metódus táblázatban ("v-table"). Ezzel szemben késői kötés esetén a fordító nem olvas el elegendő információt a módszer létezésének ellenőrzéséhez, vagy nem köti le a rést a v-táblán. Ehelyett a módszert név szerint keresik futás közben.
A késői kötés elsődleges előnye a komponensobjektum -modell (COM) programozásában az, hogy a fordítónak nem kell hivatkoznia az objektumot tartalmazó könyvtárakra fordítási időben . Ezáltal a fordítási folyamat ellenállóbbá válik a verziókonfliktusokkal szemben, amelyekben az osztály v-táblája véletlenül módosulhat. (Ez nem aggodalomra ad okot az időben fordításban összeállított platformokon, mint például .NET vagy Java, mert a v-táblát futásidőben hozza létre a virtuális gép a könyvtárakkal szemben, miközben betöltik őket a futó alkalmazásba.)
Történelem
A "késői kötés" kifejezés legalább az 1960 -as évekre nyúlik vissza, ahol megtalálható az ACM kommunikációjában . A kifejezést széles körben használták a hívó konvenciók leírására olyan nyelveken, mint a Lisp, bár általában negatív konnotációkkal a teljesítményről.
A 1980-as években a Smalltalk népszerűsítette az objektumorientált programozást (OOP) és ezzel együtt a késői kötést. Alan Kay egyszer azt mondta: "Az OOP számomra csak az üzenetküldést, a helyi megőrzést, valamint az állami folyamatok védelmét és elrejtését jelenti, és minden dolog extrém késői kötését. Ezt meg lehet tenni a Smalltalkban és a LISP-ben. Lehet, hogy vannak más rendszerek is ez lehetséges, de nem vagyok tisztában velük. "
A kilencvenes évek elején és közepén a Microsoft erősen népszerűsítette COM szabványát, mint bináris interfészt a különböző OOP programozási nyelvek között. A COM programozás egyaránt népszerűsítette a korai és a késői kötést, számos nyelv támogatja mindkettőt szintaktikai szinten.
2000 -ben Alex Martelli megalkotta a " kacsa gépelés " kifejezést, hogy hasonló fogalomra utaljon, de más hangsúllyal. Míg a késői kötés általában a megvalósítás részleteire összpontosít, a kacsa gépelés a típusok figyelmen kívül hagyásának képességére és az objektum jelenlegi módszereire koncentrál.
Késői kötési megvalósítások
Késői kötés dinamikusan beírt objektum-orientált nyelveken
A legtöbb dinamikusan beírt nyelvben az objektumon lévő metódusok listája futás közben módosítható. Ez késői kötést igényel.
Késői kötés Lispben
A Lisp . a későn kötött globális függvényhívások hatékonyan kereshetők futásidőben egy szimbólum függvénycelláján keresztül . Ezek a funkciókötések megváltoztathatók.
Példa egy interaktív Clozure Common Lisp munkamenetre:
? (defun foo ()
(bar pi)) ; a still undefined function BAR gets called
;Compiler warnings :
; In FOO: Undefined function BAR
FOO
? (defun bar (x) ; now we define it
(* x 2))
BAR
? (foo) ; calling foo and it uses the recent definition of BAR
6.283185307179586D0
? (defun bar (x) ; now we redefine BAR
(* x 1000))
BAR
? (foo) ; FOO now calls the new function, there is no need to recompile/link/load FOO
3141.592653589793D0
? (type-of 'bar) ; BAR is a symbol
SYMBOL
? (symbol-function 'bar) ; the symbol BAR has a function binding
#<Compiled-function BAR #x302000D1B21F>
Késői kötés C ++ - ban
A C ++ nyelvben a késői kötés (más néven "dinamikus kötés") arra utal, hogy általában mi történik, ha a virtualkulcsszót egy módszer deklarációjában használják. A C ++ ezután létrehoz egy úgynevezett virtuális táblát, amely keresőtábla az ilyen funkciókhoz, amelyeket mindig megkérdeznek, amikor meghívják őket. Általában a "késői kötés" kifejezést használják a " dinamikus küldés " javára .
Késői kötés COM nyelveken
A COM programozás során késői kötésű metódushívás történik az IDispatch interfész használatával. Egyes COM-alapú nyelvek, például a Visual Basic 6, szintaktikai támogatással hívják fel ezt a felületet. Ez úgy történik, hogy a változó típusát Objektumként határozzuk meg. Mások, például a C ++ megkövetelik, hogy kifejezetten hívja meg a GetIDsOfNames -t, hogy megkeresse a módszert, és hívja meg az Invoke -t annak meghívásához.
Késői kötés .NET -ben
A .NET, Késői kötés utal kényszerítő olyan virtualmódszerrel, mint a C ++, vagy végrehajtási egy interfész. A fordító virtuális táblákat készít minden virtuális vagy interfész metódus híváshoz, amelyet futás közben használnak a végrehajtandó végrehajtás meghatározásához.
A COM -hoz és a Java -hoz hasonlóan a Common Language Runtime reflexió API -kat is biztosít, amelyek késői kötési hívásokat kezdeményezhetnek. E hívások használata nyelvenként eltérő.
A C# 4 segítségével a nyelv hozzáadta a "dinamikus" pszeudo-típust is. Ezt használnánk az Objektum típus helyett annak jelzésére, hogy késői kötés kívánatos. A szükséges késői kötési mechanizmust futás közben határozzák meg, a dinamikus nyelvi futásidőt kiindulási pontként használva.
A Visual Basic ezeket használja, amikor a változó Object típusú, és a fordítói irányelv "Option Strict Off" van érvényben. Ez az új VB -projekt alapértelmezett beállítása. A 9. verziót megelőzően csak .NET és COM objektumokat lehetett későn kötni. A VB 10 esetében ezt kiterjesztették a DLR-alapú objektumokra.
Késői kötés a Java -ban
Három definíció létezik a késői kötésre a Java -ban.
A Java -val kapcsolatos korai dokumentumok arról beszéltek, hogy az osztályok nem voltak összekapcsolva a fordítás idején. Míg a típusokat statikusan ellenőrzik a fordítási időben, az osztályok különböző megvalósításai kicserélhetők közvetlenül a futásidő előtt egyszerűen az osztályfájl felülírásával. Amíg az új osztálydefiníció ugyanazokat az osztály- és metódusneveket tartalmazta, a kód továbbra is működik. Ebben az értelemben hasonlít a késői kötés hagyományos meghatározásához.
Jelenleg népszerű a késői kötés kifejezés használata a Java programozásban a dinamikus küldés szinonimájaként . Konkrétan ez a Java virtuális módszerekkel használt egyetlen feladási mechanizmusára vonatkozik.
Végül a Java a késői kötést használhatja tükröző API -jaival, és nagyjából ugyanúgy írja be az introspekciót , mint a COM és .NET programozás során. Általában azok, akik csak Java nyelven programoznak, nem nevezik ezt a késői kötésnek. Hasonlóképpen a "kacsa gépelés" technikák használatát rosszallják a Java programozásban, helyette absztrakt felületeket használnak.
Az Oracle -ről, a Java jelenlegi tulajdonosáról ismert, hogy a késői kötés kifejezést a "kacsa gépelés" értelmében használja, amikor ugyanabban a dokumentációban tárgyalja a Java -t és más nyelveket.
Korai vs késői kötés PL/SQL és Ada esetén
Az Ada és az adatbázisban tárolt eljárás közötti korai kötés használatakor az időbélyegző ellenőrzi, hogy a tárolt eljárás nem változott-e a kód fordítása óta. Ez gyorsabb végrehajtást tesz lehetővé, és megakadályozza, hogy az alkalmazás a tárolt eljárás rossz verziójával szemben fusson.
Késői kötés használatakor az időbélyegző ellenőrzése nem történik meg, és a tárolt eljárás egy anonim PL/SQL blokkon keresztül történik. Bár ez lassabb is lehet, megszünteti az összes ügyfél -alkalmazás újrafordításának szükségességét, ha egy tárolt eljárás megváltozik.
Ez a megkülönböztetés egyedülállónak tűnik a PL/SQL és az Ada esetében. Más nyelvek, amelyek PL/SQL eljárásokat hívhatnak, valamint más adatbázis -motorok csak késői kötést használnak.
Kritika
A késői kötés gyengébb teljesítményű, mint a korai kötött módszerhívás. A legtöbb megvalósítás során a helyes metóduscímet névvel kell megkeresni minden hívásnál, ami viszonylag költséges szótárkeresést és esetleg túlterhelés -feloldási logikát igényel, de a modern számítógépeken általában elhanyagolható.
Néhány fordító esetében a késői kötés megakadályozhatja a statikus típusellenőrzést. Késői kötött hívás kezdeményezésekor a fordítónak feltételeznie kell, hogy a módszer létezik. Ez azt jelenti, hogy egy egyszerű helyesírási hiba futásidejű hibát okozhat. A pontos kivétel nyelvenként változik, de általában úgy hívják, hogy "Módszer nem található" vagy "Hiányzó módszer". A modern fordítók ezt elkerülik annak biztosításával, hogy a fordítás során minden lehetséges hívásnak megvalósítással kell rendelkeznie.
A késői kötés megakadályozhatja az integrált fejlesztői környezet (IDE) által igényelt statikus elemzési formákat . Például egy IDE "go to definition" funkciója nem működik késői hívás esetén, ha az IDE nem tudja, hogy a hívás melyik osztályra utalhat. Egy modern IDE könnyen megoldja ezt, különösen az objektum-orientált nyelvek esetében, mivel a késői kötésű metódus mindig megad egy interfészt vagy alaposztályt, ahol a "go to definíció" vezet, és az "összes hivatkozás megtalálása" használható az összes megvalósítás vagy felülbírál.
Hasonló probléma, hogy a gépelési információk esetleges hiánya megakadályozhatja a függőségi grafikonok létrehozását. Más programozási módszerek, például az absztrakt interfészek azonban ugyanolyan problémákat okozhatnak. Egy modern IDE olyan könnyen hozhat létre ilyen függőségi grafikonokat, mint ahogyan kezeli az "összes hivatkozás megtalálását".
