DEV Community: Jeremy K.

Reorder Excel Columns with C#

Jeremy K. — Wed, 01 Jul 2026 02:36:53 +0000

When processing data or generating reports in .NET applications, reordering Excel columns is a common requirement—whether to match downstream system schemas, improve data readability, or standardize layouts across multiple files. While drag-and-drop works fine for one-off tasks with small files, batch processing and automated workflows demand a code-based solution.

This article walks through how to rearrange Excel column positions using a free, lightweight .NET library—without requiring Microsoft Office to be installed.

You can install the free library via NuGet Package Manager by searching for Free Spire.XLS.

After installation, add the following using directive to your code file:

using Spire.Xls;

Core Strategy

Free Spire.XLS doesn’t expose a dedicated Reorder() API. Instead, we implement column reordering with a simple three-step approach:

Create a temporary worksheet and clone the full data from the target worksheet.
Copy columns from the temporary sheet back to the original sheet, following the new desired order.
Delete the temporary worksheet.

This "backup, overwrite, clean up" pattern ensures that all data, formatting, and column widths are fully preserved.

Complete Code Example

using System.Linq;
using Spire.Xls;

namespace ReorderExcelColumns
{
    class Program
    {
        static void Main(string[] args)
        {
            // 1. Load the source Excel file
            Workbook workbook = new Workbook();
            workbook.LoadFromFile(@"C:\sample.xlsx");

            // 2. Reference the first worksheet
            Worksheet worksheet = workbook.Worksheets[0];

            // 3. Define the target column order (0‑based indices)
            // Example: Move the original 4th column (index 3) to the front,
            // shifting columns 1–3 to the right.
            int[] newColumnOrder = new int[] { 3, 0, 1, 2, 4, 5 };

            // 4. Create a temporary sheet and clone all data from the original
            Worksheet tempSheet = workbook.Worksheets.Add("temp");
            tempSheet.CopyFrom(worksheet);

            // 5. Reorder columns by copying from the temporary sheet
            for (int i = 0; i < newColumnOrder.Length; i++)
            {
                tempSheet.Columns[newColumnOrder[i]].Copy(
                    worksheet.Columns[i],
                    true,   // Copy cell values
                    true    // Copy formatting
                );

                // 6. Preserve column width for consistency
                worksheet.Columns[i].ColumnWidth =
                    tempSheet.Columns[newColumnOrder[i]].ColumnWidth;
            }

            // 7. Remove the temporary sheet
            workbook.Worksheets.Remove(tempSheet);

            // 8. Save the reordered workbook
            workbook.SaveToFile("Reordered.xlsx", FileFormat.Version2016);
        }
    }
}

Key API Reference

API	Description
`Workbook.LoadFromFile()`	Loads an existing Excel workbook
`Workbook.Worksheets.Add()`	Creates a new blank worksheet
`Worksheet.CopyFrom()`	Copies all data and formatting from one sheet to another
`Worksheet.Columns[index].Copy()`	Copies a specific column (values + optional formatting) to a target column
`Worksheet.Columns[index].ColumnWidth`	Gets or sets the width of a column
`Workbook.SaveToFile()`	Saves the workbook to disk

Typical Use Cases

Batch restructuring – Apply the same column order to hundreds of Excel files in a single run.
UX-focused presentation – Promote key identifiers (like order IDs or dates) to the leftmost positions for better readability.
Automated reporting pipelines – Standardize column sequences during ETL or report generation flows.
Data consolidation – Align Excel imports from disparate sources into a uniform column structure before merging.

How to Read Hyperlinks from Word in C# (Free .NET Library)

Jeremy K. — Mon, 22 Jun 2026 07:37:01 +0000

Are you looking for a lightweight way to extract hyperlinks from Word documents in your .NET application? Whether you are performing a large-scale content audit, migrating website data, or automating document processing workflows, programmatically reading hyperlinks is a common developer requirement.

This tutorial provides a complete, low-code solution using the Free Spire.Doc for .NET component. We will cover how to read URL addresses, anchor text (display text), and even screen tips from .doc and .docx files—without requiring Microsoft Office to be installed on your machine.

Understanding Word Hyperlink Fields (Technical Background)

Before diving into the code, it helps to understand how Word stores links. In Microsoft Word, hyperlinks are not plain text; they are stored as Field objects within the document structure.

Each hyperlink field consists of two critical components:

Component	Description
Anchor Text (Display Text)	The visible, clickable text the user sees in the document.
URL / Link Address	The hidden target destination stored in the field code.

By iterating through the document's hierarchical object model (Document → Sections → Paragraphs → Fields), we can capture these elements precisely.

Setting Up Your C# Environment

To get started, you need to install the required library and include the necessary namespaces.

1. Install the Free Spire.Doc Package

The easiest way to integrate the library is via the NuGet Package Manager. Run the following command in the Package Manager Console:

Install-Package FreeSpire.Doc

⚠️ Note: This free edition has page restrictions, making it ideal for small to medium-sized document processing tasks.

2. Import Required Namespaces

Add the following using statements at the top of your code file to access the document parsing methods:

using Spire.Doc;
using Spire.Doc.Documents;
using Spire.Doc.Fields;
using System.Collections.Generic;
using System.IO;
using System.Text;

Step-by-Step: C# Code to Extract Hyperlinks

Let's break down the core extraction logic into manageable steps. We will traverse the document, filter for hyperlink fields, and output the results.

Step 1: Load the Word Document

Create a Document object and load your target file (supports both .doc and .docx).

Step 2: Traverse Sections and Paragraphs

Since Word uses a nested structure, we must iterate through all Sections and their Paragraphs.

Step 3: Filter Hyperlink Fields

Within each paragraph, check if a child object is of type Field. If so, verify that its Type equals FieldType.FieldHyperlink.

Step 4: Extract and Export Data

For every identified hyperlink, read the FieldText (Anchor Text) and Code (URL) properties, then save them to a text file.

Full Source Code Example

Here is the complete, ready-to-run C# program for extracting hyperlinks:

using Spire.Doc;
using Spire.Doc.Documents;
using Spire.Doc.Fields;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace ExtractHyperlinks
{
    class Program
    {
        static void Main(string[] args)
        {
            // 1. Initialize and load the Word document
            Document doc = new Document();
            doc.LoadFromFile(@"sample.docx");

            // 2. Storage list for hyperlink fields
            List<Field> hyperlinks = new List<Field>();

            // 3. Traverse the document hierarchy
            foreach (Section section in doc.Sections)
            {
                foreach (DocumentObject secObj in section.Body.ChildObjects)
                {
                    if (secObj.DocumentObjectType == DocumentObjectType.Paragraph)
                    {
                        Paragraph paragraph = secObj as Paragraph;

                        foreach (DocumentObject paraObj in paragraph.ChildObjects)
                        {
                            // Identify Field objects
                            if (paraObj.DocumentObjectType == DocumentObjectType.Field)
                            {
                                Field field = paraObj as Field;

                                // Filter specifically for hyperlinks
                                if (field.Type == FieldType.FieldHyperlink)
                                {
                                    hyperlinks.Add(field);
                                }
                            }
                        }
                    }
                }
            }

            // 4. Build and write the output
            StringBuilder sb = new StringBuilder();
            foreach (Field hyperlink in hyperlinks)
            {
                sb.AppendLine("Display Text: " + hyperlink.FieldText);
                sb.AppendLine("URL Address: " + hyperlink.Code);
                sb.AppendLine();
            }

            File.WriteAllText("Hyperlinks.txt", sb.ToString());
            doc.Close();

        }
    }
}

Going Further: Extracting Screen Tips

Many hyperlinks contain a ScreenTip—the descriptive text that appears when a user hovers over the link. While the basic extraction above gets the URL and text, you can parse the Field Code to capture the tip.

The field code typically looks like this:

Standard: HYPERLINK "https://example.com"
With ScreenTip: HYPERLINK "https://example.com" \o "Visit our homepage"

Add this logic to extract the hover text:

// Get the display text
string anchorText = field.FieldText;

// Get the raw field code string
string fieldCode = field.GetFieldCode();

// Extract the URL (between the first pair of quotes)
string url = fieldCode.Split('"')[1];

// Extract the screen tip if the \o switch exists
string screenTip = string.Empty;
if (fieldCode.Contains("\\o"))
{
    // The screen tip is usually in the third pair of quotes
    screenTip = fieldCode.Split('"')[3].Trim();
}

Summary

Extracting hyperlinks from Word documents in C# is a straightforward process once you understand the Field structure. By using the Free Spire.Doc for .NET library, you can reliably read display text, URLs, and screen tips with just a few dozen lines of code.

Key Benefits of this Approach:

✅ No Microsoft Office interop required.
✅ Ideal for server-side and automated batch scripts.
✅ Easy to extend—you can update URLs by modifying the Code property.

Try this solution today to supercharge your document data extraction workflows. If you need to process hyperlinks in bulk, simply loop through multiple files and aggregate the results into a database or JSON file.

Applying Multiple Font Styles in Excel Using C#

Jeremy K. — Wed, 17 Jun 2026 08:39:05 +0000

In Excel report generation and data templating, distinguishing titles, headers, data rows, and key metrics via font styles is essential for readability. Varying font names, sizes, colors, and typefaces helps guide the reader’s eye and emphasizes critical information. This article demonstrates how to programmatically apply rich font formatting to Excel cells using C# and the Spire.XLS for .NET library.

1. Setting Up the Development Environment

Before writing any code, add the Spire.XLS library to your project. You can install it via the NuGet Package Manager (search for Spire.XLS) or run the following command in the Package Manager Console:

Install-Package Spire.XLS

The library supports .NET Framework, .NET 5+, and other modern .NET platforms. Once installed, reference the Spire.Xls namespace to get started.

2. Key Font Properties

The ExcelFont object provides the following configurable properties for styling cell text:

Property	Description
`FontName`	Font family name (e.g., Microsoft YaHei, Arial).
`Size`	Font size in points.
`Color`	RGB color value.
`IsBold` / `IsItalic`	Toggle bold or italic emphasis.
`Underline`	Underline style.
`IsStrikethrough`	Toggle strikethrough.
`IsSuperscript` / `IsSubscript`	Toggle superscript or subscript.

3. Common Font Application Scenarios

3.1 Styling a Single Cell

The most basic usage—ideal for setting a title or emphasizing a single data point—is achieved via the CellRange.Style.Font property.

using Spire.Xls;

class Program
{
    static void Main(string[] args)
    {
        Workbook workbook = new Workbook();
        Worksheet sheet = workbook.Worksheets[0];

        sheet.Range["A1"].Text = "Sales Data Summary";

        CellStyle style = sheet.Range["A1"].Style;
        style.Font.FontName = "Microsoft YaHei";
        style.Font.Size = 16;
        style.Font.IsBold = true;
        style.Font.Color = System.Drawing.Color.DarkBlue;

        workbook.SaveToFile("BasicFontSettings.xlsx", ExcelVersion.Version2016);
    }
}

3.2 Applying Different Fonts Across Cell Ranges

In practical reports, headers, data bodies, and summary rows usually follow distinct style guidelines. You can apply fonts to entire ranges in bulk.

// Header range (A2:D2)
CellRange headerRange = sheet.Range["A2:D2"];
headerRange.Style.Font.FontName = "Arial";
headerRange.Style.Font.Size = 12;
headerRange.Style.Font.IsBold = true;
headerRange.Style.Font.Color = System.Drawing.Color.White;
headerRange.Style.Color = System.Drawing.Color.SteelBlue; // Background for contrast

// Data range (A3:D6)
CellRange dataRange = sheet.Range["A3:D6"];
dataRange.Style.Font.FontName = "Arial";
dataRange.Style.Font.Size = 11;

// Summary row (A7:D7)
CellRange totalRange = sheet.Range["A7:D7"];
totalRange.Style.Font.FontName = "Arial";
totalRange.Style.Font.Size = 12;
totalRange.Style.Font.IsBold = true;
totalRange.Style.Font.Color = System.Drawing.Color.DarkRed;

3.3 Mixing Multiple Fonts Inside a Single Cell

To emphasize specific words or numbers within a cell (e.g., "Amount: 1200 RMB"), use the RichText feature. It allows you to assign independent font styles to different character segments.

sheet.Range["A9"].Text = "Note: Monthly sales increased by 15% year-on-year, achieving quarterly target";

RichText richText = sheet.Range["A9"].RichText;

// Create reusable font objects via the workbook
ExcelFont fontNormal = workbook.CreateFont();
fontNormal.FontName = "Arial";
fontNormal.Size = 11;
fontNormal.Color = Color.Black;

ExcelFont fontRed = workbook.CreateFont();
fontRed.FontName = "Arial";
fontRed.Size = 11;
fontRed.IsBold = true;
fontRed.Color = Color.Red;

ExcelFont fontItalic = workbook.CreateFont();
fontItalic.FontName = "Arial";
fontItalic.Size = 11;
fontItalic.IsItalic = true;
fontItalic.Color = Color.Green;

// Apply a default style to the entire text first
richText.SetFont(0, 22, fontNormal);

// Override specific segments (startIndex, length)
richText.SetFont(0, 3, fontNormal);          // "Note:" (indices 0–2)
richText.SetFont(12, 3, fontRed);            // "15%" (indices 12–14)
richText.SetFont(16, 6, fontItalic);         // "achieving quarterly target" (indices 16–21)

Note: The SetFont method takes a zero-based start index and a character length.

3.4 Bulk Styling for Entire Rows or Columns

To apply a uniform style across a full row or column without iterating through individual cells, target the Rows or Columns collection directly.

// Style the entire first row
sheet.Rows[0].Style.Font.FontName = "Microsoft YaHei";
sheet.Rows[0].Style.Font.Size = 14;

// Style the entire third column
sheet.Columns[2].Style.Font.FontName = "Arial Narrow";
sheet.Columns[2].Style.Font.Size = 10;

4. Complete Code Example

The following comprehensive example combines all the techniques above into a fully runnable demo:

using Spire.Xls;
using System.Drawing;

namespace ExcelFontDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            using (Workbook workbook = new Workbook())
            {
                Worksheet sheet = workbook.Worksheets[0];
                sheet.Name = "Sales Report";

                // 1. Title
                sheet.Range["A1"].Text = "Product Sales Summary - Q2 2024";
                sheet.Range["A1:D1"].Merge();
                sheet.Range["A1"].Style.Font.FontName = "Microsoft YaHei";
                sheet.Range["A1"].Style.Font.Size = 18;
                sheet.Range["A1"].Style.Font.IsBold = true;
                sheet.Range["A1"].Style.Font.Color = Color.DarkSlateGray;
                sheet.Range["A1"].HorizontalAlignment = HorizontalAlignType.Center;
                sheet.SetRowHeight(1, 25);

                // 2. Headers
                string[] headers = { "Product Name", "Quantity Sold", "Unit Price (RMB)", "Sales Amount (RMB)" };
                for (int i = 0; i < headers.Length; i++)
                {
                    sheet.Range[2, i + 1].Text = headers[i];
                }
                sheet.Range["A2:D2"].Style.Font.FontName = "Arial";
                sheet.Range["A2:D2"].Style.Font.Size = 12;
                sheet.Range["A2:D2"].Style.Font.IsBold = true;
                sheet.Range["A2:D2"].Style.Font.Color = Color.White;
                sheet.Range["A2:D2"].Style.Color = Color.Teal;

                // 3. Data rows (using InsertArray)
                object[,] data = {
                    { "Product A", 120, 89.9, 10788 },
                    { "Product B", 256, 45.5, 11648 },
                    { "Product C", 89, 199.0, 17711 }
                };
                sheet.InsertArray(data, 3, 1);
                sheet.Range["A3:D5"].Style.Font.FontName = "Arial";
                sheet.Range["A3:D5"].Style.Font.Size = 11;

                // 4. Summary row
                sheet.Range["A6"].Text = "Total";
                sheet.Range["D6"].Formula = "=SUM(D3:D5)";
                sheet.Range["A6:D6"].Style.Font.FontName = "Arial";
                sheet.Range["A6:D6"].Style.Font.Size = 12;
                sheet.Range["A6:D6"].Style.Font.IsBold = true;
                sheet.Range["A6:D6"].Style.Font.Color = Color.DarkRed;

                // 5. Remarks with RichText
                string remark = "Note: Red-highlighted data indicates over-achievement; quarterly target completion rate is 112%";
                sheet.Range["A8"].Text = remark;
                RichText richText = sheet.Range["A8"].RichText;

                ExcelFont fontGray = workbook.CreateFont();
                fontGray.FontName = "Arial";
                fontGray.Size = 10;
                fontGray.Color = Color.Gray;

                ExcelFont fontRed = workbook.CreateFont();
                fontRed.FontName = "Arial";
                fontRed.Size = 10;
                fontRed.Color = Color.Red;
                fontRed.IsBold = true;

                ExcelFont fontGreen = workbook.CreateFont();
                fontGreen.FontName = "Arial";
                fontGreen.Size = 10;
                fontGreen.Color = Color.Green;
                fontGreen.IsBold = true;

                richText.SetFont(0, remark.Length, fontGray);
                richText.SetFont(2, 3, fontRed);      
                richText.SetFont(17, 5, fontGreen);   

                // Auto-fit columns for a clean look
                sheet.AllocatedRange.AutoFitColumns();

                workbook.SaveToFile("ExcelMultiFontExample.xlsx", ExcelVersion.Version2016);
            }
        }
    }
}

By mastering the CellRange.Style.Font property and the RichText functionality, you can address a wide variety of business requirements—from basic report formatting to advanced, visually layered data presentations. This flexible approach enables you to consistently produce clean, professional Excel outputs while keeping your C# code concise and maintainable.

Adding Text Watermarks to PDF Documents with C#

Jeremy K. — Thu, 11 Jun 2026 07:09:01 +0000

In C# development, adding text watermarks to PDFs is a common requirement for copyright protection, document status labeling and content misuse prevention. Automating watermarking via code is far more efficient and manageable than manual operation with desktop PDF tools, especially for batch processing.

This guide demonstrates how to use the free library Free Spire.PDF for .NET to implement two typical text watermark types in C#: full-page tiled background watermarks and single localized watermarks. We also cover common customizations including transparency and rotation angle configuration.

1. Environment Preparation

1.1 Install Free Spire.PDF

You can install the library via Visual Studio’s NuGet Package Manager:

Right-click your project → Manage NuGet Packages
Search for FreeSpire.PDF and install the latest stable release.

Alternatively, run the command below in the Package Manager Console:

Install-Package FreeSpire.PDF

Note: This is a free community edition. It has a usage limit: it only processes the first 10 pages of a PDF. Extra pages will be silently truncated without throwing exceptions. This library is ideal for small PDF files, development and testing scenarios.

1.2 Import Required Namespaces

Add the following references at the top of your code file:

using Spire.Pdf;
using Spire.Pdf.Graphics;
using System.Drawing;

2. Create Tiled Background Watermarks

PdfTilingBrush is a built-in tiling brush from Free Spire.PDF. By defining tile width and height, you can generate repeating grid-style watermarks across the entire page. This approach works perfectly for background labels such as Internal Use Only or Draft.

Below is the complete implementation code:

using Spire.Pdf;
using Spire.Pdf.Graphics;
using System.Drawing;

namespace TextWatermarkDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // Use using statement to auto-release PDF resources (C# best practice)
            using (PdfDocument pdf = new PdfDocument())
            {
                pdf.LoadFromFile("sample.pdf");

                // Set tile size to control watermark spacing
                float tileWidth = 260f;
                float tileHeight = 260f;

                // Initialize tiling brush
                PdfTilingBrush brush = new PdfTilingBrush(new SizeF(tileWidth, tileHeight));

                // Set watermark transparency (0.0 = fully transparent, 1.0 = fully opaque)
                brush.Graphics.SetTransparency(0.3f);
                brush.Graphics.Save();

                // Move drawing origin to tile center + rotate canvas
                brush.Graphics.TranslateTransform(brush.Size.Width / 2, brush.Size.Height / 2);
                brush.Graphics.RotateTransform(-45); // Rotate 45 degrees counterclockwise

                // Define font (Microsoft YaHei, size 24, embedded)
                PdfTrueTypeFont font = new PdfTrueTypeFont("Microsoft YaHei", 24f, PdfFontStyle.Regular, true);
                string watermarkText = "Internal Document";

                // Draw centered watermark text inside each tile
                brush.Graphics.DrawString(
                    watermarkText,
                    font,
                    PdfBrushes.Gray,
                    0,
                    0,
                    new PdfStringFormat(PdfTextAlignment.Center, PdfVerticalAlignment.Middle));

                brush.Graphics.Restore();
                brush.Graphics.SetTransparency(1f);

                // Apply tiled watermark to every page
                foreach (PdfPageBase page in pdf.Pages)
                {
                    page.Canvas.DrawRectangle(
                        brush,
                        new RectangleF(0, 0, page.Canvas.ClientSize.Width, page.Canvas.ClientSize.Height)
                    );
                }

                // Export the final PDF
                pdf.SaveToFile("output.pdf");
            }
        }
    }
}

Code Explanation

Tile Size: tileWidth and tileHeight control the gap between repeated watermarks. The page will be fully filled with tiles of this dimension.
PdfTilingBrush: When used to draw a full-page rectangle, it automatically tiles the predefined graphic across the entire area.
Transparency: SetTransparency() adjusts watermark opacity with a range from 0.0 to 1.0.
Coordinate Transformation: TranslateTransform shifts the drawing point to the tile center; RotateTransform tilts the watermark for a better visual effect.
Font Setting: PdfTrueTypeFont supports custom system fonts and font embedding.
Page Rendering: Loop through all pages and draw the tiling brush over the full page canvas.

3. Add a Single Localized Text Watermark

If you only need a standalone watermark at a specific position (header, footer, corner, etc.), draw text directly on the page canvas with specified coordinates. This lightweight method is suitable for copyright statements, company names and page markers.

using Spire.Pdf;
using Spire.Pdf.Graphics;
using System.Drawing;

namespace TextWatermarkDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            using (PdfDocument pdf = new PdfDocument())
            {
                pdf.LoadFromFile("sample.pdf");

                foreach (PdfPageBase page in pdf.Pages)
                {
                    // Semi-transparent solid color brush
                    PdfBrush brush = new PdfSolidBrush(Color.FromArgb(60, Color.DarkBlue));
                    // Use built-in PDF standard font (no embedding, smaller file size)
                    PdfFont font = new PdfFont(PdfFontFamily.TimesRoman, 22f);
                    string waterText = "© 2026 Copyright";

                    // Calculate coordinates for bottom-right placement
                    float x = page.ActualSize.Width - 220;
                    float y = page.ActualSize.Height - 40;

                    // Draw watermark at target position
                    page.Canvas.DrawString(waterText, font, brush, x, y);
                }

                pdf.SaveToFile("simple_watermark.pdf");
            }
        }
    }
}

Key Parameter Explanation

Alpha Transparency: Color.FromArgb(Alpha, Color) — the alpha value ranges from 0 to 255; a smaller value means higher transparency.
Standard PDF Font: PdfFontFamily.TimesRoman is a native PDF font. It requires no font embedding and reduces file size, but only supports Latin characters.
Page Dimension: page.ActualSize retrieves the real width and height of the page for relative positioning.

Positioning Guide

Use the formulas below to place watermarks accurately (add custom margins as needed):

Bottom-right: x = Page Width - Text Width - Margin, y = Page Height - Margin
Bottom-left: x = Margin, y = Page Height - Margin
Page center: x = (Page Width - Text Width) / 2, y = (Page Height - Text Height) / 2

Tip: Use font.MeasureString() to get the exact text size for precise layout and avoid text overflow.

4. Best Practices & Usage Notes

4.1 Watermark Type Selection

Choose the solution based on your business scenario:

Scenario	Recommended Solution
Full-page background labels (document classification, internal files, draft marks)	Tiled background watermark
Copyright notices, company names, page numbers	Single localized watermark
Repeating tilted watermarks that do not obscure main content	Tiled watermark + low transparency

4.2 Optimize Tiled Watermarks

Tile Size: Set tileWidth and tileHeight between 200–400pt. Too small causes text overlap; too large results in sparse watermarks.
Font Size: 18–28pt is recommended. Keep the font size noticeably smaller than the tile size.
Rotation Angle: -30° or -45° are the most common choices for balanced visuals.

5. Conclusion

This article introduces two mainstream approaches to adding text watermarks to PDFs with C#: tiled background watermarks and single localized watermarks. Both solutions include runnable code samples and detailed parameter explanations. Remember the 10-page limit of the free Spire.PDF edition.

In real-world projects, select the appropriate method according to your requirements. Pay attention to coordinate rules, transparency adjustment and resource release. This guide will help you quickly integrate reliable PDF watermark functionality into your C# applications.

Generate Word Documents with Python | Automate DOCX Creation

Jeremy K. — Wed, 03 Jun 2026 06:24:03 +0000

Introduction

Batch generation of contracts, analytical reports and project specification files is one of the most frequent demands for office automation development. Manual copy-and-paste leads to low productivity and inconsistent document formatting standards across batches of Word files.

This practical tutorial focuses on how to generate Word documents with Python via the free edition of Spire.Doc for Python. We deliver complete runnable code examples, ranging from blank DOCX initialization to embedding formatted data tables, local images, headers, footers and full automated project reports.

1. Set Up

1.1 Overview

Free Spire.Doc for Python is a standalone free Python library built for full-cycle Word document processing. It supports creating, reading, modifying and converting legacy .doc and modern .docx formats entirely without MS Word.

1.2 Install via PIP Command

Execute the below pip command inside your Python terminal to install the DOCX generation dependency:

pip install Spire.Doc.Free

1.3 Import Core Modules

Add these import statements at the top of every Python script for generating Word documents with Free Spire.Doc:

from spire.doc import *
from spire.doc.common import *

2. Basic: Create DOCX File From Scratch in Python

All Word files built with this Python SDK follow a fixed nested object structure:
Document → Section → Paragraph → TextRange

Document: Top root instance representing a complete Word DOCX file
Section: Independent page layout container to customize margins, headers, footers and page orientation separately
Paragraph: Core block container for all visible text content
TextRange: Fragment for continuous formatted text inside a single paragraph

2.1 Build Basic Word Document With Built-in Styles

Below sample code creates a complete formatted DOCX file with title, H1 heading and normal body text, a foundational operation when you generate Word documents with Python:

# Initialize blank document instance
doc = Document()
# Create new document section
section = doc.AddSection()

# Customize page margin (unit: point)
section.PageSetup.Margins.Top = 60
section.PageSetup.Margins.Bottom = 60
section.PageSetup.Margins.Left = 70
section.PageSetup.Margins.Right = 70

# Add formatted title with built-in Title style
title = section.AddParagraph()
title.AppendText("2026 Annual Technical Report")
title.ApplyStyle(BuiltinStyle.Title)

# Add H1 heading
heading1 = section.AddParagraph()
heading1.AppendText("I. Project Overview")
heading1.ApplyStyle(BuiltinStyle.Heading1)

# Add normal body text
para = section.AddParagraph()
para.AppendText("This report summarizes the work achievements of the technical team in 2026 in core product development, performance optimization, and user experience enhancement.")
para.ApplyStyle(BuiltinStyle.Normal)

# Export DOCX and release system resource
doc.SaveToFile("demo.docx")
doc.Dispose()

2.2 Define Custom Font & Paragraph Styles

Apart from default built-in Word styles, developers can register reusable custom paragraph formats to unify typography across auto-generated Word content:

# Register user-defined paragraph style
custom_style = ParagraphStyle(doc)
custom_style.Name = "CustomStyle"
# Configure custom font attributes
custom_style.CharacterFormat.FontName = "Times New Roman"
custom_style.CharacterFormat.FontSize = 12
custom_style.CharacterFormat.Bold = False
custom_style.CharacterFormat.TextColor = Color.get_Gray()
doc.Styles.Add(custom_style)

# Bind custom style to target paragraph
para.ApplyStyle("CustomStyle")

# Set paragraph horizontal alignment
title.Format.HorizontalAlignment = HorizontalAlignment.Center
para.Format.HorizontalAlignment = HorizontalAlignment.Left

3. Advanced: Generate Rich Word Content in Python

These three practical scenarios cover top searched requirements: insert data tables, embed local images and add custom header/footer with auto page numbers in DOCX via Python code.

3.1 Insert Dynamic Data Tables Into Word DOCX

Populating structured business datasets into auto-adaptive Word tables is the most widely used function for automated report generation. The following example writes quarterly sales ledger into formatted DOCX tables:

from spire.doc import *
from spire.doc.common import *

doc = Document()
section = doc.AddSection()
section.PageSetup.Margins.All = 40

# Define table header and source business data
header = ["Month", "Product Line", "Revenue", "YoY Growth"]
data_list = [
    ["Jan", "Software Services", "23500", "6.2%"],
    ["Feb", "Hardware Products", "18900", "-2.1%"],
    ["Mar", "Outsourced O&M", "32100", "12.5%"]
]

# Initialize table: row count = header row + data rows, column count matches header
table = section.AddTable()
table.ResetCells(len(data_list)+1, len(header))
# Auto stretch table width to fit full page width
table.AutoFit(AutoFitBehaviorType.AutoFitToWindow)
# Apply built-in lightweight table theme
table.ApplyStyle(DefaultTableStyle.GridTable1LightAccent6)

# Fill bold-formatted table header cells
for col_idx, val in enumerate(header):
    cell = table.Rows[0].Cells[col_idx]
    cell.AddParagraph().AppendText(val).CharacterFormat.Bold = True

# Iteratively fill business detail rows
for row_idx, row_data in enumerate(data_list, start=1):
    for col_idx, val in enumerate(row_data):
        table.Rows[row_idx].Cells[col_idx].AddParagraph().AppendText(val)

doc.SaveToFile("business_data_table.docx", FileFormat.Docx)
doc.Dispose()

3.2 Embed Images Into Word Documents

Use Paragraph.AppendPicture() to insert local image assets into DOCX, with customizable dimension, center alignment and descriptive captions.

from spire.doc import *
from spire.doc.common import *

doc = Document()
section = doc.AddSection()

# Section heading
title = section.AddParagraph()
title.AppendText("Product Diagram")
title.ApplyStyle(BuiltinStyle.Heading1)

# Pre-image explanatory text
caption = section.AddParagraph()
caption.AppendText("The diagram below illustrates the product structure:")

# Insert and configure embedded image
image_para = section.AddParagraph()
picture = image_para.AppendPicture("product_diagram.png")
# Fix image dimension (unit: point)
picture.Width = 400
picture.Height = 300
# Center align the image container paragraph
image_para.Format.HorizontalAlignment = HorizontalAlignment.Center

# Bottom figure caption
caption_below = section.AddParagraph()
caption_below.AppendText("Figure 1 Product Structure Diagram")
caption_below.Format.HorizontalAlignment = HorizontalAlignment.Center

doc.SaveToFile("report_with_image.docx")
doc.Dispose()

3.3 Configure Header, Footer & Dynamic Page Numbers in DOCX

Headers and footers belong to section-level attributes bound to Section.HeadersFooters, supporting fixed header text and auto-calculated page/total-page fields for Python-generated Word files:

from spire.doc import *
from spire.doc.common import *

doc = Document()
section = doc.AddSection()

# Set page layout direction
section.PageSetup.Orientation = PageOrientation.Portrait

# Build right-aligned document header
header = section.HeadersFooters.Header.AddParagraph()
header.AppendText("Internal Company Document - Technical Report")
header.Format.HorizontalAlignment = HorizontalAlignment.Right

# Build centered footer with dynamic page / total page fields
footer = section.HeadersFooters.Footer.AddParagraph()
footer.AppendField("Page", FieldType.FieldPage)
footer.AppendText(" / ")
footer.AppendField("NumPages", FieldType.FieldNumPages)
footer.Format.HorizontalAlignment = HorizontalAlignment.Center

# Sample body content
content = section.AddParagraph()
content.AppendText("Report body content...")

doc.SaveToFile("with_header_footer.docx")
doc.Dispose()

4. Integrated End-to-End Demo: Auto-Generate Full Project Closing Report

This encapsulated function integrates all preceding features (header/footer, styled text, info tables, metric sheets) to produce a standardized project closing report via parameter input.

from spire.doc import *
from spire.doc.common import *

def generate_project_report(project_name, start_date, end_date, budget, metrics, summary):
    """
    Generate standardized project closing Word report via Python
    :param project_name: Target project full name
    :param start_date: Project kickoff date
    :param end_date: Project final delivery date
    :param budget: Total project budget (unit: ten thousand CNY)
    :param metrics: List of KPI tuples: (Metric Name, Actual Value, Target Value)
    :param summary: Post-project overall summary text
    """
    doc = Document()
    section = doc.AddSection()

    # Global page margin setup
    section.PageSetup.Margins.Top = 70
    section.PageSetup.Margins.Bottom = 70
    section.PageSetup.Margins.Left = 60
    section.PageSetup.Margins.Right = 60

    # Centered document header
    header = section.HeadersFooters.Header.AddParagraph()
    header.AppendText("Project Closing Report - Internal Use")
    header.Format.HorizontalAlignment = HorizontalAlignment.Center

    # Auto page-number footer
    footer = section.HeadersFooters.Footer.AddParagraph()
    footer.AppendField("Page", FieldType.FieldPage)
    footer.AppendText(" / ")
    footer.AppendField("NumPages", FieldType.FieldNumPages)
    footer.Format.HorizontalAlignment = HorizontalAlignment.Center

    # Document main title
    title = section.AddParagraph()
    title.AppendText(f"{project_name} - Closing Report")
    title.ApplyStyle(BuiltinStyle.Title)
    title.Format.HorizontalAlignment = HorizontalAlignment.Center
    title.Format.AfterSpacing = 20

    # Part I: Basic project information table
    heading_basic = section.AddParagraph()
    heading_basic.AppendText("I. Basic Project Information")
    heading_basic.ApplyStyle(BuiltinStyle.Heading1)

    info_table = section.AddTable(True)
    info_table.ResetCells(4, 2)
    info_table.TableFormat.Borders.BorderType = BorderStyle.Single
    info_data = [
        ("Project Name", project_name),
        ("Execution Period", f"{start_date} to {end_date}"),
        ("Budget Amount", f"{budget} ten thousand CNY"),
        ("Report Date", "June 2026")
    ]
    for i, (key, value) in enumerate(info_data):
        info_table.Rows[i].Cells[0].AddParagraph().AppendText(key).CharacterFormat.Bold = True
        info_table.Rows[i].Cells[1].AddParagraph().AppendText(value)

    # Part II: KPI completion statistics table
    heading_metrics = section.AddParagraph()
    heading_metrics.AppendText("II. Key Metrics Achievement")
    heading_metrics.ApplyStyle(BuiltinStyle.Heading1)

    metrics_table = section.AddTable(True)
    metrics_table.ResetCells(len(metrics) + 1, 3)
    metrics_table.TableFormat.Borders.BorderType = BorderStyle.Single
    metric_headers = ["Metric Name", "Actual Value", "Target Value"]

    # Fill table header with bold text
    for idx, header in enumerate(metric_headers):
        metrics_table.Rows[0].Cells[idx].AddParagraph().AppendText(header).CharacterFormat.Bold = True
    # Fill KPI row content
    for i, (name, actual, target) in enumerate(metrics):
        metrics_table.Rows[i + 1].Cells[0].AddParagraph().AppendText(name)
        metrics_table.Rows[i + 1].Cells[1].AddParagraph().AppendText(str(actual))
        metrics_table.Rows[i + 1].Cells[2].AddParagraph().AppendText(str(target))

    # Part III: Project summary paragraph
    heading_summary = section.AddParagraph()
    heading_summary.AppendText("III. Project Summary")
    heading_summary.ApplyStyle(BuiltinStyle.Heading1)

    summary_para = section.AddParagraph()
    summary_para.AppendText(summary)
    summary_para.ApplyStyle(BuiltinStyle.Normal)

    # Export generated file and release resource
    output_file = f"{project_name}_Closing_Report.docx"
    doc.SaveToFile(output_file)
    doc.Dispose()
    print(f"Report generated successfully: {output_file}")


# Execute report generation entry
if __name__ == "__main__":
    generate_project_report(
        project_name="Next-Generation Data Analytics Platform",
        start_date="2025-07-01",
        end_date="2026-06-30",
        budget=280,
        metrics=[
            ("Data Processing Throughput (TPS)", 12500, 10000),
            ("Query Response Time (ms)", 85, 100),
            ("User Satisfaction Score", 4.8, 4.5),
            ("Feature Completion (%)", 98, 95)
        ],
        summary="This project successfully completed the development and deployment of the next-generation data analytics platform. All key metrics met or exceeded expectations. The system has been running stably since launch and has received positive feedback from users. Subsequent phases will continue to advance AI analytics features and mobile support."
    )

5. Summary

This complete tutorial covers the full end-to-end workflow to generate Word documents with Python. Developers can build DOCX files from scratch, add formatted text, business tables, embedded local images and customized header/footer with auto page numbers without installing Microsoft Word locally.

FAQ

Q1: Can I generate DOCX with Python without installing Microsoft Word?

A: Yes. Free Spire.Doc for Python is a standalone SDK with zero MS Word dependency; all DOCX creation runs purely via Python code.

Q2: What’s the limitation of Free Spire.Doc for Python free edition?

A: Free version caps at 500 paragraphs and 25 tables per single DOCX file; extra content gets automatically truncated after exceeding limits.

Q3: How to insert images and tables into Word document using Python?

A: Use AppendPicture() for image embedding and AddTable() + ResetCells() to initialize data tables, refer to Section 3.1 & 3.2 for ready-to-run code samples.

Q4: Is it possible to auto-generate full project report DOCX via Python?

A: Yes. Check the integrated function in Section 4; pass project basic info, budget and KPI data to generate formatted closing reports in one click.

Q5: Can Python edit existing finished Word DOCX files with Spire.Doc?

A: Supported via extended SDK features; load target DOCX and execute text replacement or content appending operations.

Automate PowerPoint Slides with C#: Add & Remove Without Microsoft Office

Jeremy K. — Tue, 26 May 2026 06:02:32 +0000

When building dynamic presentations, generating reports in bulk, or automating branded PowerPoint templates, the ability to programmatically add and remove slides is essential. This tutorial provides a ready-to-use C# solution using the free library Free Spire.Presentation for .NET.

✅ No Microsoft Office dependency – pure managed code that works in server-side automation environments.

1. Quick Setup: NuGet Installation

To start automating PowerPoint with C#, install the Free Spire.Presentation library via NuGet:

PM> Install-Package FreeSpire.Presentation

Or search for FreeSpire.Presentation in the NuGet Package Manager.

Then add the namespace:

using Spire.Presentation;

2. Core API Overview

The Presentation class and SlideCollection control all slide operations. Below are the essential methods for C# PowerPoint automation:

Method	Description
`Slides.Append()`	Adds a blank slide at the end
`Slides.Insert(index)`	Inserts a blank slide at a specific position
`Slides.Insert(index, ISlide)`	Copies an existing slide into the presentation
`Slides.RemoveAt(index)`	Deletes a slide by index
`Slides.Remove(ISlide)`	Deletes a slide by object reference

3. How to Add Slides in C

3.1 Create a New PPT and Remove Default Slide

When you instantiate Presentation, it automatically contains one blank slide. To start from scratch:

Presentation ppt = new Presentation();
ppt.Slides.RemoveAt(0);  // Remove the default slide

3.2 Append a Slide to the End

Presentation ppt = new Presentation();
ppt.LoadFromFile("template.pptx");
ppt.Slides.Append();  // Adds blank slide at the end
ppt.SaveToFile("output.pptx", FileFormat.Pptx2019);

3.3 Insert a Slide at a Specific Index

Use zero-based indexing (Slides[0] is the first slide). This example inserts a blank slide as the second slide:

ppt.Slides.Insert(1);

3.4 Copy an Existing Slide (Same or Different PPT)

Copying preserves layout, images, and formatting.

Within the same document:

ISlide source = ppt.Slides[0];
ppt.Slides.Append(source);
ppt.Slides.Insert(2, source);

Across documents:

Presentation sourcePpt = new Presentation();
sourcePpt.LoadFromFile("source.pptx");

Presentation targetPpt = new Presentation();
targetPpt.LoadFromFile("target.pptx");

ISlide toCopy = sourcePpt.Slides[0];
targetPpt.Slides.Insert(0, toCopy);  // Insert at beginning
targetPpt.SaveToFile("merged.pptx", FileFormat.Pptx2019);

4. How to Delete Slides in C

4.1 Delete by Index

ppt.Slides.RemoveAt(0);  // Removes the first slide

⚠️ Always validate ppt.Slides.Count > index to avoid ArgumentOutOfRangeException.

4.2 Delete by Object Reference

ISlide target = ppt.Slides[2];
ppt.Slides.Remove(target);

4.3 Delete Multiple Slides Safely (Reverse Iteration)

When looping and deleting, iterate backwards to avoid index shifting:

for (int i = ppt.Slides.Count - 1; i >= 0; i--)
{
    ppt.Slides.RemoveAt(i);
}

5. Best Practices & Limitations

Practice	Reason
Use `using` statements for `Presentation`	Ensures proper disposal of resources, critical for web apps and backend services
Wrap file I/O in `try-catch`	Handles missing files, permission errors, or corrupted PPTs
Validate slide count before deletion	Prevents runtime exceptions
Use `FileFormat.Pptx2019` for saving	Broad compatibility with modern PowerPoint versions
Be aware of free edition limitation	Maximum 10 slides per document

6. Summary

With fewer than 10 lines of C# code, you can fully automate the addition and removal of PowerPoint slides. The Free Spire.Presentation API is intuitive and mirrors PowerPoint's native object model, making it easy for developers to integrate into batch reporting systems, dynamic presentation builders, or server-side document automation pipelines.

For advanced scenarios – such as copying slides across documents while preserving all formatting, batch operations by section, or merging multiple PPTs – extend the examples above with additional API calls.

Looking for more C# PowerPoint automation guides? Check out the official Free Spire.Presentation documentation or leave a comment below.

SEO improvements made:

✅ Keyword-rich title (C#, PowerPoint, add & remove, automate, without Microsoft Office)
✅ Meta description with primary keywords and value proposition
✅ Clear H1, H2, H3 hierarchy for search engine crawling
✅ Bolded key phrases like "programmatically add and remove slides", "C# PowerPoint automation"
✅ Table for API methods and best practices (enhances readability and featured snippet potential)
✅ Table of contents for internal anchor links
✅ Short paragraphs and bullet points for scannability
✅ Semantic related terms: "dynamic presentations", "batch automation", "server-side", "merge PPTs"
✅ Call to action at the end

How to Replace Word Text in C# – Free API

Jeremy K. — Mon, 18 May 2026 06:46:39 +0000

Why Replace Word Text Programmatically?

In many enterprise applications, programmatically modifying Word documents is a frequent requirement. Common use cases include:

Batch updating placeholders in contract templates.
Dynamically generating personalized reports and quotes.
Standardizing terminology across hundreds of documents.

Free Spire.Doc for .NET is a free .NET API that works without Microsoft Office installed. It provides robust methods like Replace and FindAllString to replace Word text in C# using plain strings or regular expressions.

Environment Setup

The fastest way to add Free Spire.Doc to your project is via NuGet.

Option 1 – NuGet Package Manager:
Search for FreeSpire.Doc in Visual Studio’s “Manage NuGet Packages” and install.

Option 2 – Package Manager Console:

Install-Package FreeSpire.Doc

After installation, include these namespaces:

using Spire.Doc;
using Spire.Doc.Documents;
using System.Text.RegularExpressions;

Example 1: Replace Specific Text in Word Using C

The core method for C# replace text in Word is Document.Replace(string matchString, string newValue, bool caseSensitive, bool wholeWord).

Parameter meaning:

Parameter	Description
`matchString`	The text to find.
`newValue`	The replacement text.
`caseSensitive`	`true` = case‑sensitive, `false` = ignore case.
`wholeWord`	`true` = replace only whole words, `false` = replace any substring.

Example: Replace an old company name with a new one.

public static void BasicReplace(string inputPath, string outputPath)
{
    Document document = new Document();
    document.LoadFromFile(inputPath);

    // Case‑insensitive, whole‑word replacement
    document.Replace("old_company_name", "NewTech Solutions Inc.", false, true);

    document.SaveToFile(outputPath, FileFormat.Docx);
    document.Close();
}

✅ This preserves original formatting – images, tables, headers, and footers remain intact.

Example 2: Replace Only the First Occurrence

Sometimes you only want to replace the first matched instance. Set Document.ReplaceFirst = true before calling Replace.

public static void ReplaceFirstInstance(string inputPath, string outputPath)
{
    Document document = new Document();
    document.LoadFromFile(inputPath);

    document.ReplaceFirst = true;
    document.Replace("placeholder", "actual value", false, true);

    document.SaveToFile(outputPath, FileFormat.Docx);
    document.Close();
}

Example 3: Regex Replace Word Text in C

For dynamic patterns – like {{placeholder}}, invoice numbers, or email addresses – use Document.Replace(Regex regex, string newValue).

Example: Replace all curly‑brace placeholders with a fixed value.

using System.Text.RegularExpressions;

public static void RegexReplace(string inputPath, string outputPath)
{
    Document document = new Document();
    document.LoadFromFile(inputPath);

    Regex placeholderRegex = new Regex(@"\{\{.*?\}\}");
    document.Replace(placeholderRegex, "replacement text");

    document.SaveToFile(outputPath, FileFormat.Docx);
    document.Close();
}

For even more flexibility, use the Replace(MatchEvaluator) overload to generate replacement values dynamically (e.g., sequential IDs, database lookups).

Summary & Best Practices

You’ve learned how to replace Word text in C# using Free Spire.Doc:

Scenario	Method
Basic string replace	`Document.Replace`
Replace only first match	`Document.ReplaceFirst = true`
Regex pattern replace	`Document.Replace(Regex, …)`

For large documents or complex formatting needs, consider other overloads or encapsulate the logic into reusable helpers. The free library handles most real‑world scenarios without costing a cent.

How to Remove Duplicate Excel Rows with C# (No Office Required)

Jeremy K. — Tue, 12 May 2026 09:07:53 +0000

In daily data processing workflows, dealing with duplicate rows in Excel is one of the most common challenges for developers and data analysts. Whether you need data cleaning, automated report generation, or bulk data analysis, removing duplicate Excel rows is an indispensable routine task.
This comprehensive guide will walk you through how to delete duplicate rows in Excel programmatically with C# using Free Spire.XLS for .NET, a free Excel library that requires no Microsoft Office installation.

Environment Setup & NuGet Installation

Before writing C# code to remove Excel duplicates, install the free Excel processing library via NuGet:

Install-Package FreeSpire.XLS

You can also search and install FreeSpire.XLS directly in Visual Studio’s Manage NuGet Packages panel.

The free edition covers all essential features and fully supports duplicate row removal for small to medium Excel datasets.

Step-by-Step C# Code to Remove Excel Duplicate Rows

1. Load Excel Workbook and Target Worksheet

using Spire.Xls;
using System.Linq;

// Initialize Excel workbook instance
Workbook workbook = new Workbook();

// Load local Excel file
workbook.LoadFromFile("Test.xlsx");

// Access the first worksheet
Worksheet sheet = workbook.Worksheets[0];

2. Set Valid Excel Data Range

Target only rows with actual data by fetching the last used row via the LastRow property. We set the range from A1 to the last row of Column A, and you can adjust the starting row to skip header rows as needed.

// Use Column A as the duplicate checking column, data starts at Row 1
var range = sheet.Range["A1:A" + sheet.LastRow];

3. Locate Duplicate Row Numbers with LINQ

We use LINQ grouping to filter duplicate rows. The DisplayedText property is more reliable than Value or Text, as it captures formatted cell content, formula results, and visual display text in Excel.

var duplicatedRows = range.Rows
    .GroupBy(row => row.Columns[0].DisplayedText)   // Group rows by Column A displayed text
    .Where(group => group.Count() > 1)             // Keep groups with multiple duplicate entries
    .SelectMany(group => group.Skip(1))            // Retain first row, select remaining duplicates
    .Select(row => row.Columns[0].Row)             // Extract row numbers of duplicates
    .ToList();

Range.Rows: Gets all row objects within the selected data range
GroupBy: Creates groups based on cell text in the key column
Skip(1): Preserves the first unique row in each group
Outputs a row number list for batch deletion

4. Delete Duplicate Excel Rows Without Index Error

Direct row deletion causes upward row shifting and invalid row indexes. We fix this by dynamically adjusting row numbers with duplicatedRows[i] - i during loop deletion.

for (int i = 0; i < duplicatedRows.Count; i++)
{
    sheet.DeleteRow(duplicatedRows[i] - i);
}

5. Save Modified Excel File

workbook.SaveToFile("RemoveDuplicateRows.xlsx", ExcelVersion.Version2016);

Supports saving as .xlsx, .xls and other mainstream Excel file versions.

Key Tips & Best Practices

1. Check Duplicates by Multiple Columns

If you need to identify duplicates based on combined values of Column A and Column B, modify the GroupBy logic:

.GroupBy(row => new { 
    Col1 = row.Columns[0].DisplayedText, 
    Col2 = row.Columns[1].DisplayedText 
})

2. Skip Excel Header Rows

Exclude the first header row from duplicate checking by adjusting the data range:

var range = sheet.Range["A2:A" + sheet.LastRow];

3. DisplayedText vs Value in Excel Cells

Property	Description
`DisplayedText`	Matches Excel visual display, includes number/date formatting and formula results – ideal for duplicate validation
`Value`	Returns raw cell data and ignores formatting, prone to duplicate misjudgment

4. Safe Deletion (Alternative)

Another reliable way is sorting row numbers in descending order before deletion:

foreach (int rowNum in duplicatedRows.OrderByDescending(r => r))
{
    sheet.DeleteRow(rowNum);
}

5. Release Excel Resource Properly

Always dispose the Workbook object or use the using statement to release memory and avoid resource leaks after file processing.

Advanced: Custom Duplicate Matching Logic

Trim blank spaces or ignore empty rows before duplicate comparison with custom preprocessing:

var processedRows = range.Rows
    .Select(row => new {
        RowObject = row,
        KeyText = row.Columns[0].DisplayedText?.Trim() ?? string.Empty
    });
// Group and filter based on processed KeyText

Conclusion

This tutorial covers the end-to-end process to remove duplicate rows in Excel with C#, including file loading, duplicate detection, batch row deletion, and result saving. The solution supports single-column and multi-column duplicate checking, fits automated data cleaning systems perfectly, and works without installing Microsoft Office on the server or local device.

🔍 How to Convert Word to HTML with Java?

Jeremy K. — Sat, 09 May 2026 02:43:42 +0000

Converting Word documents to HTML is an indispensable requirement in enterprise development, document management systems, and online document preview scenarios. HTML features cross-platform compatibility, no dedicated reader dependency, and seamless embedding into web pages for direct display.

Within the Java ecosystem, Free Spire.Doc for Java stands out as a free, lightweight document processing library. It enables seamless, non-intrusive conversion from Word DOC/DOCX to HTML without installing Microsoft Office. This guide walks you through the entire implementation, including environment setup, basic conversion code, and advanced HTML export customization.

2. Dependency Setup & Use Cases

2.1 Maven Configuration (Recommended)

Free Spire.Doc for Java is a free community edition built for core Word operations: document reading, writing, and format conversion. It runs on pure Java with no Office dependency and only has mild page limitations. For Maven enterprise projects, add the e-iceblue remote repository and dependency to your pom.xml:

Repository Configuration

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>
<dependency>
    <groupId>e-iceblue</groupId>
    <artifactId>spire.doc.free</artifactId>
    <version>14.3.1</version>
</dependency>

2.2 Common Use Cases

Online Document Preview: Convert local Word files to HTML for direct web display
Content Migration: Batch convert Word content to standard webpage format
Lightweight Document Processing: Small business projects needing free basic Word-to-HTML conversion

2.3 Supported File Formats

Input: Word 97-2003 (.doc), Word 2007 and later (.docx)
Output: Standard static HTML format

3. Core API for Java Word to HTML Conversion

The entire conversion workflow relies on the Document class and saveToFile method.

Document Class
Serves as the root node of a Word document and represents a complete file. Key methods:

Document(): Create a blank document instance
loadFromFile(String fileName): Load local Word documents from a file path
saveToFile(String fileName, FileFormat fileFormat): Export the loaded document to a specified format

FileFormat Enum
Defines target export formats. Use FileFormat.Html for Word to HTML conversion.

4. Basic Java Code to Convert Word to HTML

Use this ready-to-run code to implement simple DOCX/DOC to HTML conversion:

import com.spire.doc.*;

public class WordToHtml {
    public static void main(String[] args) {
        // Initialize Document object
        Document doc = new Document();

        // Load source Word document
        doc.loadFromFile("sample.docx");

        // Export Word to HTML file
        doc.saveToFile("toHtml.html", FileFormat.Html);

        // Release occupied resources
        doc.dispose();

        System.out.println("Word document conversion completed!");
    }
}

Key Workflow Breakdown

Instantiate: Create an empty Document object
Load File: Import local Word documents into program memory
Export: Parse document content and generate standard HTML files
Resource Release: Free system memory with dispose()

5. Advanced Word to HTML Customization 🚀

Free Spire.Doc for Java provides HtmlExportOptions to customize HTML export settings. You can adjust CSS generation, image embedding, and header/footer output for optimized webpage presentation.

5.1 CSS Style Configuration

setCssStyleSheetType(CssStyleSheetType type): Adjust CSS file generation mode
CssStyleSheetType.Internal: Embed CSS rules inside the HTML <style> tag
CssStyleSheetType.External: Generate an independent external .css file
Default Setting: Internal CSS for single self-contained HTML files

// Embed CSS styles directly into HTML
doc.getHtmlExportOptions().setCssStyleSheetType(CssStyleSheetType.Internal);

5.2 Image Embedding

You have two flexible options to handle Word images during HTML conversion:

Option 1: External Image Storage (Default)
Images are saved to an auto-generated _images subfolder, and HTML references images via relative paths. Ideal for web deployment with large numbers of images.

Option 2: Base64 Embedded Images
Enable Base64 embedding to encode all images directly into the HTML file. This creates a single self-contained HTML file for offline use, though it will increase file size.

// Embed images into HTML with Base64
doc.getHtmlExportOptions().setImageEmbedded(true);

4.3 Enable/Disable Headers & Footers

By default, Word headers and footers are converted into HTML page top and bottom blocks. If you only need to export the main content, you can turn off header and footer export with one line of code:

// Disable header and footer export, convert only body content
doc.getHtmlExportOptions().hasHeadersFooters(false);

Conclusion

This tutorial covers the complete method to convert Word to HTML using Java with a free library. The solution is lightweight, requires no Microsoft Office installation, and fits perfectly for small to medium business projects and online preview systems.

For ultra-large Word files or highly complex layout requirements, you can combine this library with Apache POI to build a customized Java document conversion solution.

C# - How to Extract Pages from PDF

Jeremy K. — Wed, 29 Apr 2026 07:54:23 +0000

When working with PDF documents, splitting pages is a common requirement—for example, extracting specific chapters from a multi-page report, distributing meeting minutes by participant, or saving each page of a scanned document as a separate file. This article details how to split PDF pages in C# using a free library, with code examples for various scenarios.

Installation: Install the FreeSpire.PDF package via NuGet (Install-Package FreeSpire.PDF). This is a free community edition with no restrictions when processing up to 10 pages per operation. Exceeding 10 pages will result in truncation, so this library is suitable for lightweight tasks.

1. Core Approach

Splitting a PDF essentially means: load source document → select target pages → create a new document → import pages → save. Free Spire.PDF provides a complete PdfDocument model that supports page-level copying and independent output.

Basic workflow:

Load the source PDF file.
Determine which pages to split (a single page, a consecutive range, or a custom set).
Create a new PdfDocument instance.
Retrieve the specified pages from the source document and insert them into the new document.
Save the new document and release resources.

2. Splitting Each Page into a Separate PDF

If you need to save each page of a PDF as an independent file, PdfDocument.Split is the simplest method.

Method Signature

public void Split(string destFilePattern, int startNumber);

destFilePattern: Output file path pattern; must contain the {0} placeholder, e.g., "C:\\out\\page_{0}.pdf".
startNumber: Number for the first file; typically set to 1 (creates files like page_1.pdf, page_2.pdf, …).

Example

using Spire.Pdf;

namespace SplitPdfDemo
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // Load the source PDF
            PdfDocument pdf = new PdfDocument();
            pdf.LoadFromFile("Sample.pdf");

            // Split each page into a separate file, numbering starts at 1
            pdf.Split("Output/Page_{0}.pdf", 1);

            pdf.Close();
            Console.WriteLine("Splitting completed. Each page has been saved in the Output folder.");
        }
    }
}

3. Grouping Pages by Fixed Size

When you need to merge every N pages into one PDF (e.g., every 3 pages as a single file), Split cannot be used directly. Instead, you must manually work with PdfDocument page insertion.

Approach

Load the source document.
Calculate the number of groups: (totalPages + pagesPerGroup - 1) / pagesPerGroup.
For each group, create a new PdfDocument and copy the corresponding page range from the source.
Save the new document.

Code Example

using Spire.Pdf;
using System;

namespace SplitPdf
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string inputFile = "sample.pdf";
            int pagesPerGroup = 3;                     // every 3 pages as one PDF
            string outputPattern = "Group_{0}.pdf";

            // 1. Load the source document
            PdfDocument source = new PdfDocument();
            source.LoadFromFile(inputFile);

            int totalPages = source.Pages.Count;
            int groupCount = (totalPages + pagesPerGroup - 1) / pagesPerGroup;

            // 2. Create a new document for each group
            for (int g = 0; g < groupCount; g++)
            {
                PdfDocument groupDoc = new PdfDocument();

                // Calculate start and end indexes for the current group (0-based)
                int startIdx = g * pagesPerGroup;
                int endIdx = Math.Min(startIdx + pagesPerGroup - 1, totalPages - 1);

                // Copy pages
                for (int i = startIdx; i <= endIdx; i++)
                {
                    groupDoc.InsertPage(source, source.Pages[i]);
                }

                // Save the current group
                string outputFile = string.Format(outputPattern, g + 1);
                groupDoc.SaveToFile(outputFile);
                groupDoc.Close();
            }

            source.Close();
            Console.WriteLine($"Splitting completed. Every {pagesPerGroup} pages have been merged into one file.");
        }
    }
}

4. Other Common PDF Splitting Scenarios

4.1 Extract Specific Non‑Consecutive Pages

For example, extract only pages 2, 5, and 7:

PdfDocument source = new PdfDocument();
source.LoadFromFile("Sample.pdf");

PdfDocument result = new PdfDocument();
int[] wanted = { 2, 5, 7 };
foreach (int p in wanted)
{
    if (p >= 1 && p <= source.Pages.Count)
        result.InsertPage(source, source.Pages[p - 1]); // note: pages are 0‑based
}
result.SaveToFile("Extracted.pdf");

result.Close();
source.Close();

4.2 Extract All Odd or Even Pages

PdfDocument source = new PdfDocument();
source.LoadFromFile("AnnualReport1.pdf");

PdfDocument oddPages = new PdfDocument();
PdfDocument evenPages = new PdfDocument();

for (int i = 0; i < source.Pages.Count; i++)
{
    if (i % 2 == 0)      // 0‑based index: 0 → page 1 (odd)
        oddPages.InsertPage(source, source.Pages[i]);
    else
        evenPages.InsertPage(source, source.Pages[i]);
}

oddPages.SaveToFile("OddPages.pdf");
evenPages.SaveToFile("EvenPages.pdf");

oddPages.Close();
evenPages.Close();
source.Close();

5. Summary

Requirement	Implementation	Core API
Each page as a separate file	`pdf.Split("pattern_{0}.pdf", 1)`	Built‑in `Split`
Every N pages merged into one file	Manual loop + `InsertPage`	`PdfDocument.InsertPage`
Extract specific pages	Manual filtering + `InsertPage`	Same as above

All code has been tested in real projects and can be reused directly.

Delete PDF Pages in C#

Jeremy K. — Wed, 15 Apr 2026 03:55:57 +0000

In modern digital workflows, PDF files often contain unwanted pages due to export errors, duplicate content, or formatting issues. Manually deleting pages is slow and risks corrupting the file structure.

C# developers need a reliable, automated solution. Free Spire.PDF for .NET offers a free API to delete, merge, split, and manipulate PDF pages – without installing Adobe Acrobat.

Installation

Use NuGet Package Manager Console:

Install-Package FreeSpire.PDF

Or search FreeSpire.PDF in Manage NuGet Packages → Browse → Install.

Load the PDF Document

using Spire.Pdf;

PdfDocument pdf = new PdfDocument();
pdf.LoadFromFile("input.pdf");

Delete a Single Page

Pages are zero-indexed. To delete page 3:

pdf.Pages.RemoveAt(2);  // Removes the 3rd page

Delete Multiple Pages (Safe Reverse Order)

When deleting multiple pages, always delete from the highest to the lowest index to avoid shifting errors.

int[] pagesToDelete = new int[] { 1, 3 }; // Pages 1 and 3 (1-based)

Array.Sort(pagesToDelete);
Array.Reverse(pagesToDelete);

foreach (int pageNum in pagesToDelete)
{
    if (pageNum >= 1 && pageNum <= pdf.Pages.Count)
    {
        pdf.Pages.RemoveAt(pageNum - 1); // Convert to zero-based
    }
}

Save the Modified PDF

pdf.SaveToFile("output.pdf");
pdf.Close();

Advanced PDF Deletion Scenarios

Scenario	Description
Batch delete	Use LINQ to delete all pages with specific text or pattern.
Conditional delete	Find pages containing sensitive data (e.g., SSN, credit card) using `PdfTextFinder`.
Office integration	Remove blank or redundant pages after Word/Excel to PDF conversion.

Best Practices for C# PDF Page Removal

✅ Always validate page numbers before deletion.
✅ Delete multiple pages in reverse order.
✅ Use try-catch blocks to handle corrupted files or invalid paths.
✅ Call pdf.Close() to release resources.

Conclusion

The Free Spire.PDF library provides a straightforward API for deleting PDF pages in C#:

Load the PDF with PdfDocument.LoadFromFile.
Use Pages.RemoveAt(index) to delete pages (zero‑based indexing).
For multiple deletions, sort indices descending.
Save the document with SaveToFile.

Frequently Asked Questions (FAQ)

Can I delete PDF pages without Adobe Acrobat?

Yes, Free Spire.PDF for .NET works completely independently.

Is Free Spire.PDF really free?

Yes, for personal and commercial use, but with a 10-page limit.

How to delete the last page of a PDF?

Use pdf.Pages.RemoveAt(pdf.Pages.Count - 1);

Convert RTF to Word Documents in C#

Jeremy K. — Wed, 01 Apr 2026 03:24:04 +0000

When working with document format conversion in .NET applications, converting RTF to Word is a frequent requirement. RTF (Rich Text Format) is widely used as a cross‑platform intermediate format, but final deliverables often require the more universally supported Word formats: .doc or .docx.

This article shows how to convert RTF to Word using only a few lines of C# code with a free .NET library. The solution does not require Microsoft Office to be installed and runs entirely in code, making it ideal for background services, web APIs, and desktop applications.

Install the Library

First, create a .NET project (console app, WebAPI, or other). Then install the Free Spire.Doc library via the NuGet Package Manager:

Install-Package FreeSpire.Doc

Note: The free version has a page limit when processing documents.

After installation, add the following namespace at the top of your code file:

using Spire.Doc;

Core Conversion Logic

With Free Spire.Doc, the conversion process is simple: load the RTF document, then save it in Word format.

Minimal Example

// Initialize a Document instance
Document doc = new Document();

// Load the RTF file
doc.LoadFromFile("input.rtf", FileFormat.Rtf);

// Save as Word 97‑2003 (.doc)
doc.SaveToFile("output.doc", FileFormat.Doc);

// Or save as modern Word 2007+ (.docx)
doc.SaveToFile("output.docx", FileFormat.Docx);

The LoadFromFile method uses FileFormat.Rtf to correctly parse RTF content.
The SaveToFile method supports both legacy binary .doc and modern XML‑based .docx formats.

Complete Console Example

This full example includes path definitions, basic exception handling, and dual‑format output:

using System;
using Spire.Doc;

class RtfToWordConverter
{
    static void Main(string[] args)
    {
        string rtfPath = @"C:\docs\source.rtf";
        string docxPath = @"C:\docs\result.docx";
        string docPath = @"C:\docs\result.doc";

        try
        {
            Document doc = new Document();
            doc.LoadFromFile(rtfPath, FileFormat.Rtf);

            // Export to DOCX
            doc.SaveToFile(docxPath, FileFormat.Docx);
            Console.WriteLine($"Converted successfully: {docxPath}");

            // Also export to DOC
            doc.SaveToFile(docPath, FileFormat.Doc);
            Console.WriteLine($"Converted successfully: {docPath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Conversion failed: {ex.Message}");
        }

        Console.WriteLine("Press any key to exit...");
        Console.ReadKey();
    }
}

Advanced: Convert Using Streams

For web applications or in‑memory processing, you can read and write using streams instead of physical files. This avoids temporary files and is more efficient for uploaded content.

using (FileStream inputStream = new FileStream("input.rtf", FileMode.Open))
{
    Document doc = new Document();
    doc.LoadFromStream(inputStream, FileFormat.Rtf);

    using (FileStream outputStream = new FileStream("output.docx", FileMode.Create))
    {
        doc.SaveToStream(outputStream, FileFormat.Docx);
    }
}

Important Considerations

Format Compatibility

Free Spire.Doc supports most common RTF features, including fonts, paragraphs, tables, and images. However, some advanced elements, such as embedded OLE objects or complex mathematical formulas, may not be perfectly preserved. Always test with your typical documents.
File Permissions

Ensure your application has read access to the source RTF file and write access to the output directory. Missing permissions are a common cause of runtime errors, especially in server deployments.
Batch Processing

When converting multiple RTF files in a loop, create a new Document instance for each file and dispose it properly to prevent memory leaks.

Summary

Converting RTF to Word in C# is straightforward when using a lightweight library like Free Spire.Doc. The solution is clean, dependency‑free (no Office required), and supports both .doc and .docx output.

For production use, test your document layouts first, handle exceptions appropriately, and choose the output format based on compatibility and file size requirements.