FAQ C#Consultez toutes les FAQ

Microsoft fournit des interfaces permettant de piloter les applications Office depuis une application .NET. C'est ce qu'on appelle l'automation (cf. Qu'est-ce que l'automation Office ? ) . Ces interfaces sont appelées Primary Interop Assemblies (cf. Que sont les Primary Interop Assemblies ? ).

Cette citation, tirée de l'Aide et Support Microsoft, illustre bien les possibilités offertes par l'automation Office :

« Avec Automation, vous pouvez utiliser la fonctionnalité de publipostage de Microsoft Word pour générer des lettres types à partir de données d'une base de données sans que l'utilisateur se rende compte que Word est impliqué. Vous pouvez même utiliser toutes les fonctionnalités de graphiques et d'analyse de données de Microsoft Excel à l'aide d'Automation. Vous n'avez pas besoin d'écrire votre propre moteur de calcul pour fournir la multitude de fonctions mathématiques, financières et techniques fournies par Excel. Il vous suffit d'automatiser Microsoft Excel pour « emprunter » ces fonctionnalités et les incorporer dans votre propre application. »

Un autre moyen de communiquer avec un document Office, est de le considérer comme une base de données. C'est valable évidemment pour Access, mais aussi, et c'est moins connu, pour Excel (cf. Comment lire dans un fichier Excel ? ).

Une troisième méthode est de manipuler directement le format natif des fichiers Office. C'est le cas du projet SourceForge Koogra qui permet de lire un fichier Excel à partir de son format natif BIFF (Binary Interchange File Format).

Depuis la version 2007 d'Office, un nouveau format a vu le jour, c'est le format OpenXML qui n'est autre qu'un fichier XML et donc aisément lisible et modifiable par programmation. Cependant, ce format n'est compatible que pour Office 2007 et éventuellement Office 2003, après avoir installé un patch permettant de lire ce format.

Enfin, sachez qu'il existe des librairies payantes de pilotage des applications Office. Nul besoin d'en dire plus, vous pourrez trouver toutes les informations nécessaires sur votre moteur de recherche préféré, avec des mots-clés tels que : read, write, excel, word, powerpoint, files, .net...

Il est aussi possible de développer un Add-in pour Office ou de développer une application à partir d'un document Office. C'est ce que permettent les Visual Studio Tools pour Office (cf. Que sont les Visual Studio Tools for Office ? ).

L'automation Office est la technologie automation appliquée au modèle objet Office. Cette définition plus détaillée de l'automation est tirée du Support Microsoft :

« Automation (anciennement OLE Automation) est une technologie qui vous permet de tirer parti d'une fonctionnalité ou du contenu d'un programme existant et de l'incorporer à vos propres applications. Automation est basé sur le composant COM (Component Object Model). COM est une architecture logicielle standard basée sur des interfaces, et conçue pour séparer le code en objets autonomes ou composants. Chaque composant expose un jeu d'interfaces par lesquelles toute la communication avec le composant est gérée. Automation est constitué d'un serveur et d'un client. Le serveur Automation est l'application qui expose ses fonctionnalités au travers d'interfaces COM à d'autres applications, appelées clients Automation. »

Les Primary Interop Assemblies (PIAs) sont des assemblys de code managé capables de communiquer avec les assemblys (de code non managé) du modèle objet Office. Cela est rendu possible parce que les assemblys du modèle objet Office exposent des interfaces COM.

Le mot « Primary » est utilisé lorsque ces assemblys sont fournis par l'éditeur. En l'occurrence, pour les assemblys Office, l'éditeur est Microsoft.

	Chaque version d'Office a ses propres versions de PIAs. Mais chaque version de PIAs est compatible avec les versions précédentes.

Les PIAs sont disponibles dans les installations des applications Office version 2003 et supérieures. Ces modules sont intitulés « Prise en charge de la programmabilité .NET » (« .NET Programmability support »).

Certains PIAs sont aussi disponibles au téléchargement :

• Office XP (voir le lien : Office XP Primary Interop Assemblies (PIAs))
• Office 2003 (voir le lien : Office 2003 Update: Redistributable Primary Interop Assemblies)
  Les PIAs s'installent dans le Global Assembly Cache (GAC) du poste.
  

Les outils Visual Studio pour Office permettent d'utiliser la technologie .NET à partir d'un document Office. Autrement dit, presque tout ce qu'il est possible de faire en winform ou webform est possible au sein du document Office.

Les outils Visual Studio pour Office ne sont valables qu'avec Office 2003 et 2007.

	Les modèles de projet VSTO ne sont pas disponibles dans les versions Express de Visual Studio.

Pour pouvoir développer et exécuter des solutions VSTO, il faut installer le Runtime VSTO (VSTOR), dans sa version 2.0 pour Office 2003 et 3.0 pour Office 2007. Celui-ci est disponible sur le centre de téléchargement Microsoft avec le mot-clé : VSTOR.

Les autres composants indispensables sont

• Le Framework .NET
• Office 2003 ou 2007, dont :
  • La programmabilité .NET (PIAs)
  • Visual Basic pour Applications
  
  

• Les ressources Developpez.com
  Les articles Developpez.com sont un bon point de départ pour l'automation Office : Cours et tutoriels C#.NET avec Office sur Developpez.com
• La MSDN
  La documentation MSDN regorge d'informations concernant l'automation Office et les modèles objet Office. Voici quelques points d'entrée intéressants :
  • Visual Studio Tools pour Office
  • Understanding the Excel Object Model from a Visual Studio 2005 Developer's Perspective
• Les macros VBA
  Enregistrer une macro Office puis visualiser le code VBA généré permet de découvrir les objets Office utilisés et leurs paramètres. C'est très pratique lorsque l'on connaît la fonctionnalité à programmer mais qu'on ne connaît pas l'objet Office correspondant.
• La documentation du modèle objet
  Office fournit une aide décrivant le modèle objet des applications avec des exemples d'utilisation en VBA. Cette aide se trouve dans le répertoire d'installation Office. Pour retrouver ces documents, voir : How to find and use Office object model documentation
  

1. Référencer les assemblys
- Ouvrez un nouveau projet dans Visual Studio.
- Dans le menu Projet, cliquez sur Ajouter une référence. Sous l'onglet .NET, sélectionnez l'assembly PIA souhaité dans la liste. Exemple pour Excel 2007 :

• Il est inutile de référencer les PIAs pour un projet VSTO.
• Si les PIAs ne sont pas installés, il est possible de générer les IAs à partir de l'installation d'Office. Dans ce cas, la référence à ajouter se trouve dans l'onglet COM et le composant s'intitule « Microsoft NomDeLApplication Version Object Library ». Exemple pour Excel :
  

Chaque version d'Office a ses propres assemblys. Mais, de la même façon qu'Office, chaque version des assemblys est compatible avec les versions précédentes.

Ainsi, pour être sûr d'être compatible avec un maximum de versions Office, le mieux est d'utiliser les assemblys les plus anciens. Tout ce qui fonctionne avec une version ancienne, fonctionnera avec une version plus récente d'Office.

D'un autre côté, une version ancienne ne permet pas de bénéficier des fonctions apparues dans les versions récentes d'Office.

En général, les assemblys de la version 9 d'Office (Office 2000) suffisent amplement. Mais si vous souhaitez absolument travailler avec des PIAs, alors les assemblys les plus anciennes sont celles d'Office XP.

Il faut savoir que le format des documents Office a été profondément modifié entre la version 8 (Office 97) et 9 (Office 2000). Par conséquent, l'automation Office avec des PIAs d'Office 97 pour des versions supérieures est déconseillée.

Tableau récapitulatif des versions d'Office et de leur appellation commerciale :

Nombreux sont ceux qui rencontrent ce problème : lorsque vous quittez une automation, vous utilisez (à quelques détails près) cette portion de code :

1
2
monAppli.Quit(); 
monAppli = null;

1. Déclarer les objets avec des variables indépendantes :
   Par exemple, ne faites pas :
   
   

   Code c# :

   Sélectionner tout

   Workbook monClasseur = monAppli.Workbooks.Add();

   Mais plutôt :
   
   

   Code c# :

   Sélectionner tout

   1
   2
   Workbooks mesClasseurs = monappli.Workbooks; 
   Workbook monClasseur = mesClasseurs.Add();

   Pour une automation simple, cela peut passer ; mais pour une automation complexe, cela peut s'avérer extrêmement fastidieux !
2. Libérer les références aux objets COM :
   Utilisez la méthode suivante pour libérer les références à vos objets COM :
   
   

   Code c# :

   Sélectionner tout

   System.Runtime.InteropServices.Marshal.ReleaseComObject(monAppli);

3. Utiliser le Garbage Collector (GC) :
   
   

   Code c# :

   Sélectionner tout

   1
   2
   GC.Collect(); 
   GC.WaitForPendingFinalizers();

   Il peut être utile de doubler cette portion, dans le cas où la référence mémoire du process est conservée après le premier appel.
4. Récupérer l'identifiant du processus office :
   La méthode la plus définitive est de tuer le processus à la fin de l'automation. Il faut pour cela, dans un premier temps, récupérer l'identifiant du processus, et le stocker pendant tout le temps que doit durer l'automation. Exemple pour une automation Word :
   
   

   Code c# :

   Sélectionner tout

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   int processId = 0; 
   // 1. Additionner les identifiants des processus winword avant l'ouverture de l'automation : 
   foreach (Process item in Process.GetProcessesByName("winword")) 
       processId -= item.Id; 
     
   // 2. Ouvrir l'automation : 
   ApplicationClass monAppli = new ApplicationClass(); 
     
   // 3. Ajouter les identifiants des processus winword après l'ouverture de l'automation, 
   // la différence (après - avant) donnera l'identifiant du processus ouvert : 
   foreach (Process item in Process.GetProcessesByName("winword")) 
       processId += item.Id; 
     
   // Automation... 
     
   // Enfin, lorsque l'automation est terminée, il suffit de tuer le processus à partir de son identifiant : 
   Process.GetProcessById(processId).Kill();