Een tabel maken

Aspose.Words stelt gebruikers in staat om tabellen in een document helemaal opnieuw te maken en biedt verschillende methoden om dit te doen. Dit artikel bevat details over het toevoegen van opgemaakte tabellen 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 krijgt standaardwaarden die vergelijkbaar zijn met die in Microsoft Word:

Tabel Eigenschap	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 kan inline zijn als deze strak is geplaatst, of zwevend als deze overal op de pagina kan worden geplaatst. Standaard maakt Aspose.Words altijd inline tabellen.

Een tabel maken met DocumentBuilder

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

1. Begin de tabel met StartTable
2. Voeg een cel toe aan de tabel met InsertCell – hiermee wordt automatisch een nieuwe rij gestart
3. Gebruik optioneel de eigenschap CellFormat 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 is voltooid
6. Roep EndRow aan om de huidige rij te beëindigen
7. Gebruik optioneel de eigenschap RowFormat om rijopmaak op te geven
8. Herhaal stap 2-7 totdat de tabel is voltooid
9. Roep EndTable aan om de tabel af te maken

Belangrijke details:

• StartTable kan ook binnen een cel worden aangeroepen, in welk geval het begint met het maken van een geneste tabel binnen de cel.
• Na het aanroepen van InsertCell wordt een nieuwe cel gemaakt en alle inhoud die u met andere methoden van de DocumentBuilder - klasse toevoegt, wordt aan de huidige cel toegevoegd. Als u een nieuwe cel in dezelfde rij wilt maken, roept u InsertCell opnieuw op.
• Als InsertCell direct na EndRow en het einde van een rij wordt aangeroepen, gaat de tabel verder op een nieuwe rij.
• De EndTable methode om de tabel te beëindigen mag slechts één keer aangeroepen worden na het aanroepen van EndRow. Aanroepen van EndTable verplaatst de cursor van de huidige cel naar de positie direct na de tabel.

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

Het volgende codevoorbeeld laat zien hoe u een eenvoudige tabel maakt met DocumentBuilder met standaardopmaak:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>();
auto builder = MakeObject<DocumentBuilder>(doc);

// Start building the table.
builder->StartTable();
builder->InsertCell();
builder->Write(u"Row 1, Cell 1 Content.");

// Build the second cell.
builder->InsertCell();
builder->Write(u"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(u"Row 2, Cell 1 Content");

// Build the second cell.
builder->InsertCell();
builder->Write(u"Row 2, Cell 2 Content.");
builder->EndRow();

// Signal that we have finished building the table.
builder->EndTable();

doc->Save(ArtifactsDir + u"WorkingWithTables.CreateSimpleTable.docx");

Het volgende codevoorbeeld laat zien hoe u een opgemaakte tabel maakt met DocumentBuilder:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>();
auto builder = MakeObject<DocumentBuilder>(doc);

SharedPtr<Table> table = builder->StartTable();
builder->InsertCell();

// Table wide formatting must be applied after at least one row is present in the table.
table->set_LeftIndent(20.0);

// Set height and define the height rule for the header row.
builder->get_RowFormat()->set_Height(40.0);
builder->get_RowFormat()->set_HeightRule(HeightRule::AtLeast);

builder->get_CellFormat()->get_Shading()->set_BackgroundPatternColor(System::Drawing::Color::FromArgb(198, 217, 241));
builder->get_ParagraphFormat()->set_Alignment(ParagraphAlignment::Center);
builder->get_Font()->set_Size(16);
builder->get_Font()->set_Name(u"Arial");
builder->get_Font()->set_Bold(true);

builder->get_CellFormat()->set_Width(100.0);
builder->Write(u"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(u"Header Row,\n Cell 2");

builder->InsertCell();
builder->get_CellFormat()->set_Width(200.0);
builder->Write(u"Header Row,\n Cell 3");
builder->EndRow();

builder->get_CellFormat()->get_Shading()->set_BackgroundPatternColor(System::Drawing::Color::get_White());
builder->get_CellFormat()->set_Width(100.0);
builder->get_CellFormat()->set_VerticalAlignment(CellVerticalAlignment::Center);

// Reset height and define a different height rule for table body.
builder->get_RowFormat()->set_Height(30.0);
builder->get_RowFormat()->set_HeightRule(HeightRule::Auto);
builder->InsertCell();

// Reset font formatting.
builder->get_Font()->set_Size(12);
builder->get_Font()->set_Bold(false);

builder->Write(u"Row 1, Cell 1 Content");
builder->InsertCell();
builder->Write(u"Row 1, Cell 2 Content");

builder->InsertCell();
builder->get_CellFormat()->set_Width(200.0);
builder->Write(u"Row 1, Cell 3 Content");
builder->EndRow();

builder->InsertCell();
builder->get_CellFormat()->set_Width(100.0);
builder->Write(u"Row 2, Cell 1 Content");

builder->InsertCell();
builder->Write(u"Row 2, Cell 2 Content");

builder->InsertCell();
builder->get_CellFormat()->set_Width(200.0);
builder->Write(u"Row 2, Cell 3 Content.");
builder->EndRow();
builder->EndTable();

doc->Save(ArtifactsDir + u"WorkingWithTables.FormattedTable.docx");

Het volgende codevoorbeeld laat zien hoe u een geneste tabel invoegt met DocumentBuilder:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>();
auto builder = MakeObject<DocumentBuilder>(doc);

SharedPtr<Cell> cell = builder->InsertCell();
builder->Writeln(u"Outer Table Cell 1");

builder->InsertCell();
builder->Writeln(u"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->get_FirstParagraph());

// Build the inner table.
builder->InsertCell();
builder->Writeln(u"Inner Table Cell 1");
builder->InsertCell();
builder->Writeln(u"Inner Table Cell 2");
builder->EndTable();

doc->Save(ArtifactsDir + u"WorkingWithTables.NestedTable.docx");

Een tabel maken via DOM (Document Object Model)

U kunt tabellen rechtstreeks in DOM invoegen door een nieuw Table knooppunt op een specifieke positie toe te voegen.

Houd er rekening mee dat onmiddellijk na het maken van de tabelknoop de tabel zelf volledig leeg zal zijn, dat wil zeggen dat deze nog geen rijen en cellen bevat. Als u rijen en cellen in een tabel wilt invoegen, voegt u de juiste Row en Cell onderliggende knooppunten toe aan de DOM.

Deze methode voor het maken van een tabel gebruikt dezelfde standaardwaarden als bij het gebruik van DocumentBuilder.

Het volgende codevoorbeeld laat zien hoe u een nieuwe tabel helemaal opnieuw kunt maken door de juiste onderliggende knooppunten aan de documentstructuur toe te voegen:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<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.
auto table = MakeObject<Table>(doc);
doc->get_FirstSection()->get_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.
auto row = MakeObject<Row>(doc);
row->get_RowFormat()->set_AllowBreakAcrossPages(true);
table->AppendChild(row);

// We can now apply any auto fit settings.
table->AutoFit(AutoFitBehavior::FixedColumnWidths);

auto cell = MakeObject<Cell>(doc);
cell->get_CellFormat()->get_Shading()->set_BackgroundPatternColor(System::Drawing::Color::get_LightBlue());
cell->get_CellFormat()->set_Width(80);
cell->AppendChild(MakeObject<Paragraph>(doc));
cell->get_FirstParagraph()->AppendChild(MakeObject<Run>(doc, u"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->get_LastCell()->AppendChild(MakeObject<Paragraph>(doc));
row->get_LastCell()->get_FirstParagraph()->AppendChild(MakeObject<Run>(doc, u"Row 1, Cell 2 Text"));

doc->Save(ArtifactsDir + u"WorkingWithTables.InsertTableDirectly.docx");

Een tabel maken van HTML

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

Met de methode InsertHtml kunnen gebruikers tabellen invoegen in het document via tabellabels zoals <table>, <tr>, <td>.

Het volgende codevoorbeeld laat zien hoe u een tabel invoegt in een document vanuit een tekenreeks met HTML - tags:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>();
auto builder = MakeObject<DocumentBuilder>(doc);

// Note that AutoFitSettings does not apply to tables inserted from HTML.
builder->InsertHtml(String(u"<table>") + u"<tr>" + u"<td>Row 1, Cell 1</td>" + u"<td>Row 1, Cell 2</td>" + u"</tr>" + u"<tr>" +
                    u"<td>Row 2, Cell 2</td>" + u"<td>Row 2, Cell 2</td>" + u"</tr>" + u"</table>");

doc->Save(ArtifactsDir + u"WorkingWithTables.InsertTableFromHtml.docx");

Een kopie van een bestaande tabel invoegen

Er zijn vaak momenten waarop u een tabel moet 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 Tabelknooppunt te klonen met behulp van de methode Clone.

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

Het volgende codevoorbeeld toont hoe een tabel te dupliceren met behulp van knoopconstructeurs:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>(MyDir + u"Tables.docx");

auto table = System::ExplicitCast<Table>(doc->GetChild(NodeType::Table, 0, true));

// Clone the table and insert it into the document after the original.
auto tableClone = System::ExplicitCast<Table>(table->Clone(true));
table->get_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->get_ParentNode()->InsertAfter(MakeObject<Paragraph>(doc), table);

doc->Save(ArtifactsDir + u"WorkingWithTables.CloneCompleteTable.docx");

Het volgende codevoorbeeld laat zien hoe u de laatste rij van een tabel kunt klonen en aan de tabel kunt toevoegen:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>(MyDir + u"Tables.docx");

auto table = System::ExplicitCast<Table>(doc->GetChild(NodeType::Table, 0, true));

auto clonedRow = System::ExplicitCast<Row>(table->get_LastRow()->Clone(true));
// Remove all content from the cloned row's cells. This makes the row ready for new content to be inserted into.
for (const auto& cell : System::IterateOver<Cell>(clonedRow->get_Cells()))
{
    cell->RemoveAllChildren();
}

table->AppendChild(clonedRow);

doc->Save(ArtifactsDir + u"WorkingWithTables.CloneLastRow.docx");

Als u tabellen in een document wilt maken die dynamisch groeien met elke record uit uw gegevensbron, wordt de bovenstaande methode niet aanbevolen. In plaats daarvan wordt de gewenste output gemakkelijker bereikt door Mail merge met regio ' s te gebruiken. Meer informatie over deze techniek vindt u in de Mail Merge Met regio ' s sectie.

Manieren om een tabel te maken vergelijken

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

Laten we deze manieren van het maken van tabellen nader bekijken en hun voor-en nadelen vergelijken:

Methode	Voordeel	Nadelen
DocumentBuilder	De standaardmethode voor het invoegen van tabellen en andere documentinhoud	Soms moeilijk om meerdere soorten tabellen tegelijkertijd te maken met dezelfde builder-instantie
Via DOM	Past beter in de omringende code die knooppunten direct in de DOM maakt en invoegt zonder een DocumentBuilderte gebruiken	De tabel wordt “leeg” gemaakt: voordat u de meeste bewerkingen uitvoert, moet u EnsureMinimum aanroepen om eventuele ontbrekende kindknooppunten te maken
Van HTML	Kan een nieuwe tabel maken van HTML bron met behulp van tags zoals <table>, <tr>, <td>	Niet alle mogelijke Microsoft Word tabelindelingen kunnen worden toegepast op HTML
Klonen van een bestaande tabel	U kunt een kopie van een bestaande tabel maken met behoud van alle rij-en celopmaak	De juiste kindknooppunten moeten worden verwijderd voordat de tabel klaar is voor gebruik