TableCollection

TableCollection class

Ger maskinskriven åtkomst till en samling avTable noder.

public class TableCollection : NodeCollection

Egenskaper

namn Beskrivning
Count { get; } Hämtar antalet noder i samlingen.
Item { get; } Hämtar en Tabell vid det givna indexet. (2 indexers)

Metoder

namn Beskrivning
Add(Node) Lägger till en nod i slutet av samlingen.
Clear() Tar bort alla noder från den här samlingen och från dokumentet.
Contains(Node) Bestämmer om en nod finns i samlingen.
GetEnumerator() Ger en enkel “foreach” stil iteration över samlingen av noder.
IndexOf(Node) Returnerar det nollbaserade indexet för den angivna noden.
Insert(int, Node) Infogar en nod i samlingen vid det angivna indexet.
Remove(Node) Tar bort noden från samlingen och från dokumentet.
RemoveAt(int) Tar bort noden vid det angivna indexet från samlingen och från dokumentet.
ToArray() Kopierar alla tabeller från samlingen till en ny array av tabeller. (2 methods)

Exempel

Visar hur man tar bort den första och sista raden i alla tabeller i ett dokument.

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

Visar hur man tar reda på om en tabell är kapslad.

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

        // Ta reda på om några celler i tabellen har andra tabeller som underordnade.
        int count = GetChildTableCount(table);
        Console.WriteLine("Table #{0} has {1} tables directly within its cells", i, count);

        // Ta reda på om tabellen är kapslad i en annan tabell, och i så fall på vilket djup.
        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>
/// Beräknar vilken nivå en tabell är kapslad i andra tabeller.
/// </summary>
/// <returns>
/// Ett heltal som anger tabellens kapsningsdjup (antal överordnade tabellnoder).
/// </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>
/// Bestämmer om en tabell innehåller någon omedelbar underordnad tabell i sina celler.
/// Gå inte rekursivt genom dessa tabeller för att leta efter ytterligare tabeller.
/// </summary>
/// <returns>
/// Returnerar sant om minst en underordnad cell innehåller en tabell.
/// Returnerar false om inga celler i tabellen innehåller en tabell.
/// </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;
}

Se även