Arbeiten Sie mit Spalten und Zeilen

Um mehr Kontrolle über die Funktionsweise von Tabellen zu erhalten, erfahren Sie, wie Sie Spalten und Zeilen bearbeiten.

Suchen Sie den Tabellenelementindex

Spalten, Zeilen und Zellen werden verwaltet, indem auf den ausgewählten Dokumentknoten über seinen Index zugegriffen wird. Um den Index eines beliebigen Knotens zu finden, müssen alle untergeordneten Knoten des Elementtyps vom übergeordneten Knoten erfasst und dann mithilfe der IndexOf-Methode der Index des gewünschten Knotens in der Sammlung ermittelt werden.

Finden Sie den Index einer Tabelle in einem Dokument

Manchmal müssen Sie möglicherweise Änderungen an einer bestimmten Tabelle in einem Dokument vornehmen. Dazu können Sie über ihren Index auf eine Tabelle verweisen.

Das folgende Codebeispiel zeigt, wie der Index einer Tabelle in einem Dokument abgerufen wird:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
Table table = (Table) doc.GetChild(NodeType.Table, 0, true);
NodeCollection allTables = doc.GetChildNodes(NodeType.Table, true);
int tableIndex = allTables.IndexOf(table);

Finden Sie den Index einer Zeile in einer Tabelle

Ebenso müssen Sie möglicherweise Änderungen an einer bestimmten Zeile in einer ausgewählten Tabelle vornehmen. Dazu können Sie eine Zeile auch über ihren Index referenzieren.

Das folgende Codebeispiel zeigt, wie der Index einer Zeile in einer Tabelle abgerufen wird:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
int rowIndex = table.IndexOf(table.LastRow);

Finden Sie den Index einer Zelle in einer Zeile

Schließlich müssen Sie möglicherweise Änderungen an einer bestimmten Zelle vornehmen, und Sie können dies auch über den Zellindex tun.

Das folgende Codebeispiel zeigt, wie der Index einer Zelle in einer Zeile abgerufen wird:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
int cellIndex = row.IndexOf(row.Cells[4]);

Arbeiten Sie mit {#work-with-columns}-Spalten

Im Aspose.Words Document Object Model (DOM) besteht der Table-Knoten aus Row-Knoten und dann aus Cell-Knoten. Daher gibt es im Document-Objektmodell von Aspose.Words, wie auch in Word-Dokumenten, kein Konzept einer Spalte.

Die Tabellenzeilen in Microsoft Word und Aspose.Words sind konstruktionsbedingt völlig unabhängig und die grundlegenden Eigenschaften und Operationen sind nur in den Zeilen und Zellen der Tabelle enthalten. Dies gibt Tabellen die Möglichkeit, einige interessante Attribute zu haben:

  • Jede Tabellenzeile kann eine völlig unterschiedliche Anzahl von Zellen haben
  • Vertikal können die Zellen jeder Zeile unterschiedliche Breiten haben
  • Es ist möglich, Tabellen mit unterschiedlichen Zeilenformaten und Zellenanzahlen zu verbinden

Alle an Spalten ausgeführten Operationen sind eigentlich “Abkürzungen”, die die Operation ausführen, indem sie Zeilenzellen gemeinsam so ändern, dass es aussieht, als würden sie auf Spalten angewendet. Das heißt, Sie können Operationen an Spalten ausführen, indem Sie einfach über denselben Zellenindex der Tabellenzeile iterieren.

Das folgende Codebeispiel vereinfacht solche Vorgänge, indem es eine Fassadenklasse beweist, die die Zellen sammelt, aus denen eine “Spalte” einer Tabelle besteht:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
/// <summary>
/// Represents a facade object for a column of a table in a Microsoft Word document.
/// </summary>
internal class Column
{
private Column(Table table, int columnIndex)
{
mTable = table ?? throw new ArgumentException("table");
mColumnIndex = columnIndex;
}
/// <summary>
/// Returns a new column facade from the table and supplied zero-based index.
/// </summary>
public static Column FromIndex(Table table, int columnIndex)
{
return new Column(table, columnIndex);
}
/// <summary>
/// Returns the cells which make up the column.
/// </summary>
public Cell[] Cells => GetColumnCells().ToArray();
/// <summary>
/// Returns the index of the given cell in the column.
/// </summary>
public int IndexOf(Cell cell)
{
return GetColumnCells().IndexOf(cell);
}
/// <summary>
/// Inserts a brand new column before this column into the table.
/// </summary>
public Column InsertColumnBefore()
{
Cell[] columnCells = Cells;
if (columnCells.Length == 0)
throw new ArgumentException("Column must not be empty");
// Create a clone of this column.
foreach (Cell cell in columnCells)
cell.ParentRow.InsertBefore(cell.Clone(false), cell);
// This is the new column.
Column column = new Column(columnCells[0].ParentRow.ParentTable, mColumnIndex);
// We want to make sure that the cells are all valid to work with (have at least one paragraph).
foreach (Cell cell in column.Cells)
cell.EnsureMinimum();
// Increase the index which this column represents since there is now one extra column in front.
mColumnIndex++;
return column;
}
/// <summary>
/// Removes the column from the table.
/// </summary>
public void Remove()
{
foreach (Cell cell in Cells)
cell.Remove();
}
/// <summary>
/// Returns the text of the column.
/// </summary>
public string ToTxt()
{
StringBuilder builder = new StringBuilder();
foreach (Cell cell in Cells)
builder.Append(cell.ToString(SaveFormat.Text));
return builder.ToString();
}
/// <summary>
/// Provides an up-to-date collection of cells which make up the column represented by this facade.
/// </summary>
private List<Cell> GetColumnCells()
{
List<Cell> columnCells = new List<Cell>();
foreach (Row row in mTable.Rows)
{
Cell cell = row.Cells[mColumnIndex];
if (cell != null)
columnCells.Add(cell);
}
return columnCells;
}
private int mColumnIndex;
private readonly Table mTable;
}
view raw column-class.cs hosted with ❤ by GitHub

Das folgende Codebeispiel zeigt, wie man eine leere Spalte in eine Tabelle einfügt:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
Document doc = new Document(MyDir + "Tables.docx");
Table table = (Table) doc.GetChild(NodeType.Table, 0, true);
Column column = Column.FromIndex(table, 0);
// Print the plain text of the column to the screen.
Console.WriteLine(column.ToTxt());
// Create a new column to the left of this column.
// This is the same as using the "Insert Column Before" command in Microsoft Word.
Column newColumn = column.InsertColumnBefore();
foreach (Cell cell in newColumn.Cells)
cell.FirstParagraph.AppendChild(new Run(doc, "Column Text " + newColumn.IndexOf(cell)));

Das folgende Codebeispiel zeigt, wie eine Spalte aus einer Tabelle in einem Dokument entfernt wird:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
Document doc = new Document(MyDir + "Tables.docx");
Table table = (Table) doc.GetChild(NodeType.Table, 1, true);
Column column = Column.FromIndex(table, 2);
column.Remove();

Geben Sie Zeilen als Kopfzeilen an

Sie können die erste Zeile in der Tabelle als Kopfzeile nur auf der ersten Seite oder auf jeder Seite wiederholen, wenn die Tabelle in mehrere geteilt ist. In Aspose.Words können Sie die Kopfzeile mithilfe der HeadingFormat-Eigenschaft auf jeder Seite wiederholen.

Sie können auch mehrere Kopfzeilen markieren, wenn diese am Anfang der Tabelle hintereinander stehen. Dazu müssen Sie die HeadingFormat-Eigenschaften auf diese Zeilen anwenden.

Das folgende Codebeispiel zeigt, wie eine Tabelle erstellt wird, die Kopfzeilen enthält, die sich auf nachfolgenden Seiten wiederholen:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
builder.StartTable();
builder.RowFormat.HeadingFormat = true;
builder.ParagraphFormat.Alignment = ParagraphAlignment.Center;
builder.CellFormat.Width = 100;
builder.InsertCell();
builder.Writeln("Heading row 1");
builder.EndRow();
builder.InsertCell();
builder.Writeln("Heading row 2");
builder.EndRow();
builder.CellFormat.Width = 50;
builder.ParagraphFormat.ClearFormatting();
for (int i = 0; i < 50; i++)
{
builder.InsertCell();
builder.RowFormat.HeadingFormat = false;
builder.Write("Column 1 Text");
builder.InsertCell();
builder.Write("Column 2 Text");
builder.EndRow();
}
doc.Save(ArtifactsDir + "WorkingWithTables.RepeatRowsOnSubsequentPages.docx");

Verhindern Sie, dass Tabellen und Zeilen über Seiten hinweg umbrechen.

Es gibt Zeiten, in denen der Inhalt einer Tabelle nicht auf mehrere Seiten aufgeteilt werden sollte. Wenn beispielsweise ein Titel über einer Tabelle steht, sollten Titel und Tabelle immer zusammen auf derselben Seite bleiben, um das richtige Erscheinungsbild zu gewährleisten.

Es gibt zwei verschiedene Techniken, die zum Erreichen dieser Funktionalität nützlich sind:

  • Allow row break across pages, das auf Tabellenzeilen angewendet wird
  • Keep with next, das auf Absätze in Tabellenzellen angewendet wird

Standardmäßig sind die oben genannten Eigenschaften deaktiviert.

Verhindern Sie, dass eine Zeile über mehrere Seiten bricht,

Dabei wird verhindert, dass Inhalte innerhalb der Zellen einer Zeile auf eine Seite aufgeteilt werden. In Microsoft Word ist dies unter “Tabelleneigenschaften” als Option “Zeilenumbruch über Seiten hinweg zulassen” zu finden. In Aspose.Words ist dies unter dem RowFormat-Objekt eines Row als Eigenschaft RowFormat.AllowBreakAcrossPages zu finden.

Das folgende Codebeispiel zeigt, wie Sie den seitenübergreifenden Zeilenumbruch für jede Zeile in einer Tabelle deaktivieren:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
Document doc = new Document(MyDir + "Table spanning two pages.docx");
Table table = (Table) doc.GetChild(NodeType.Table, 0, true);
// Disable breaking across pages for all rows in the table.
foreach (Row row in table.Rows)
row.RowFormat.AllowBreakAcrossPages = false;
doc.Save(ArtifactsDir + "WorkingWithTables.RowFormatDisableBreakAcrossPages.docx");

Verhindern Sie, dass eine Tabelle über mehrere Seiten bricht,

Um zu verhindern, dass die Tabelle auf mehrere Seiten aufgeteilt wird, müssen wir angeben, dass der in der Tabelle enthaltene Inhalt zusammen bleiben soll.

Zu diesem Zweck verwendet Aspose.Words eine Methode, die es Benutzern ermöglicht, eine Tabelle auszuwählen und den KeepWithNext-Parameter für jeden Absatz innerhalb der Tabellenzellen in true zu aktivieren. Die Ausnahme bildet der letzte Absatz in der Tabelle, der auf false eingestellt werden sollte.

Das folgende Codebeispiel zeigt, wie man eine Tabelle so einrichtet, dass sie zusammen auf derselben Seite bleibt:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
Document doc = new Document(MyDir + "Table spanning two pages.docx");
Table table = (Table) doc.GetChild(NodeType.Table, 0, true);
// We need to enable KeepWithNext for every paragraph in the table to keep it from breaking across a page,
// except for the last paragraphs in the last row of the table.
foreach (Cell cell in table.GetChildNodes(NodeType.Cell, true))
{
cell.EnsureMinimum();
foreach (Paragraph para in cell.Paragraphs)
if (!(cell.ParentRow.IsLastRow && para.IsEndOfCell))
para.ParagraphFormat.KeepWithNext = true;
}
doc.Save(ArtifactsDir + "WorkingWithTables.KeepTableTogether.docx");