Table

Table class

Representerar en tabell i ett Word-dokument.

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

public class Table : CompositeNode

Konstruktörer

namn	Beskrivning
Table(DocumentBase)	Initierar en ny instans av`Table` klass.

Egenskaper

namn	Beskrivning
AbsoluteHorizontalDistance { get; set; }	Hämtar eller ställer in absolut horisontell flytande tabellposition som anges av tabellegenskaperna, i punkter. Standardvärdet är 0.
AbsoluteVerticalDistance { get; set; }	Hämtar eller ställer in den absoluta vertikala flytande tabellpositionen som anges av tabellegenskaperna, i punkter. Standardvärdet är 0.
Alignment { get; set; }	Anger hur en inbäddad tabell är justerad i dokumentet.
AllowAutoFit { get; set; }	Tillåter Microsoft Word och Aspose.Words att automatiskt ändra storlek på celler i en tabell så att de passar deras innehåll.
AllowCellSpacing { get; set; }	Hämtar eller ställer in alternativet “Tillåt avstånd mellan celler”.
AllowOverlap { get; }	Hämtar om en flytande tabell ska tillåta andra flytande objekt i dokumentet att överlappa dess omfattning när den visas. Standardvärdet är`sann` .
Bidi { get; set; }	Hämtar eller anger om detta är en tabell som skrivs från höger till vänster.
BottomPadding { get; set; }	Hämtar eller anger mängden utrymme (i punkter) som ska läggas till under innehållet i cellerna.
CellSpacing { get; set; }	Hämtar eller anger mängden utrymme (i punkter) mellan cellerna.
Count { get; }	Hämtar antalet omedelbara barn till denna nod.
CustomNodeId { get; set; }	Anger anpassad nodidentifierare.
Description { get; set; }	Hämtar eller anger beskrivning av denna tabell. Den ger en alternativ textrepresentation av informationen i tabellen.
DistanceBottom { get; set; }	Hämtar eller ställer in avståndet mellan tabellens botten och den omgivande texten, i punkter.
DistanceLeft { get; set; }	Hämtar eller ställer in avståndet mellan tabellens vänstra sida och den omgivande texten, i punkter.
DistanceRight { get; set; }	Hämtar eller ställer in avståndet mellan tabellens högra sida och den omgivande texten, i punkter.
DistanceTop { get; set; }	Hämtar eller ställer in avståndet mellan bordsskivan och den omgivande texten, i punkter.
virtual Document { get; }	Hämtar dokumentet som denna nod tillhör.
FirstChild { get; }	Hämtar nodens första barn.
FirstRow { get; }	Returnerar det första`Row` nod i tabellen.
HasChildNodes { get; }	Returer`sann` om den här noden har några undernoder.
HorizontalAnchor { get; set; }	Hämtar basobjektet från vilket den horisontella positioneringen av den flytande tabellen ska beräknas. Standardvärdet ärColumn .
override IsComposite { get; }	Returer`sann` eftersom denna nod kan ha underordnade noder.
LastChild { get; }	Hämtar nodens sista barn.
LastRow { get; }	Returnerar det sista`Row` nod i tabellen.
LeftIndent { get; set; }	Hämtar eller anger värdet som representerar tabellens vänstra indrag.
LeftPadding { get; set; }	Hämtar eller anger mängden utrymme (i punkter) som ska läggas till vänster om innehållet i cellerna.
NextSibling { get; }	Hämtar noden som följer direkt efter denna nod.
override NodeType { get; }	ReturerTable .
ParentNode { get; }	Hämtar den omedelbara föräldern till denna nod.
PreferredWidth { get; set; }	Hämtar eller ställer in tabellens önskade bredd.
PreviousSibling { get; }	Hämtar noden som omedelbart föregår denna nod.
Range { get; }	Returnerar en`Range`objekt som representerar den del av ett dokument som finns i denna nod.
RelativeHorizontalAlignment { get; set; }	Hämtar eller ställer in den flytande tabellens relativa horisontella justering.
RelativeVerticalAlignment { get; set; }	Hämtar eller ställer in den flytande tabellens relativa vertikala justering.
RightPadding { get; set; }	Hämtar eller anger mängden utrymme (i punkter) som ska läggas till till höger om innehållet i cellerna.
Rows { get; }	Ger åtkomst till tabellens rader med maskinskriven kod.
Style { get; set; }	Hämtar eller ställer in tabellstilen som tillämpas på den här tabellen.
StyleIdentifier { get; set; }	Hämtar eller ställer in den språkoberoende stilidentifieraren för tabellstilen som tillämpats på den här tabellen.
StyleName { get; set; }	Hämtar eller anger namnet på tabellformatet som tillämpats på den här tabellen.
StyleOptions { get; set; }	Hämtar eller ställer in bitflaggor som anger hur en tabellstil tillämpas på den här tabellen.
TextWrapping { get; set; }	Hämtar eller sätter`TextWrapping` för tabell.
Title { get; set; }	Hämtar eller anger titeln för denna tabell. Tillhandahåller en alternativ textrepresentation av informationen i tabellen.
TopPadding { get; set; }	Hämtar eller anger mängden utrymme (i punkter) som ska läggas till ovanför innehållet i cellerna.
VerticalAnchor { get; set; }	Hämtar basobjektet från vilket den vertikala positioneringen av den flytande tabellen ska beräknas. Standardvärdet ärMargin .

Metoder

namn	Beskrivning
override Accept(DocumentVisitor)	Tar emot en besökare.
override AcceptEnd(DocumentVisitor)	Accepterar en besökare för att besöka slutet av bordet.
override AcceptStart(DocumentVisitor)	Accepterar en besökare för att besöka början av bordet.
AppendChild<T>(T)	Lägger till den angivna noden i slutet av listan över underordnade noder för denna nod.
AutoFit(AutoFitBehavior)	Ändrar storleken på tabellen och cellerna enligt det angivna automatiska anpassningsbeteendet.
ClearBorders()	Tar bort alla tabell- och cellkanter i den här tabellen.
ClearShading()	Tar bort all skuggning på tabellen.
Clone(bool)	Skapar en duplikat av noden.
ConvertToHorizontallyMergedCells()	Konverterar celler som sammanfogats horisontellt efter bredd till celler som sammanfogats efter`HorizontalMerge` .
CreateNavigator()	Skapar en navigator som kan användas för att korsa och läsa noder.
EnsureMinimum()	Om tabellen inte har några rader, skapas och läggs till en`Row` .
GetAncestor(NodeType)	Hämtar den första förfadern till den angivna`NodeType` .
GetAncestor(Type)	Hämtar den första förfadern till den angivna objekttypen.
GetChild(NodeType, int, bool)	Returnerar en N:te underordnad nod som matchar den angivna typen.
GetChildNodes(NodeType, bool)	Returnerar en live-samling av underordnade noder som matchar den angivna typen.
GetEnumerator()	Ger stöd för iterationen för varje stil över de underordnade noderna till denna nod.
override GetText()	Hämtar texten för denna nod och alla dess underordnade noder.
IndexOf(Node)	Returnerar indexet för den angivna undernoden i undernodsmatrisen.
InsertAfter<T>(T, Node)	Infogar den angivna noden omedelbart efter den angivna referensnoden.
InsertBefore<T>(T, Node)	Infogar den angivna noden omedelbart före den angivna referensnoden.
NextPreOrder(Node)	Hämtar nästa nod enligt algoritmen för förbeställningsträdtraversering.
PrependChild<T>(T)	Lägger till den angivna noden i början av listan över underordnade noder för denna nod.
PreviousPreOrder(Node)	Hämtar föregående nod enligt algoritmen för trädtraversering i förbeställning.
Remove()	Tar bort sig själv från föräldern.
RemoveAllChildren()	Tar bort alla undernoder till den aktuella noden.
RemoveChild<T>(T)	Tar bort den angivna undernoden.
RemoveSmartTags()	Tar bort alla`SmartTag` underordnade noder till den aktuella noden.
SelectNodes(string)	Väljer en lista med noder som matchar XPath-uttrycket.
SelectSingleNode(string)	Väljer den första`Node` som matchar XPath-uttrycket.
SetBorder(BorderType, LineStyle, double, Color, bool)	Ställer in den angivna tabellkanten till den angivna linjestilen, bredden och färgen.
SetBorders(LineStyle, double, Color)	Ställer in alla tabellkanter till angiven linjestil, bredd och färg.
SetShading(TextureIndex, Color, Color)	Ställer in skuggning till de angivna värdena för hela tabellen.
ToString(SaveFormat)	Exporterar nodens innehåll till en sträng i det angivna formatet.
ToString(SaveOptions)	Exporterar nodens innehåll till en sträng med de angivna sparalternativen.

Anmärkningar

Table är en blocknivånod och kan vara ett barn till klasser som härrör frånStory eller InlineStory.

Table kan innehålla en eller fleraRow noder.

En minimal giltig tabell måste ha minst enRow.

Exempel

Visar hur man skapar en tabell.

Document doc = new Document();
Table table = new Table(doc);
doc.FirstSection.Body.AppendChild(table);

// Tabeller innehåller rader, som innehåller celler, vilka kan innehålla stycken
// med typiska element som körningar, former och även andra tabeller.
// Att anropa metoden "EnsureMinimum" på en tabell säkerställer att
// tabellen har minst en rad, cell och stycke.
Row firstRow = new Row(doc);
table.AppendChild(firstRow);

Cell firstCell = new Cell(doc);
firstRow.AppendChild(firstCell);

Paragraph paragraph = new Paragraph(doc);
firstCell.AppendChild(paragraph);

// Lägg till text i den första cellen på den första raden i tabellen.
Run run = new Run(doc, "Hello world!");
paragraph.AppendChild(run);

doc.Save(ArtifactsDir + "Table.CreateTable.docx");

Visar hur man itererar igenom alla tabeller i dokumentet och skriver ut innehållet i varje cell.

Document doc = new Document(MyDir + "Tables.docx");
TableCollection tables = doc.FirstSection.Body.Tables;

Assert.AreEqual(2, tables.ToArray().Length);

for (int i = 0; i < tables.Count; i++)
{
    Console.WriteLine($"Start of Table {i}");

    RowCollection rows = tables[i].Rows;

    // Vi kan använda metoden "ToArray" på en radsamling för att klona den till en array.
    Assert.AreEqual(rows, rows.ToArray());
    Assert.AreNotSame(rows, rows.ToArray());

    for (int j = 0; j < rows.Count; j++)
    {
        Console.WriteLine($"\tStart of Row {j}");

        CellCollection cells = rows[j].Cells;

        // Vi kan använda metoden "ToArray" på en cellsamling för att klona den till en array.
        Assert.AreEqual(cells, cells.ToArray());
        Assert.AreNotSame(cells, cells.ToArray());

        for (int k = 0; k < cells.Count; k++)
        {
            string cellText = cells[k].ToString(SaveFormat.Text).Trim();
            Console.WriteLine($"\t\tContents of Cell:{k} = \"{cellText}\"");
        }

        Console.WriteLine($"\tEnd of Row {j}");
    }

    Console.WriteLine($"End of Table {i}\n");
}

Visar hur man bygger en formaterad 2x2-tabell.

Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);

Table table = builder.StartTable();
builder.InsertCell();
builder.CellFormat.VerticalAlignment = CellVerticalAlignment.Center;
builder.Write("Row 1, cell 1.");
builder.InsertCell();
builder.Write("Row 1, cell 2.");
builder.EndRow();

// När tabellen skapas kommer dokumentbyggaren att tillämpa dess aktuella RowFormat/CellFormat-egenskapsvärden
// till den aktuella raden/cellen där markören befinner sig och alla nya rader/celler allt eftersom de skapas.
Assert.AreEqual(CellVerticalAlignment.Center, table.Rows[0].Cells[0].CellFormat.VerticalAlignment);
Assert.AreEqual(CellVerticalAlignment.Center, table.Rows[0].Cells[1].CellFormat.VerticalAlignment);

builder.InsertCell();
builder.RowFormat.Height = 100;
builder.RowFormat.HeightRule = HeightRule.Exactly;
builder.CellFormat.Orientation = TextOrientation.Upward;
builder.Write("Row 2, cell 1.");
builder.InsertCell();
builder.CellFormat.Orientation = TextOrientation.Downward;
builder.Write("Row 2, cell 2.");
builder.EndRow();
builder.EndTable();

// Tidigare tillagda rader och celler påverkas inte retroaktivt av ändringar i formateringen i verktyget.
Assert.AreEqual(0, table.Rows[0].RowFormat.Height);
Assert.AreEqual(HeightRule.Auto, table.Rows[0].RowFormat.HeightRule);
Assert.AreEqual(100, table.Rows[1].RowFormat.Height);
Assert.AreEqual(HeightRule.Exactly, table.Rows[1].RowFormat.HeightRule);
Assert.AreEqual(TextOrientation.Upward, table.Rows[1].Cells[0].CellFormat.Orientation);
Assert.AreEqual(TextOrientation.Downward, table.Rows[1].Cells[1].CellFormat.Orientation);

doc.Save(ArtifactsDir + "DocumentBuilder.BuildTable.docx");

Visar hur man bygger en kapslad tabell utan att använda en dokumentbyggare.

public void CreateNestedTable()
{
    Document doc = new Document();

    // Skapa den yttre tabellen med tre rader och fyra kolumner och lägg sedan till den i dokumentet.
    Table outerTable = CreateTable(doc, 3, 4, "Outer Table");
    doc.FirstSection.Body.AppendChild(outerTable);

    // Skapa en annan tabell med två rader och två kolumner och infoga den sedan i den första tabellens första cell.
    Table innerTable = CreateTable(doc, 2, 2, "Inner Table");
    outerTable.FirstRow.FirstCell.AppendChild(innerTable);

    doc.Save(ArtifactsDir + "Table.CreateNestedTable.docx");
}

/// <summary>
/// Skapar en ny tabell i dokumentet med de angivna dimensionerna och texten i varje cell.
/// </summary>
private static Table CreateTable(Document doc, int rowCount, int cellCount, string cellText)
{
    Table table = new Table(doc);

    for (int rowId = 1; rowId <= rowCount; rowId++)
    {
        Row row = new Row(doc);
        table.AppendChild(row);

        for (int cellId = 1; cellId <= cellCount; cellId++)
        {
            Cell cell = new Cell(doc);
            cell.AppendChild(new Paragraph(doc));
            cell.FirstParagraph.AppendChild(new Run(doc, cellText));

            row.AppendChild(cell);
        }
    }

    // Du kan använda egenskaperna "Titel" och "Beskrivning" för att lägga till en titel respektive beskrivning till din tabell.
    // Tabellen måste ha minst en rad innan vi kan använda dessa egenskaper.
    // Dessa egenskaper är betydelsefulla för ISO/IEC 29500-kompatibla .docx-dokument (se OoxmlCompliance-klassen).
    // Om vi sparar dokumentet i format före ISO/IEC 29500 ignorerar Microsoft Word dessa egenskaper.
    table.Title = "Aspose table title";
    table.Description = "Aspose table description";

    return table;
}

Se även

class CompositeNode
namnutrymme Aspose.Words.Tables
hopsättning Aspose.Words

RowFormat Class TableAlignment Enum