Cómo utilizar el formato de archivo XML de Office y los componentes del embalaje de la versión 3.0 de.NET Framework para crear un libro de Excel 2007 simple o un documento de Word 2007 simple

INTRODUCCIÓN

Este artículo describe cómo utilizar el formato de archivo XML de Microsoft Office y los componentes de empaquetado de la de Microsoft.NET Framework 3.0 para crear un libro de Microsoft Office Excel 2007 simple o un documento de Microsoft Office Word 2007 simple.

Más información

Los ejemplos de código de este artículo crean un nuevo libro de Excel o un documento nuevo de Word que contiene el texto "Hello World" sin automatizar Excel 2007 o Word 2007.

Requisitos del cliente

  • Microsoft Visual Studio 2005 o Microsoft Visual C# 2005
  • El.NET Framework 3.0
  • Visual Studio 2005 Extensions para el.NET Framework 3.0
  • Excel 2007 o Word 2007

Ejemplo paso a paso

Crear la aplicación basada en Windows

  1. Inicie Visual Studio 2005 o Visual C# 2005.
  2. Cree una nueva aplicación para Windows de Visual C#.
  3. Agregue una referencia al ensamblado Windowsbase.dll.

    Nota: Si la referencia Windowsbase.dll no aparece en la ficha .NET del cuadro de diálogo Agregar referencia , haga clic en la ficha Examinar , busque la carpeta de C:\Program programa\Reference assemblies\Microsoft\Framework\v3.0 y, a continuación, haga clic en WindowsBase.dll.
  4. En Visual Studio, haga clic en
    Código en el menú Ver para cambiar a la vista código.
  5. Agregue las directivas siguientes en la clase Form1 .
    using System.Xml;
    using System.IO;
    using System.IO.Packaging;


Agregue código para crear el libro de Excel

  1. En Visual Studio, haga clic en
    Diseñador en el menú Ver para cambiar a la vista Diseño del formulario.
  2. Agregue un control Button al formulario de Windows. Establezca la propiedad Textdel botón a Crear el libro de Excel.
  3. Haga doble clic en el control de botón para generar el
    controlador de eventos Button1_Click .
  4. Agregue el siguiente ejemplo de código para el
    controlador de eventos Button1_Click . El nuevo código de controlador de eventos debe ser similar a la del ejemplo de código siguiente.
    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. Agregue el ejemplo de código siguiente a la clase Form1 . Este ejemplo de código se crea e inserta los componentes XML que contienen las hojas de cálculo de 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. Guarde el proyecto.

Agregue código para crear el documento de Word

  1. En Visual Studio, haga clic en
    Diseñador en el menú Ver para cambiar a la vista Diseño del formulario.
  2. Agregue otro control Button al formulario de Windows. Establecer el
    Propiedad Text del botón para Crear el documento de Word.
  3. Haga doble clic en el control de botón para generar el
    controlador de eventos Button2_Click .
  4. Agregue código a la
    en el controlador de eventos Button2_Click para que TI se parece el ejemplo de código siguiente.
    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. Agregue el ejemplo de código siguiente a la clase Form1 . Este ejemplo de código se crea e inserta los componentes XML que contienen el documento de Word.
    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. En Visual Studio 2005, haga clic en Iniciar depuración en el menú Depurar .
  7. Haga clic en Crear libro de Excel. Aparecerá un cuadro de mensaje que indica que el libro se ha creado correctamente y se crea un archivo HelloWorld.xlsx en el escritorio.
  8. En Excel 2007, abra el libro. Observe que se abre el libro en Excel 2007 y que la hoja de cálculo Sheet1 contiene el texto "Hello World".
  9. Haga clic en Crear documento de Word. Aparecerá un cuadro de mensaje que indica que el documento se ha creado correctamente y se crea un archivo HelloWorld.docx en el escritorio.
  10. En Word 2007, abra el documento. Observe que se abre el documento en Word y que el documento contiene el texto "Hello World".
Propiedades

Id. de artículo: 931866 - Última revisión: 14 ene. 2017 - Revisión: 1

Comentarios