1. Public concerné

Image non disponible


Testé sous le framework .NET 1.1 et Delphi 2005.
Version 1.0

1-1. Les sources

Les fichiers sources des différents exemples :
FTP.
HTTP.

L'article au format .PDF.

2. Introduction

Interop Assembly :
Un assemblage produit par l'outil d'import de librairie de type est connue en tant qu'assemblage d'interopérabilité (Interop Assembly) parce qu'il contient des définitions des types COM qui peuvent être employées dans du code managé par l'intermédiaire de l'interopérabilité de COM.
Les méta-données à l'intérieur d'un assemblage Interop permettent aux compilateurs .NET de résoudre les appels, et au CLR de générer dynamiquement un Runtime-Callable Wrapper (RCW) (cf. l'aide Delphi 2005).

Vous trouverez dans cet article de Bidou le détail de COM interop.

Avoir aussi :
Assemblies PIA
Chapitre de l'ouvrage ".NET and COM: The Complete Interoperability Guide"

3. Gestion de la librairie de type

Le modèle COM étant une composante importante du système Windows, Microsoft l'a parfaitement intégré dans la plate-forme .NET. On manipule toujours une librairie de type pour créer un proxy d'un serveur d'automation. L'outil du SDK TLibImp.exe permet de générer les fichiers nécessaires à son utilisation.
La simplicité d'utilisation restant de mise sous Delphi 2005, l'IDE gère pour vous cette création de manière transparente.

Pour utiliser un serveur OLEAutomation sous Delphi .NET, par exemple ici Word d'Office 2000, la démarche diffère de celle utilisée sous Win32.
On doit dans un premier temps créer les assemblages d'interopérabilité entre le serveur automation Win32 et la plate-forme .NET, et ce, pour que le compilateur puisse trouver les interfaces et co-classes exposées par le serveur automation. Ces assemblages peuvent être soit créés à partir de la librairie de type soit fournis par l'éditeur, dans ce cas ils portent le nom de PIA (Primary Interop Assemblies) et sont certifiés par l'éditeur.

 
Sélectionnez

Les assemblages PIA COM autorisent l'appel de code non managé (COM) à partir de code managé (.NET) à l'aide du 
Microsoft .NET Framework et du Common Language Runtime. Les assemblages PIA COM permettent de lier les 
applications managées aux types non managés lors de la compilation, puis fournissent des informations au 
Common Language Runtime sur la façon dont les types non managés doivent être mis en ordre lors de l'exécution. 

Après avoir créé un projet VCL pour .NET, placez-vous dans l'onglet 'Gestionnaire de projet' :

Image non disponible
Référence du projet avant l'ajout des références du serveur COM

Ajoutons, par un clic droit sur l'entrée références, une référence au serveur automation Word :

Image non disponible
Ajout d'une référence

Dans la fenêtre suivante sélectionnons l'onglet 'Imports COM' :

Image non disponible
Ajout d'une référence via l'import d'un serveur COM

Ici nous pouvons soit sélectionner un fichier de librairie dans un répertoire particulier, ici celui d'Office 2000 :

Image non disponible
Sélection d'un fichier de librairie

Pour Excel, la librairie de type se trouve directement dans l'exécutable Excel.exe.

Soit sélectionner une librairie de type déclarée dans la liste :

Image non disponible
Sélection d'une librairie de type déclarée

Les deux approches étant identiques, l'IDE ajoute dans le fichier DPR du projet courant les lignes suivantes :

 
Sélectionnez

{%DelphiDotNetAssemblyCompiler 'comimports\Interop.Office.dll'}
{%DelphiDotNetAssemblyCompiler 'comimports\Interop.VBIDE.dll'}
{%DelphiDotNetAssemblyCompiler 'comimports\Interop.Word.dll'}

Notez qu'ici la création des DLL est automatique. La liste des références devenant :

Image non disponible
Nouvelles références

Dans ce cas précis, la création des dépendances est gérée de manière automatique.
Ces lignes ne doivent être modifiées qu'au travers de l'IDE, principalement par le menu 'retirer du projet' dans le 'Gestionnaire de projet'. Tout autre manipulation se fait à vos risques et périls (principalement une perte de temps). L'IDE crée dans le répertoire de votre projet un sous-répertoire nommé ComImports et par défaut place les références en 'copie locale', c'est à dire qu'il recopie à la racine de votre projet les fichiers nécessaires lors de l'exécution.

Aide de Delphi 2005 : Ajout d'une référence à un serveur COM.

Lors d'une copie de projet les références Interop ne sont pas modifiées.

4. Utilisation du serveur automation

4-1. Les déclarations

Projet : ...\MSWord\prj1\MSWord1

L'ajout de Word dans la clause uses permet d'accéder aux déclarations des classes et interfaces. Dans la partie publique de la déclaration de la forme principale, déclarons les deux variables suivantes :

 
Sélectionnez

  TForm1 = class(TForm)
   ...  
  public
    msWord : Word.ApplicationClass; // L'application Word
    Empty  : TObject;               // Pour les paramètres optionnels
  end;

Puis ajoutons la déclaration de l'espace de nom dans la clause uses de la partie implementation :

 
Sélectionnez

implementation

{$R *.nfm}
uses System.Reflection; // Pour la classe Missing

4-2. Création du serveur Word (Early Binding)

Dans le contexte de l'édition des liens à la compilation (Early Binding), la déclaration suivante msWord:=Application; compile mais provoque une exception lors de l'exécution En effet, Application étant une interface elle ne peut être instanciée directement, il n'est donc pas possible de créer le serveur comme sous le langage C# :

 
Sélectionnez

Microsoft.Office.Interop.Word.Application msWord = new Microsoft.Office.Interop.Word.Application();

L'interface est par contre accessible via la classe ApplicationClass, information qu'on peut retrouver via l'outil IL Dasm.
La création est donc :

 
Sélectionnez

 msWord := Word.ApplicationClass.Create;
  // Word visible
 msWord.Visible:=True;

En utilisant l'export d'IL Dasm on peut retrouver les classes possédant un constructeur .ctor :

  • ApplicationClass,
  • DocumentClass,
  • FontClass,
  • GlobalClass,
  • LetterContentClass,
  • OLEControlClass,
  • ParagraphFormatClass,
  • il y a aussi les classes xxxEventsxxx ...

Dans un fichier de librairie de type importée sous Delphi Win32 on retrouve certaines correspondances :

  • TWordApplication = class(TOleServer)
  • TWordDocument = class(TOleServer)
  • TWordFont = class(TOleServer)
  • TWordLetterContent = class(TOleServer)
  • TWordParagraphFormat = class(TOleServer)
  • ...

4-3. Manipulation de paramètres optionnels

L'utilisation du type variant n'étant pas compatible avec le CLR qui lui est basé sur le type System.Object, on ne peut plus utiliser VarEmpty comme variable pour les paramètres optionnels d'un appel de méthode d'un serveur automation.

 
Sélectionnez

 msWord.Application.Quit(VarEmpty,VarEmpty,VarEmpty);

Sous .NET on utilisera une instance de la classe Missing déclarée dans System.Reflection.
Dans la méthode associée à l'événement Oncreate de la fiche, ajoutons l'initialisation de la variable Empty :

 
Sélectionnez

 Empty := System.Reflection.Missing.Value;

La classe Missing ne peut pas être héritée et il n'existe qu'une seule instance de cette classe.

La méthode Quit attend 3 paramètres, de type TObject, passés par référence. On ne peut donc pas utiliser l'appel suivant :

 
Sélectionnez

 msWord.Application.Quit(nil,nil,nil);

On doit donc utiliser :

 
Sélectionnez

 msWord.Application.Quit(Empty,Empty,Empty);

4-4. Création du serveur Word (Late Binding)

Projet : ...\MSWord\prj1-1\MSWord11

Dans le contexte de l'édition des liens tardive (Late Binding), permettant un appel dynamique, le code d'appel utilise le système de réflexion de .NET.
On doit par contre modifier la déclaration du type de la variable msWord :

 
Sélectionnez

  TForm1 = class(TForm)
   ...  
  public
    msWord : TObject; // L'application Word
    Empty  : TObject; // Pour les paramètres optionnels
  end;

Ensuite le code de base pour instancier le serveur devient :

 
Sélectionnez

procedure TForm1.btOpenWordClick(Sender: TObject);
var objetClassType : System.&Type;    // Pour le système de réflexion
    Parametres     : TObjectDynArray; // Tableau de paramétres
    isWordVisible  : Boolean;         // Récupération d'une propriété du serveur automation
    errorMessage   : String;
begin
 try
   // Obtient le type de la classe type.
   objetClassType:= System.&Type.GetTypeFromProgID('Word.Application');

    // Instancie Word.
   msWord:= Activator.CreateInstance(objetClassType);

Extrait du SDK :

 
Sélectionnez

La classe Type constitue la base de la fonctionnalité System.Reflection et représente le principal moyen 
d'accéder aux métadonnées. Utilisez les membres de Type pour obtenir les informations concernant une 
déclaration de type, tel que les constructeurs, méthodes, champs, propriétés et événements d'une classe, 
ainsi que le module et l'assembly dans lesquels la classe est déployée.

L'appel de méthodes du serveur automation, ici la variable msWord, se fait grâce à la méthode InvokeMember de la classe Type. Dans l'exemple suivant on demande la lecture de la propriété 'visible' en invoquant l'appel de l'accesseur approprié, défini par le paramètre BindingFlags.GetProperty :

 
Sélectionnez

     // Invoque un accesseur pour lire la propriété visible
   isWordVisible:=Boolean(msWord.GetType.InvokeMember('Visible', BindingFlags.GetProperty,Nil, msWord, Nil));

Le résultat de l'exécution de la méthode, de type TObject, doit être transtypé dans le type désiré, ici un Boolean.

La modification d'une propriété se fait en utilisant un tableau dynamique, de type TObject, contenant les paramètres déclarés dans l'entête de la méthode appelée. Il suffit ici de modifier le paramètre BindingFlags.GetProperty en BindingFlags.SetProperty :

 
Sélectionnez

    // Word visible
   Parametres:= New(TObjectDynArray,1);   // Crée un tableau dynamique
   Parametres[0]:= TObject(True);         // Affecte la valeur True au premier et unique paramètre.

     // Invoque un accesseur pour modifier la propriété visible
   msWord.GetType.InvokeMember('Visible', BindingFlags.SetProperty,Nil, msWord, Parametres);

L'appel d'une méthode, autre qu'accesseur, se fait en utilisant le paramètre BindingFlags.InvokeMethod, en ayant au préalable renseigné le tableau de paramètres :

 
Sélectionnez

begin
   Parametres:= New(TObjectDynArray,3); // ou New(array[3] of TObject);
   For I:=0 to Length (Parametres)-1 do
    Parametres[I]:=Empty;

    // Invoque une méthode
   msWord.GetType.InvokeMember('Quit', BindingFlags.InvokeMethod,Nil, msWord, Parametres);

Dans ce contexte, où tous les paramètres sont optionnels, on utilise soit une référence nulle (le tableau Parametres n'est pas instancié) :

 
Sélectionnez

begin
    // Invoque une méthode
   msWord.GetType.InvokeMember('Quit', BindingFlags.InvokeMethod,Nil, msWord, Parametres);

Soit plus simplement Nil à la place de la référence :

 
Sélectionnez

begin
    // Invoque une méthode
   msWord.GetType.InvokeMember('Quit', BindingFlags.InvokeMethod,Nil, msWord, Nil);

5. Construire un PIA non-certifié pour Office 2000

Fichiers : ...\MSWord\PIAOffice\*.*

A mon avis la méthode de gestion des objets COM vue au chapitre 2 a comme inconvénient de dupliquer les DLL pour chaque nouveau projet manipulant un serveur automation identique, par exemple Word.

Les éditeurs tiers offrant des possibilités d'automation pour leur produits proposent des PIA natifs, pouvant donc être partagés via leur inscription dans le cache global des assemblages (GAC) et éviter ainsi une duplication des DLL.
Microsoft propose des PIA pour Office XP et Office 2003 uniquement, il nous faut donc les générer pour les versions antérieures.

Cette méthode ne crée pas de PIA certifié par l'éditeur, Microsoft en l'occurrence, mais peut être une solution au sein d'une entreprise en prenant le soin d'utiliser le même assemblage pour tout le parc machine. Dans ce cas la politique de signature des assemblages de l'entreprise peut se substituer à celle de l'éditeur.
Le code restant identique entre ce PIA non-certifié et les DLL COM Interop dupliqués.

Pour nommer les espaces de nom on peut s'inspirer de ceux des assemblages PIA fournis par Microsoft pour Office XP :

  • Microsoft.Office.Interop.Access.dll
  • Microsoft.Office.Interop.Excel.dll
  • Microsoft.Office.Interop.FrontPage.dll
  • Microsoft.Office.Interop.FrontPageEditor.dll
  • Microsoft.Office.Interop.Graph.dll
  • Microsoft.Office.Interop.Outlook.dll
  • Microsoft.Office.Interop.OutlookViewCtl.dll
  • Microsoft.Office.Interop.Owc.dll
  • Microsoft.Office.Interop.PowerPoint.dll
  • Microsoft.Office.Interop.Publisher.dll
  • Microsoft.Office.Interop.SmartTag.dll
  • Microsoft.Office.Interop.Visio.dll
  • Microsoft.Office.Interop.Word.dll
  • Microsoft.Vbe.Interop.dll
  • dao.dll
  • mscomctl.dll
  • msdatasrc.dll
  • office.dll
  • stdole.dll

Informations complémentaires : Installing and Using the Office 2003 Primary Interop Assemblies

La solution proposée ici s'appuie sur les outils du SDK mis en oeuvre dans un script console, fichier batch. Par expérience, je paramètre le plus possible les batchs au détriment parfois de la relecture pour un débutant.

Recopiez, dans le répertoire contenant le SDK .NET, le script "...\Microsoft.NET\SDK\v1.1\Bin\sdkvars.bat" dans le répertoire C:\Windows. Vous pourrez ainsi déclarer les variables d'environnement selon les besoins.

Voici le script principal enchaînant les opérations :

 
Sélectionnez

@echo off
 rem Main.CMD
Title Construit un PIA non-certifié

 rem Le script sdkvars.bat déclare cette variable d'environnement.
 rem Ce test évite l'ajout répété des chemins du SDK dans le PATH de l'environnement courant
If not "%NetSamplePath%"=="" goto suite

 rem Suppose que le script sdkvars.bat se trouve dans le répertoire %Windir%
if not exist %Windir%\sdkvars.bat goto Erreur
Call sdkvars

:Suite
Call BuildPIA.cmd
Call MakePIARegistry.cmd

Goto End

:Erreur
Echo Le fichier sdkvars.bat, issue du SDK .NET, n'existe pas dans le répertoire %Windir%
Pause

:End

Voici le script de construction des PIA :

 
Sélectionnez

@echo off
 rem BuildPIA.CMD
 rem Construit un PIA 'privé' pour Word2000.
 rem 'Privé' signifiant que l'éditeur d'origine n'assume pas le contenu de ce PIA. 
 rem On simule donc cette partie ...
Title Construit un PIA non-officiel : PIA 

Set OfficeDir=C:\Program Files\Microsoft Office\Office
Set OfficeSharedDir=C:\Program Files\Fichiers communs\Microsoft Shared
 rem Installation US 
 rem Set OfficeSharedDir=C:\Program Files\Common Files\Microsoft Shared

Set SpaceNameOffice=Microsoft.Office.Core
Set SpaceNameVBE=Microsoft.Vbe.Interop
Set SpaceNameWord=Microsoft.Office.Interop.Word

 rem Utilise le même nom que l'espace de nom
Set PiaNameVBE=%SpaceNameVBE%
Set PiaNameWord=%SpaceNameWord%
 rem Office est une des exceptions
Set PiaNameOffice=Office

 rem  Déclare les chemins pour les outils du SDK
 rem * A modifier si l'appel ne se fait pas via le batch Main.cmd *
rem call sdkvars

rem Récupère le chemin d'exécution là où on crée les DLLs.
for /F "tokens=*"  %%i in ('CD') do set LocalDir=%%i

 rem Placez ici votre clé
Set FichierDeSignature=%LocalDir%\MaCle.snk

 rem Crée le fichier de signature.
 rem la variable %NetSamplePath% contient le caractère '\' final.
rem * Inutile si vous souhaitez utiliser le vôtre.
"%NetSamplePath%Bin\sn.exe" -k "%FichierDeSignature%"

 rem Création des PIA signés avec le fichier de signature adéquate.
"%NetSamplePath%Bin\TlbImp" "%OfficeDir%\MSO9.DLL" /out:%PiaNameOffice%.DLL /namespace:%SpaceNameOffice%
  /keyfile:"%FichierDeSignature%" /primary /asmversion:9.0.6926

"%NetSamplePath%Bin\TlbImp" "%OfficeSharedDir%\VBA\VBA6\VBE6EXT.OLB" /out:%PiaNameVBE%.DLL 
 /namespace:%SpaceNameVBE%  /keyfile:"%FichierDeSignature%" /primary 
 /reference:%PiaNameOffice%.DLL /asmversion:6.00.8667

"%NetSamplePath%Bin\TlbImp" "%OfficeDir%\MSWORD9.OLB" /out:%PiaNameWord%.DLL /namespace:%SpaceNameWord% 
 /keyfile:"%FichierDeSignature%" /primary /reference:%PiaNameOffice%.DLL /reference:%PiaNameVBE%.DLL 
 /asmversion:9.0.2717

:end

Set OfficeDir=
Set OfficeSharedDir=
Set SpaceNameOffice=
Set SpaceNameVBE=
Set SpaceNameWord=
Set PiaNameOffice=
Set PiaNameVBE=
Set PiaNameWord=
Set LocalDir=

Les variables d'environnement SpaceNamexxx sont utilisées pour définir les noms des espaces de nom.
Les variables d'environnement PiaNamexxx sont utilisées pour définir les noms de fichier des DLL, certaines portent le même nom que son propre espace de nom.
Le script sdkvars.bat se trouve dans le répertoire du SDK .NET, sur mon poste je l'ai recopié dans le répertoire c:\windows afin de faciliter son appel dans mes différents batch, vous devez soit procéder de la même manière soit indiquer le chemin complet.
Vous pouvez ne pas générer de nouvelle clé mais à la place utiliser votre clé de signature personnelle.

Chaque appel de ce script ajoute dans la variable path les différents chemins d'accès au SDK .NET. Veillez à ne l'appeler qu'une seule fois.

La création du PIA s'effectue en utilisant l'utilitaire TlbImp en lui passant les paramètres adéquats:

 
Sélectionnez

"%NetSamplePath%Bin\TlbImp" "%OfficeSharedDir%\VBA\VBA6\VBE6EXT.OLB" /out:%PiaNameVBE%.DLL 
 /namespace:%SpaceNameVBE%  /reference:%PiaNameOffice%.DLL /keyfile:"%FichierDeSignature%" 
 /primary /asmversion:6.00.8667
Paramètre Usage
%OfficeSharedDir%\VBA\VBA6\VBE6EXT.OLB Nom du fichier contenant la librairie de type (TLB)
/out:%PiaNameVBE%.DLL Nom du fichier de l'assemblage à créer
/namespace:%SpaceNameVBE% Nom de l'espace de nom où déclarer le serveur automation
/reference:%PiaNameOffice%.DLL Spécifie le fichier d'assemblage à utiliser pour résoudre les références aux types définis en dehors de la bibliothèque de types en cours
/keyfile:"%FichierDeSignature%" Signe l'assemblage résultant avec un nom fort en utilisant la paire de clés publique/privée présente dans le fichier indiqué
/primary Produit un assembly PIA (Primary Interop Assembly) pour la bibliothèque de types spécifiée
/asmversion:9.0.6926 Version de l'assemblage, provient du fichier de la TLB

C'est par l'utilisation de ce fichier de signature qu'on se substitue à l'éditeur de la bibliothèque de types importée (ici Microsoft). Une fois ceci fait, si on souhaite se rapprocher de la démarche de Microsoft, il ne reste qu'à créer le fichier de registry associé.
Nous utiliserons un second script pour automatiser sa création :

 
Sélectionnez

@echo off
 rem MakePIARegistry.cmd
 rem Filtre les lignes issues de Regasm et crée un fichier de registry associé au PIA
 rem Nécessite la présence d'un fichier texte nommé pattern.txt contenant :
 rem Class"$
 
 rem prépare l'environnement
rem * A modifier si l'appel ne se fait pas via le batch Main.cmd *
rem call sdkvars

 rem Récupére le chemin d'exécution là où on crée les DLLs.
for /F "tokens=*"  %%i in ('CD') do set Directory=%%i

Set Assemblage=Microsoft.Office.Interop.Word.dll

rem * A modifier si vous recopier l'utilitaire en ligne de commande Grep.exe dans un autre répertoire *
rem Ici le chemin contient le caractère '\' final 
rem Sinon provoque une erreur dans la ligne %Tools%Grep
rem Set Tools=C:\Tools\

Set EnteteReg=REGEDIT4

Set ExportAsm=%Temp%\%Assemblage%.reg
Set TamponReg=%Directory%\%Assemblage%Temp.reg
Set FileReg=%Directory%\%Assemblage%.reg
Set FileAsm=%Directory%\%Assemblage%
Set PatternFile=%Directory%\Pattern.txt
 

 rem Récupère les informations de classe à partir de l'assemblage Interop / PIA
 rem regasm.exe n'est pas dans le répertoire %NetSamplePath%Bin mais dans le répertoire
 rem  C:\WINDOWS\Microsoft.NET\Framework\v1.1.4322
RegAsm /nologo /silent "%FileAsm%" /regfile:"%ExportAsm%"
If exist "%FileReg%" Del "%FileReg%"
 

 rem Recrée le fichier de registry
Echo %EnteteReg%>"%FileReg%"
Echo. >>"%FileReg%"


 rem Première passe
 rem Recherche en fin de chaîne l'occurrence : Class"
 rem Ici pour contourner un pb de grep on utilise un fichier contenant le pattern de recherche
 rem  -i sans distinction de la casse
 rem  -a indique un fichier ASCII
 rem  -B1 affiche 1 lignes avant l'occurrence trouvée
 rem  -A2 affiche 2 lignes après l'occurrence trouvée
 rem Distribution de Grep disponible sur  http://unxutils.sourceforge.net. 
 rem Find supprime la ligne parasite entre 2 occurrences
%Tools%Grep -f"%PatternFile%" -i -a -B1 -A2 "%ExportAsm%" |Find /V "--" >>"%TamponReg%"



 rem Seconde passe
 rem Recherche uniquement les clés contenant la chaîne : \InprocServer32]
 rem  -A3 affiche 3 lignes après l'occurrence trouvée
%Tools%Grep -i -a -A3 "\\InprocServer32\]" "%TamponReg%"|Find /V "--" >>"%FileReg%"



 rem Finalise la création du fichier de registry
 rem Récupère la ligne concernant la librairie de type
%Tools%Grep -i -a -A1 "TypeLib" "%ExportAsm%" |Find /V "--" >>"%FileReg%"

 rem Supprime le fichier temporaire
If exist "%ExportAsm%" Del "%ExportAsm%"
If exist "%TamponReg%" Del "%TamponReg%"

 rem Supprime les variables d'environnement.
Set EnteteReg=
Set Directory=
Set Assemblage=

Set ExportAsm=
Set FileAsm=
Set FileReg=
Set TamponReg=

L'utilitaire Regasm nous permet de générer un fichier de registry contenant toutes les informations du Serveur COM. Par contre, seul nous intéresse les clés suivantes et ce pour chaque classe déclarée :

 
Sélectionnez

[HKEY_CLASSES_ROOT\CLSID\{000209F0-0000-0000-C000-000000000046}\InprocServer32]
"Class"="Microsoft.Office.Interop.Word.GlobalClass"
"Assembly"="Microsoft.Office.Interop.Word, Version=9.0.2717.0, Culture=neutral, PublicKeyToken=0c4e7d4ce931d46d"
"RuntimeVersion"="v1.1.4322"

Le fichier de registry livré avec Office XP ne contient pas les clés de type xxx\InprocServer32\9.0.2717.0.

La création du fichier de registry approprié à notre contexte, et ce, à partir de celui généré par Regasm, s'effectue en plusieurs étapes en utilisant les possibilités de l'utilitaire Grep fournis dans les sources de cet article.

Il vous reste à inscrire ces fichiers dans le GAC.
Pensez à renseigner dans la registry le répertoire hébergeant ces PIA.
Les déclarations présentes dans ce fichier de registry sont utilisiées pour la gestion des versions d'un même composant, voir Clés de Registre dépendantes de la version .

Si vous n'utilisez pas le script Main.cmd, modifiez les lignes suivantes :

 
Sélectionnez

 rem prépare l'environnement
rem * A modifier si l'appel ne se fait pas via le batch Main.cmd *
rem call sdkvars

en :

 
Sélectionnez

 rem prépare l'environnement
call sdkvars

6. Utilisation des PIA générés

Projet : ...\MSWord\prjPIA\MSWordPIA

Il est désormais possible d'ajouter aux projets les références de ces PIA :

Image non disponible
Ajout des assemblages .NET

L'IDE ajoute dans le fichier DPR du projet courant les lignes suivantes :

 
Sélectionnez

{%DelphiDotNetAssemblyCompiler '..\..\unit\piaoffice\Microsoft.Office.Interop.Word.DLL'}
{%DelphiDotNetAssemblyCompiler '..\..\unit\piaoffice\Microsoft.Vbe.Interop.DLL'}
{%DelphiDotNetAssemblyCompiler '..\..\unit\piaoffice\Office.DLL'}

Ici le répertoire cible se trouve dans le répertoire du profil utilisateur :

 
Sélectionnez

C:\Documents and Settings\Laurent\Mes documents\Projets Borland Studio\UNIT\PIAOffice

6-1. Les déclarations

Projet : MSWord1

L'ajout de Microsoft.Office.Interop.Word dans la clause uses permet d'accéder aux déclarations des classes et interfaces. Les déclarations publiques de la forme principale devenant :

 
Sélectionnez

  TForm1 = class(TForm)
   ...  
  public
    msWord : Microsoft.Office.Interop.Word.ApplicationClass; // L'application Word
    Empty  : TObject;               // Pour les paramètres optionnels
  end;

Vous pouvez utiliser la possibilité suivante si vous souhaitez ne pas utiliser des noms longs :

 
Sélectionnez

type
  TWordApplication = Microsoft.Office.Interop.Word.ApplicationClass;

  TForm1 = class(TForm)
    ...
    msWord : TWordApplication; // L'application Word
    Empty  : TObject;               // Pour les paramètres optionnels
  end;

Cette astuce peut faciliter la migration, mais prenez garde au fait que la classe TWordApplication sous Win32 est dérivée de TOleServer.

7. Gestion des événements en provenance du serveur

Pour utiliser les événements du serveur automation nous utiliserons les délégués.
Dans un premier temps déclarons une méthode ayant le même prototype que l'événement que nous souhaitons recevoir. En consultant la documentation livrée avec Ms Office nous obtenons :

 
Sélectionnez

DocumentOpen, événement
 Se produit lors de l'ouverture d'un document.
Syntaxe :
 Private Sub object_DocumentOpen(ByVal Doc As Document)

object
Objet de type Application déclaré avec les événements d'un module de classe.

Doc
Document en cours d'ouverture.

Ce qui se traduit sous Delphi .NET par :

 
Sélectionnez

Procedure TForm1.InformeOpenDoc(Document: Microsoft.Office.Interop.Word.Document);
Begin
 log.Lines.Add('Ouvre le fichier :');
 log.Lines.Add(#9+Document.Name);
end;

Ensuite, une fois l'objet automation de Word créé, connectons notre méthode, DocumenOpen, au délégué souhaité :

 
Sélectionnez

 Include(msWord.DocumentOpen,@InformeOpenDoc);

Pour terminer ajoutons, avant la destruction de l'objet automation de Word, la déconnexion de l'événement précédent:

 
Sélectionnez

 Exclude(msWord.DocumentOpen,@InformeOpenDoc);

Il n'y a rien d'autre à ajouter !

8. Liens