Partager via

Ouvrir un document de traitement de texte à partir d’un flux

  • Article

Cette rubrique montre comment utiliser les classes du Kit de développement logiciel (SDK) Open XML pour Office afin d’ouvrir par programmation un document Word de traitement à partir d’un flux.

Quand ouvrir un document à partir d’un flux

Si vous disposez d’une application, telle qu’une application SharePoint, qui fonctionne avec des documents à l’aide d’une entrée/sortie de flux, et que vous souhaitez utiliser le Kit de développement logiciel (SDK) Open XML pour travailler avec l’un des documents, cela est conçu pour être facile à faire. Cela est particulièrement vrai si le document existe et que vous pouvez l’ouvrir à l’aide du Kit de développement logiciel (SDK) Open XML. Mais supposez que le document est un flux ouvert au point dans votre code où vous devez employer le kit SDK pour travailler dessus ? Il s’agit du scénario discuté dans cette rubrique. L’exemple de méthode dans l’exemple de code accepte un flux ouvert en tant que paramètre, puis ajoute du texte au document derrière le flux à l’aide du Kit de développement logiciel (SDK) Open XML.

Création d’un objet WordprocessingDocument

Dans le Kit de développement logiciel (SDK) Open XML, la WordprocessingDocument classe représente un package de document Word. Pour utiliser un document Word, commencez par créer un instance de la WordprocessingDocument classe à partir du document, puis utilisez cette instance. Lorsque vous créez l’instance à partir du document, vous pouvez accéder au composant document principal qui contient le texte du document. Chaque package Open XML contient plusieurs composants. Au minimum, un WordprocessingDocument doit contenir un composant de document main qui fait office de conteneur pour le texte main du document. Le package peut également contenir des composants supplémentaires. Notez que dans un document Word, le texte du composant de document main est représenté dans le package au format XML à l’aide WordprocessingML d’un balisage.

Pour créer la classe instance à partir du document, appelez la Open(Stream, Boolean) méthode . Plusieurs Open méthodes sont fournies, chacune avec une signature différente. L’exemple de code de cette rubrique utilise la Open méthode avec une signature qui nécessite deux paramètres. Le premier paramètre prend un pointeur vers le flux à partir duquel ouvrir le document. Le deuxième paramètre est ou truefalse et indique si le flux est ouvert pour modification.

L’exemple de code suivant appelle la Open méthode .

// Open a WordProcessingDocument based on a stream.
using (WordprocessingDocument wordprocessingDocument = WordprocessingDocument.Open(stream, true))
{

Structure d’un document WordProcessingML

La structure de base d’un WordProcessingML document se compose des document éléments 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 r éléments. l’acronyme r de run, qui est une région de texte avec un ensemble commun de propriétés, telles que la mise en forme. Une exécution contient un ou plusieurs t éléments. L’élément t contient une plage de texte. L’exemple de code suivant montre le WordprocessingML balisage d’un document qui contient le texte « Exemple de texte ».

    <w:document xmlns:w="http://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 à WordprocessingML des éléments. Vous trouverez ces classes dans l’espace de DocumentFormat.OpenXml.Wordprocessing noms . Le tableau suivant répertorie les noms de classes des classes qui correspondent aux documentéléments , body, p, ret 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.

Fonctionnement de l’exemple de code

Lors de l’ouverture du package de document Word, vous pouvez ajouter du texte au composant document principal. Pour accéder au corps du composant de document main, vous affectez une référence au corps du document, comme indiqué dans le segment de code suivant.

// Assign a reference to the document body.
MainDocumentPart mainDocumentPart = wordprocessingDocument.MainDocumentPart ?? wordprocessingDocument.AddMainDocumentPart();
mainDocumentPart.Document ??= new Document();
Body body = mainDocumentPart.Document.Body ?? mainDocumentPart.Document.AppendChild(new Body());

Lorsque vous accédez au corps du composant de document main, ajoutez du texte en ajoutant des instances des Paragraphclasses , Runet Text . Cela génère le balisage requis WordprocessingML . Les lignes suivantes de l’exemple de code ajoutent le paragraphe, la séquence et le texte.

// Add new text.
Paragraph para = body.AppendChild(new Paragraph());
Run run = para.AppendChild(new Run());
run.AppendChild(new Text(txt));

Exemple de code

L’exemple OpenAndAddToWordprocessingStream de méthode présenté ici peut être utilisé pour ouvrir un document Word à partir d’un flux déjà ouvert et ajouter du texte à l’aide du Kit de développement logiciel (SDK) Open XML. Pour appeler cette méthode, passez un pointeur vers un flux ouvert comme premier paramètre et le texte à ajouter comme second paramètre. Par exemple, l’exemple de code suivant ouvre le fichier spécifié dans le premier argument et y ajoute le texte du deuxième argument.

string filePath = args[0];
string txt = args[1];

using (FileStream fileStream = new FileStream(filePath, FileMode.Open))
{
    OpenAndAddToWordprocessingStream(fileStream, txt);
}

Remarque

Notez que la OpenAddAddToWordprocessingStream méthode ne ferme pas le flux qui lui est passé. Le code appelant doit le faire en encapsulant l’appel de méthode dans une using instruction ou en appelant explicitement Dispose.

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

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


static void OpenAndAddToWordprocessingStream(Stream stream, string txt)
{
    // Open a WordProcessingDocument based on a stream.
    using (WordprocessingDocument wordprocessingDocument = WordprocessingDocument.Open(stream, true))
    {

        // Assign a reference to the document body.
        MainDocumentPart mainDocumentPart = wordprocessingDocument.MainDocumentPart ?? wordprocessingDocument.AddMainDocumentPart();
        mainDocumentPart.Document ??= new Document();
        Body body = mainDocumentPart.Document.Body ?? mainDocumentPart.Document.AppendChild(new Body());

        // Add new text.
        Paragraph para = body.AppendChild(new Paragraph());
        Run run = para.AppendChild(new Run());
        run.AppendChild(new Text(txt));
    }
    // Caller must close the stream.
}