Comment utiliser le format de fichier XML Office et les composants d'empaquetage de .NET Framework 3.0 pour créer un classeur Excel 2007 simple ou un document Word 2007 simple

Traductions disponibles Traductions disponibles
Numéro d'article: 931866 - Voir les produits auxquels s'applique cet article
Agrandir tout | Réduire tout

Sommaire

INTRODUCTION

Cet article explique comment utiliser Microsoft Office XML fichier format et les composants de packaging de Microsoft .NET Framework 3.0 pour créer un classeur Microsoft Office Excel 2007 simple ou un document Microsoft Office Word 2007 simple.

Plus d'informations

Les exemples de code de cet article créer un nouveau Excel classeur ou un nouveau document Word qui contient le texte « Hello World » sans automatiser Excel 2007 ou Word 2007.

Configuration requise du client

  • Microsoft Visual Studio 2005 ou Microsoft Visual C# 2005
  • Le .NET Framework 3.0
  • Extensions Visual Studio 2005 pour .NET Framework 3.0
  • Excel 2007 ou Word 2007

Exemple pas à pas

Créer l'application basée sur Windows

  1. Démarrez Visual Studio 2005 ou Visual C# 2005.
  2. Créer une nouvelle application Visual C# Windows.
  3. Ajouter une référence à l'assembly windowsbase.dll.

    note Si la référence windowsbase.dll n'apparaît pas sous l'onglet .NET de la boîte de dialogue Ajouter une référence , cliquez sur l'onglet Parcourir , recherchez le dossier assemblies\Microsoft\Framework\v3.0 C:\Program Files\Reference et puis cliquez sur WindowsBase.dll .
  4. Dans Visual Studio, cliquez sur code dans le menu Affichage pour basculer vers l'affichage Code.
  5. Ajoutez les directives suivantes dans la classe Form1 .
    	
    	using System.Xml;
    	using System.IO;
    	using System.IO.Packaging;
    
    

Ajouter du code pour créer le classeur Excel

  1. Dans Visual Studio, cliquez sur Concepteur dans le menu Affichage pour basculer en mode Création pour le formulaire.
  2. Ajouter un contrôle Button à l'écran de Windows. Définir le texte de propriété du bouton pour créer le classeur Excel .
  3. Double-cliquez sur le contrôle de bouton pour générer le gestionnaire d'événements Button1_Click .
  4. Ajouter l'exemple de code suivant au gestionnaire d'événements Button1_Click . Le nouveau code gestionnaire d'événement doit ressembler à l'exemple de code suivant.
    	private void button1_Click(object sender, EventArgs e)
            {
                //Create the XML documents.
                XmlDocument workbookDoc = null;
                workbookDoc = CreateExcelXML("workbook");
    
                XmlDocument worksheetDoc = null;
                worksheetDoc = CreateExcelXML("worksheet");
    
                XmlDocument sharedstringsDoc = null;
                sharedstringsDoc = CreateExcelXML("sharedstrings");
    
                //Create the Excel package.
                Package xlPackage = null;
                xlPackage = CreateExcelWorkbookPackage("HelloWorld.xlsx");
    
                //Add the parts to the Excel package.
                if (xlPackage != null)
                {
                    //Add the workbook part.
                    AddExcelPart(xlPackage, "workbook", workbookDoc);
    
                    //Add the worksheet part.
                    AddExcelPart(xlPackage, "worksheet", worksheetDoc);
    
                    //Add the sharedstrings part.
                    AddExcelPart(xlPackage, "sharedstrings", sharedstringsDoc);
    
                }
    
                //Save the changes, and then close the package.
                if (xlPackage != null)
                {
                    xlPackage.Flush();
                    xlPackage.Close();
                }
    
                MessageBox.Show("Successfully created Excel workbook");
            }
    
    Si (xlPackage! = null) {xlPackage.Flush() ; xlPackage.Close();} MessageBox.Show ("correctement créé classeur Excel");}
  5. Add the following code example to the Form1 class. This code example creates and inserts the XML components that contain the Excel worksheets.
    	  private XmlDocument CreateExcelXML(string partType)
            {
                switch (partType)
                {
                    case "workbook":
                        //Create a new XML document for the workbook.
                        XmlDocument workbookDoc = new XmlDocument();
    
                        //Obtain a reference to the root node, and then add
                        //the XML declaration.
                        XmlElement wbRoot = workbookDoc.DocumentElement;
                        XmlDeclaration wbxmldecl = 
    					workbookDoc.CreateXmlDeclaration
    					("1.0", "UTF-8", "yes");
                        workbookDoc.InsertBefore(wbxmldecl, wbRoot);
    
                        //Create and append the workbook node
                        //to the document.
                        XmlElement workBook = 
    					workbookDoc.CreateElement("workbook");
                        workBook.SetAttribute("xmlns",
                            "http://schemas.openxmlformats.org/" +
                            "spreadsheetml/2006/main");
                        workBook.SetAttribute("xmlns:r",
                            "http://schemas.openxmlformats.org/officeDocument/" +
                            "2006/relationships");
                        workbookDoc.AppendChild(workBook);
    
                        //Create and append the sheets node to the 
                        //workBook node.
                        XmlElement sheets = workbookDoc.CreateElement("sheets");
                        workBook.AppendChild(sheets);
    
    
                        //Create and append the sheet node to the 
                        //sheets node.
                        XmlElement sheet = workbookDoc.CreateElement("sheet");
                        sheet.SetAttribute("name", "Sheet1");
                        sheet.SetAttribute("sheetId", "1");
      sheet.SetAttribute("id",
    				"http://schemas.openxmlformats.org/" +
    				"officeDocument/2006/relationships","rId1");
                        sheets.AppendChild(sheet);
    
                        return workbookDoc;
    
                    case "worksheet":
                        //Create a new XML document for the worksheet.
                        XmlDocument worksheetDoc = new XmlDocument();
    
                        //Get a reference to the root node, and then add
                        //the XML declaration.
                        XmlElement wsRoot = worksheetDoc.DocumentElement;
                        XmlDeclaration wsxmldecl = 
                            worksheetDoc.CreateXmlDeclaration("1.0", 
    "UTF-8", "yes");
                        worksheetDoc.InsertBefore(wsxmldecl, wsRoot);
    
    
                        //Create and append the worksheet node
                        //to the document.
                        XmlElement workSheet = 
    					worksheetDoc.CreateElement("worksheet");
                        workSheet.SetAttribute("xmlns",
                            "http://schemas.openxmlformats.org/" +
                            "spreadsheetml/2006/main");
                        workSheet.SetAttribute("xmlns:r",
                            "http://schemas.openxmlformats.org/" +
                            "officeDocument/2006/relationships");
                        worksheetDoc.AppendChild(workSheet);
                                           
                        //Create and add the sheetData node.
                        XmlElement sheetData = 
    					worksheetDoc.CreateElement("sheetData");
                        workSheet.AppendChild(sheetData);
    
                        //Create and add the row node. 
                        XmlElement rNode = worksheetDoc.CreateElement("row");
                        rNode.SetAttribute("r", (1).ToString());
                        rNode.SetAttribute("spans", "1:1");
                        sheetData.AppendChild(rNode);
    
                        //Create and add the column node.
                        XmlElement cNode = worksheetDoc.CreateElement("c");
                        cNode.SetAttribute("r", "A1");
                        cNode.SetAttribute("t", "s");
                        rNode.AppendChild(cNode);
    
                        //Add the "Hello World" text to the worksheet.
                        XmlElement vNode = worksheetDoc.CreateElement("v");
                        vNode.InnerText = "0";
                        cNode.AppendChild(vNode);
    
                        return worksheetDoc;
                        
                    case "sharedstrings":
                        //Create a new XML document for the sharedStrings.
                        XmlDocument sharedStringsDoc = new XmlDocument();
    
                        //Get a reference to the root node, and then add
                        //the XML declaration.
                        XmlElement ssRoot = sharedStringsDoc.DocumentElement;
                        XmlDeclaration ssxmldecl =
                            sharedStringsDoc.CreateXmlDeclaration("1.0", 
    "UTF-8", "yes");
                        sharedStringsDoc.InsertBefore(ssxmldecl, ssRoot);
    
                        //Create and append the sst node.
                        XmlElement sstNode = 
    					sharedStringsDoc.CreateElement("sst");
                        sstNode.SetAttribute("xmlns", 
    					"http://schemas.openxmlformats.org/" +
                            "spreadsheetml/2006/main");
                        sstNode.SetAttribute("count", "1");
                        sstNode.SetAttribute("uniqueCount", "1");
                        sharedStringsDoc.AppendChild(sstNode);
    
                        //Create and append the si node.
                        XmlElement siNode = sharedStringsDoc.CreateElement("si");
                        sstNode.AppendChild(siNode);
    
                        //Create and append the t node.
                        XmlElement tNode = sharedStringsDoc.CreateElement("t");
                        tNode.InnerText = "Hello World";
                        siNode.AppendChild(tNode);
    
                        return sharedStringsDoc;   
             
                    default:
                        return null;
                }
            }
    
            private Package CreateExcelWorkbookPackage(string fileName)
            {
                //Create a new Excel workbook package on the
                //desktop of the user by using the specified name.
                string desktopDir = System.Environment.GetFolderPath(
                            Environment.SpecialFolder.DesktopDirectory);
    
                Package xlPackage = Package.Open(desktopDir + "\\" + fileName,
                        FileMode.Create, FileAccess.ReadWrite);
    
                return xlPackage;
    
            }
    
            private void AddExcelPart(Package fPackage, string part, 
    XmlDocument xDoc)
            {
                switch (part)
                { 
                    case "workbook":
                        string nsWorkbook = "application/vnd.openxmlformats-" +
                                "officedocument.spreadsheetml.sheet.main+xml";
                        string workbookRelationshipType = 
    "http://schemas.openxmlformats.org/" +                            "officeDocument/2006/relationships/" +
    "officeDocument";
                        Uri workBookUri = PackUriHelper.CreatePartUri(new 
                                Uri("xl/workbook.xml",UriKind.Relative));
    
                        //Create the workbook part.
                        PackagePart wbPart =
                                fPackage.CreatePart(workBookUri, nsWorkbook);
    
                        //Write the workbook XML to the workbook part.
                        Stream workbookStream = 
                                wbPart.GetStream(FileMode.Create, 
    					FileAccess.Write);
                        xDoc.Save(workbookStream);
    
                        //Create the relationship for the workbook part.
                        fPackage.CreateRelationship(workBookUri,
                            TargetMode.Internal,
    workbookRelationshipType,"rId1");
    
                        break;
    
                    case "worksheet":
                        string nsWorksheet = "application/vnd.openxmlformats-" +
                                "officedocument.spreadsheetml.worksheet+xml";
                        string worksheetRelationshipType = 
    				"http://schemas.openxmlformats.org/" +
                            "officeDocument/2006/relationships/worksheet";
                        Uri workSheetUri = PackUriHelper.CreatePartUri(new
                              Uri("xl/worksheets/sheet1.xml",UriKind.Relative));
    
                        //Create the workbook part.
                        PackagePart wsPart =
                                fPackage.CreatePart(workSheetUri, nsWorksheet);
    
                        //Write the workbook XML to the workbook part.
                        Stream worksheetStream =
                                  wsPart.GetStream(FileMode.Create, 
    					FileAccess.Write);
                        xDoc.Save(worksheetStream);
    
                        //Create the relationship for the workbook part.
                        Uri wsworkbookPartUri = PackUriHelper.CreatePartUri(new 
                                Uri("xl/workbook.xml",UriKind.Relative));
                        PackagePart wsworkbookPart = 
    					fPackage.GetPart(wsworkbookPartUri);
                        wsworkbookPart.CreateRelationship(workSheetUri,
                                  TargetMode.Internal, 
    worksheetRelationshipType,"rId1");
                        
                        break;
    
                    case "sharedstrings":
                        string nsSharedStrings = 
    				"application/vnd.openxmlformats-officedocument" +
                            ".spreadsheetml.sharedStrings+xml";
                        string sharedStringsRelationshipType = 
    "http://schemas.openxmlformats.org" +                            "/officeDocument/2006/relationships/sharedStrings";
                        Uri sharedStringsUri = PackUriHelper.CreatePartUri(new
                              Uri("xl/sharedStrings.xml", UriKind.Relative));
    
                        //Create the workbook part.
                        PackagePart sharedStringsPart =                          						fPackage.CreatePart(sharedStringsUri,
    nsSharedStrings);
    
                        //Write the workbook XML to the workbook part.
                        Stream sharedStringsStream =
                                sharedStringsPart.GetStream(FileMode.Create,
    FileAccess.Write);
                        xDoc.Save(sharedStringsStream);
    
                        //Create the relationship for the workbook part.
                        Uri ssworkbookPartUri = PackUriHelper.CreatePartUri(new
                                Uri("xl/workbook.xml", UriKind.Relative));
                        PackagePart ssworkbookPart = 
    					fPackage.GetPart(ssworkbookPartUri);
                        ssworkbookPart.CreateRelationship(sharedStringsUri,
                                TargetMode.Internal, 
    					sharedStringsRelationshipType,"rId2");
    
                        break;
                }
            }
    
  6. Enregistrez le projet.

Ajouter du code pour créer le document Word

  1. Dans Visual Studio, cliquez sur Concepteur dans le menu Affichage pour basculer en mode Création pour le formulaire.
  2. Ajouter un autre contrôle de bouton au formulaire Windows. Définissez la propriété Text du bouton au document Word créer .
  3. Double-cliquez sur le contrôle de bouton pour générer le gestionnaire d'événements button2_Click .
  4. Ajoutez code au gestionnaire d'événements button2_Click afin qu'il ressemble à l'exemple de code suivant.
    	private void button2_Click(object sender, EventArgs e)
            {
                //Create the XML for the Word document.
                XmlDocument xDoc = null;
                xDoc = CreateDocumentXML("Hello World");
    
                //Create the Word document package.
                if (xDoc != null)
                {
                    bool hResult = CreateWordDocumentPackage("HelloWorld.docx",
    			 xDoc);
    
                    if (hResult == true)
                    {
                        MessageBox.Show("Successfully created Word document");
                    }
                }
            }
            
    
    Si (xDoc! = null) {résultat booléen = CreateWordDocumentPackage (« HelloWorld.docx », xDoc); if (résultat == vrai) {MessageBox.Show ("correctement créé document Word");}}}
  5. Ajouter l'exemple de code suivant à la classe Form1 . Cet exemple de code crée et insère les composants XML qui contient la Word document.
    	private XmlDocument CreateDocumentXML(string docText)
            {
                string nsWordML =
                      "http://schemas.openxmlformats.org/wordprocessingml" +
                      "/2006/main";
                
                //Create a new XML document.
                XmlDocument xDoc = new XmlDocument();
    
                //Create and add the document node.
                XmlElement docNode =
                   xDoc.CreateElement("w:document", nsWordML);
                xDoc.AppendChild(docNode);
    
                //Create and add the body node to the 
                //document node.
                XmlElement bodyNode = 
                    xDoc.CreateElement("w:body", nsWordML);
                docNode.AppendChild(bodyNode);
    
                //Create and add the wp node to the docNode.
                XmlElement wpNode =
                   xDoc.CreateElement("w:p", nsWordML);
                bodyNode.AppendChild(wpNode);
    
                //Create and add the wr node to the wpNode.
                XmlElement wrNode =
                   xDoc.CreateElement("w:r", nsWordML);
                wpNode.AppendChild(wrNode);
    
                //Create and add the wt node to the wrNode.
                XmlElement wtNode =
                   (XmlElement)xDoc.CreateNode(XmlNodeType.Element,
                   "w", "t", nsWordML);
                wrNode.AppendChild(wtNode);
    
                //Add the supplied text to the wtNode.
                wtNode.InnerText = docText;
    
                return xDoc;
            }
    
           private bool CreateWordDocumentPackage(string fileName, 
    XmlDocument xDoc)
            {
                try
                {
                    string docContentType = "application/vnd.openxmlformats-" +
                            "officedocument.wordprocessingml." +
                            "document.main+xml";
                    
                    string docRelationshipType = 
    				"http://schemas.openxmlformats.org" +
                            "/officeDocument/2006/relationships/" +
                            "officeDocument";
    
                    //Create a new package file on the desktop of the user by using
                    //the supplied file name.
                    string desktopDir = System.Environment.GetFolderPath(
                            Environment.SpecialFolder.DesktopDirectory);
    
                    Package pkg = Package.Open(desktopDir + "\\" + fileName, 
                          FileMode.Create, FileAccess.ReadWrite);
                    
                                
                    //Create a Uri for the document part.
                    Uri docPartURI = PackUriHelper.CreatePartUri(
                           new Uri("/word/document.xml", 
                           UriKind.Relative));
    
                    //Create the document part.
                    PackagePart pkgPart = 
    				pkg.CreatePart(docPartURI,docContentType);
    
                    //Add the data from XMLDocument to the document part.
                    Stream partStream = pkgPart.GetStream(
                        FileMode.Create, FileAccess.Write);
                       
                    xDoc.Save(partStream);
    
                    //Create a relationship between the document part
                    //and the package.
                    PackageRelationship pkgRelationship = 
                            pkg.CreateRelationship(docPartURI,
                            TargetMode.Internal,docRelationshipType, "rId1");
                    
                    
                    //Flush the changes, and then close the package.
                    pkg.Flush();
                    pkg.Close();
                    
                    return true;
    
                }
                catch (Exception ex)
                {
                    //Display a message to the user the indicates that an error
                    //occurred, and then return a result of false.
                    MessageBox.Show("An error occurred creating the document." +
                        " " + ex.Message,"Error Creating Document",
                        MessageBoxButtons.OK,MessageBoxIcon.Error);
                    return false;
                }
            }
    
    MessageBox.Show("An error occurred creating the document." + " " + ex.Message,"Error Creating Document", MessageBoxButtons.OK,MessageBoxIcon.Error) ; false retour;}}
  6. Dans Visual Studio 2005, cliquez sur Démarrer le débogage dans le menu Déboguer .
  7. Cliquez sur Créer un classeur Excel . Une boîte de message s'affiche indiquant que le classeur a été créé avec succès et un fichier HelloWorld.xlsx est créé sur le Bureau.
  8. Dans Excel 2007, ouvrez le classeur. Notez que le classeur s'ouvre dans Excel 2007 et que la feuille de calcul Sheet1 contient le texte « Hello World ».
  9. Cliquez sur Créer un document Word . Une boîte de message s'affiche indiquant que le document a été créé avec succès et un fichier HelloWorld.docx est créé sur le Bureau.
  10. Dans Word 2007, ouvrez le document. Notez que le document s'ouvre dans Word et que le document contient le texte « Hello World ».

Propriétés

Numéro d'article: 931866 - Dernière mise à jour: mardi 27 février 2007 - Version: 1.3
Les informations contenues dans cet article s'appliquent au(x) produit(s) suivant(s):
  • Microsoft Visual Studio 2005 Professional Edition
  • Microsoft Visual Studio 2005 Standard Edition
  • Microsoft Visual Studio 2005 Express Edition
  • Microsoft Office Excel 2007
  • Microsoft Office Word 2007
  • Microsoft .NET Framework 3.0
  • Microsoft Visual C# 2005 Express Edition
Mots-clés : 
kbmt kbexpertiseinter kbhowto KB931866 KbMtfr
Traduction automatique
IMPORTANT : Cet article est issu du système de traduction automatique mis au point par Microsoft (http://support.microsoft.com/gp/mtdetails). Un certain nombre d?articles obtenus par traduction automatique sont en effet mis à votre disposition en complément des articles traduits en langue française par des traducteurs professionnels. Cela vous permet d?avoir accès, dans votre propre langue, à l?ensemble des articles de la base de connaissances rédigés originellement en langue anglaise. Les articles traduits automatiquement ne sont pas toujours parfaits et peuvent comporter des erreurs de vocabulaire, de syntaxe ou de grammaire (probablement semblables aux erreurs que ferait une personne étrangère s?exprimant dans votre langue !). Néanmoins, mis à part ces imperfections, ces articles devraient suffire à vous orienter et à vous aider à résoudre votre problème. Microsoft s?efforce aussi continuellement de faire évoluer son système de traduction automatique.
La version anglaise de cet article est la suivante: 931866
L'INFORMATION CONTENUE DANS CE DOCUMENT EST FOURNIE PAR MICROSOFT SANS GARANTIE D'AUCUNE SORTE, EXPLICITE OU IMPLICITE. L'UTILISATEUR ASSUME LE RISQUE DE L'UTILISATION DU CONTENU DE CE DOCUMENT. CE DOCUMENT NE PEUT ETRE REVENDU OU CEDE EN ECHANGE D'UN QUELCONQUE PROFIT.

Envoyer des commentaires

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com