Lire et modifier un document Word OpenXML en C#

Avec l'arrivée de la nouvelle version de Microsoft Office 2007, Microsoft introduit le nouveau format de document Office Open XML pour Word, Excel et PowerPoint et qui succèdent aux formats de fichier binaires d'Office (.doc, .xls et .ppt) apparus avec la sortie d'Office 97.

Grâce à ce nouveau format standardisé à l'ECMA, les fichiers Word deviennent de simples packages zip contenant des fichiers XML. Ainsi, il n'est plus nécessaire de posséder Microsoft Word pour créer ou visualiser des fichiers, un simple éditeur de texte ou une application « maison » suffit.

Le but de cet article est de vous montrer comment lire un document Word au format Open XML. Nous verrons plus spécifiquement, au travers de plusieurs exemples, le code nécessaire afin de charger un document OpenXML, d'en récupérer les propriétés (auteur, date de création, etc.), d'y rechercher l'existence d'un mot ou encore d'extraire les images qu'il contient.

WordprocessingML est un ensemble de conventions pour représenter un document Word au format Open XML. Pour les documents Excel il existe SpreadsheetML et pour les documents PowerPoint il s'agit de PresentationML.

Cet article n'a pas pour but de vous présenter l'architecture et la structure d'un document au format Open XML. Vous devez en avoir pris connaissance avant de lire cet article. Si tel n'est pas le cas, je vous conseille d'aller visiter ces quelques liens : les livres blancs et Structure d'un document Open XML. Cependant, nous allons tout de même faire un petit rappel sur la structure d'un document (ou package) Open XML de type WordprocessingML que vous pouvez visualiser notamment en ajoutant l'extension .zip à un fichier .docx et en l'ouvrant avec votre lecteur de fichiers zip.

Le dossier docProps contient les fichiers de propriétés du document.
Le fichier document.xml est la Part principale d'un document WordprocessingML et contient le texte du corps du document.

Pour nous faciliter la tâche, le Framework 3.0 de Microsoft .NET inclut la nouvelle API de packaging fournie dans l'assembly WindowsBase.dll. Les classes qui constituent l'API packaging sont contenues dans l'espace de noms System.IO.Package.

Vous aurez donc besoin du Framework 3.0 et de son SDK (non obligatoire).

Pour ajouter une référence à votre projet sous Visual Studio : dans le menu projet, cliquez sur ajouter une référence. Si la dll WindowsBase ne se trouve pas dans l'onglet .Net, choisissez l'onglet Parcourir et aller la chercher dans \Program Files\Reference Assemblies\Microsoft\Framework\v3.0.

Vous devrez aussi référencer les espaces de noms System.IO et System.Xml dans votre projet :

using System.IO;
using System.Xml;
using System.IO.Packaging;

La première chose à faire pour pouvoir lire un document OpenXML, est de le charger dans un objet de type Package. Cela se fait en une ligne grâce à la fonction Open de la classe Package. N'oubliez pas à la fin de vos traitements, d'appeler la méthode Close pour fermer le package. Voici le code permettant d'ouvrir en lecture/écriture un document OpenXML :

docWord = @"C:\monFichier.docx";
 
//overture du package en lecture/écriture
Package officePackage = Package.Open(docWord, FileMode.Open, FileAccess.ReadWrite);
 
//mettre ici le code des traitements
 
//fermeture du package
officePackage.Close();

Maintenant que nous disposons de notre objet Package, nous allons voir comment récupérer les différentes parties composant le document.

IV-A. Présentation▲

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<cp:coreProperties 
  xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" 
  xmlns:dc="http://purl.org/dc/elements/1.1/" 
  xmlns:dcterms="http://purl.org/dc/terms/" 
  xmlns:dcmitype="http://purl.org/dc/dcmitype/" 
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <dc:title>OpenXML et dotnet</dc:title>
  <dc:subject>Lire un fichier Word 2007</dc:subject>
  <dc:creator>Florian</dc:creator>
  <dc:description>commentaires</dc:description>
  <dcterms:created xsi:type="dcterms:W3CDTF">2007-05-20T10:16:00Z</dcterms:created>
  <dcterms:modified xsi:type="dcterms:W3CDTF">2007-05-20T10:16:00Z</dcterms:modified>
  <cp:category>Article dotnet</cp:category>
  <cp:contentStatus>En cours</cp:contentStatus>
  <cp:keywords>dotnet OpenXML</cp:keywords>
  <cp:revision>2</cp:revision>
</cp:coreProperties>

IV-B. Récupérer la partie core.xml▲

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<cp:coreProperties 
  xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" 
  xmlns:dc="http://purl.org/dc/elements/1.1/" 
  xmlns:dcterms="http://purl.org/dc/terms/" 
  xmlns:dcmitype="http://purl.org/dc/dcmitype/" 
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <dc:title>OpenXML et dotnet</dc:title>
  <dc:subject>Lire un fichier Word 2007</dc:subject>
  <dc:creator>Florian</dc:creator>
  <dc:description>commentaires</dc:description>
  <dcterms:created xsi:type="dcterms:W3CDTF">2007-05-20T10:16:00Z</dcterms:created>
  <dcterms:modified xsi:type="dcterms:W3CDTF">2007-05-20T10:16:00Z</dcterms:modified>
  <cp:category>Article dotnet</cp:category>
  <cp:contentStatus>En cours</cp:contentStatus> 
  <cp:keywords>dotnet OpenXML</cp:keywords>
  <cp:revision>2</cp:revision>
</cp:coreProperties>

IV-C. Lecture des propriétés▲

if (corePart != null)
{
    //construction d'un XmlNamespaceManager contenant les namespaces utilisés
    NameTable nt = new NameTable();
    XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt);
    nsmgr.AddNamespace("dc", dcPropertiesSchema);
    nsmgr.AddNamespace("cp", cpPropertiesSchema);
    nsmgr.AddNamespace("dcterms", dctermsPropertiesSchema);
 
    //chargement de la partie dans un XmlDocument
    XmlDocument doc = new XmlDocument(nt);
    doc.Load(corePart.GetStream());
 
    XmlNode nodeAuteur = doc.DocumentElement.SelectSingleNode("//dc:creator", nsmgr);
    if (nodeAuteur != null)
        labelAuteur.Text = nodeAuteur.InnerText;
 
    XmlNode nodeTitre = doc.DocumentElement.SelectSingleNode("//dc:title", nsmgr);
    if (nodeTitre != null)
        labelTitre.Text = nodeTitre.InnerText;
 
    XmlNode nodeMotsClefs = doc.DocumentElement.SelectSingleNode("//cp:keywords", nsmgr);
    if (nodeMotsClefs != null)
        labelMotsClefs.Text = nodeMotsClefs.InnerText;
 
    XmlNode nodeDate = doc.DocumentElement.SelectSingleNode("//dcterms:created", nsmgr);
    if (nodeDate != null)
        labelDate.Text = DateTime.Parse(nodeDate.InnerText).ToShortDateString();
}

IV-D. Modification des propriétés▲

//  Met à jour la valeur:
nodeAuteur.InnerText = "Toto";

//  Enregistre le XML des propriétés dans sa partie:
doc.Save(corePart.GetStream(FileMode.Create, FileAccess.Write));

La partie principale d'un document Word OpenXML est générale représentée par le fichier document.xml contenu dans le dossier word (voir l'arborescence présentée au début de ce tutoriel). Tout le contenu textuel d'un document Word s'y trouve. Nous allons illustrer ici la lecture de cette partie par l'écriture d'une méthode qui aura pour but de rechercher un mot (ou une expression) quelconque dans un fichier Word.

La première chose à faire est donc de récupérer la partie principale du document OpenXML au travers d'un objet PackagePart. Pour cela il nous suffit de réutiliser la méthode vue précédemment en changeant simplement le type de contenu à rechercher :

//type de contenu pour la partie principale
const String officeDocRelType = @"http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
 
PackagePart mainPart = null;
Uri documentUri = null;
//on récupère la partie contenant les propriétés
foreach (PackageRelationship relationship in officePackage.GetRelationshipsByType(officeDocRelType))
{
    // Il n'y a qu'une seule partie de type partType dans le package
    documentUri = PackUriHelper.ResolvePartUri(new Uri("/", UriKind.Relative), relationship.TargetUri);
    mainPart = officePackage.GetPart(documentUri);
    break;
}

« http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument » correspond au type de contenu de la partie principale d'un document OpenXML.

Nous pouvons ensuite charger le contenu de cette partie dans un objet XmlDocument et y rechercher un mot grâce à la méthode Contains :

if (mainPart != null)
{    
    //chargement de la partie dans un XmlDocument
    XmlDocument doc = new XmlDocument();
    doc.Load(mainPart.GetStream());
 
    //sensible à la casse
    if (doc.DocumentElement.InnerText.Contains(textBoxRechercher.Text))                    
    {
        MessageBox.Show("Texte trouvé dans le document");
    }
    else
    {
        MessageBox.Show("Impossible de trouver le texte dans le document");
    }
}

Et ce n'est pas plus compliqué que ça !

Le traitement des images va nécessiter un peu plus de code (mais vraiment pas beaucoup plus). Le principe reste en fait toujours le même: les images sont des parties comme les autres qu'il va falloir récupérer à l'aide de la technique vue précédemment. Bien évidemment, leur lecture différera de celle d'un ficher XML.

La première chose à faire est de récupérer la partie principale du document OpenXML. Nous l'avons fait juste au-dessus, il est donc inutile de remettre le code. Peut-être vous demandez-vous pourquoi nous avons besoin de cette partie. En effet, jusqu'à présent nous récupérions directement la partie qui nous intéressait grâce à notre bout de code passe-partout et en changeant uniquement le type de contenu. Pourquoi donc ne pas simplement refaire la même chose ?

Pour une raison très simple: le package ignore où se trouvent ces images. Pour mieux comprendre, jetez de nouveau un coup d'œil à l'arborescence d'un fichier OpenXML qui se trouve en début d'article. À la racine se trouve un dossier _rels avec un fichier .rels à l'intérieur. Voici un extrait de ce qu'il contient :

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
<Relationship Id="rId3"
   Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties"
   Target="docProps/app.xml"/>
<Relationship Id="rId2"
   Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties"
   Target="docProps/core.xml"/>
<Relationship Id="rId1"
   Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument"
   Target="word/document.xml"/>
</Relationships>

On y retrouve quelques vieux amis… Ce fichier indique au package où se trouvent certains types de contenu (comme la partie principale ou les parties propriétés). Comme vous pouvez le voir, aucune trace d'une quelconque image. Déplaçons-nous maintenant dans le dossier _rels se trouvant dans le dossier word et ouvrons le fichier document.xml.rels (qui rassemble les liaisons existantes entre document.xml et d'autres parties).

Voilà enfin nos fameuses images ! Notez au passage la référence à la partie des styles; cela indique que sa récupération se fera de la même manière que pour les images.

Que faut-il retenir de tout ceci ? Simplement que certaines parties (comme document.xml ou core.xml) sont liées directement au package alors que d'autres (comme les images) sont liées à une autre partie (ici la partie document.xml). Il faut voir les choses de cette manière : un package OpenXML est lié à une partie principale, de parties de propriétés, etc. La partie principale peut elle-même être liée à d'autres parties (styles, images, vidéos, etc.). Ainsi les images sont connues de la partie principale qui est elle-même connue du package. Bref, pour avoir les images il faut avoir la partie principale.

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
<Relationship Id="rId1"
   Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles"
   Target="styles.xml"/>
<Relationship Id="rId5"
   Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image"
   Target="media/image2.png"/>
<Relationship Id="rId4"
   Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image"
   Target="media/image1.png"/>
</Relationships>

Tel qu'il est écrit, le code permettant de récupérer une partie n'autorise que la récupération d'une partie liée au package. Nous allons donc le modifier un peu pour qu'il puisse récupérer une partie liée à la partie principale du package. Dans notre cas nous voulons récupérer les images liées. En voici la nouvelle version :

//type de contenu pour une image
const String imageRelType = @"http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
 
 
List<PackagePart> listePackageParts = new List<PackagePart>();
Uri imageUri = null;
//on récupère les parties correspondantes aux images. Les images sont relatives à la mainPart
foreach (PackageRelationship relationship in mainPart.GetRelationshipsByType(imageRelType))
{
    //relationship.TargetUri contient media/image1.jpg (par exemple)
    imageUri = PackUriHelper.ResolvePartUri(new Uri(mainPart.Uri.ToString(), UriKind.Relative),
                        relationship.TargetUri);
    listePackageParts.Add(officePackage.GetPart(imageUri));
 
    //il n'y a pas forcément qu'une seule image donc on ne fait pas de break !!!!
}

Quelles sont les nouveautés ? Nous avons bien entendu modifié le type de contenu pour y mettre le type correspondant aux images. Nous avons ensuite déclaré une liste d'objets PackagePar. En effet, cette fois-ci il n'y aura pas qu'une seule partie à récupérer, mais plusieurs (tout dépendra évidemment du nombre d'images dans le package). La nouveauté suivante concerne la méthode GetRelationshipsByType. Nous ne l'appelons plus depuis l'objet Package, mais depuis la partie principale (objet PackagePart). Comme dit précédemment nous voulons récupérer les relations entre la partie principale et les parties de type image.

La propriété TargetUri des objets PackageRelationship va renvoyer une Uri relative d'une partie de type image par rapport à la partie principale (par exemple media/image1.jpg). Pour récupérer la partie il va nous falloir l'Uri absolue que l'on construit grâce à la méthode ResolvePartUri à laquelle on donne en paramètre l'Uri source (la partie principale) et l'Uri relative de l'image.

Bien, nous voilà à présent propriétaires d'une liste de PackagePart correspondant aux différentes images du package. Comme pour les précédents exemples, nous pouvons en récupérer le contenu grâce à la méthode GetStream (sauf qu'évidemment cette fois-ci on ne le charge pas dans un fichier XML).

Plusieurs choix s'offrent maintenant à vous. Vous pouvez par exemple construire un objet de type Image :

foreach (PackagePart imagePart in listePackageParts)
{
   Image image = Image.FromStream(imagePart.GetStream());
   // traitement quelconque avec image
}

Ou bien enregistrer les images sur le disque dur :

// pour chaque partie image, on l'enregistre
foreach (PackagePart imagePart in listePackageParts)
{
    // pour récupérer le nom des images
    String[] tab = imagePart.Uri.ToString().Split(new Char[] { '/' });
    String nomImage = tab[tab.Length-1];
 
    using (Stream sourceStream = imagePart.GetStream())
    {
        // répertoire de destination
        String path = Path.Combine(@"C:\", "images");
        if (!Directory.Exists(path))
            Directory.CreateDirectory(Path.Combine(@"C:\", "images"));
        using (FileStream targetStream = new FileStream(Path.Combine(path, nomImage),
         FileMode.Create, FileAccess.Write))
        {
            byte[] buffer = new byte[1024];
            int nrBytesWritten = sourceStream.Read(buffer, 0, 1024);
            while (nrBytesWritten > 0)
            {
                targetStream.Write(buffer, 0, nrBytesWritten);
                nrBytesWritten = sourceStream.Read(buffer, 0, 1024);
            }
        }
    }
}

Microsoft a sorti un package de snippets utilisable avec Visual Studio 2005 destiné au format de documents Open XML (Word, Excel et PowerPoint). Et ça se trouve ici : snipets. Ces modèles de code sont une véritable mine d'informations pour mieux comprendre comment manipuler le format OpenXML.

Nous avons donc vu au travers de cet article les bases pour la lecture de documents Word au format Open XML en utilisant les briques du Framework 3.0 autour de l'assembly System.IO.Package.

La lecture de documents Office (Word dans cet exemple) peut désormais être exécutée sans qu'Office ne soit installé et sans devoir utilisé les Primary Interop Assemblies d'Office comme c'était le cas avec les anciens formats.

Vous pouvez dorénavant lire simplement le contenu d'un fichier Word OpenXML afin d'en récupérer ou d'en changer le contenu.

Le site Open XML chez Microsoft

Introducing the Office (2007) Open XML File Formats

How to: Manipulate Office Open XML Formats Documents

Structure d'un document Open XML

Open XML sur le blog de Julien Chable

openxmldeveloper.org

Spécifications du format à l'ECMA

Les webcast sur Open XML

Structure des fichiers OpenXML (developpez.com)

Lecture des fichiers OpenXML avec PHP 5 (developpez.com)

J'adresse ici tous mes remerciements à l'équipe de rédaction de « developpez.com » pour le temps qu'ils ont bien voulu passer à la correction et à l'amélioration de cet article.

Si vous constatez une erreur dans le tutoriel, dans les sources, dans la programmation ou pour toutes informations, n'hésitez pas à me contacter par le forum.