Zastosuj formatowanie tabeli

Do każdego elementu tabeli można zastosować inne formatowanie. Na przykład formatowanie tabeli zostanie zastosowane do całej tabeli, formatowanie wierszy tylko do określonych wierszy, a formatowanie komórek tylko do wybranych komórek.

Aspose.Words zapewnia bogaty format API do pobierania i stosowania formatowania w tabeli. Do ustawienia formatowania można użyć węzłów Table, RowFormat i CellFormat.

W tym artykule porozmawiamy o tym, jak zastosować formatowanie do różnych węzłów tabeli i jakie ustawienia formatowania tabeli obsługuje Aspose.Words.

Zastosuj formatowanie do różnych węzłów

W tej sekcji przyjrzymy się stosowaniu formatowania do różnych węzłów tabeli.

Formatowanie na poziomie tabeli

Aby zastosować formatowanie do tabeli, możesz użyć właściwości dostępnych w odpowiednim węźle Table przy użyciu klas Table, PreferredWidth i TableCollection.

Należy pamiętać, że aby można było zastosować właściwości tabeli, tabela musi zawierać co najmniej jeden wiersz. Oznacza to, że podczas budowania tabeli w formacie DocumentBuilder formatowanie to należy wykonać po pierwszym wywołaniu InsertCell, po dodaniu pierwszego wiersza do tabeli lub po wstawieniu węzłów bezpośrednio do pliku DOM.

Poniższe ilustracje przedstawiają funkcje formatowania Table w formacie Microsoft Word i odpowiadające im właściwości w formacie Aspose.Words.

Poniższy przykład kodu pokazuje, jak zastosować obramowanie konspektu do tabeli:

// 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);
// Align the table to the center of the page.
table.Alignment = TableAlignment.Center;
// Clear any existing borders from the table.
table.ClearBorders();

// Set a green border around the table but not inside.
table.SetBorder(BorderType.Left, LineStyle.Single, 1.5, Color.Green, true);
table.SetBorder(BorderType.Right, LineStyle.Single, 1.5, Color.Green, true);
table.SetBorder(BorderType.Top, LineStyle.Single, 1.5, Color.Green, true);
table.SetBorder(BorderType.Bottom, LineStyle.Single, 1.5, Color.Green, true);

// Fill the cells with a light green solid color.
table.SetShading(TextureIndex.TextureSolid, Color.LightGreen, Color.Empty);

doc.Save(ArtifactsDir + "WorkingWithTableStylesAndFormatting.ApplyOutlineBorder.docx");

Możesz pobrać przykładowy plik tego przykładu z Aspose.Words GitHub.

Poniższy przykład kodu pokazuje, jak zbudować tabelę z włączonymi wszystkimi obramowaniami (siatką):

// 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);
            
// Clear any existing borders from the table.
table.ClearBorders();
            
// Set a green border around and inside the table.
table.SetBorders(LineStyle.Single, 1.5, Color.Green);

doc.Save(ArtifactsDir + "WorkingWithTableStylesAndFormatting.BuildTableWithBorders.docx");

Możesz pobrać przykładowy plik tego przykładu z Aspose.Words GitHub.

Formatowanie na poziomie wiersza

Formatowaniem Poziom wiersza można sterować za pomocą klas Row, RowFormat i RowCollection.

Należy pamiętać, że Row może być tylko węzłem podrzędnym Table. Jednocześnie w pliku Row musi znajdować się co najmniej jeden plik Cell, aby można było zastosować do niego formatowanie.

Poniższe rysunki przedstawiają funkcje formatowania Row w formacie Microsoft Word i odpowiadające im właściwości w formacie Aspose.Words.

Poniższy przykład kodu pokazuje, jak zmodyfikować formatowanie wierszy tabeli:

// 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);
            
// Retrieve the first row in the table.
Row firstRow = table.FirstRow;
firstRow.RowFormat.Borders.LineStyle = LineStyle.None;
firstRow.RowFormat.HeightRule = HeightRule.Auto;
firstRow.RowFormat.AllowBreakAcrossPages = true;

Możesz pobrać przykładowy plik tego przykładu z Aspose.Words GitHub.

Formatowanie na poziomie komórki

Formatowanie na poziomie komórki jest kontrolowane przez klasy Cell, CellFormat i CellCollection.

Należy pamiętać, że Cell może być tylko węzłem podrzędnym Row. Jednocześnie w pliku Cell musi znajdować się co najmniej jeden plik Paragraph, aby można było zastosować do niego formatowanie.

Oprócz Paragraph możesz także wstawić Table do Cell.

Poniższe rysunki przedstawiają funkcje formatowania Cell w formacie Microsoft Word i odpowiadające im właściwości w formacie Aspose.Words.

Poniższy przykład kodu pokazuje, jak zmodyfikować formatowanie komórki tabeli:

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

Cell firstCell = table.FirstRow.FirstCell;
firstCell.CellFormat.Width = 30;
firstCell.CellFormat.Orientation = TextOrientation.Downward;
firstCell.CellFormat.Shading.ForegroundPatternColor = Color.LightGreen;

Możesz pobrać przykładowy plik tego przykładu z Aspose.Words GitHub.

Poniższy przykład kodu pokazuje, jak ustawić ilość miejsca (w punktach), które ma zostać dodane po lewej/górze/prawej/dolnej stronie zawartości komórki:

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

// Sets the amount of space (in points) to add to the left/top/right/bottom of the cell's contents.
builder.CellFormat.SetPaddings(30, 50, 30, 50);
builder.Writeln("I'm a wonderful formatted cell.");

builder.EndRow();
builder.EndTable();

doc.Save(ArtifactsDir + "WorkingWithTableStylesAndFormatting.CellPadding.docx");

Określ wysokość wierszy

Najprostszym sposobem ustawienia wysokości wiersza jest użycie DocumentBuilder. Korzystając z odpowiednich właściwości RowFormat, możesz ustawić domyślne ustawienie wysokości lub zastosować inną wysokość dla każdego wiersza w tabeli.

W Aspose.Words wysokość wiersza tabeli jest kontrolowana przez:

• właściwość wysokości wiersza – Height
• właściwość reguły wysokości dla danego wiersza – HeightRule

Jednocześnie dla każdego rzędu można ustawić inną wysokość – pozwala to na szeroką kontrolę ustawień stołu.

Opcje reguł określające wysokość obiektu można ustawić za pomocą wyliczenia HeightRule.

Poniższy przykład kodu pokazuje, jak utworzyć tabelę zawierającą pojedynczą komórkę i zastosować formatowanie wierszy:

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

Table table = builder.StartTable();
builder.InsertCell();

RowFormat rowFormat = builder.RowFormat;
rowFormat.Height = 100;
rowFormat.HeightRule = HeightRule.Exactly;
            
// These formatting properties are set on the table and are applied to all rows in the table.
table.LeftPadding = 30;
table.RightPadding = 30;
table.TopPadding = 30;
table.BottomPadding = 30;

builder.Writeln("I'm a wonderful formatted row.");

builder.EndRow();
builder.EndTable();

doc.Save(ArtifactsDir + "WorkingWithTableStylesAndFormatting.ApplyRowFormatting.docx");

Określ szerokość tabeli i komórki

Tabela w dokumencie Microsoft Word udostępnia kilka różnych sposobów zmiany rozmiaru tabeli i poszczególnych komórek. Właściwości te pozwalają na znaczną kontrolę nad wyglądem i zachowaniem tabeli, dzięki czemu Aspose.Words wspiera zachowanie tabel, podobnie jak w Microsoft Word.

Ważne jest, aby wiedzieć, że elementy tabeli mają kilka różnych właściwości, które mogą wpływać na sposób obliczania szerokości całej tabeli, a także poszczególnych komórek:

• Preferowana szerokość na stole
• Preferowana szerokość poszczególnych komórek
• Umożliwienie automatycznego dopasowania na stole

W tym artykule szczegółowo opisano, jak działają różne właściwości obliczania szerokości tabeli i jak uzyskać pełną kontrolę nad obliczaniem szerokości tabeli. To jest Jest to szczególnie przydatne w przypadkach, gdy układ tabeli nie wygląda zgodnie z oczekiwaniami.

W większości przypadków zalecana jest preferowana komórka niż szerokość tabeli. Preferowana szerokość komórki jest bardziej zgodna ze specyfikacją formatu DOCX, a także modelem Aspose.Words.

Szerokość komórki jest w rzeczywistości wartością obliczoną dla formatu DOCX. Rzeczywista szerokość komórki może zależeć od wielu rzeczy. Na przykład zmiana marginesów strony lub preferowanej szerokości tabeli może wpłynąć na rzeczywistą szerokość komórki.

Preferowana szerokość komórki to właściwość komórki przechowywana w dokumencie. Nie zależy od niczego i nie zmienia się, gdy zmieniasz tabelę lub inne właściwości komórki.

Wszystkie właściwości i metody opisane w tym artykule są powiązane z działaniem tabel w Microsoft Word. Zatem w większości przypadków, jeśli programowo budujesz tabelę, ale masz trudności z utworzeniem żądanej tabeli, możesz zamiast tego spróbować najpierw wizualnie utworzyć ją w Microsoft Word, a następnie po prostu skopiować wartości formatowania do swojej aplikacji.

Jak korzystać z preferowanej szerokości

Pożądaną szerokość tabeli lub poszczególnych komórek definiuje się poprzez preferowaną właściwość szerokości, czyli rozmiar, do jakiego stara się dopasować element. Oznacza to, że preferowaną szerokość można określić dla całej tabeli lub dla poszczególnych komórek. W niektórych sytuacjach dokładne dopasowanie tej szerokości może nie być możliwe, ale w większości przypadków rzeczywista szerokość będzie zbliżona do tej wartości.

Odpowiedni preferowany typ szerokości i wartość ustawia się za pomocą metod klasy PreferredWidth:

• metoda Auto do określenia szerokości automatycznej lub “brak preferowanej”
• metoda FromPercent służąca do określenia procentowej szerokości
• metoda FromPoints określająca szerokość w punktach

Poniższe rysunki przedstawiają preferowane funkcje ustawiania szerokości w formacie Microsoft Word i odpowiadające im właściwości w formacie Aspose.Words.

Przykład zastosowania tych opcji do rzeczywistej tabeli w dokumencie widać na poniższym obrazku.

Zanim będzie można użyć preferowanej szerokości w tabeli, należy upewnić się, że tabela zawiera co najmniej jeden wiersz. Dzieje się tak dlatego, że takie formatowanie tabeli w dokumencie Microsoft Word lub w dokumencie utworzonym w formacie Aspose.Words jest przechowywane w wierszach tabeli.

Określ preferowaną szerokość tabeli lub komórki

W Aspose.Words szerokość tabeli i komórki jest ustawiana za pomocą właściwości Table.PreferredWidth i właściwości CellFormat.PreferredWidth, z opcjami dostępnymi w wyliczeniu PreferredWidthType:

• Auto, co jest równoznaczne z brakiem zestawu preferowanej szerokości
• Percent, który dopasowuje element względem dostępnej przestrzeni w oknie lub rozmiarze kontenera i przelicza wartość w przypadku zmiany dostępnej szerokości
• Points, który odpowiada elementowi o określonej szerokości w punktach

Domyślnie tabelę można opisać jako zajmującą 100% dostępnego miejsca na stronie. W tym przypadku oznacza to, że tabela będzie próbowała zająć miejsce pomiędzy lewym i prawym marginesem strony.

Użycie właściwości Table.PreferredWidth spowoduje dostosowanie preferowanej szerokości względem kontenera: strony, kolumny tekstowej lub zewnętrznej komórki tabeli, jeśli jest to tabela zagnieżdżona.

Poniższy przykład kodu pokazuje, jak ustawić tabelę tak, aby automatycznie dopasowywała się do 50% szerokości strony:

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

// Insert a table with a width that takes up half the page width.
Table table = builder.StartTable();

builder.InsertCell();
table.PreferredWidth = PreferredWidth.FromPercent(50);
builder.Writeln("Cell #1");

builder.InsertCell();
builder.Writeln("Cell #2");

builder.InsertCell();
builder.Writeln("Cell #3");

doc.Save(ArtifactsDir + "WorkingWithTables.AutoFitPageWidth.docx");

Użycie właściwości CellFormat.PreferredWidth w danej komórce spowoduje dostosowanie jej preferowanej szerokości.

Poniższy przykład kodu pokazuje, jak ustawić różne preferowane ustawienia szerokości:

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

// Insert a table row made up of three cells which have different preferred widths.
// Insert an absolute sized cell.
builder.InsertCell();
builder.CellFormat.PreferredWidth = PreferredWidth.FromPoints(40);
builder.CellFormat.Shading.BackgroundPatternColor = Color.LightYellow;
builder.Writeln("Cell at 40 points width");

// Insert a relative (percent) sized cell.
builder.InsertCell();
builder.CellFormat.PreferredWidth = PreferredWidth.FromPercent(20);
builder.CellFormat.Shading.BackgroundPatternColor = Color.LightBlue;
builder.Writeln("Cell at 20% width");

// Insert a auto sized cell.
builder.InsertCell();
builder.CellFormat.PreferredWidth = PreferredWidth.Auto;
builder.CellFormat.Shading.BackgroundPatternColor = Color.LightGreen;
builder.Writeln(
    "Cell automatically sized. The size of this cell is calculated from the table preferred width.");
builder.Writeln("In this case the cell will fill up the rest of the available space.");

doc.Save(ArtifactsDir + "WorkingWithTables.PreferredWidthSettings.docx");

Znajdź preferowany typ i wartość szerokości

Możesz użyć właściwości Type i Value, aby znaleźć preferowane szczegóły szerokości żądanej tabeli lub komórki.

Poniższy przykład kodu pokazuje, jak pobrać preferowany typ szerokości komórki tabeli:

// 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);
table.AllowAutoFit = true;

Cell firstCell = table.FirstRow.FirstCell;
PreferredWidthType type = firstCell.CellFormat.PreferredWidth.Type;
double value = firstCell.CellFormat.PreferredWidth.Value;

Możesz pobrać przykładowy plik tego przykładu z Aspose.Words GitHub.

Jak ustawić automatyczne dopasowanie

Właściwość AllowAutoFit umożliwia powiększanie i zmniejszanie komórek w tabeli zgodnie z wybranym kryterium. Na przykład możesz użyć opcji Automatyczne dopasowanie do okna, aby dopasować tabelę do szerokości strony, oraz opcji Automatyczne dopasowanie do treści, aby umożliwić powiększanie lub zmniejszanie każdej komórki w zależności od jej zawartości.

Ponadto właściwości AllowAutoFit można użyć w połączeniu z preferowaną szerokością komórki, aby sformatować komórkę, która automatycznie dopasowuje się do jej zawartości, ale ma również początkową szerokość. Jeśli to konieczne, szerokość komórki może następnie wzrosnąć powyżej tej szerokości.

Domyślnie Aspose.Words wstawia nową tabelę za pomocą Automatyczne dopasowanie do okna. Rozmiar tabeli zostanie dostosowany do dostępnej szerokości strony. Aby zmienić rozmiar tabeli, możesz wywołać metodę AutoFit. Ta metoda akceptuje wyliczenie AutoFitBehavior, które określa, jaki typ automatycznego dopasowania jest stosowany w tabeli.

Warto wiedzieć, że metoda automatycznego dopasowania jest w rzeczywistości skrótem, który jednocześnie stosuje do tabeli różne właściwości. Są to właściwości, które faktycznie nadają tabeli obserwowane zachowanie. Omówimy te właściwości dla każdej opcji automatycznego dopasowania.

Poniższy przykład kodu pokazuje, jak ustawić tabelę tak, aby zmniejszała lub powiększała każdą komórkę zgodnie z jej zawartością:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
table.AllowAutoFit = true;

Automatyczne dopasowanie tabeli do okna

Gdy do tabeli zostanie zastosowane automatyczne dopasowanie do okna, w tle faktycznie wykonywane są następujące operacje:

1. Właściwość Table.AllowAutoFit umożliwia automatyczną zmianę rozmiaru kolumn w celu dopasowania ich do dostępnej treści przy użyciu wartości Table.PreferredWidth wynoszącej 100%
2. CellFormat.PreferredWidth zostanie usunięty ze wszystkich komórek tabeli
   Należy zauważyć, że różni się to nieco od zachowania Microsoft Word, gdzie preferowana szerokość każdej komórki jest ustawiana na odpowiednie wartości w oparciu o jej bieżący rozmiar i zawartość. Aspose.Words nie aktualizuje preferowanej szerokości, więc zamiast tego jest ona po prostu czyszczona.
3. Szerokości kolumn są przeliczane pod kątem aktualnej zawartości tabeli – efektem końcowym jest tabela zajmująca całą dostępną szerokość
4. Szerokość kolumn tabeli zmienia się automatycznie w miarę edycji tekstu przez użytkownika

Poniższy przykład kodu pokazuje, jak automatycznie dopasować tabelę do szerokości strony:

// 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);
// Autofit the first table to the page width.
table.AutoFit(AutoFitBehavior.AutoFitToWindow);

doc.Save(ArtifactsDir + "WorkingWithTables.AutoFitTableToWindow.docx");

Możesz pobrać przykładowy plik tego przykładu z Aspose.Words GitHub.

Automatyczne dopasowanie tabeli do zawartości

Kiedy zawartość tabeli jest automatycznie dopasowywana, w tle wykonywane są następujące kroki:

1. Właściwość Table.AllowAutoFit jest włączona, aby automatycznie zmieniać rozmiar każdej komórki zgodnie z jej zawartością

2. Preferowana szerokość tabeli jest usuwana z Table.PreferredWidth, CellFormat.PreferredWidth jest usuwany dla każdej komórki tabeli

   Należy pamiętać, że ta opcja automatycznego dopasowania usuwa preferowaną szerokość z komórek, podobnie jak w Microsoft Word. Jeśli chcesz zachować rozmiary kolumn i zwiększyć lub zmniejszyć kolumny, aby dopasować je do treści, powinieneś ustawić właściwość Table.AllowAutoFit samodzielnie na True, zamiast używać skrótu automatycznego dopasowania.

3. Szerokość kolumn jest przeliczana dla aktualnej zawartości tabeli – efektem końcowym jest tabela, w której szerokość kolumn i szerokość całej tabeli są automatycznie dopasowywane do treści podczas edycji tekstu przez użytkownika

Poniższy przykład kodu pokazuje, jak automatycznie dopasować tabelę do jej zawartości:

// 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);
table.AutoFit(AutoFitBehavior.AutoFitToContents);

doc.Save(ArtifactsDir + "WorkingWithTables.AutoFitTableToContents.docx");

Możesz pobrać przykładowy plik tego przykładu z Aspose.Words GitHub.

Wyłącz automatyczne dopasowanie w tabeli i użyj stałych szerokości kolumn

Jeśli w tabeli wyłączono automatyczne dopasowanie i zamiast tego używane są stałe szerokości kolumn, wykonywane są następujące kroki:

1. Właściwość Table.AllowAutoFit jest wyłączona, więc kolumny nie powiększają się ani nie zmniejszają do swojej zawartości

2. Z Table.PreferredWidth usunięto preferowaną szerokość całej tabeli, ze wszystkich komórek tabeli usunięto CellFormat.PreferredWidth

3. Efektem końcowym jest tabela, której szerokość kolumn jest określona przez właściwość CellFormat.Width i której rozmiar kolumn nie jest automatycznie zmieniany, gdy użytkownik wprowadza tekst lub gdy zmienia się rozmiar strony

Należy pamiętać, że jeśli dla CellFormat.Width nie określono szerokości, używana jest domyślna wartość jednego cala (72 punkty).

Poniższy przykład kodu pokazuje, jak wyłączyć automatyczne dopasowanie i włączyć stałą szerokość dla określonej tabeli:

// 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);
// Disable autofitting on this table.
table.AutoFit(AutoFitBehavior.FixedColumnWidths);

doc.Save(ArtifactsDir + "WorkingWithTables.AutoFitTableToFixedColumnWidths.docx");

Możesz pobrać przykładowy plik tego przykładu z Aspose.Words GitHub.

Kolejność pierwszeństwa przy obliczaniu szerokości komórki

Aspose.Words pozwala użytkownikom definiować szerokość tabeli lub komórki za pomocą wielu obiektów, w tym CellFormat – jego właściwość Width jest w większości pozostałością z poprzednich wersji, jednak nadal jest przydatna do uproszczenia ustawiania szerokości komórki.

Ważne jest, aby wiedzieć, że właściwość CellFormat.Width działa inaczej w zależności od tego, które inne właściwości szerokości już istnieją w tabeli.

Aspose.Words stosuje następującą kolejność obliczania szerokości komórek:

Zamówienie	Nieruchomość	Opis
1	AllowAutoFit jest określony	Jeśli AutoFit jest włączony: - stół może urosnąć powyżej preferowanej szerokości, aby pomieścić zawartość - zwykle nie zmniejsza się poniżej preferowanej szerokości - jakakolwiek zmiana wartości CellFormat.Width zostanie zignorowana i zamiast tego komórka dopasuje się do jej zawartości
2	PreferredWidthType o wartości Points lub Percent	CellFormat.Width jest ignorowany
3	PreferredWidthType o wartości Auto	Wartość z CellFormat.Width jest kopiowana i staje się preferowaną szerokością komórki (w punktach)

Wszelkie zmiany właściwości szerokości nie są aktualizowane w preferowanej szerokości i zamiast tego muszą zostać zastosowane do preferowanej szerokości.

Tworząc stały układ tabeli, określ szerokość komórki. Komórki bez szerokości nie można zapisać w formacie DOC. Formaty dokumentów inne niż DOC, takie jak DOCX, pozwalają w zasadzie na zapisywanie komórek bez szerokości w ustalonym układzie tabeli.

Zezwalaj na odstępy między komórkami

Możesz uzyskać lub ustawić dowolny dodatkowy odstęp między komórkami tabeli, podobnie jak w przypadku opcji “Odstępy komórek” w Microsoft Word. Można to zrobić za pomocą właściwości AllowCellSpacing.

Przykład zastosowania tych opcji do rzeczywistej tabeli w dokumencie widać na poniższym obrazku.

Poniższy przykład kodu pokazuje, jak ustawić odstępy między komórkami:

// 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);
table.AllowCellSpacing = true;
table.CellSpacing = 2;
            
doc.Save(ArtifactsDir + "WorkingWithTableStylesAndFormatting.AllowCellSpacing.docx");

Zastosuj obramowania i cieniowanie

Obramowania i cieniowanie można zastosować do całej tabeli przy użyciu formatów Table.SetBorder, Table.SetBorders i Table.SetShading lub tylko do określonych komórek przy użyciu formatów CellFormat.Borders i CellFormat.Shading. Dodatkowo granice wierszy można ustawić za pomocą pliku RowFormat.Borders, jednak w ten sposób nie można zastosować cieniowania.

Poniższe zdjęcia pokazują ustawienia obramowania i cienia w formacie Microsoft Word oraz odpowiadające im właściwości w formacie Aspose.Words.

Poniższy przykład kodu pokazuje, jak sformatować tabelę i komórkę z różnymi obramowaniami i cieniami:

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

Table table = builder.StartTable();
builder.InsertCell();

// Set the borders for the entire table.
table.SetBorders(LineStyle.Single, 2.0, Color.Black);
            
// Set the cell shading for this cell.
builder.CellFormat.Shading.BackgroundPatternColor = Color.Red;
builder.Writeln("Cell #1");

builder.InsertCell();
            
// Specify a different cell shading for the second cell.
builder.CellFormat.Shading.BackgroundPatternColor = Color.Green;
builder.Writeln("Cell #2");

builder.EndRow();

// Clear the cell formatting from previous operations.
builder.CellFormat.ClearFormatting();

builder.InsertCell();

// Create larger borders for the first cell of this row. This will be different
// compared to the borders set for the table.
builder.CellFormat.Borders.Left.LineWidth = 4.0;
builder.CellFormat.Borders.Right.LineWidth = 4.0;
builder.CellFormat.Borders.Top.LineWidth = 4.0;
builder.CellFormat.Borders.Bottom.LineWidth = 4.0;
builder.Writeln("Cell #3");

builder.InsertCell();
builder.CellFormat.ClearFormatting();
builder.Writeln("Cell #4");
            
doc.Save(ArtifactsDir + "WorkingWithTableStylesAndFormatting.FormatTableAndCellWithDifferentBorders.docx");