Créer un tableau
Aspose.Words permet aux utilisateurs de créer des tableaux dans un document à partir de zéro et propose plusieurs méthodes différentes pour ce faire. Cet article présente des détails sur la façon d’ajouter des tableaux formatés à votre document à l’aide de chaque méthode, ainsi qu’une comparaison de chaque méthode à la fin de l’article.
Styles de tableau par défaut
Le tableau nouvellement créé reçoit des valeurs par défaut similaires à celles utilisées dans Microsoft Word:
Propriété du tableau | Par défaut dans 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 |
Créer un tableau avec DocumentBuilder
Dans Aspose.Words, les utilisateurs peuvent créer un tableau dans un document à l’aide du DocumentBuilder. L’algorithme de base pour créer un tableau est le suivant:
- Démarrez le tableau avec StartTable
- Ajoutez une cellule au tableau à l’aide de InsertCell – cela démarre automatiquement une nouvelle ligne
- Vous pouvez éventuellement utiliser la propriété CellFormat pour spécifier le formatage des cellules
- Insérez le contenu de la cellule à l’aide des méthodes DocumentBuilder appropriées telles que Writeln, InsertImage et autres
- Répétez les étapes 2 à 4 jusqu’à ce que la rangée soit terminée
- Appelez EndRow pour terminer la ligne actuelle
- Vous pouvez éventuellement utiliser la propriété RowFormat pour spécifier le formatage des lignes
- Répétez les étapes 2 à 7 jusqu’à ce que le tableau soit terminé
- Appelez EndTable pour terminer la création de la table
Détails importants:
- StartTable peut également être appelé à l’intérieur d’une cellule, auquel cas il démarre la création d’un tableau imbriqué au sein de la cellule.
- Après avoir appelé InsertCell, une nouvelle cellule est créée et tout contenu que vous ajoutez à l’aide d’autres méthodes de la classe DocumentBuilder sera ajouté à la cellule actuelle. Pour créer une nouvelle cellule sur la même ligne, appelez à nouveau InsertCell.
- Si InsertCell est appelé immédiatement après EndRow et la fin d’une ligne, le tableau continuera sur une nouvelle ligne.
- La méthode EndTable pour terminer la table ne doit être appelée qu’une seule fois après l’appel de EndRow. L’appel de EndTable déplace le curseur de la cellule actuelle vers la position immédiatement après le tableau.
Le processus de création d’un tableau est clairement visible dans l’image suivante:
L’exemple de code suivant montre comment créer un tableau simple à l’aide de DocumentBuilder avec le formatage par défaut:
// 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"); |
L’exemple de code suivant montre comment créer un tableau formaté à l’aide de 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"); |
L’exemple de code suivant montre comment insérer une table imbriquée à l’aide de 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"); |
Créer un tableau via DOM (Document Object Model)
Vous pouvez insérer des tableaux directement dans le DOM en ajoutant un nouveau nœud Table à une position spécifique.
Veuillez noter qu’immédiatement après la création du nœud de table, la table elle-même sera complètement vide, c’est-à-dire qu’elle ne contient pas encore de lignes ni de cellules. Pour insérer des lignes et des cellules dans un tableau, ajoutez les nœuds enfants Row et Cell appropriés au DOM.
L’exemple de code suivant montre comment créer une nouvelle table à partir de zéro en ajoutant les nœuds enfants appropriés à l’arborescence du document:
// 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"); |
Créer un tableau à partir de HTML
Aspose.Words prend en charge l’insertion de contenu dans un document à partir d’une source HTML à l’aide de la méthode InsertHtml. L’entrée peut être une page HTML complète ou simplement un extrait partiel.
En utilisant la méthode InsertHtml, les utilisateurs peuvent insérer des tableaux dans le document via des balises de tableau telles que <table>
, <tr>
, <td>
.
L’exemple de code suivant montre comment insérer un tableau dans un document à partir d’une chaîne contenant des balises HTML:
// 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"); |
Insérer une copie d’une table existante
Il arrive souvent que vous deviez créer un tableau basé sur un tableau déjà existant dans un document. Le moyen le plus simple de dupliquer un tableau tout en conservant toute la mise en forme consiste à cloner le nœud Table à l’aide de la méthode Clone.
La même technique peut être utilisée pour ajouter des copies d’une ligne ou d’une cellule existante à un tableau.
L’exemple de code suivant montre comment dupliquer une table à l’aide de constructeurs de nœuds:
// 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"); |
L’exemple de code suivant montre comment cloner la dernière ligne d’une table et l’ajouter à la table:
// 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"); |
Si vous envisagez de créer des tableaux dans un document qui grandissent dynamiquement avec chaque enregistrement de votre source de données, la méthode ci-dessus n’est pas conseillée. Au lieu de cela, le résultat souhaité est plus facilement obtenu en utilisant Mail merge avec des régions. Vous pouvez en savoir plus sur cette technique dans la section Mail Merge avec régions.
Comparez les façons de créer un tableau
Aspose.Words propose plusieurs méthodes pour créer de nouveaux tableaux dans un document. Chaque méthode a ses propres avantages et inconvénients, de sorte que le choix de celle à utiliser dépend souvent de la situation spécifique.
Examinons de plus près ces façons de créer des tableaux et comparons leurs avantages et leurs inconvénients:
Méthode | Avantages | Désavantages |
---|---|---|
Via DocumentBuilder |
La méthode standard pour insérer des tableaux et autres contenus de documents | Parfois difficile de créer plusieurs variétés de tables en même temps avec la même instance de constructeur |
Via DOM | S’intègre mieux au code environnant qui crée et insère des nœuds directement dans le DOM sans utiliser de DocumentBuilder | La table est créée “vide”: avant d’effectuer la plupart des opérations, vous devez appeler EnsureMinimum pour créer les éventuels nœuds enfants manquants |
À partir du HTML | Peut créer un nouveau tableau à partir d’une source HTML en utilisant des balises telles que <table> , <tr> , <td> |
Tous les formats de tableaux Microsoft Word possibles ne peuvent pas être appliqués au HTML |
Cloner une table existante | Vous pouvez créer une copie d’un tableau existant tout en conservant la mise en forme des lignes et des cellules | Les nœuds enfants appropriés doivent être supprimés avant que la table soit prête à être utilisée |