Sütunlar ve Satırlar ile Çalışma

Tabloların nasıl çalıştığı üzerinde daha fazla kontrol sahibi olmak için sütunları ve satırları nasıl değiştireceğinizi öğrenin.

Tablo Öğesi Dizinini {#find-the-index-of-table-elements}‘i Bulun

Sütunlar, satırlar ve hücreler, seçilen belge düğümüne indeksinden erişilerek yönetilir. Herhangi bir düğümün dizinini bulmak, öğe türündeki tüm alt düğümlerin üst düğümden toplanmasını ve ardından koleksiyonda istenen düğümün dizinini bulmak için IndexOf yöntemini kullanmayı içerir.

{#find-the-index-of-table-in-a-document} Belgesindeki Tablonun Dizinini Bulma

Bazen bir belgedeki belirli bir tabloda değişiklik yapmanız gerekebilir. Bunu yapmak için bir tabloya indeksine göre başvurabilirsiniz.

Aşağıdaki kod örneği, bir belgedeki tablonun dizininin nasıl alınacağını gösterir:

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

Tablo {#find-the-index-of-a-row-in-a-table}‘teki Satırın Dizinini Bulma

Benzer şekilde seçilen bir tablodaki belirli bir satırda değişiklik yapmanız gerekebilir. Bunu yapmak için bir satıra dizinine göre de başvurabilirsiniz.

Aşağıdaki kod örneği, bir tablodaki bir satırın dizininin nasıl alınacağını gösterir:

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

Bir Satırdaki Hücrenin Dizinini Bul

Son olarak, belirli bir hücrede değişiklik yapmanız gerekebilir ve bunu hücre indeksi ile de yapabilirsiniz.

Aşağıdaki kod örneği, satırdaki bir hücrenin dizininin nasıl alınacağını gösterir:

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

Sütunlar {#work-with-columns} ile Çalışma

Aspose.Words Document Object Model’de (DOM), Table düğümü Row düğümlerinden ve ardından Cell düğümlerinden oluşur. Dolayısıyla Aspose.Words’in Document Nesne Modelinde, Word belgelerinde olduğu gibi sütun kavramı yoktur.

Tasarım gereği, Microsoft Word ve Aspose.Words’deki tablo satırları tamamen bağımsızdır ve temel özellikler ve işlemler yalnızca tablonun satırlarında ve hücrelerinde bulunur. Bu, tablolara bazı ilginç özelliklere sahip olma yeteneği kazandırır:

• Her tablo satırı tamamen farklı sayıda hücreye sahip olabilir
• Dikey olarak her satırın hücreleri farklı genişliklere sahip olabilir
• Farklı satır formatına ve hücre sayısına sahip tabloları birleştirmek mümkündür

Sütunlar üzerinde gerçekleştirilen işlemler aslında satır hücrelerini sütunlara uygulanıyormuş gibi toplu olarak değiştirerek işlemi gerçekleştiren “kısayollardır”. Yani, aynı tablo satırı hücre dizini üzerinde basitçe yineleme yaparak sütunlar üzerinde işlemler gerçekleştirebilirsiniz.

Aşağıdaki kod örneği, bir tablonun “sütununu” oluşturan hücreleri toplayan bir cephe sınıfını kanıtlayarak bu tür işlemleri basitleştirir:

// 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;
}

Aşağıdaki kod örneği, boş bir sütunun tabloya nasıl ekleneceğini gösterir:

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

Aşağıdaki kod örneği, bir belgedeki tablodan bir sütunun nasıl kaldırılacağını gösterir:

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

Satırları Başlık Satırları Olarak Belirtin

Tablodaki ilk satırı Başlık Satırı olarak yalnızca ilk sayfada veya tablo birkaç sayfaya bölünmüşse her sayfada tekrarlamayı seçebilirsiniz. Aspose.Words’te, HeadingFormat özelliğini kullanarak Başlık Satırını her sayfada tekrarlayabilirsiniz.

Ayrıca, birden fazla başlık satırını, bu satırların tablonun başında birbiri ardına yerleştirilmesi durumunda da işaretleyebilirsiniz. Bunu yapmak için HeadingFormat özelliklerini bu satırlara uygulamanız gerekir.

Başlık Satırlarının iç içe geçmiş tablolarda çalışmadığını unutmayın. Yani başka bir tablonun içinde bir tablonuz varsa bu ayarın hiçbir etkisi olmayacaktır. Buna izin vermeyen Aspose.Words’nin değil Microsoft Word’in bir sınırlamasıdır.

Aşağıdaki kod örneği, sonraki sayfalarda tekrarlanan Başlık Satırlarını içeren bir tablonun nasıl oluşturulacağını gösterir:

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

Tabloların ve Satırların Sayfalar Arasında Ayrılmasını Önleyin

Bir tablonun içeriğinin sayfalara bölünmemesi gereken zamanlar vardır. Örneğin, bir başlık bir tablonun üzerindeyse, düzgün görünümü korumak için başlık ve tablo her zaman aynı sayfada bir arada tutulmalıdır.

Bu işlevselliği elde etmek için yararlı olan iki ayrı teknik vardır:

• Tablo satırlarına uygulanan Allow row break across pages
• Tablo hücrelerindeki paragraflara uygulanan Keep with next

Varsayılan olarak yukarıdaki özellikler devre dışıdır.

Bir Satırın Sayfalar Arasında Kırılmasını Önleyin

Bu, bir satırın hücreleri içindeki içeriğin sayfaya bölünmesinin kısıtlanmasını içerir. Microsoft Word’te bu, Tablo Özellikleri altında “Satırın sayfalar arasında bölünmesine izin ver” seçeneği olarak bulunabilir. Aspose.Words’de bu, bir Row‘in RowFormat nesnesi altında RowFormat.AllowBreakAcrossPages özelliği olarak bulunur.

Aşağıdaki kod örneği, bir tablodaki her satır için satırların sayfalar arasında bölünmesinin nasıl devre dışı bırakılacağını gösterir:

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

Bu örneğin örnek dosyasını Aspose.Words GitHub‘ten indirebilirsiniz.

Bir Tablonun Sayfalar Arasında Bozulmasını Önleyin

Tablonun sayfalara bölünmesini engellemek için tablonun içerdiği içeriğin bir arada kalmasını istediğimizi belirtmemiz gerekir.

Bunu yapmak için Aspose.Words, kullanıcıların bir tablo seçmesine ve tablo hücreleri içindeki her paragraf için true’e KeepWithNext parametresini etkinleştirmesine olanak tanıyan bir yöntem kullanır. Bunun istisnası, tablonun false olarak ayarlanması gereken son paragrafıdır.

Aşağıdaki kod örneği, bir tablonun aynı sayfada birlikte kalacak şekilde nasıl ayarlanacağını gösterir:

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

Bu örneğin örnek dosyasını Aspose.Words GitHub‘ten indirebilirsiniz.