Gestion d'un serveur OLEAutomation sous Delphi .NET

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

I-A. Les sources▲

Interop Assembly
Un assemblage produit par l'outil d'import de librairie de type est connu 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étadonné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 ».

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 coclasses 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.

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' :

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

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

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

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

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

{%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 :

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'. Toute 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.

IV-A. Les déclarations▲

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

implementation

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

IV-B. Création du serveur Word (Early Binding)▲

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

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

IV-C. Manipulation de paramètres optionnels▲

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

Empty := System.Reflection.Missing.Value;

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

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

IV-D. Création du serveur Word (Late Binding)▲

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

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);

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.

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

    // 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);

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);

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

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

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 leurs 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.

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

La solution proposée ici s'appuie sur les outils du SDK mis en œuvre 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.

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

@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 :

@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 DLL.
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.

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

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

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 :

@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 DLL.
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 ligne 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, seules nous intéressent les clés suivantes, et ce, pour chaque classe déclarée :

[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 fourni 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 utilisées pour la gestion des versions d'un même composant, voir Clés de Registre dépendantes de la version.

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

en :

rem prépare l'environnement
call sdkvars

Projet : …\MSWord\prjPIA\MSWordPIA

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

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

{%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 :

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

VI-A. Les déclarations▲

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

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

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

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 :

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 :

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é :

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:

Exclude(msWord.DocumentOpen,@InformeOpenDoc);

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

Develop Microsoft Office Solutions with Visual Studio .NET

System.Interop (local)

Primary Interop Assemblies (PIAs)

Livre gratuit sur le sujet (EBook Freeware)
COM and .NET Interoperability