Een tabel aanmaken

Aspose.Words stelt gebruikers in staat om tabellen te maken in een document vanaf nul en biedt verschillende methoden om dit te doen. Dit artikel geeft details over hoe u geformatteerde tabellen toe te voegen aan uw document met behulp van elke methode, evenals een vergelijking van elke methode aan het einde van het artikel.

Standaard tabelstijlen

De nieuw aangemaakte tabel wordt standaardwaarden gegeven die vergelijkbaar zijn met die in Microsoft Word:

Tabeleigenschappen Standaard 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

Een tabel aanmaken met DocumentBuilder

In Aspose.Words, gebruikers kunnen een tabel maken in een document met behulp van de DocumentBuilder. Het basisalgoritme voor het maken van een tabel is als volgt:

  1. Start de tabel met StartTable
  2. Voeg een cel toe aan de tabel met behulp van InsertCell Dit start automatisch een nieuwe rij
  3. Optioneel, gebruik de CellFormat eigenschap om celopmaak op te geven
  4. De celinhoud invoegen met behulp van de juiste DocumentBuilder methoden zoals Writeln, InsertImage, en andere
  5. Herhaal stap 2-4 totdat de rij voltooid is
  6. Oproep EndRow om de huidige rij te beëindigen
  7. Optioneel, gebruik de RowFormat eigenschap om rijopmaak op te geven
  8. Herhaal stap 2-7 totdat de tabel volledig is
  9. Oproep EndTable om de tafel te bouwen

Het proces van het maken van een tabel is duidelijk te zien in de volgende afbeelding:

creating-table-process

Het volgende voorbeeld van code laat zien hoe u een eenvoudige tabel maakt met behulp van DocumentBuilder met standaardopmaak:

// 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");

Het volgende voorbeeld van code laat zien hoe u een geformatteerde tabel kunt maken met behulp van DocumentBuilder:

// 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");

Het volgende voorbeeld van code laat zien hoe u een geneste tabel invoegt met behulp van DocumentBuilder:

// 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");
view raw nested-table.cs hosted with ❤ by GitHub

Een tabel aanmaken via DOM (Document Object Model)

U kunt tabellen direct invoegen in de DOM door een nieuwe Table knooppunt op een specifieke positie.

Houd er rekening mee dat direct na het aanmaken van de tabel node, de tabel zelf volledig leeg zal zijn, dat wil zeggen dat het nog geen rijen en cellen bevat. Om rijen en cellen in een tabel in te voegen, voeg de juiste Row en Cell kind knooppunten naar de DOM.

Het volgende voorbeeld van code laat zien hoe je een nieuwe tabel vanaf nul kunt bouwen door de juiste kindknooppunten toe te voegen aan de documentboom:

// 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");

Een tabel aanmaken van HTML

Aspose.Words ondersteunt het invoegen van inhoud in een document van een HTML bron met behulp van de InsertHtml methode. De invoer kan een volledige HTML-pagina zijn of slechts een gedeeltelijk knipsel.

Gebruik van de InsertHtml methode, kunnen gebruikers tabellen in het document via tabel tags zoals <table>, <tr>, <td>.

Het volgende voorbeeld van code laat zien hoe je een tabel in een document van een string met HTML-tags invoegt:

// 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");

Een kopie van een bestaande tabel invoegen

Vaak moet je een tabel maken op basis van een reeds bestaande tabel in een document. De eenvoudigste manier om een tabel te dupliceren met behoud van alle opmaak is om de tabel knooppunt te klonen met behulp van de Clone methode.

Dezelfde techniek kan worden gebruikt om kopieën van een bestaande rij of cel aan een tabel toe te voegen.

Het volgende voorbeeld van code laat zien hoe een tabel te dupliceren met behulp van node constructors:

// 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");

Het volgende voorbeeld van code laat zien hoe je de laatste rij van een tabel kloont en toevoegt aan de tabel:

// 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");

Als u kijkt naar het maken van tabellen in een document dat dynamisch groeit met elke record van uw gegevensbron, dan wordt bovenstaande methode niet geadviseerd. In plaats daarvan wordt de gewenste output gemakkelijker bereikt door het gebruik van Mail merge de regio’s. U kunt meer over deze techniek leren in de Mail Merge met regio’s Section.

Vergelijk manieren om een tabel aan te maken

Aspose.Words biedt verschillende methoden om nieuwe tabellen aan te maken in een document. Elke methode heeft zijn eigen voor- en nadelen, zodat de keuze van welke te gebruiken vaak afhankelijk is van de specifieke situatie.

Laten we eens nader kijken naar deze manieren om tabellen te maken en hun voors en nadelen te vergelijken:

Methode Voordelen Nadelen
Via DocumentBuilder De standaardmethode voor het invoegen van tabellen en andere documentinhoud Soms moeilijk om veel soorten tabellen tegelijk met dezelfde bouwer instantie te creëren
Via DOM Past beter met de omringende code die knooppunten direct in de DOM zonder gebruik van een DocumentBuilder De tabel is aangemaakt “leeg”: voordat u de meeste operaties uitvoert, moet u bellen EnsureMinimum om ontbrekende kindknooppunten aan te maken
Van HTML Kan een nieuwe tabel maken van HTML bron met tags als <table>, <tr>, <td> Niet allemaal mogelijk Microsoft Word tabelformaten kunnen worden toegepast op HTML
Een bestaande tabel klonen U kunt een kopie maken van een bestaande tabel met behoud van alle rij en celopmaak De juiste kindernodes moeten worden verwijderd voordat de tabel klaar is voor gebruik