TableCollection

TableCollection class

Fornisce l’accesso tipizzato a una raccolta diTable nodi.

public class TableCollection : NodeCollection

Proprietà

Nome Descrizione
Count { get; } Ottiene il numero di nodi nella raccolta.
Item { get; } Recupera a Tavolo all’indice dato. (2 indexers)

Metodi

Nome Descrizione
Add(Node) Aggiunge un nodo alla fine della raccolta.
Clear() Rimuove tutti i nodi da questa raccolta e dal documento.
Contains(Node) Determina se un nodo è nella raccolta.
GetEnumerator() Fornisce una semplice iterazione di stile “foreach” sulla raccolta di nodi.
IndexOf(Node) Restituisce l’indice in base zero del nodo specificato.
Insert(int, Node) Inserisce un nodo nella raccolta in corrispondenza dell’indice specificato.
Remove(Node) Rimuove il nodo dalla raccolta e dal documento.
RemoveAt(int) Rimuove il nodo in corrispondenza dell’indice specificato dalla raccolta e dal documento.
ToArray() Copia tutte le tabelle dalla raccolta in un nuovo array di tabelle. (2 methods)

Esempi

Mostra come rimuovere la prima e l’ultima riga di tutte le tabelle in un documento.

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

Mostra come scoprire se una tabella è nidificata.

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];

        // Scopri se alcune celle nella tabella hanno altre tabelle come figli.
        int count = GetChildTableCount(table);
        Console.WriteLine("Table #{0} has {1} tables directly within its cells", i, count);

        // Scopri se la tabella è nidificata all'interno di un'altra tabella e, in tal caso, a quale profondità.
        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>
/// Calcola a quale livello è nidificata una tabella all'interno di altre tabelle.
/// </summary>
/// <returns>
/// Un numero intero che indica la profondità di annidamento della tabella (numero di nodi della tabella padre).
/// </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>
/// Determina se una tabella contiene una tabella figlio immediata all'interno delle sue celle.
/// Non attraversare in modo ricorsivo queste tabelle per cercare altre tabelle.
/// </summary>
/// <returns>
/// Restituisce true se almeno una cella figlio contiene una tabella.
/// Restituisce false se nessuna cella nella tabella contiene una tabella.
/// </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;
}

Guarda anche