Erstellen Sie eine Tabelle
Aspose.Words ermöglicht Benutzern das Erstellen von Tabellen in einem Dokument von Grund auf und bietet hierfür verschiedene Methoden. Dieser Artikel enthält Einzelheiten zum Hinzufügen formatierter Tabellen zu Ihrem Dokument mit den einzelnen Methoden sowie einen Vergleich der einzelnen Methoden am Ende des Artikels.
Standardtabellenstile
Die neu erstellte Tabelle erhält Standardwerte, die denen in Microsoft Word ähneln:
Tabelleneigenschaft | Standard in Aspose.Words |
---|---|
Border Style |
Single |
Border Width |
1/2 pt |
Border Color |
Black |
Left and Right Padding |
5.4 pts |
AutoFit Mode |
AutoFit to Window |
Allow AutoFit |
True |
Erstellen Sie eine Tabelle mit DocumentBuilder
In Aspose.Words können Benutzer mithilfe von DocumentBuilder eine Tabelle in einem Dokument erstellen. Der grundlegende Algorithmus zum Erstellen einer Tabelle ist wie folgt:
- Starten Sie die Tabelle mit StartTable
- Fügen Sie mit InsertCell eine Zelle zur Tabelle hinzu – dadurch beginnt automatisch eine neue Zeile
- Optional können Sie die CellFormat-Eigenschaft verwenden, um die Zellformatierung anzugeben
- Fügen Sie den Zellinhalt mit den entsprechenden DocumentBuilder-Methoden wie Writeln, InsertImage und anderen ein
- Wiederholen Sie die Schritte 2–4, bis die Reihe vollständig ist
- Rufen Sie EndRow auf, um die aktuelle Zeile zu beenden
- Optional können Sie die RowFormat-Eigenschaft verwenden, um die Zeilenformatierung anzugeben
- Wiederholen Sie die Schritte 2–7, bis die Tabelle vollständig ist
- Rufen Sie EndTable auf, um die Erstellung der Tabelle abzuschließen
Wichtige Details:
- StartTable kann auch innerhalb einer Zelle aufgerufen werden. In diesem Fall startet es die Erstellung einer verschachtelten Tabelle innerhalb der Zelle.
- Nach dem Aufruf von InsertCell wird eine neue Zelle erstellt und alle Inhalte, die Sie mit anderen Methoden der DocumentBuilder-Klasse hinzufügen, werden der aktuellen Zelle hinzugefügt. Um eine neue Zelle in derselben Zeile zu erstellen, rufen Sie InsertCell erneut auf.
- Wenn InsertCell unmittelbar nach EndRow und dem Ende einer Zeile aufgerufen wird, wird die Tabelle in einer neuen Zeile fortgesetzt.
- Die EndTable-Methode zum Beenden der Tabelle sollte nur einmal nach dem Aufruf von EndRow aufgerufen werden. Durch den Aufruf von EndTable wird der Cursor von der aktuellen Zelle an die Position unmittelbar nach der Tabelle verschoben.
Der Prozess der Tabellenerstellung ist im folgenden Bild deutlich zu erkennen:
Das folgende Codebeispiel zeigt, wie Sie mit DocumentBuilder eine einfache Tabelle mit Standardformatierung erstellen:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git. | |
Document doc = new Document(); | |
DocumentBuilder builder = new DocumentBuilder(doc); | |
// Start building the table. | |
builder.StartTable(); | |
builder.InsertCell(); | |
builder.Write("Row 1, Cell 1 Content."); | |
// Build the second cell. | |
builder.InsertCell(); | |
builder.Write("Row 1, Cell 2 Content."); | |
// Call the following method to end the row and start a new row. | |
builder.EndRow(); | |
// Build the first cell of the second row. | |
builder.InsertCell(); | |
builder.Write("Row 2, Cell 1 Content"); | |
// Build the second cell. | |
builder.InsertCell(); | |
builder.Write("Row 2, Cell 2 Content."); | |
builder.EndRow(); | |
// Signal that we have finished building the table. | |
builder.EndTable(); | |
doc.Save(ArtifactsDir + "WorkingWithTables.CreateSimpleTable.docx"); |
Das folgende Codebeispiel zeigt, wie Sie mit DocumentBuilder eine formatierte Tabelle erstellen:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git. | |
Document doc = new Document(); | |
DocumentBuilder builder = new DocumentBuilder(doc); | |
Table table = builder.StartTable(); | |
builder.InsertCell(); | |
// Table wide formatting must be applied after at least one row is present in the table. | |
table.LeftIndent = 20.0; | |
// Set height and define the height rule for the header row. | |
builder.RowFormat.Height = 40.0; | |
builder.RowFormat.HeightRule = HeightRule.AtLeast; | |
builder.CellFormat.Shading.BackgroundPatternColor = Color.FromArgb(198, 217, 241); | |
builder.ParagraphFormat.Alignment = ParagraphAlignment.Center; | |
builder.Font.Size = 16; | |
builder.Font.Name = "Arial"; | |
builder.Font.Bold = true; | |
builder.CellFormat.Width = 100.0; | |
builder.Write("Header Row,\n Cell 1"); | |
// We don't need to specify this cell's width because it's inherited from the previous cell. | |
builder.InsertCell(); | |
builder.Write("Header Row,\n Cell 2"); | |
builder.InsertCell(); | |
builder.CellFormat.Width = 200.0; | |
builder.Write("Header Row,\n Cell 3"); | |
builder.EndRow(); | |
builder.CellFormat.Shading.BackgroundPatternColor = Color.White; | |
builder.CellFormat.Width = 100.0; | |
builder.CellFormat.VerticalAlignment = CellVerticalAlignment.Center; | |
// Reset height and define a different height rule for table body. | |
builder.RowFormat.Height = 30.0; | |
builder.RowFormat.HeightRule = HeightRule.Auto; | |
builder.InsertCell(); | |
// Reset font formatting. | |
builder.Font.Size = 12; | |
builder.Font.Bold = false; | |
builder.Write("Row 1, Cell 1 Content"); | |
builder.InsertCell(); | |
builder.Write("Row 1, Cell 2 Content"); | |
builder.InsertCell(); | |
builder.CellFormat.Width = 200.0; | |
builder.Write("Row 1, Cell 3 Content"); | |
builder.EndRow(); | |
builder.InsertCell(); | |
builder.CellFormat.Width = 100.0; | |
builder.Write("Row 2, Cell 1 Content"); | |
builder.InsertCell(); | |
builder.Write("Row 2, Cell 2 Content"); | |
builder.InsertCell(); | |
builder.CellFormat.Width = 200.0; | |
builder.Write("Row 2, Cell 3 Content."); | |
builder.EndRow(); | |
builder.EndTable(); | |
doc.Save(ArtifactsDir + "WorkingWithTables.FormattedTable.docx"); |
Das folgende Codebeispiel zeigt, wie Sie mit DocumentBuilder eine verschachtelte Tabelle einfügen:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git. | |
Document doc = new Document(); | |
DocumentBuilder builder = new DocumentBuilder(doc); | |
Cell cell = builder.InsertCell(); | |
builder.Writeln("Outer Table Cell 1"); | |
builder.InsertCell(); | |
builder.Writeln("Outer Table Cell 2"); | |
// This call is important to create a nested table within the first table. | |
// Without this call, the cells inserted below will be appended to the outer table. | |
builder.EndTable(); | |
// Move to the first cell of the outer table. | |
builder.MoveTo(cell.FirstParagraph); | |
// Build the inner table. | |
builder.InsertCell(); | |
builder.Writeln("Inner Table Cell 1"); | |
builder.InsertCell(); | |
builder.Writeln("Inner Table Cell 2"); | |
builder.EndTable(); | |
doc.Save(ArtifactsDir + "WorkingWithTables.NestedTable.docx"); |
Erstellen Sie eine Tabelle über DOM (Document Object Model)
Sie können Tabellen direkt in das DOM einfügen, indem Sie an einer bestimmten Position einen neuen Table-Knoten hinzufügen.
Bitte beachten Sie, dass unmittelbar nach der Erstellung des Tabellenknotens die Tabelle selbst vollständig leer ist, also noch keine Zeilen und Zellen enthält. Um Zeilen und Zellen in eine Tabelle einzufügen, fügen Sie die entsprechenden untergeordneten Row- und Cell-Knoten zum DOM hinzu.
Das folgende Codebeispiel zeigt, wie Sie eine neue Tabelle von Grund auf erstellen, indem Sie der Dokumentstruktur die entsprechenden untergeordneten Knoten hinzufügen:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git. | |
Document doc = new Document(); | |
// We start by creating the table object. Note that we must pass the document object | |
// to the constructor of each node. This is because every node we create must belong | |
// to some document. | |
Table table = new Table(doc); | |
doc.FirstSection.Body.AppendChild(table); | |
// Here we could call EnsureMinimum to create the rows and cells for us. This method is used | |
// to ensure that the specified node is valid. In this case, a valid table should have at least one Row and one cell. | |
// Instead, we will handle creating the row and table ourselves. | |
// This would be the best way to do this if we were creating a table inside an algorithm. | |
Row row = new Row(doc); | |
row.RowFormat.AllowBreakAcrossPages = true; | |
table.AppendChild(row); | |
Cell cell = new Cell(doc); | |
cell.CellFormat.Shading.BackgroundPatternColor = Color.LightBlue; | |
cell.CellFormat.Width = 80; | |
cell.AppendChild(new Paragraph(doc)); | |
cell.FirstParagraph.AppendChild(new Run(doc, "Row 1, Cell 1 Text")); | |
row.AppendChild(cell); | |
// We would then repeat the process for the other cells and rows in the table. | |
// We can also speed things up by cloning existing cells and rows. | |
row.AppendChild(cell.Clone(false)); | |
row.LastCell.AppendChild(new Paragraph(doc)); | |
row.LastCell.FirstParagraph.AppendChild(new Run(doc, "Row 1, Cell 2 Text")); | |
// We can now apply any auto fit settings. | |
table.AutoFit(AutoFitBehavior.FixedColumnWidths); | |
doc.Save(ArtifactsDir + "WorkingWithTables.InsertTableDirectly.docx"); |
Erstellen Sie eine Tabelle aus HTML
Aspose.Words unterstützt das Einfügen von Inhalten aus einer HTML-Quelle in ein Dokument mithilfe der InsertHtml-Methode. Die Eingabe kann eine vollständige HTML-Seite oder nur ein Teilausschnitt sein.
Mit der InsertHtml-Methode können Benutzer Tabellen über Tabellen-Tags wie <table>
, <tr>
, <td>
in das Dokument einfügen.
Das folgende Codebeispiel zeigt, wie Sie aus einer Zeichenfolge mit HTML-Tags eine Tabelle in ein Dokument einfügen:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git. | |
Document doc = new Document(); | |
DocumentBuilder builder = new DocumentBuilder(doc); | |
// Note that AutoFitSettings does not apply to tables inserted from HTML. | |
builder.InsertHtml("<table>" + | |
"<tr>" + | |
"<td>Row 1, Cell 1</td>" + | |
"<td>Row 1, Cell 2</td>" + | |
"</tr>" + | |
"<tr>" + | |
"<td>Row 2, Cell 2</td>" + | |
"<td>Row 2, Cell 2</td>" + | |
"</tr>" + | |
"</table>"); | |
doc.Save(ArtifactsDir + "WorkingWithTables.InsertTableFromHtml.docx"); |
Fügen Sie eine Kopie einer vorhandenen Tabelle ein
Es kommt häufig vor, dass Sie eine Tabelle basierend auf einer bereits vorhandenen Tabelle in einem Dokument erstellen müssen. Der einfachste Weg, eine Tabelle zu duplizieren und dabei die gesamte Formatierung beizubehalten, besteht darin, den Tabellenknoten mithilfe der Clone-Methode zu klonen.
Die gleiche Technik kann verwendet werden, um einer Tabelle Kopien einer vorhandenen Zeile oder Zelle hinzuzufügen.
Das folgende Codebeispiel zeigt, wie eine Tabelle mithilfe von Knotenkonstruktoren dupliziert wird:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git. | |
Document doc = new Document(MyDir + "Tables.docx"); | |
Table table = (Table) doc.GetChild(NodeType.Table, 0, true); | |
// Clone the table and insert it into the document after the original. | |
Table tableClone = (Table) table.Clone(true); | |
table.ParentNode.InsertAfter(tableClone, table); | |
// Insert an empty paragraph between the two tables, | |
// or else they will be combined into one upon saving this has to do with document validation. | |
table.ParentNode.InsertAfter(new Paragraph(doc), table); | |
doc.Save(ArtifactsDir + "WorkingWithTables.CloneCompleteTable.docx"); |
Das folgende Codebeispiel zeigt, wie Sie die letzte Zeile einer Tabelle klonen und an die Tabelle anhängen:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git. | |
Document doc = new Document(MyDir + "Tables.docx"); | |
Table table = (Table) doc.GetChild(NodeType.Table, 0, true); | |
Row clonedRow = (Row) table.LastRow.Clone(true); | |
// Remove all content from the cloned row's cells. This makes the row ready for new content to be inserted into. | |
foreach (Cell cell in clonedRow.Cells) | |
cell.RemoveAllChildren(); | |
table.AppendChild(clonedRow); | |
doc.Save(ArtifactsDir + "WorkingWithTables.CloneLastRow.docx"); |
Wenn Sie Tabellen in einem Dokument erstellen möchten, die mit jedem Datensatz aus Ihrer Datenquelle dynamisch wachsen, ist die oben beschriebene Methode nicht zu empfehlen. Stattdessen lässt sich die gewünschte Ausgabe einfacher erreichen, indem Mail merge mit Regionen verwendet wird. Weitere Informationen zu dieser Technik finden Sie im Abschnitt Mail Merge mit Regionen.
Vergleichen Sie Möglichkeiten zum Erstellen einer Tabelle
Aspose.Words bietet mehrere Methoden zum Erstellen neuer Tabellen in einem Dokument. Jede Methode hat ihre eigenen Vor- und Nachteile, sodass die Wahl der zu verwendenden Methode häufig von der jeweiligen Situation abhängt.
Schauen wir uns diese Möglichkeiten zum Erstellen von Tabellen genauer an und vergleichen ihre Vor- und Nachteile:
Methode | Vorteile | Nachteile |
---|---|---|
Über DocumentBuilder |
Die Standardmethode zum Einfügen von Tabellen und anderen Dokumentinhalten | Manchmal ist es schwierig, mit derselben Builder-Instanz viele verschiedene Tabellen gleichzeitig zu erstellen |
Über DOM | Passt besser zu umgebendem Code, der Knoten direkt in DOM erstellt und einfügt, ohne einen DocumentBuilder zu verwenden | Die Tabelle wird “leer” erstellt: Bevor Sie die meisten Vorgänge ausführen, müssen Sie EnsureMinimum aufrufen, um fehlende untergeordnete Knoten zu erstellen |
Aus HTML | Kann eine neue Tabelle aus einer HTML-Quelle mit Tags wie <table> , <tr> , <td> erstellen |
Nicht alle möglichen Microsoft Word-Tabellenformate können auf HTML angewendet werden |
Klonen einer vorhandenen Tabelle | Sie können eine Kopie einer vorhandenen Tabelle erstellen und dabei alle Zeilen- und Zellenformatierungen beibehalten | Die entsprechenden untergeordneten Knoten müssen entfernt werden, bevor die Tabelle verwendet werden kann |