Zusammenstellen von Dokumenten auf SharePoint 2010-Websites durch das Zusammenführen von Inhalt aus Excel, PowerPoint und Word

Office 2010

Zusammenfassung: Das Kombinieren von Daten und Bildern aus verschiedenen Microsoft Office-Programmen zum Erstellen eines einzelnen Dokuments ist ein Szenario, das von Entwicklern häufig angefordert wird. Wenn hierzu Dokumente verwendet werden, die in SharePoint Foundation 2010 gespeichert sind, besitzt dies zahlreiche Vorteile. Hier erhalten Sie Informationen zum Erstellen von Word-Dokumenten in einer Dokumentbibliothek durch das Zusammenführen von Komponenten aus Excel, PowerPoint und anderen Word-Dokumenten. (25 gedruckte Seiten)

Die Dokumentzusammenfassung ist in diesen Tagen ein wichtiges Thema, besonders, wenn sie mit den Stärken von Microsoft SharePoint Server 2010 kombiniert wird. Vor 2007 Microsoft Office System wurde beim Zugriff auf Text, Tabellen, Bildern und anderen Informationen zum Erstellen von Dokumenten z. B. in Microsoft Word auf die COM-Automatisierung vertraut, um auf jedes Programm zuzugreifen, das an der Zusammenführung beteiligt ist. Die Automatisierung bringt einige Problem mit sich, z. B. Unterbrechungen bei Popupdialogfeldern, Zeiteinschränkungen, fehlende Möglichkeiten zur horizontalen Skalierung und weitere Einschränkungen. Darüber hinaus wird das Ausführen von Microsoft Office-Lösungen auf dem Server von Microsoft weder empfohlen noch unterstützt.

Mit der Veröffentlichung von 2007 Microsoft Office System werden Dokumente durch die Open XML-Dateiformate als eine Komposition aus Teilen und Beziehungen präsentiert. So sind z. B. Bildteile, Dokumentteile und Diagrammteile vorhanden. Dadurch können Sie auf Dokumente und ihre Komponenten zugreifen und diese erstellen, ohne dass Sie die Automatisierung verwenden. Zudem können Sie mit Open XML SDK 2.0 für Microsoft Office Dokumente erstellen und ändern sowie Daten und andere Komponente programmgesteuert offen legen, ohne dass die Microsoft Office-Automatisierung verwendet wird. Und da die Automatisierung nicht mehr erforderlich ist, um Microsoft Office-Dokumente zu verwenden, können Sie nun Zusammenführungen und andere Aktionen direkt auf dem Server ausführen.

Ebenso ist SharePoint Server 2010 ein hervorragendes Tool zum Speichern, Freigeben und Steuern von Dokumenten und zum Bereitstellen von Funktionen zur Verwendung von Dokumenten. Das Dokumentcenter in SharePoint Server 2010 ist z. B. ein Bereich, in dem das Zusammenarbeiten an Dokumenten und deren Speicherung in Dokumentbibliotheken möglich ist. Dokumentbibliotheken sind Container, die bereits für die Verwendung von Workflow, Versionsverlauf und anderen Features konfiguriert sind, die für die Verwendung von Dokumenten auf Unternehmensebene wichtig sind.

In diesem Artikel wird eine komplexe Lösung für die Dokumentzusammenführung erläutert, die Microsoft Word 2010-Dokumente, Microsoft Excel 2010-Dokumente und Microsoft PowerPoint 2010-Dokumente zum Erstellen eines Abschlussberichts in Word zusammenführt. Dies alles geschieht über ein SharePoint 2010-Webpart.

Das Lösungsprojekt kann aus der Code Gallery heruntergeladen werden.

Stellen Sie sich vor, Sie arbeiten für ein Unternehmen, das Aktien analysiert und Berichte für jedes Unternehmen und jede analysierte Aktie generiert. Diese Berichte sind in der Regel sehr komplex, und an der Erstellung ihres Inhalts sind typischerweise mehrere Personen beteiligt. Der Inhalt ist auf mehrere Word-Dokumente, Excel-Dokumente und PowerPoint-Dokumente aufgeteilt, wobei jedes Dokument einer Person zugeordnet ist. Nachdem der gesamte Inhalt geschrieben wurde, wird er in einem Abschlussbericht als ein Word-Dokument zusammengefasst. Das Unternehmen bittet Sie, eine Lösung zum programmgesteuerten Zusammenführen all dieser Dokumente zu schreiben.

In dieser Lösung werden Dokumentenmappen verwendet, ein Feature in SharePoint 2010. Mit Dokumentenmappen können Sie die Auflistung der Dokumente als einzelne Objekte verwalten. Stellen Sie sich dieses Feature als Sammelmappe für verwandten Inhalt vor.

In dieser Lösung enthält eine benutzerdefinierte Dokumentenmappe eine Gruppe von Dateien (in diesem Beispiel sechs), die den verschiedenen Komponenten des Abschlussanalyseberichts entsprechen. Abbildung 1 zeigt eine Dokumentenmappe für ein Unternehmen namens Contoso.

Abbildung 1. Dokumentenmappe für das Contoso-Unternehmensbeispiel

Dokumentenmappe für das Contoso-Unternehmensbeispiel

Führen Sie basierend auf diesen Szenarios mithilfe von Dokumentenmappen die folgenden Schritte aus:

  1. Erstellen Sie eine Gruppe von Dokumenten, die die Dokumentenmappe für diese Lösung darstellen. Eines der Dokumente ist eine Word-Vorlage, die das Aussehen des Abschlussberichts darstellt.

  2. Erstellen Sie eine Dokumentenmappe, und fügen Sie sie einer Dokumentbibliothek hinzu.

  3. Erstellen Sie ein Webpart für die Dokumentbibliothek mit einer Schaltfläche zum Zusammenfassen der Dokumente (Assemble Documents). Mit dieser Schaltfläche wird der gesamte Inhalt in einem Abschlussdokument zusammengeführt. Fügen Sie dieses Webpart der Dokumentmappenbibliothek hinzu.

  4. Öffnen Sie mithilfe von Open XML SDK 2.0 das Vorlagendokument aus der Dokumentmappe, und suchen Sie alle Inhaltssteuerelemente.

  5. Suchen Sie für jedes gefundene Inhaltssteuerelement nach dem entsprechenden Inhalt in der Bibliothek, und führen Sie diesen Inhalt im Abschlussdokument zusammen.

  6. Bieten Sie nach Abschluss der Dokumentzusammenfassung dem Benutzer an, den Bericht zu öffnen oder zu speichern.

Schritt 1 – Erstellen der Vorlage

Beim Erstellen von Office-Dokumentlösungen besteht die wichtigste Aufgabe darin, die richtige Vorlage einzurichten. In dieser Lösung ist eine Dokumentmappe mit sechs Dateien enthalten, wobei eine der Dateien eine Vorlagendatei ist. Das Vorlagendokument stellt das Aussehen des Abschlussberichts dar. Anschließend verwenden Sie Inhaltssteuerelemente innerhalb der Vorlage, um semantische Bereiche im Dokument anzugeben, die zum Zusammenführen des Inhalts verwendet werden sollen.

Zur Vereinfachung des Prozesses stellen die Titel der Inhaltssteuerelemente die zusammenzuführenden Inhaltstypen dar. Beispiele sind ein Word-Dokument, ein Diagramm aus einer Arbeitsmappe, eine Tabelle aus einer Arbeitsmappe und eine SmartArt-Grafik aus einer Präsentation. Der Inhalt eines Inhaltssteuerelements stellt den Namen der Datei dar, die den zusammenzuführenden Inhalt enthält. Abbildung 2 zeigt z. B. das Vorlagendokument, das eins der Inhaltssteuerelemente mit der Bezeichnung Word:Document mit dem Inhalt Introduction hervorhebt.

Abbildung 2. Inhaltssteuerelement für Informationen aus dem Word-Dokument

Inhaltssteuerelement für Dokumentinformationen

Dieses Inhaltssteuerelement stellt den Bereich dar, in dem Sie das Dokument Contoso - Introduction (aus Word) in der Vorlagendatei zusammenführen. Der Vollständigkeit halber sei erwähnt, dass die anderen Inhaltssteuerelemente die Bezeichnungen Spreadsheet:Chart, Spreadsheet:Tableund Presentation:SmartArtbesitzen.

Schritt 2 – Einrichten einer Dokumentmappe in SharePoint 2010

Im nächsten Schritt müssen Sie Dokumentmappen für sechs Dokumente auf der SharePoint 2010-Website erstellen.

So erstellen Sie Dokumentmappen

  1. Erstellen Sie zunächst die Dokumentbibliothek. Klicken Sie im Navigationsbereich auf Bibliotheken, und klicken Sie dann auf Erstellen.

  2. Klicken Sie im Dialogfeld Erstellen auf Dokumentbibliothek, geben Sie einen Namen für die Bibliothek ein (Doc Set Assembly Demo), und klicken Sie dann auf OK.

  3. Erstellen Sie dann den Inhaltstyp. Klicken Sie auf Websiteaktionen, auf Websiteeinstellungen und dann im Abschnitt Galerien auf Websiteinhaltstypen.

  4. Klicken Sie auf Erstellen, und geben Sie dann einen Namen für den Inhaltstyp ein.

  5. Wählen Sie in der Liste Übergeordneten Inhaltstyp auswählen aus die Option Inhaltstypen der Dokumentenmappe aus, und klicken Sie dann auf OK.

  6. Erstellen Sie nun die Dokumentmappe. Klicken Sie im Dialogfeld Websiteinhaltstypen im Abschnitt Einstellungen auf Einstellungen für Dokumentenmappe.

  7. Klicken Sie im Dialogfeld Erstellen auf Dokumentbibliothek, geben Sie einen Namen für die Bibliothek ein (Doc Set Assembly Demo), und klicken Sie dann auf OK.

  8. Wechseln Sie im Abschnitt Standardinhalt zum ersten Dokument (Analysis.docx), wählen Sie es aus, und klicken Sie dann auf Öffnen.

  9. Klicken Sie nun auf Neuen Standardinhalt hinzufügen, wechseln Sie zum zweiten Dokument (Introduction.docx), und klicken Sie dann auf Öffnen.

  10. Wiederholen Sie dies für die übrigen vier Dokumente, und klicken Sie dann zum Abschluss auf OK.

  11. Klicken Sie zurück in die Dokumentbibliothek, und klicken Sie dann unter Bibliothekstools auf Bibliothek, und klicken Sie dann auf Bibliothekseinstellungen.

  12. Klicken Sie im Dialogfeld Bibliothekseinstellungen unter Allgemeine Einstellungen auf Erweiterte Einstellungen.

  13. Klicken Sie im Abschnitt Inhaltstypen für Verwaltung von Inhaltstypen zulassen auf Ja, und klicken Sie dann auf OK.

  14. Klicken Sie zurück im Dialogfeld Dokumentbibliothekseinstellungen unter Inhaltstypen auf Aus vorhandenen Websiteinhaltstypen hinzufügen.

  15. Wählen Sie in der Liste Verfügbare Websiteinhaltstypen Ihren Inhaltstyp aus, und klicken Sie dann auf Hinzufügen.

  16. Fügen Sie die neue Dokumentmappe der Bibliothek hinzu. Klicken Sie zurück in die Dokumentbibliothek und unter Bibliothekstools auf Dokumente.

  17. Klicken Sie auf die Liste Neues Dokument, und wählen Sie Ihren Inhaltstyp aus, geben Sie einen Namen für die neue Dokumentmappe ein, und klicken Sie dann auf OK.

Zu diesem Zeitpunkt sollten Sie eine Bibliothek mit einer Dokumentmappe mit den sechs Dokumenten eingerichtet haben, die das Präfix des Dokumentmappennamens verwenden (siehe Abbildung 1).

Schritt 3 – Erstellen eines Webparts mit einem Befehl zum Zusammenfassen von Dokumenten

Diese Lösung kann erst verwendet werden, wenn Sie einen Befehl innerhalb der Dokumentbibliothek hinzugefügt haben, mit dem Sie die Dokumente zusammenführen können. Dies geschieht am Einfachsten durch das Erstellen eines Webparts innerhalb des Microsoft Visual Studio 2010-Projekts.

So erstellen Sie das Webpartprojekt in Visual Studio 2010

  1. Starten Sie Visual Studio 2010.

  2. Klicken Sie im Menü Datei auf Neu, und klicken Sie dann auf Projekt.

  3. Klicken Sie unter Installierte Vorlagen auf SharePoint, 2010 und dann auf Visual-Webpart.

  4. Geben Sie im Feld Name die Bezeichnung DocumentAssembly ein, und klicken Sie dann auf OK.

  5. Wählen Sie auf der Seite des Konfigurations-Assistenten für SharePoint Ihre Webanwendung aus, und klicken Sie dann auf Fertig stellen.

  6. Öffnen Sie nach der Erstellung des Webparts die Datei VisualWebPart1.cs, und fügen Sie den vorhandenen Verweisen oben in der Datei die folgenden Verweise hinzu.

    using System.Linq;
    using System.IO;
    using DocumentFormat.OpenXml.Packaging;
    using Word = DocumentFormat.OpenXml.Wordprocessing;
    using Draw = DocumentFormat.OpenXml.Drawing;
    using DocumentFormat.OpenXml.Drawing.Charts;
    using WP = DocumentFormat.OpenXml.Drawing.Wordprocessing;
    using DocumentFormat.OpenXml.Drawing.Spreadsheet;
    using Excel = DocumentFormat.OpenXml.Spreadsheet;
    using DocumentFormat.OpenXml;
    using PPT = DocumentFormat.OpenXml.Presentation;
    using Dgm = DocumentFormat.OpenXml.Drawing.Diagrams;
    
    
  7. Ändern Sie dann die CreateChildControls-Methode wie folgt.

    protected override void CreateChildControls() 
    { 
       Control control = this.Page.LoadControl(_ascxPath); 
       Controls.Add(control); 
       base.CreateChildControls(); 
       Button btnSubmit = new Button(); 
       btnSubmit.Text = "Assemble Documents"; 
       btnSubmit.Click += new EventHandler(btnSubmit_Click); 
       Controls.Add(btnSubmit); 
    }
    

    Mit dieser Methode wird ein neues Schaltflächensteuerelement hinzugefügt, dem Sie Logik zum Zusammenführen der Dokumente hinzufügen können, die in einer angegebenen Dokumentmappe enthalten sind (der Code für das Zusammenführen wird vom btnSubmit_Click-Ereignis aufgerufen).

Beim Erstellen des Webparts fügen Sie die Schaltfläche der Dokumentmappe hinzu. Am Einfachsten verwenden Sie hierzu Microsoft SharePoint Designer 2010.

So fügen Sie das benutzerdefinierte Webpart der Dokumentmappenbibliothek hinzu

  1. Öffnen Sie in SharePoint Designer 2010 die SharePoint-Website.

  2. Wechseln Sie zu der Dokumentbibliothek, die die Dokumentmappe enthält.

  3. Klicken Sie auf Alle Dateien, Benutzerdefinierter Dokumentbibliothekname, Formulare und dann auf Dokumentmappenname. Geben Sie docsethomepage.aspx ein.

  4. Klicken Sie auf den unteren Teil von WebPartZone_CenterMain.

  5. Klicken Sie dann auf Einfügen, auf Webpart, und wählen Sie dann das benutzerdefinierte Webpart aus.

    Abbildung 3. Hinzufügen des Webparts in SharePoint Designer 2010

    Hinzufügen eines Webparts in SharePoint Designer 2010
  6. Speichern und schließen Sie SharePoint Designer 2010.

Zu diesem Zeitpunkt sollte wie in Abbildung 4 dargestellt ein Befehl Assemble Documents für jede Dokumentmappe angezeigt werden.

Abbildung 4. Die Schaltfläche 'Assemble Documents' wurde der Dokumentmappe hinzugefügt

Schaltfläche zum Zusammenfassen von Dokumenten im Dokument

Schritt 4 – Suchen der Inhaltssteuerelemente

Die Suche der Inhaltssteuerelemente in einem Dokument umfasst die folgenden Schritte:

  1. Öffnen des Vorlagendokuments von der SharePoint-Website.

  2. Laden des Dokuments in den Arbeitsspeicher.

  3. Öffnen des Dokuments (aus dem Arbeitsspeicher) mit Open XML SDK 2.0.

  4. Ausführen einer Schleife durch alle Inhaltssteuerelemente im Dokument.

  5. Bestimmen des Titels für jedes Inhaltssteuerelement.

  6. Ausführen einer bestimmten Aktion auf der Grundlage des Titels.

Im folgenden Code werden diese Schritte ausgeführt.

void btnSubmit_Click(object sender, EventArgs e) 
{ 
   SPFolder folder = SPContext.Current.ListItem.Folder; 
   char[] splitter = { '/' }; 
   string[] folderName = folder.Name.Split(splitter); 
   string filePrefix = @"Stock Analysis Demo/" + folderName[0] + "/" + folderName[0]; 
 
   SPFile template = folder.Files[filePrefix + " - Template.docx"]; 
   SPFile file; 
   byte[] byteArray = template.OpenBinary(); 
 
   using (MemoryStream mem = new MemoryStream()) 
   { 
      mem.Write(byteArray, 0, (int)byteArray.Length); 
 
      using (WordprocessingDocument myDoc = WordprocessingDocument.Open(mem, true)) 
      { 
         MainDocumentPart mainPart = myDoc.MainDocumentPart; 
 
         foreach (Word.SdtElement sdt in mainPart.Document .Descendants<Word.SdtElement>().ToList()) 
         { 
            Word.SdtAlias alias = sdt.Descendants<Word.SdtAlias>().FirstOrDefault(); 
            if (alias != null) 
            { 
               string sdtTitle = alias.Val.Value; 
 
               if (sdtTitle == "Spreadsheet:Table") 
               { 
                  file = folder.Files[filePrefix + " - " + sdt.InnerText + ".xlsx"]; 
                  ImportTableFromSpreadsheet(mainPart, sdt, file); 
               } 
               else if (sdtTitle == "Spreadsheet:Chart") 
               { 
                  file = folder.Files[filePrefix + " - " + sdt.InnerText + ".xlsx"]; 
                  ImportChartFromSpreadsheet(mainPart, sdt, file); 
               } 
               else if (sdtTitle == "Presentation:SmartArt") 
               { 
                  file = folder.Files[filePrefix + " - " + sdt.InnerText + ".pptx"]; 
                  ImportSmartArtFromPowerPoint(mainPart, sdt, file); 
               } 
               else if (sdtTitle == "Word:Document") 
               { 
                  file = folder.Files[filePrefix + " - " + sdt.InnerText + ".docx"]; 
                  AddAltChunk(mainPart, sdt, file); 
               } 
            } 
         } 
      }
  
      // For the remainder of the code in this procedure, see step 6.
 
   }
} 

Schritt 5 – Zusammenführen des Inhalts

In dieser Lösung müssen vier Arten von Inhalt zusammengeführt werden:

  • Text aus einem Word-Dokument

  • SmartArt-Grafiken aus einer PowerPoint-Präsentation

  • Diagramme aus einer Excel-Arbeitsmappe

  • Datentabellen aus einer Excel-Arbeitsmappe

In den folgenden Abschnitten werden diese Schritte erläutert.

Schritt 5a – Zusammenführen der Word-Dokumente

Die einfachste Möglichkeit zum Zusammenfassen von Word-Dokumenten besteht darin, das altChunks-Objekt zu nutzen. Weitere Informationen zum Zusammenfassen von Dokumenten mit dem altChunks-Objekt finden Sie im Artikel Erstellen von Dokumenten mit Open XML Format SDK 2.0 (Teil 3 von 3))

Es folgt der Code zum Zusammenführen der Dokumente in SharePoint Server 2010.

protected int id = 1; 
 
void AddAltChunk(MainDocumentPart mainPart, Word.SdtElement sdt, SPFile filename) 
{ 
   string altChunkId = "AltChunkId" + id; 
   id++; 
   byte[] byteArray = filename.OpenBinary(); 
 
   AlternativeFormatImportPart chunk = mainPart.AddAlternativeFormatImportPart( 
   AlternativeFormatImportPartType.WordprocessingML, altChunkId); 
 
   using (MemoryStream mem = new MemoryStream()) 
   { 
      mem.Write(byteArray, 0, (int)byteArray.Length); 
      mem.Seek(0, SeekOrigin.Begin); 
      chunk.FeedData(mem); 
   } 
 
   Word.AltChunk altChunk = new Word.AltChunk(); 
   altChunk.Id = altChunkId; 

   // Replace content control with altChunk information.  
   OpenXmlElement parent = sdt.Parent; 
   parent.InsertAfter(altChunk, sdt); 
   sdt.Remove(); 
 
}

Schritt 5b – Importieren von SmartArt-Grafiken aus PowerPoint in Word

Im nächsten Schritt wird SmartArt aus PowerPoint in Word importiert. Weitere Informationen hierzu finden Sie im Blogbeitrag Importing SmartArt from PowerPoint to Word.

Es folgt der für diese Aufgabe erforderliche Code.

void ImportSmartArtFromPowerPoint(MainDocumentPart mainPart, Word.SdtElement sdt, SPFile filename) 
{ 
   string docLayoutPartId = ""; 
   string docDataPartId = ""; 
   string docColorsPartId = ""; 
   string docStylePartId = ""; 
 
   byte[] byteArray = filename.OpenBinary(); 
 
   using (MemoryStream mem = new MemoryStream()) 
   { 
      mem.Write(byteArray, 0, (int)byteArray.Length); 
 
      using (PresentationDocument myPres = PresentationDocument.Open(mem, true)) 
      { 
         PresentationPart presPart = myPres.PresentationPart; 
         // Get the slide that contains the SmartArt graphic. 
         SlidePart slide = (SlidePart)presPart.GetPartById("rId3"); 
         // Get all the appropriate parts associated with the SmartArt. 
         DiagramLayoutDefinitionPart layoutPart = 
            slide.DiagramLayoutDefinitionParts.First(); 
         DiagramDataPart dataPart = slide.DiagramDataParts.First(); 
         DiagramColorsPart colorsPart = slide.DiagramColorsParts.First(); 
         DiagramStylePart stylePart = slide.DiagramStyleParts.First(); 
 
         // Get some of the appropriate properties off the SmartArt graphic. 
         PPT.GraphicFrame graphicFrame = 
            slide.Slide.Descendants<PPT.GraphicFrame>().First(); 
         PPT.NonVisualDrawingProperties drawingPr = graphicFrame 
            .Descendants<PPT.NonVisualDrawingProperties>().First(); 
         Draw.Extents extents = 
            graphicFrame.Descendants<Draw.Extents>().First(); 
 
         // Import SmartArt into the Word document. 
         // Add the SmartArt parts to the Word document. 
         DiagramLayoutDefinitionPart docLayoutPart = 
            mainPart.AddPart<DiagramLayoutDefinitionPart>(layoutPart); 
         DiagramDataPart docDataPart = 
            mainPart.AddPart<DiagramDataPart>(dataPart); 
         DiagramColorsPart docColorsPart = 
            mainPart.AddPart<DiagramColorsPart>(colorsPart); 
         DiagramStylePart docStylePart = 
            mainPart.AddPart<DiagramStylePart>(stylePart); 
         // Get all the relationship ids of the added parts. 
         docLayoutPartId = mainPart.GetIdOfPart(docLayoutPart); 
         docDataPartId = mainPart.GetIdOfPart(docDataPart); 
         docColorsPartId = mainPart.GetIdOfPart(docColorsPart); 
         docStylePartId = mainPart.GetIdOfPart(docStylePart); 
 
         // Use the document reflector to figure out how to add a SmartArt 
         // graphic to Word. 
         // Change attribute values based on specifics related to the SmartArt. 
         Word.Paragraph p = new Word.Paragraph( 
            new Word.Run( 
            new Word.Drawing( 
            new WP.Inline( 
            new WP.Extent() { Cx = extents.Cx, Cy = extents.Cy }, 
            new WP.EffectExtent() 
            { LeftEdge = 0L, TopEdge = 0L, RightEdge = 0L, BottomEdge = 0L }, 
            new WP.DocProperties() {Id = drawingPr.Id, Name = drawingPr.Name }, 
            new WP.NonVisualGraphicFrameDrawingProperties(), 
            new Draw.Graphic( 
            new Draw.GraphicData( 
            new Dgm.RelationshipIds() { DataPart = docDataPartId, 
               LayoutPart = docLayoutPartId, StylePart = docStylePartId, 
               ColorPart = docColorsPartId }) 
            { Uri = "http://schemas.openxmlformats.org/drawingml/2006/diagram" })) 
            { DistanceFromTop = (UInt32Value)0U, DistanceFromBottom = (UInt32Value)0U, 
               DistanceFromLeft = (UInt32Value)0U, DistanceFromRight = (UInt32Value)0U 
            }))); 
 
           // Swap out the content control for the SmartArt. 
           OpenXmlElement parent = sdt.Parent; 
          parent.InsertAfter(p, sdt); 
          sdt.Remove(); 
       } 
   } 
}

Schritt 5c – Importieren des Diagramms aus Excel in Word

In diesem Schritt importieren Sie ein Diagramm aus einer Excel-Arbeitsmappe in die Word-Vorlage. Weitere Informationen hierzu finden Sie im Blogbeitrag Importing Charts from Spreadsheets to Wordprocessing Documents.

Es folgt derselbe Code wie im Blogbeitrag, er wurde lediglich geändert, damit in SharePoint 2010 vorhandene Dateien verwendet werden können.

void ImportChartFromSpreadsheet(MainDocumentPart mainPart, Word.SdtElement sdt, 
   SPFile spreadsheetFileName) 
{ 
   // Create a paragraph that has an inline drawing object. 
   Word.Paragraph p = new Word.Paragraph(); 
   Word.Run r = new Word.Run(); 
   p.Append(r); 
   Word.Drawing drawing = new Word.Drawing(); 
   r.Append(drawing); 
   // These dimensions work perfectly for the template document. 
   WP.Inline inline = new WP.Inline( new WP.Extent() { Cx = 5486400, Cy = 3200400 }); 
   byte[] byteArray = spreadsheetFileName.OpenBinary(); 
 
   using (MemoryStream mem = new MemoryStream()) 
   { 
      mem.Write(byteArray, 0, (int)byteArray.Length); 
 
     // Open the Excel spreadsheet. 
     using (SpreadsheetDocument mySpreadsheet = SpreadsheetDocument.Open(mem, true)) 
     { 
        // Get all of the appropriate parts. 
        WorkbookPart workbookPart = mySpreadsheet.WorkbookPart; 
        WorksheetPart worksheetPart = XLGetWorksheetPartByName(mySpreadsheet, 
           "Sheet2"); 
        DrawingsPart drawingPart = worksheetPart.DrawingsPart; 
        ChartPart chartPart = (ChartPart)drawingPart.GetPartById("rId1"); 
 
       // Clone the chart part and add it to the Word document. 
       ChartPart importedChartPart = mainPart.AddPart<ChartPart>(chartPart); 
       string relId = mainPart.GetIdOfPart(importedChartPart); 
 
       // The frame element contains information for the chart. 
       GraphicFrame frame = 
          drawingPart.WorksheetDrawing.Descendants<GraphicFrame>().First(); 
       string chartName =      frame.NonVisualGraphicFrameProperties.NonVisualDrawingProperties.Name; 
       // Clone this node so that you can add it to the Word document. 
       Draw.Graphic clonedGraphic = (Draw.Graphic)frame.Graphic.CloneNode(true); 
       ChartReference c = clonedGraphic.GraphicData.GetFirstChild<ChartReference>(); 
       c.Id = relId; 
 
       // Give the chart a unique ID and name. 
       WP.DocProperties docPr = new WP.DocProperties(); 
       docPr.Name = chartName; 
       docPr.Id = GetMaxDocPrId(mainPart) + 1; 
 
       // Add the chart data to the inline drawing object. 
       inline.Append(docPr, clonedGraphic); 
       drawing.Append(inline); 
     } 
   } 
   OpenXmlElement parent = sdt.Parent; 
   parent.InsertAfter(p, sdt); 
   sdt.Remove(); 
} 

WorksheetPart XLGetWorksheetPartByName(SpreadsheetDocument document, string sheetName) 
{ 
   WorkbookPart wbPart = document.WorkbookPart; 
 
   // Find the sheet with the supplied name, and then use that Sheet object 
   // to retrieve a reference to the appropriate worksheet. 
   Excel.Sheet theSheet = wbPart.Workbook.Descendants<Excel.Sheet>() 
      .Where(s => s.Name == sheetName).FirstOrDefault(); 
 
   if (theSheet == null) 
   { 
       throw new ArgumentException("sheetName"); 
   } 
 
   return (WorksheetPart)(wbPart.GetPartById(theSheet.Id)); 
} 
 
uint GetMaxDocPrId(MainDocumentPart mainPart) 
{ 
   uint max = 1; 
 
   // Get the maximum ID value of the docPr elements. 
   foreach (WP.DocProperties docPr in mainPart.Document.Descendants<WP.DocProperties>()) 
   { 
      uint id = docPr.Id; 
      if (id > max) max = id; 
   } 
   return max; 
}

Schritt 5d – Importieren von Tabellendaten aus Excel in Word

In diesem Schritt importieren Sie eine Tabelle aus Excel in die Vorlage. Es folgen die für diese Aufgabe auszuführenden Schritte.

  1. Erstellen Sie eine Word-Tabelle mit Open XML SDK 2.0, die die Daten aus Excel enthält.

  2. Öffnen Sie die Datei Excel mit Open XML SDK 2.0.

  3. Rufen Sie das spezifische Blatt ab, das die Tabelle mit den Daten enthält.

  4. Suchen Sie in diesem Blatt das SheetData-Objekt, das die Tabellendaten enthält.

  5. Rufen Sie für jede Zeile im SheetData-Objekt alle Zellendaten ab.

  6. Nachdem alle Daten in der Zeile abgerufen wurden, erstellen Sie eine Word-Zeile mit denselben Daten.

  7. Fügen Sie die erstellte Word-Zeile an die Word-Tabelle an.

Zur Unterstützung bei diesen Aufgaben können Sie einige Open XML SDK 2.0-Codebeispiele nutzen. Weitere Informationen finden Sie unter 2007 Office System Sample: Open XML Format SDK 2.0 Code Snippets for Visual Studio 2008.

Es folgt der für diese Aufgaben erforderliche Code.

void ImportTableFromSpreadsheet(MainDocumentPart mainPart, Word.SdtElement sdt, SPFile spreadsheetFileName) 
{ 
   ArrayList cellText = new ArrayList(); 
 
   // Create a Word table. 
   Word.Table tbl = new Word.Table(); 
   Word.TableProperties tblPr = new Word.TableProperties(); 
   Word.TableStyle tblStyle = new Word.TableStyle(); 
   tblStyle.Val = "LightShading-Accent1"; 
   tblPr.AppendChild(tblStyle); 
 
   Word.TableWidth tblW = new Word.TableWidth(); 
   tblW.Width = 5000; 
   tblW.Type = Word.TableWidthUnitValues.Pct; 
   tblPr.Append(tblW); 
   tbl.AppendChild(tblPr); 
   byte[] byteArray = spreadsheetFileName.OpenBinary(); 
 
   using (MemoryStream mem = new MemoryStream()) 
   { 
      mem.Write(byteArray, 0, (int)byteArray.Length); 
 
      using (SpreadsheetDocument mySpreadsheet = SpreadsheetDocument.Open(mem, true)) 
      { 
         WorkbookPart workbookPart = mySpreadsheet.WorkbookPart; 
         WorksheetPart worksheetPart = XLGetWorksheetPartByName(mySpreadsheet, "Sheet1"); 
 
         Excel.SheetData sheetData = 
            worksheetPart.Worksheet.GetFirstChild<Excel.SheetData>(); 
 
         foreach (Excel.Row r in sheetData) 
         { 
            foreach (Excel.Cell c in r) 
            { 
               cellText.Add(XLGetCellValue(c, workbookPart)); 
            } 
            Word.TableRow tr = CreateRow(cellText); 
            tbl.Append(tr); 
            cellText = new ArrayList(); 
         } 
      } 
   } 
   // Swap out the content control for the SmartArt. 
   OpenXmlElement parent = sdt.Parent; 
   parent.InsertAfter(tbl, sdt); 
   sdt.Remove(); 
} 
 
Word.TableRow CreateRow(ArrayList cellText) 
{ 
   Word.TableRow tr = new Word.TableRow(); 
   // Create cells with simple text. 
   foreach (string s in cellText) 
   { 
      Word.TableCell tc = new Word.TableCell(); 
      Word.Paragraph p = new Word.Paragraph(); 
      Word.Run r = new Word.Run(); 
      Word.Text t = new Word.Text(s); 
      r.AppendChild(t); 
      p.AppendChild(r); 
      tc.AppendChild(p); 
      tr.AppendChild(tc); 
   } 
   return tr; 
} 
 
// Get the value of a cell, given a file name, sheet name, and address name. 
string XLGetCellValue(Excel.Cell c, WorkbookPart wbPart) 
{ 
   string value = null; 
   // If the cell does not exist, return an empty string. 
   if (c != null) 
   { 
      value = c.InnerText; 
 
      // If the cell represents an integer number, you are finished. 
      // For dates, this code returns the serialized value that 
      // represents the date. The code handles strings and Boolean values 
      // individually. For shared strings, the code looks up the corresponding 
      // value in the shared string table. For Boolean values, the code converts 
      // the value into the words TRUE or FALSE. 
      if (c.DataType != null) 
      { 
         switch (c.DataType.Value) 
         { 
            case Excel.CellValues.SharedString: 
              // For shared strings, look up the value in the shared strings table. 
              var stringTable =  wbPart.GetPartsOfType<SharedStringTablePart>().FirstOrDefault(); 
              // If the shared string table is missing, something is wrong. 
              // Just return the index that you found in the cell. 
              // Otherwise, look up the correct text in the table. 
              if (stringTable != null) 
              { 
                 value =  stringTable.SharedStringTable.ElementAt(int.Parse(value)).InnerText; 
              } 
              break; 
          case Excel.CellValues.Boolean: 
             switch (value) 
             { 
                case "0": 
                   value = "FALSE"; 
                   break; 
                default: 
                   value = "TRUE"; 
                   break; 
             } 
             break; 
         } 
      } 
   } 
 
   return value; 
}

Schritt 6 – Anbieten des zusammengefassten Dokuments für den Benutzer

Bieten Sie das zusammengefasste Dokument nun dem Benutzer an, indem Sie ein Dialogfeld Öffnen, Speichern oder Abbrechen wie in Abbildung 5 gezeigt verwenden.

Abbildung 5. Für den Benutzer angezeigtes Dialogfeld zum Herunterladen der Datei

Dialogfeld 'Dateidownload'

Es folgt das Codebeispiel zum Erstellen dieses Dialogfelds basierend auf einem Dokument im Arbeitsspeicher.

void btnSubmit_Click(object sender, EventArgs e) 
{ 
   // For the code that goes here, see step 4.
 
   HttpResponse resp = HttpContext.Current.Response; 
   resp.ClearContent(); 
   resp.ClearHeaders(); 
   resp.AddHeader("Content-Disposition", "attachment; filename=Assembled Document.docx"); 
   resp.ContentEncoding = System.Text.Encoding.UTF8; 
   resp.OutputStream.Write(mem.ToArray(), 0, (int)mem.Length); 
   resp.Flush(); 
   resp.Close(); 
   resp.End(); 
}

Schritt 7 - Signieren des Projekts

Im letzten Schritt bei der Erstellung des Projekts signieren Sie das Projekt mit einer Schlüsseldatei mit starkem Namen, falls noch nicht vorhanden.

So signieren Sie das Projekt mit einer Schlüsseldatei mit starkem Namen

  1. Klicken Sie bei ausgewähltem Knoten DocumentAssembly im Projektmappen-Explorer mit der rechten Maustaste, und klicken Sie dann auf Eigenschaften.

  2. Klicken Sie im Projekt-Designer auf die Registerkarte Signieren.

  3. Aktivieren Sie das Kontrollkästchen Assembly signieren.

  4. Geben Sie eine neue Schlüsseldatei an. Wählen Sie in der Dropdownliste Schlüsseldatei mit starkem Namen auswählen die Option <Neu...> aus. Beachten Sie, dass neue Schlüsseldateien immer im PFX-Format erstellt werden.

    Das Dialogfeld Schlüssel für einen starken Namen erstellen wird geöffnet.

  5. Geben Sie im Dialogfeld Schlüssel für einen starken Namen erstellen einen Namen und ein Kennwort für die neue Schlüsseldatei ein, und klicken Sie dann auf OK.

Nachdem Sie alle Teile zusammengestellt und den Code ausgeführt haben, besitzen Sie ein Dokument mit dem gesamten Inhalt, der in der Bibliothek enthalten ist, zusammengeführt in einem Abschlussbericht, wie in Abbildung 6 dargestellt.

Abbildung 6. Vollständiges Dokument mit den zusammengeführten Komponenten

Vervollständigtes Dokument mit zusammengeführten Komponenten

In diesem Artikel wird erläutert, wie Sie die Leistungsstärke von SharePoint 2010-Webparts und von Open XML SDK 2.0 kombinieren können, um das Zusammenstellen von Dokumenten aus verschiedenen Teilen zu vereinfachen. Durch die Verwendung von Inhaltssteuerelementen und altChunks-Objekten können Sie auf einfache Art und Weise ganze Abschnitte aus anderen Dokumenten einfügen. Ich möchte Sie ermutigen, die hier beschriebenen Techniken weiter auszuprobieren, um eigene benutzerdefinierte Lösungen zu erstellen.

Anzeigen: