Qu'est-ce que la compatibilité binaire ?
Toutes les classes des composants COM (DLL ActiveX, EXE ActiveX, Contrôles
ActiveX (OCX)...) sont identifiables par :
- un ProgID, ex : MonComposant.Classe
- un CLSID (CLaSs IDentifier), sous la forme d'un GUID (Global Unique
IDentifier) : {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}
En late-binding (CreateObject() sous VB), généralement on se sert du
ProgID pour créer une instance de la classe. Celui-ci étant basé sur le
nom du composant et celui de la classe, il ne varie pas d'une version à une
autre, donc aucun problème de compatibilité n'apparaît (notamment avec les
applications déjà existantes utilisant des anciennes versions de notre
composant). Donc tout va bien dans le meilleur des mondes :-) !
Par contre en early-binding c'est le CLSID qui est utilisé, or
hélas celui-ci varie à chaque compilation en VB (alors qu'en VC++ par exemple il
est fixé très simplement une bonne fois pour toute lors la création de la
classe). Ainsi les versions ne sont pas compatibles entre elles ! C'est à dire
qu'une application utilisant une ancienne version de notre composant ne saura
pas reconnaître, et donc utiliser, nos nouvelles versions. Il faudrait donc
recompiler à chaque mise à jour toutes les applications utilisant notre
composant ! Cela pose donc un énorme problème surtout que de telles
incompatibilités empêchent, dans la plupart des cas, le démarrage complet de
l'application client, et que c'est l'early-binding qui est le plus couramment
utilisé (pour les OCX surtout ou pour les DLL si l'on veut bénéficier de l'Intellisense
notamment). Pour rappel, l'utilisation de l'early-binding sous VB se fait par
les Composants (Ctrl + T) et par les Références.
C'est donc là qu'intervient la compatibilité binaire : elle permet de régler
ce problème en fixant le CLSID des classes du composant. Pour l'activer il faut
aller dans le menu "Projet / Propriétés" puis cocher "Compatibilité binaire"
dans le cadre "Compatibilité des versions" (sous l'onglet "Composants"). Un
champ vous permet alors de spécifier un fichier avec lequel rester compatible,
traditionnellement, et pour plus de facilité, on indique notre composant
lui-même (il faut donc déjà compiler une fois le projet, VB associe alors un
CLSID par classe, puis on configure seulement après la compatibilité binaire qui
fixera ces CLSID).
Ainsi les différentes versions seront compatibles entre elles (dans un sens
seulement : une application utilisant une ancienne version pourra sans problème
utiliser une version plus récente alors que l'inverse ne sera pas forcément
toujours vrai). Bien entendu pour que cela fonctionne comme il faut, il est
nécessaire de respecter un minimum de règles (qui sont d'ailleurs tout à fait
logiques) :
- Il ne faut pas supprimer de classe
- Il ne faut pas supprimer de méthodes/propriétés d'une classe
- Il ne faut pas modifier la signature d'une méthode/propriété existante
(type de la valeur de retour, nombre d'argument et type des arguments)
On peut par contre sans problème ajouter des méthodes, des classes, modifier
le code du corps des fonctions/propriétés déjà existantes...
Voir aussi :
Article 104 : Qu'entend-t-on par "early binding" et "late binding" ? Que
préférer ?
http://faq.vb.free.fr/index.php?question=104 |
Top