TableCollection

TableCollection class

Fournit un accès typé à une collection deTable nœuds.

public class TableCollection : NodeCollection

Propriétés

Nom La description
Count { get; } Obtient le nombre de nœuds dans la collection.
Item { get; } Récupère un Table à l’index donné. (2 indexers)

Méthodes

Nom La description
Add(Node) Ajoute un nœud à la fin de la collection.
Clear() Supprime tous les nœuds de cette collection et du document.
Contains(Node) Détermine si un nœud est dans la collection.
GetEnumerator() Fournit une simple itération de style “foreach” sur la collection de nœuds.
IndexOf(Node) Renvoie l’index de base zéro du nœud spécifié.
Insert(int, Node) Insère un nœud dans la collection à l’index spécifié.
Remove(Node) Supprime le nœud de la collection et du document.
RemoveAt(int) Supprime le nœud à l’index spécifié de la collection et du document.
ToArray() Copie toutes les tables de la collection dans un nouveau tableau de tables. (2 methods)

Exemples

Montre comment supprimer les première et dernière lignes de tous les tableaux d’un document.

Document doc = new Document(MyDir + "Tables.docx");

TableCollection tables = doc.FirstSection.Body.Tables;

Assert.AreEqual(5, tables[0].Rows.Count);
Assert.AreEqual(4, tables[1].Rows.Count);

foreach (Table table in tables.OfType<Table>())
{
    table.FirstRow?.Remove();
    table.LastRow?.Remove();
}

Assert.AreEqual(3, tables[0].Rows.Count);
Assert.AreEqual(2, tables[1].Rows.Count);

Montre comment savoir si une table est imbriquée.

public void CalculateDepthOfNestedTables()
{
    Document doc = new Document(MyDir + "Nested tables.docx");
    NodeCollection tables = doc.GetChildNodes(NodeType.Table, true);

    for (int i = 0; i < tables.Count; i++)
    {
        Table table = (Table)tables[i];

        // Détermine si des cellules du tableau ont d'autres tableaux comme enfants.
        int count = GetChildTableCount(table);
        Console.WriteLine("Table #{0} has {1} tables directly within its cells", i, count);

        // Détermine si la table est imbriquée dans une autre table et, si oui, à quelle profondeur.
        int tableDepth = GetNestedDepthOfTable(table);

        if (tableDepth > 0)
            Console.WriteLine("Table #{0} is nested inside another table at depth of {1}", i,
                tableDepth);
        else
            Console.WriteLine("Table #{0} is a non nested table (is not a child of another table)", i);
    }
}

/// <summary>
/// Calcule à quel niveau une table est imbriquée dans d'autres tables.
/// </summary>
/// <returns>
/// Un entier indiquant la profondeur d'imbrication de la table (nombre de nœuds de la table parent).
/// </returns>
private static int GetNestedDepthOfTable(Table table)
{
    int depth = 0;
    Node parent = table.GetAncestor(table.NodeType);

    while (parent != null)
    {
        depth++;
        parent = parent.GetAncestor(typeof(Table));
    }

    return depth;
}

/// <summary>
/// Détermine si une table contient une table enfant immédiate dans ses cellules.
/// Ne parcourez pas ces tables de manière récursive pour rechercher d'autres tables.
/// </summary>
/// <returns>
/// Renvoie true si au moins une cellule enfant contient un tableau.
/// Renvoie faux si aucune cellule du tableau ne contient de tableau.
/// </returns>
private static int GetChildTableCount(Table table)
{
    int childTableCount = 0;

    foreach (Row row in table.Rows.OfType<Row>())
    {
        foreach (Cell Cell in row.Cells.OfType<Cell>())
        {
            TableCollection childTables = Cell.Tables;

            if (childTables.Count > 0)
                childTableCount++;
        }
    }

    return childTableCount;
}

Voir également