Partager via

Créer un package

  • Article

Cette rubrique montre comment utiliser les classes du Kit de développement logiciel (SDK) Open XML pour Office afin de créer par programme un package de document de traitement de texte à partir de contenu sous forme de balisage XML WordprocessingML .

Packages et parties de documents

Un document Open XML est stocké en tant que package, dont le format est défini par la norme ISO/IEC 29500-2. Le package peut contenir plusieurs parties avec des relations entre elles. La relation entre les parties détermine la catégorie du document. Un document peut être défini comme un document de traitement de texte si son élément de relation de package contient une relation avec une partie principale de document. Si son élément de relation de package contient une relation avec une partie de présentation, il peut être défini comme un document de présentation. Si son élément de relation de package contient une relation avec une partie de classeur, il est défini en tant que feuille de calcul. Dans cette rubrique, vous utiliserez un package de documents de traitement de texte.

Obtention d’un objet WordprocessingDocument

Dans le kit de développement logiciel (SDK) Open XML, la classe WordprocessingDocument représente un package de document Word. Pour créer un document Word, vous devez créer une instance de la classe WordprocessingDocument et la remplir de composants. Au minimum, le document doit avoir un composant de document principal qui sert de conteneur pour le texte principal du document. Le texte est représenté dans le package au format XML à l’aide du balisage WordprocessingML .

Pour créer l'instance de classe, appelez la méthode Create(String, WordprocessingDocumentType) . Plusieurs méthodes Create sont fournies, chacune avec une signature différente. L'exemple de code de cette rubrique utilise la méthode Create avec une signature qui requiert deux paramètres. Le premier paramètre accepte une chaîne de chemin d’accès complet qui représente le document que vous voulez créer. Le deuxième paramètre est un membre de l’énumération WordprocessingDocumentType. Ce paramètre représente le type de document. Par exemple, il existe différents membres de l'énumération WordProcessingDocumentType pour les documents, les modèles et les divers documents et modèles prenant en charge les macros.

Remarque

[!REMARQUE] Sélectionnez soigneusement le WordProcessingDocumentType approprié et vérifiez que le fichier persistant possède l'extension de nom de fichier correspondante correcte. Si le WordProcessingDocumentType ne correspond pas à l'extension de nom de fichier, une erreur se produit lors de l'ouverture du fichier dans Microsoft Word. Le code qui appelle la méthode Create fait partie d'une instruction using suivie d'un bloc entre crochets, comme illustré dans l'exemple de code suivant.

    using (WordprocessingDocument wordDoc = WordprocessingDocument.Create(document, WordprocessingDocumentType.Document))
    {
       // Insert other code here. 
    }

L'instruction using fournit une alternative recommandée à la séquence .Create, .Save, .Close par défaut. Elle permet de s'assurer que la méthode Dispose () (méthode interne utilisée par le Kit de développement logiciel (SDK) Open XML pour nettoyer les ressources) est appelée automatiquement lorsque le crochet fermant est atteint. Le bloc qui suit l’instruction using établit une étendue pour l’objet créé ou nommé dans l’instruction using, dans le cas présent wordDoc. Étant donné que la classe WordprocessingDocument dans le Kit de développement logiciel (SDK) Open XML enregistre et ferme automatiquement l'objet dans le cadre de son implémentation System.IDisposable, et étant donné que la méthode Dispose est appelée automatiquement lorsque vous quittez le bloc entre crochets, il n'est pas nécessaire d'appeler explicitement Save et Close, à condition d'utiliser using.

Une fois le package de document Word créé, vous pouvez y ajouter des composants. Pour ajouter le composant de document principal, vous devez appeler la méthode AddMainDocumentPart() de la classe WordprocessingDocument. Après cela, vous pouvez ajouter la structure de document et le texte.

Structure d’un document WordProcessingML

La structure de base d’un document WordProcessingML se compose des éléments document et body , suivis d’un ou plusieurs éléments de niveau bloc tels que p, qui représente un paragraphe. Un paragraphe contient un ou plusieurs éléments r. Le r signifie « run » (exécution), qui est une zone de texte avec un ensemble de propriétés courant, comme par exemple la mise en forme. Une exécution contient un ou plusieurs éléments t. L'élément t contient une plage de texte. L’exemple de code suivant montre le balisage WordprocessingML pour un document qui contient le texte « Exemple de texte ».

    <w:document xmlns:w="https://schemas.openxmlformats.org/wordprocessingml/2006/main">
      <w:body>
        <w:p>
          <w:r>
            <w:t>Example text.</w:t>
          </w:r>
        </w:p>
      </w:body>
    </w:document>

À l’aide du Kit de développement logiciel (SDK) Open XML, vous pouvez créer une structure de document et du contenu à l’aide de classes fortement typées qui correspondent à des éléments WordprocessingML . Vous trouverez ces classes dans l'espace de noms DocumentFormat.OpenXml.Wordprocessing . Le tableau suivant répertorie les noms des classes qui correspondent aux éléments document, body, p, r et t.

Élément WordprocessingML Classe du Kit de développement logiciel (SDK) Open XML Description
document Document Élément racine de la partie principale du document.
body Body Conteneur des structures de niveau bloc, telles que paragraphs, tables, annotations et autres structures décrites dans la spécification ISO/IEC 29500.
p Paragraph Paragraphe.
r Run Exécution.
t Text Plage de texte.

Pour plus d’informations sur la structure globale des parties et éléments d’un document WordprocessingML, consultez Structure d’un document WordprocessingML.

Exemple de code

Voici l’exemple de code complet qui vous permet de créer un package de documents de traitement de texte Open XML à partir d’un contenu XML basé sur le balisage WordprocessingML. Dans votre programme, vous pouvez appeler la méthode CreateNewWordDocument à l’aide de l’appel suivant :

    CreateNewWordDocument(@"C:\Users\Public\Documents\MyPkg4.docx");

Après avoir exécuté le programme, ouvrez le fichier créé « myPkg4.docx » et examinez son contenu . il doit s’agir d’un paragraphe contenant l’expression « Hello world ! »

Voici un exemple de code complet en C# et Visual Basic.


using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Packaging;
using System.IO;
using System.Text;

CreateNewWordDocument(args[0]);

// To create a new package as a Word document.
static void CreateNewWordDocument(string document)
{
    using (WordprocessingDocument wordDoc = WordprocessingDocument.Create(document, WordprocessingDocumentType.Document))
    {
        // Set the content of the document so that Word can open it.
        MainDocumentPart mainPart = wordDoc.AddMainDocumentPart();

        SetMainDocumentContent(mainPart);
    }
}

// Set the content of MainDocumentPart.
static void SetMainDocumentContent(MainDocumentPart part)
{
    const string docXml = @"<?xml version=""1.0"" encoding=""utf-8""?>
                            <w:document xmlns:w=""http://schemas.openxmlformats.org/wordprocessingml/2006/main"">
                              <w:body>
                                <w:p>
                                  <w:r>
                                    <w:t>Hello World</w:t>
                                  </w:r>
                                </w:p>
                              </w:body>
                            </w:document>";

    using (Stream stream = part.GetStream())
    {
        byte[] buf = (new UTF8Encoding()).GetBytes(docXml);
        stream.Write(buf, 0, buf.Length);
    }
}