Verwendung der Office XML-Dateiformat und das Packen von Komponenten von.NET Framework 3.0 zum Erstellen einer einfachen Excel 2007-Arbeitsmappe oder ein einfaches Word 2007-Dokument

Einführung

Dieser Artikel beschreibt, wie mit Microsoft Office XML-Dateiformat und das Packen von Komponenten von Microsoft.NET Framework 3.0 einen einfachen Microsoft Office Excel 2007-Arbeitsmappe oder ein einfaches Microsoft Office Word 2007-Dokument erstellen.

Weitere Informationen

Die Codebeispiele in diesem Artikel erstellen, eine neue Excel-Arbeitsmappe oder ein neues Worddokument mit dem Text "Hello World" ohne Automatisierung von Excel 2007 oder Word 2007.

Clientanforderungen

  • Microsoft Visual Studio 2005 oder Microsoft Visual C# 2005
  • .NET Framework 3.0
  • Visual Studio 2005 Extensions for.NET Framework 3.0
  • Excel 2007 oder Word 2007

Schrittweises Beispiel

Die Windows-basierte Anwendung

  1. Starten Sie Visual Studio 2005 oder Visual C# 2005.
  2. Erstellen Sie eine neue Visual C# Windows-Anwendung.
  3. Fügen Sie einen Verweis auf die Assembly Windowsbase.dll.

    Hinweis Wenn der Windowsbase.dll Verweis auf der Registerkarte .NET des Dialogfelds Verweis hinzufügen nicht angezeigt wird, klicken Sie auf die Registerkarte Durchsuchen , suchen Sie den Ordner c:\Programme\Microsoft c:\Programme\Reference assemblies\Microsoft\Framework\v3.0 und dann auf WindowsBase.dll.
  4. Klicken Sie in Visual Studio auf
    Der Code im Menü Ansicht zur Codeansicht wechseln.
  5. Fügen Sie die folgenden Direktiven in der Klasse Form1 .
    using System.Xml;
    using System.IO;
    using System.IO.Packaging;


Fügen Sie Code zum Erstellen der Excel-Arbeitsmappe

  1. Klicken Sie in Visual Studio auf
    Designer im Menü Ansicht auf Entwurfsansicht für das Formular.
  2. Fügen Sie ein Button -Steuerelement auf das Windows Form. Legen Sie die Text-Eigenschaft der Schaltfläche auf Excel-Arbeitsmappe erstellen.
  3. Doppelklicken Sie auf das Button -Steuerelement zum Generieren der
    Button1_Click -Ereignishandler.
  4. Das folgende Codebeispiel zum Hinzufügen der
    Button1_Click -Ereignishandler. Neue Ereignishandlercode in etwa das folgenden Codebeispiel.
    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. Im folgenden Codebeispiel wird die Klasse Form1 hinzuzufügen. Dieses Codebeispiel erstellt und fügt die XML-Komponenten, die mit den Excel-Arbeitsblättern.
      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. Speichern Sie das Projekt.

Fügen Sie Code zum Word-Dokument erstellen

  1. Klicken Sie in Visual Studio auf
    Designer im Menü Ansicht auf Entwurfsansicht für das Formular.
  2. Fügen Sie ein weiteres Button -Steuerelement auf das Windows Form. Legen Sie die
    Text -Eigenschaft der Schaltfläche zum Word-Dokument erstellen.
  3. Doppelklicken Sie auf das Button -Steuerelement zum Generieren der
    Button2_Click -Ereignishandler.
  4. Hinzufügen von Code für die
    Button2_Click -Ereignishandler so, dass es das folgende Codebeispiel ähnelt.
    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. Im folgenden Codebeispiel wird die Klasse Form1 hinzuzufügen. Dieses Codebeispiel erstellt und die XML-Komponenten, die das Word-Dokument eingefügt.
    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. Klicken Sie in Visual Studio 2005 im Menü Debuggen auf Debuggen starten .
  7. Klicken Sie auf Excel-Arbeitsmappe erstellen. Ein Meldungsfeld angezeigt wird, dass die Arbeitsmappe erfolgreich erstellt wurde und eine HelloWorld.xlsx-Datei auf dem Desktop erstellt.
  8. Öffnen Sie die Arbeitsmappe in Excel 2007. Beachten Sie die Arbeitsmappe in Excel 2007 geöffnet und im Arbeitsblatt Sheet1 den Text "Hello World" enthält.
  9. Klicken Sie auf Word-Dokument erstellen. Ein Meldungsfeld angezeigt wird, dass das Dokument erfolgreich erstellt wurde und eine HelloWorld.docx-Datei auf dem Desktop erstellt.
  10. Öffnen Sie das Dokument in Word 2007. Beachten Sie, dass das Dokument in Word geöffnet und das Dokument den Text "Hello World" enthält.
Eigenschaften

Artikelnummer: 931866 – Letzte Überarbeitung: 14.01.2017 – Revision: 1

Feedback