Como usar o formato de arquivo XML do Office e os componentes de empacotamento do .NET Framework 3.0 para criar uma pasta de trabalho Excel 2007 simples ou um documento simples do Word 2007

Traduções deste artigo Traduções deste artigo
ID do artigo: 931866 - Exibir os produtos aos quais esse artigo se aplica.
Expandir tudo | Recolher tudo

Neste artigo

INTRODUÇÃO

Este artigo descreve como usar o Microsoft Office XML arquivo formato e os componentes de compactação do Microsoft .NET Framework 3.0 para criar uma pasta de trabalho do Microsoft Office Excel 2007 simples ou um documento simples do Microsoft Office Word 2007.

Mais Informações

Os exemplos de código neste artigo criar uma nova pasta de trabalho ou um novo documento do Word que contém o texto "Hello World" do Excel sem automatizar o Excel 2007 ou Word 2007.

Requisitos do cliente

  • Microsoft Visual Studio 2005 ou Microsoft Visual 2005 translation from VPE for Csharp
  • O .NET Framework 3.0
  • Visual Studio 2005 Extensions para o .NET Framework 3.0
  • Excel 2007 ou Word 2007

Exemplo passo a passo

Criar o aplicativo baseado no Windows

  1. Inicie o Visual Studio 2005 ou Visual translation from VPE for Csharp 2005.
  2. Crie um novo aplicativo Windows translation from VPE for Csharp Visual.
  3. Adicione uma referência ao assembly windowsbase.dll.

    Observação Se a referência windowsbase.dll não aparecer na guia .NET da caixa de diálogo Add Reference , clique na guia Procurar , localize a pasta de assemblies\Microsoft\Framework\v3.0 c:\Arquivos de arquivos e, em seguida, clique em WindowsBase.dll .
  4. No Visual Studio, clique em código no menu Exibir para alternar para o modo de exibição código.
  5. Adicione as seguintes diretivas na classe Form1 .
    	
    	using System.Xml;
    	using System.IO;
    	using System.IO.Packaging;
    
    

Adicione código para criar a pasta de trabalho do Excel

  1. No Visual Studio, clique em Designer no menu Exibir para alternar para modo Design para o formulário.
  2. Adicione um controle Button ao formulário do Windows. Definir o texto de propriedade do botão para Criar pasta de trabalho do Excel .
  3. Clique duas vezes no controle Button para gerar o manipulador de eventos Button1_Click .
  4. Adicione o seguinte exemplo de código ao manipulador de eventos Button1_Click . O novo código manipulador de eventos deve se parecer com o exemplo de código a seguir.
    	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");
            }
    
  5. Adicione o seguinte exemplo de código para a classe Form1 . Este exemplo de código cria e insere os componentes XML que contêm as planilhas do Excel.
    	  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. Salve o projeto.

Adicione código para criar o documento do Word

  1. No Visual Studio, clique em Designer no menu Exibir para alternar para modo Design para o formulário.
  2. Adicione outro controle de botão ao formulário do Windows. Defina a propriedade Text do botão para Criar documento do Word .
  3. Clique duas vezes no controle Button para gerar o manipulador de eventos button2_Click .
  4. Adicione código ao manipulador de eventos button2_Click para que se pareça com o exemplo de código a seguir.
    	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");
                    }
                }
            }
            
    
  5. Adicione o seguinte exemplo de código para a classe Form1 . Este exemplo de código cria e insere os componentes XML que contêm a palavra documento.
    	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;
                }
            }
    
  6. No Visual Studio 2005, clique em Start Debugging no menu Debug .
  7. Clique em criar pasta de trabalho do Excel . Será exibida uma caixa de mensagem que indica que a pasta de trabalho foi criada com êxito e um arquivo HelloWorld.xlsx é criado na área de trabalho.
  8. No Excel 2007, abra a pasta de trabalho. Observe que a pasta de trabalho aberta dentro do Excel 2007 e que a planilha Sheet1 contém o texto "Hello World".
  9. Clique em Criar documento do Word . Será exibida uma caixa de mensagem que indica que o documento foi criado com êxito e um arquivo HelloWorld.docx é criado na área de trabalho.
  10. No Word 2007, abra o documento. Observe que o documento é aberto no Word e que o documento contém o texto "Hello World".

Propriedades

ID do artigo: 931866 - Última revisão: terça-feira, 27 de fevereiro de 2007 - Revisão: 1.3
A informação contida neste artigo aplica-se a:
  • 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
Palavras-chave: 
kbmt kbexpertiseinter kbhowto KB931866 KbMtpt
Tradução automática
IMPORTANTE: Este artigo foi traduzido por um sistema de tradução automática (também designado por Machine Translation ou MT), não tendo sido portanto traduzido ou revisto por pessoas. A Microsoft possui artigos traduzidos por aplicações (MT) e artigos traduzidos por tradutores profissionais, com o objetivo de oferecer em português a totalidade dos artigos existentes na base de dados de suporte. No entanto, a tradução automática não é sempre perfeita, podendo conter erros de vocabulário, sintaxe ou gramática. A Microsoft não é responsável por incoerências, erros ou prejuízos ocorridos em decorrência da utilização dos artigos MT por parte dos nossos clientes. A Microsoft realiza atualizações freqüentes ao software de tradução automática (MT). Obrigado.
Clique aqui para ver a versão em Inglês deste artigo: 931866

Submeter comentários

 

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