AutoIt et les Extensions COM

Introduction rapide

Qu'est-ce que COM ?

COM signifie "Component Object Model". C'est la méthode Microsoft pour connecter des logiciels en utilisant une interface commune. Ces interfaces sont définies dans un Objet COM.

Avant COM, vous deviez connaître l'implémentation exacte d'un programme avant de pouvoir vous 'interfacer' avec. En utilisant COM, vous pouvez maintenant "parler" à ses Objets définis. Les seules choses que vous devez connaître sont les noms des Objets qui sont utilisés et leurs 'propriétés' et 'méthodes'.

Que sont les propriétés et les méthodes des objets?

Voici les deux caractéristiques de base d'un Objet. Vous pouvez voir une 'propriété' comme le stockage de données d'un Objet. On peut voir une 'méthode' comme un appel de fonction interne pour faire quelque chose avec les données.

Est-ce que j'ai besoin de COM dans mon script AutoIt ?

Cela dépend. AutoIt a beaucoup de fonctions incorporées et une énorme bibliothèque d'UDF. Vous pouvez faire la plupart de votre programmation avec ces fonctions. Cependant si vous avez besoin d'un 'interfaçage' spécial avec d'autres applications, l'utilisation de COM pourrait vous soulager de quelques lignes de code. Les Scripteurs doivent être conscients que l'existence d'Objets COM dépend LOURDEMENT du système d'exploitation ET des logiciels installés. Les exemples suivant ont tous été évalués sous une version 'standard' de Windows XP professionnel avec Microsoft Office 2000.

Un exemple d'utilisation de COM dans AutoIt

Supposons que vous vouliez réduire toutes les fenêtres ouvertes. Vous pourriez faire ceci, en utilisant les fonctions classiques d'AutoIt telles que WinList et WinSetState. Cependant, deux lignes de Code-COM peuvent vous donner le même résultat :

$oShell = ObjCreate("shell.application")
$oShell.MinimizeAll

Note: Cet exemple n'est plus la façon la plus courte de réduire toutes les fenêtres après l'introduction de la fonction WinMinimizeAll() dans AutoIt.


Sur la première ligne nous créons un nouvel objet appelé "shell.application". C'est un objet interne de Windows, défini dans shell32.dll. Le pointeur de ce nouvel objet est assigné à la variable $oShell qui devient une variable d'Objet.

Sur la deuxième ligne, nous appliquons une Méthode appelée "MinimizeAll" de l'objet oShell, qui réduira toutes les fenêtres.

Tous les types de Fenêtres ont une quantité importante d'Objets internes à buts divers. Des applications comme Excel ou Word ont aussi leur propre jeu d'Objets.

Cependant, il est parfois difficile d'obtenir une liste de tous les Objets existants définis sur votre système ainsi que leurs propriétés et méthodes correspondantes. La recherche sur Microsoft.com ou Google.com pourrait vous donner quelques indices de l'Objet 'X' que vous voulez utilisez.

Par exemple, vous pouvez trouver des informations sur l'objet "shell.application" à :
http://msdn.microsoft.com/en-us/library/bb774094.aspx


Pour jeter un coup d'œil sur tous les objets installés sur votre système, le "OLE/COM Object Viewer" est un outil très utile. Cet outil, sera expliqué dans une autre section ci-dessous.

Regardons un autre exemple. Pour obtenir le code source HTML d'une certaine page Web, vous pourriez utiliser la fonction interne InetGet() et sauver le résultat dans un fichier pour le récupérer ultérieurement avec FileRead (). Les lignes de code suivante, font la même chose en COM :

$oHTTP = ObjCreate("winhttp.winhttprequest.5.1")
$oHTTP.Open("GET", "http://www.AutoItScript.com")
$oHTTP.Send()
$HTMLSource = $oHTTP.Responsetext

La variable (chaîne) $HTMLSource contient maintenant le code HTML complet de la page d'accueil AutoItScript.com (C'est-à-dire le CADRE HTML supérieur).

(Les informations sur l'objet "winhttp.winhttprequest" peuvent être trouvées à:
http://msdn.microsoft.com/en-us/library/aa384106.aspx )


Gardez à l'esprit : L'existence d'Objet dépend du système d'exploitation de l'ordinateur et des programmes installés. Par exemple, l'objet winhttp.winhttprequest.5.1 existe seulement sur les ordinateurs qui ont au moins la version 5 d'Internet Explorer installée. Lorsque vous partagez des scripts qui utilisent des objets COM, soyez sûr que les objets sont disponibles sur tous les ordinateurs.

Les variables Objet ont un comportement légèrement différent des autres types de variables AutoIt. Un Objet n'est pas réellement une valeur, mais un 'pointeur' sur quelque chose d'extérieur au script. Donc vous ne pouvez pas exécuter d'opération arithmétique, ni de comparaison sur des variables Objet. Lorsque vous assignez une valeur différente à une variable Objet, le 'pointeur' sera automatiquement libéré. Vous pouvez, par exemple, forcer l'effacement d'un Objet en lui assignant n'importe quel nombre ou valeur de texte.

$oHTTP = ObjCreate("winhttp.winhttprequest.5.1") ; Objet créé
$oHTTP = 0 ; Objet supprimé

Vous n'avez pas besoin de supprimer des Objets lorsque vous avez fini. Si un script se termine, AutoIt essaye de libérer toutes les références actives aux Objets qui avaient été créées dans le script. C'est la même chose qui arrive lorsque vous avez défini une variable locale Objet à l'intérieur d'une fonction et que celle-ci prend fin avec un retour au code.


Automatisation avec COM

Une application très populaire de COM est d'automatiser des programmes au lieu d'utiliser les fonctions habituelles de AutoIt comme Send() ou WinActivate(), vous pouvez vous servir des Objets qui sont définis à l'intérieur du programme.

Voici un exemple qui 'automatise' Microsoft Excel:

$oExcel = ObjCreate("Excel.Application") ; Crée un objet Excel
$oExcel.Visible = 1 ; Laisse Excel s'afficher lui-même
$oExcel.WorkBooks.Add ; Ajoute une nouvelle feuille de calcul
$oExcel.ActiveWorkBook.ActiveSheet.Cells(1, 1).Value = "Text" ; Remplit une cellule
Sleep(4000) ; Affiche le résultat pendant 4 secondes
$oExcel.ActiveWorkBook.Saved = 1 ; Simule une sauvegarde du classeur
$oExcel.Quit ; Quitte Excel

La complexité de contrôler d'autres programmes dépend de ceux-ci, et non du script AutoIt. Si quelque chose ne fonctionne pas correctement, vous devez consulter la documentation de l'application et non l'aide de AutoIt.


Instructions Spéciales

Dans AutoIt, deux instructions spéciales sont désignées pour l'utilisation de COM :

WITH/ENDWITH et les boucles FOR/IN/NEXT.

WITH..ENDWITH

L'instruction WITH/ENDWITH n'ajoute aucune fonctionnalité, mais elle permet de rendre votre script plus lisible. Si on reprend l'exemple précédent avec Excel, voici comment il peut être écrit :

$oExcel = ObjCreate("Excel.Application") ; Crée une fenêtre Excel Object

With $oExcel
    .Visible = 1 ; Laisse Excel s'afficher lui-même
    .WorkBooks.Add ; Ajoute une nouvelle feuille de calcul
    .ActiveWorkBook.ActiveSheet.Cells(1, 1).Value = "Text" ; Fill a cell
    Sleep(4000) ; Affiche le résultat pendant 4 secondes
    .ActiveWorkBook.Saved = 1 ; Simule une sauvegarde du classeur Excel
    .Quit ; Quitte Excel
EndWith

Cet exemple ne vous économise pas beaucoup de texte, mais lorsque votre objet utilise de longues lignes de propriétés/méthodes, vous pouvez le raccourcir très fortement en utilisant l'instruction WITH.

FOR..IN

La boucle FOR...IN est requis lors de l'utilisation des Collections. Une collection est un type spécial d'objet, qui existe en dehors des multiples sous-objets. Vous pourriez les voir comme des Tableaux (En réalité, l'instruction FOR.. IN fonctionne aussi sur des variables de type array).

La boucle FOR..IN avec un tableau

Voici un exemple d'une boucle FOR..IN. Cet exemple utilise un tableau normal sous AutoIt, il n'a donc aucun rapport avec COM. Il vous montre simplement le principe :

Local $sString = "" ; A string for displaying purposes

Local $aArray[4]
$aArray[0] = "A" ; Nous remplissons un tableau
$aArray[1] = 0 ; avec plusieurs
$aArray[2] = 1.3434 ; différentes
$aArray[3] = "Example Text" ; valeurs pour exemple.

For $iElement In $aArray ; Ici il démarre...
    $sString = $sString & $iElement & @CRLF
Next

; Affiche les résultats
MsgBox(0, "Exemple For..In avec un tableau", "Résultats: " & @CRLF & $sString)

Boucle FOR..IN avec un Objet

Dans la plupart des cas vous ne pourrez pas utiliser les méthodes 'normales' d'objet pour récupérer les éléments d'une collection. Dans les termes d'utilisation de COM il est dit que vous devez les 'énumérer'. C'est ici que la boucle FOR..IN intervient.

L'exemple Excel ci-dessous fait une boucle sur les cellules A1:O16 de la feuille active. Si une des cellules a une valeur inférieure à 5, le code remplace la valeur par 0 (zéro) :

$oExcel = ObjCreate("Excel.Application") ; Crée un objet Excel

$oExcel.Visible = 1 ; Laisse Excel s'afficher mui-même
$oExcel.WorkBooks.Add ; Ajoute une feuille de calcul

Local $aArray[16][16] ; Ces lignes
For $i = 0 To 15 ; sont juste
    For $j = 0 To 15 ; un exemple pour
        $aArray[$i][$j] = $i ; créer quelques
    Next ; contenus de cellules.
Next

$oExcel.activesheet.range("A1:O16").value = $aArray ; Remplit des cellules avec des nombres

Sleep(2000) ; Attendre un peu avant de continuer

For $iCell In $oExcel.ActiveSheet.Range("A1:O16")
    If $iCell.Value < 5 Then
        $iCell.Value = 0
    EndIf
Next

$oExcel.ActiveWorkBook.Saved = 1 ; Simule une sauvegarde du classeur Excel
Sleep(2000) ; Attendre un peu avant de fermer
$oExcel.Quit ; Quit Excel


Utilisation Avancée de COM

Les caractéristiques suivantes d'AutoItCOM exigent une connaissance approfondie des événements COM et du traitement des erreurs COM.

Si vous êtes néophyte dans la programmation COM, lisez d'abord une bonne documentation sur COM.


La Bible de COM est le livre appelé "Inside OLE 2" par Kraig Brockschmidt (Microsoft Press).


Vous pouvez aussi trouver quelques ressources COM sur Internet (Non lié à AutoIt) :

http://msdn.microsoft.com/en-us/library/ms694363.aspx (introduction)

http://www.garybeene.com/vb/tut-obj.htm (about Objects in Visual Basic)

http://java.sun.com/docs/books/tutorial/java/concepts/ (Using objects in Java)

http://msdn.microsoft.com/archive/en-us/dnarguion/html/drgui082399.asp (Object Events in C++)

http://www.garybeene.com/vb/tut-err.htm (Error handling in Visual Basic)

Evénements COM

L'automatisation COM normale utilise principalement la communication à sens unique. Vous 'demandez' à l'Objet n'importe quelles propriétés ou résultat de Méthode. Toutefois un Objet COM peut aussi 'répondre' à votre script lorsqu'il convient.

Cela est très pratique dans des cas où vous devez attendre qu'une action COM arrive.

Au lieu d'écrire une sorte de boucle, demandant à l'Objet si quelque chose d'intéressant est arrivé, vous pouvez laisser l'Objet lui-même, appeler une fonction spécifique dans votre script. En attendant vous pouvez faire d'autres choses dans votre script (presque) simultanément.


Pas tous les Objets supportent les événements. Vous devez lire la documentation de l'objet soigneusement pour savoir s'il supporte les événements ou non.

Si c'est bon, la deuxième chose à connaître est le type d'événements qu'il supporte. AutoItCOM peut seulement recevoir des événements de type 'opération'.

Finalement vous devez connaître les noms des événements que l'Objet peut produire, y compris leurs arguments (s'il y en a).


Ce n'est que lorsque vous avez toutes ces informations, que vous pouvez commencer à construire un script AutoIt utilisant des Événements COM.

Vous trouverez ci-dessous un petit bout de script qui montre comment recevoir des événements d'Internet Explorer :

$oIE = ObjCreate("InternetExplorer.Application.1") ; Crée un Objet Internet Explorer

$EventObject = ObjEvent($oIE, "IEEvent_", "DWebBrowserEvents") ; Démarre la réception des événements.

$oIE.url = "http://www.autoitscript.com" ; Charge une page Web d'exemple
; Dorénavant, l'Objet $oIE produit des événements pendant le chargement de la page Web.
; Ils sont traités dans les fonctions d'événement ci-dessous.

; Ici vous pouvez laisser le script attendre jusqu'à ce que l'utilisateur veuille terminer.
...(votre code ici)...

$EventObject.stop ; Dit à IE que nous ne désirons plus recevoir des événements
$EventObject = 0 ; Détruit l'Objet Event
$oIE.quit ; Quitte IE
$oIE = 0 ; Décharge IE de la mémoire (pas réellement nécessaire)
Exit ; Fin du script principal


; Fonctions déclenchées par quelques événements d'Internet Explorer.
;
; Pour la liste complète des fonctions Event de IE, voir la documentation MSDN de WebBrowser à:
; http://msdn.microsoft.com/en-us/library/system.windows.forms.webbrowser.aspx

Func IEEvent_StatusTextChange($Text)
    ; Dans le script complet (voir lien ci-dessous) nous montrons le contenu d'une boîte d'édition GUI.
    GUICtrlSetData($GUIEdit, "IE Status text changed to: " & $Text & @CRLF, "append")
EndFunc   ;==>IEEvent_StatusTextChange

Func IEEvent_BeforeNavigate($URL, $Flags, $TargetFrameName, $PostData, $Headers, $Cancel)
    ; Dans le script complet (Voir lien ci-dessous) nous montrons le contenu dans une boite d'édition GUI.
    ; Note: La déclaration est différente de celle de MSDN.
    GUICtrlSetData($GUIEdit, "BeforeNavigate: " & $URL & " Flags: " & $Flags & @CRLF, "append")
EndFunc   ;==>IEEvent_BeforeNavigate

Cliquez ici pour voir le script complet.

La ligne principale de ce script est: $EventObject = ObjEvent ($oIE, "IEEvent_", ...).
Cette fonction prend l'objet $oIE et redirige ses événements vers les fonctions AutoIt dont le nom commence avec IEEvent_. Le troisième paramètre est optionnel. Il est utilisé lorsqu'un Objet a de multiples interfaces d'événements et que vous ne voulez pas que AutoIt en choisisse une automatiquement.

L'Objet responsable de la redirection continue, est $EventObject. Cette variable n'exige pas d'attention particulière, à moins que vous ne vouliez arrêter les événements.

Pour arrêter la redirection des événements, vous ne pouvez pas simplement supprimer la variable comme ceci: $EventObject="". La raison est que l'Objet 'appelant' garde toujours une référence à cette variable et il ne la lâchera pas tant que l'Objet ne quittera pas lui-même. Vous pourriez résoudre ce problème en détruisant l'Objet 'appelant', mais vous pouvez aussi dire à l'Objet que vous ne voulez plus recevoir d'événements en utilisant : $EventObject.Stop. Alors vous pourrez (mais ce n'est pas vraiment nécessaire) tuer l'événement en lui assignant n'importe quelle valeur, comme ceci : $EventObject = "".

Si vous connaissez le nom des événements $oIE envoyés, vous pouvez mettre en œuvre les événements qui vous intéressent en créant un UDF AutoIt avec le nom IEEvent_Eventname (Arguments optionnels). Assurez-vous d'utiliser le nombre correct d'arguments et dans le bon ordre comme spécifié pour CETTE fonction d'événement. Autrement vous pourriez terminer avec des valeurs inattendues.

Vous n'avez pas besoin d'implémenter TOUTES les fonctions d'événement. Celles qui ne le seront pas, seront simplement ignorées.

Beaucoup d'autres exemples de scripts utilisants des fonctions d'événement COM peuvent être trouvés dans le répertoire tests de la distribution Zip bêta de AutoIt, téléchargeable ici: http://www.autoitscript.com/autoit3/files/beta/autoit/


Limitations sur les événements COM dans AutoIt

Quelques Objets (comme le 'Navigateur Internet') passent des arguments à leurs Fonctions d'événement 'par référence'. Ceci est destiné à autoriser l'utilisateur à changer ses arguments et de les renvoyer à l'Objet. Cependant, AutoIt utilise son propre système de variable, qui n'est pas compatible avec les variables COM. Cela signifie que toutes les valeurs d'Objets doivent être converties en variables AutoIt, libérant ainsi la référence à l'espace de mémoire d'origine. Peut-être que dans un avenir proche nous résoudrons ce problème pour vous !

Traitement d'Erreur COM

L'utilisation de COM sans traitement d'erreur approprié peut être très astucieux. Particulièrement quand vous n'êtes pas familiers avec les Objets dans votre script.

Seulement s'il n'y a aucune façon de prévenir une erreur COM, vous pourriez installer un "gestionnaire d'erreur" dans lequel vous agiriez après que l'erreur soit arrivée. Ce n'est pas une solution pour faire fonctionner proprement un script buggé. Les erreurs non-COM rattachées au script, ne seront pas retournées non plus (par ex. déclaration et erreurs de syntaxe).

Le gestionnaire d'erreur est implémenté de la même manière qu'un événement COM normal, en utilisant ObjEvent() et une fonction utilisateur d'Événement COM. La seule différence est l'utilisation d'une chaîne fixe "AutoIt.Error" comme nom d'objet.

Un exemple:

Global $iEventError = 0 ; Pour analyser si une erreur COM se produit. Doit être réinitialisé après traitement.

$oMyError = ObjEvent("AutoIt.Error", "ErrFunc") ; Installe un gestionnaire d'erreur personnalisé

; Provoque une erreur volontaire (l'objet n'existe pas)
$oIE = ObjCreate("InternetExplorer.Application")
$oIE.visible = 1
$oIE.bogus
If $iEventError Then
    MsgBox(0, "", "Il y avait une erreur sur la ligne précédente.")
    $iEventError = 0 ; Re-initialise après affichage d'une erreur COM trouvée
EndIf
Exit

; Ceci est un gestionnaire personnalisé d'erreur
Func ErrFunc()
    $HexNumber = Hex($oMyError.number, 8)
    MsgBox(0, "", "Nous interceptons une erreur COM !" & @CRLF & _
            "Number is: " & $HexNumber & @CRLF & _
            "WinDescription is: " & $oMyError.windescription)
    $iEventError = 1 ; Use to check when a COM Error occurs
EndFunc   ;==>ErrFunc


Une chose est spéciale au sujet du traitement d'erreur d'événement, c'est l'Objet qu'il retourne. C'est un Objet d'Erreur AutoIt qui contient quelques propriétés et méthodes utiles. Sa mise en œuvre est en partie basée sur l'Objet "Err" dans VB (Script) :

Les propriétés de l'Objet d'Erreur AutoIt :

.number La valeur HRESULT Windows d'un appel à COM
.windescription Le texte FormatWinError() dérivé de .number
.source Nom de l'Objet produisant l'erreur (Contenu de ExcepInfo.source)
.description Description d'Objet source de l'erreur(Contenu de ExcepInfo.description)
.helpfile Aide de l'Objet Source pour l'erreur(Contenu de ExcepInfo.helpfile)
.helpcontext Numéro ID du contexte du fichier d'aide de l'Objet Source (Contenu de ExcepInfo.helpcontext)
.lastdllerror Le numéro retourné par GetLastError()
.scriptline La ligne du script sur laquelle l'erreur a été générée

Méthodes de l'Objet d'Erreur AutoIt :

.raise Lève un événement d'erreur, lancé par l'utilisateur
.clear Nettoie le contenu de l'Objet d'Erreur (C'est-à-dire les nombres à 0, les chaînes à "")

Note pour les créateurs de UDF

Vous pouvez avoir plusieurs gestionnaires d'erreurs d'événements COM. Le dernier enregistré est celui qui sera appelé.

Cependant, vous ne pouvez jamais arrêter un gestionnaire d'erreurs existant sans corriger la variable qui avait été assignée. Cela se produit lorsque cette variable est hors de portée ou est réaffectée.

Visualisateur d'Objet OLE/COM

Le "Visualisateur d'Objet OLE/COM" est un outil très utile pour pouvoir jeter un coup d'oeil sur tous les objets COM actuellement installés sur votre système. C'est un élément du kit de ressource de Windows 2000 et il peut être téléchargé gratuitement ici : http://www.microsoft.com/downloads/details.aspx?familyid=5233b70d-d9b2-4cb5-aeb6-45664be858b6&displaylang=en

L'installation de ce programme est un peu maladroite. Il ne créera pas d'icône dans le menu Démarrer. Au lieu de cela, un fichier appelé oleview.exe sera installé dans le répertoire d'installation par défaut C:\Program Files\Resource Kit.

Lors de l'exécution de oleview.exe, quelques systèmes réclament un fichier appelé iviewers.dll. Ce fichier est nécessaire, mais, étrangement, n'est pas inclus dans la dernière version du setup. Vous pouvez obtenir cette dll à partir d'une ancienne version de oleview.exe à: http://download.microsoft.com/download/2/f/1/2f15a59b-6cd7-467b-8ff2-f162c3932235/ovi386.exe. Elle installera les fichiers par défaut dans le répertoire C:\MSTOOLS\BIN. Vous avez seulement besoin du fichier iviewer.dll. Copiez le vers le répertoire où se trouve oleview.exe, puis enregistrez la dll avec la ligne de commande: regsvr32 iviewers.dll.

Exemple avec Oleviewer. Exécutez-le et suivez ce chemin: Object Classes->Grouped by Component Category->Control->Microsoft Web Browser.



Dans la colonne gauche vous pouvez voir toutes les Interfaces COM qui ont été définies pour cet objet. Nous parlerons de cela plus tard. Regardez de plus près la colonne de droite. Elle contient beaucoup d'informations pour utiliser cet objet dans un script AutoIt. Le plus important est "VersionIndependentProgID". C'est le nom à utiliser dans un ObjCreate(), ObjGet() ou ObjEvent(). En outre il contient le répertoire et le nom de fichier qui contient l'objet. Cela peut être un EXE, une DLL ou un fichier OCX. InProcServer32 signifie que l'objet fonctionne dans le même processus (thread) que votre script (à l'exécution). Lorsque vous voyez LocalServer32 les objets fonctionnent dans des processus séparés. L'objet doit aussi contenir une bibliothèque de type (les lignes après "TypeLib="), autrement il ne peut pas être utilisé dans un script AutoIt.

Les interfaces de la colonne de gauche sont utilisées pour agir de différentes manières avec l'objet. Certaines sont utilisées pour le stockage (IStorage, IPersist), les autres pour être embarquées dans une GUI (IOleObject, IOleControl). AutoIt utilise l'interface IDispatch pour l'automatisation. Cette interface 'expose' toutes les méthodes et les propriétés scriptables que l'objet supporte. Si elle n'existe pas, vous ne pouvez pas utiliser l'objet dans un script AutoIt.

Jetons un coup d'œil à cette interface. Faites un clic-droit sur le nom IDispatch et choisissez "View..." à partir du menu contextuel. Cliquez alors le bouton "View TypeInfo...". (Note : Si ce boutton est grisé, vous n'avez pas enregistré le fichier iviewers.dll, ou c'est que l'objet n'a pas de bibliothèque de type)



La fenêtre "ITypeInfo Viewer" montre seulement les informations fournie avec l'objet. Si le développeur décide de ne pas inclure un fichier d'aide, vous ne verrez que les noms des méthodes/propriétés et rien d'autre. La bibliothèque de type du "Navigateur Web Microsoft" est cependant trés vaste. Cliquez juste sur un élément dans la colonne de gauche et une description sera montrée à droite. Parfois vous devrez examiner "Inherited Interfaces" pour récupérer plus de méthodes pour l'objet.

La syntaxe des méthodes/propriétés décrites sont dans le style C/C++. Une propriété décrite comme "HRESULT Resizable([in] VARIANT_BOOL pbOffline)", a été réécrite dans AutoIt comme ceci : $Resizable=$Object.Resizable ($Object contient l'objet créé avec ObjCreate ou ObjGet).

Termes COMmunément confondus

Ces termes sont généralement confondus avec COM, mais ils ont une signification différente:

OOP = Object Oriented Programming (Programmation Orienté Objet). Une technique de programmation dans laquelle des composants logiciels sont réunis à partir de composantes réutilisables connus comme des Objets.

DDE = Dynamic Data Exchange (Echange de Données Dynamiques).

Vous pouvez dire que c'est le prédécesseur de COM. Il a utilisé IPC pour transférer des informations et des commandes entre des applications différentes.

OLE = Object Linking and Embedding (Liaison et Imbrication d'Objet)

Dans sa première version, OLE fut une version étendue de DDE pour 'imbriquer' les données d'un programme vers un autre. La génération actuelle d'OLE est construite sur la partie supérieure de COM et fait partie d'ActiveX.

Automation = C'est une façon de manipuler les objets d'une autre application. Elle est utilisée dans OLE, ActiveX et COM.

ActiveX = La nouvelle génération d'OLE avec l'Automation, au début surtout développé pour interfacer les applications sur un réseau (Surtout les navigateurs web). ActiveX est construit sur la partie supérieure de COM.

DCOM = Distributed COM (COM Distribué). Une légère modification de COM, le rendant capable de communiquer entre différents ordinateurs physiques.

.NET (Point Net)= Ce n'est pas vraiment une partie de logiciel, mais plutôt 'une idée' de Microsoft pour interconnecter à peu près "tout" par (leur) logiciel. "Point Net" est utilisé principalement pour des services à base Web.

COMmunist = Ce n'est pas un partisan de COM, mais quelqu'un qui croit au communisme (Une théorie dont le peuple devrait posséder toutes les propriétés).