TableCollection

TableCollection class

Ger maskinskriven åtkomst till en samling avTable noder.

För att lära dig mer, besökArbeta med tabeller dokumentationsartikel.

public class TableCollection : NodeCollection

Egenskaper

namnBeskrivning
Count { get; }Hämtar antalet noder i samlingen.
Item { get; }Hämtar enTable vid det givna indexet. (2 indexers)

Metoder

namnBeskrivning
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)Avgör om en nod finns i samlingen.
GetEnumerator()Ger en enkel iteration i “foreach”-stil ö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 tabellmatris. (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 inuti 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 inuti andra tabeller.
/// </summary>
/// <returns>
/// Ett heltal som anger tabellens kapslingsdjup (antal noder i överordnade tabeller).
/// </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>
/// Avgör om en tabell innehåller någon direkt underordnad tabell i sina celler.
/// Gå inte rekursivt igenom dessa tabeller för att söka efter ytterligare tabeller.
/// </summary>
/// <returns>
/// Returnerar sant om minst en undercell innehåller en tabell.
/// Returnerar falskt 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)
    {
        foreach (Cell Cell in row.Cells)
        {
            TableCollection childTables = Cell.Tables;

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

    return childTableCount;
}

Se även

TableAlignment Enum TableStyleOptions Enum