DEV Community: jelizaveta

How to Compare Word Documents for Differences Using C#

jelizaveta — Thu, 13 Aug 2026 01:35:35 +0000

Version management for Word documents is a common demand in daily office work and .NET development. In team collaborative writing, document review and version iteration scenarios, it’s essential to quickly and accurately spot differences between two document files to guarantee content accuracy and standardize version management.

Manual word-by-word comparison is never a good choice. It’s time-consuming, labor-intensive, and easy to miss subtle changes or make misjudgments. To solve this problem, this article uses the Spire.Doc for .NET library with practical C# code examples, covering two common Word comparison solutions: generating visual revision documents and extracting structured difference data programmatically, to help developers quickly implement automated Word comparison functions.

1. Overview of Spire.Doc for .NET

Spire.Doc for .NET is a lightweight, high-performance third-party library for Word processing. The biggest advantage is that it runs independently without relying on the local Microsoft Office environment. It supports the full lifecycle of Word file operations, including creation, reading, editing, format conversion, export and version comparison.

The library provides simple and well-encapsulated APIs. Its built-in document comparison feature can intelligently identify text insertion, deletion and format modification changes. Developers can implement professional-grade Word version comparison without writing complex business logic, which fits perfectly with all kinds of .NET project development scenarios.

2. Environment Setup: Install the Component

All comparison functions in this article depend on Spire.Doc for .NET. Before coding, install the library via NuGet. You can quickly complete the installation through the Visual Studio Package Manager Console with the following command:

Install-Package Spire.Doc

3. Basic Usage: Generate Visual Revision Documents

The most widely used comparison scenario is to compare an original document with a revised version and generate a new file with complete revision marks. All changes are displayed intuitively through Word’s native revision mode. Below is the full runnable C# code:

using Spire.Doc;

namespace CompareDocuments
{
    class Program
    {
        static void Main(string[] args)
        {
            // Load original baseline document
            Document originalDoc = new Document("original.docx");

            // Load modified document for comparison
            Document revisedDoc = new Document("revised.docx");

            // Compare documents and set revision author
            originalDoc.Compare(revisedDoc, "John");

            // Save comparison results with revision marks to a new file
            originalDoc.SaveToFile("Differences.docx", FileFormat.Docx2013);

            // Release resources to avoid memory occupation
            originalDoc.Dispose();
        }
    }
}

The core of the code lies in the Compare() method. It automatically analyzes content and format differences between two files and marks three types of changes in the original document: inserted content, deleted content and format adjustments.

The generated Differences.docx can be opened directly in Microsoft Word. It adopts the standard revision view, with the same accurate effect as Office’s built-in professional document comparison tool.

4. Advanced Usage: Extract Structured Difference Details

In many business scenarios, visual revision files are not enough. We need to obtain precise, structured difference data programmatically — for scenarios such as generating audit logs, synchronizing changes to databases, building custom comparison reports, or docking with business approval workflows.

Spire.Doc provides the DifferRevisions class to separately extract all inserted and deleted text content, enabling structured parsing of comparison results. The complete implementation code is as follows:

using Spire.Doc;
using Spire.Doc.Fields;
using System;

namespace GetDifferencesInList
{
    class Program
    {
        static void Main(string[] args)
        {
            // Load original and revised documents
            Document originalDoc = new Document("original.docx");
            Document revisedDoc = new Document("revised.docx");

            // Execute comparison to generate revision data
            originalDoc.Compare(revisedDoc, "Author");

            // Parse all revision records
            DifferRevisions revisions = new DifferRevisions(originalDoc);

            // Obtain insertion and deletion revision collections
            var insertRevisions = revisions.InsertRevisions;
            var deleteRevisions = revisions.DeleteRevisions;

            int insertCount = 0;
            int deleteCount = 0;

            // Traverse and output all added content
            Console.WriteLine("List of Added Content");
            for (int i = 0; i < insertRevisions.Count; i++)
            {
                if (insertRevisions[i] is TextRange textRange)
                {
                    insertCount++;
                    Console.WriteLine($"Insert #{insertCount}: {textRange.Text.Trim()}");
                }
            }

            Console.WriteLine("=====================");

            // Traverse and output all deleted content
            Console.WriteLine("List of Deleted Content");
            for (int i = 0; i < deleteRevisions.Count; i++)
            {
                if (deleteRevisions[i] is TextRange textRange)
                {
                    deleteCount++;
                    Console.WriteLine($"Delete #{deleteCount}: {textRange.Text.Trim()}");
                }
            }

            Console.ReadKey();
        }
    }
}

This code accurately filters valid text changes and excludes invalid format interference. Developers can perform secondary processing on the extracted difference data, which is the core basis for building automated document auditing and intelligent comparison systems.

5. Core Application Scenarios & Advantages

The automated Word comparison function based on Spire.Doc can replace inefficient manual comparison, greatly improving office and development efficiency, and is applicable to multiple industries and business scenarios:

5.1 Legal Contract Review

Legal teams and enterprise legal departments often need to compare multiple versions of contracts and agreements. This tool can generate complete revision reports with one click, accurately capturing clause additions, deletions and wording modifications, effectively reducing contract risks and improving review efficiency.

5.2 Team Technical Document Collaboration

Product requirements, technical manuals and API documents are usually updated collaboratively by multiple team members. Programmatic comparison can automatically track everyone’s modifications, making document changes traceable and statistically analyzable.

5.3 Document Version Iteration Management

For long-term maintained documents such as management policies, project plans and official notices, regular automatic comparison of different versions can completely record the entire iteration process, realizing standardized version archiving and full change traceability.

5.4 Industry Compliance Auditing

Regulatory industries including finance, healthcare and government have strict audit requirements for document changes. Automated comparison can retain every modification record completely, meeting compliance review and traceability standards.

6. Development Tips & Performance Optimization

Spire.Doc delivers stable compatibility and processing performance even for large Word files. To ensure program stability, pay attention to the following key points during development:

6.1 Standardize Memory Management

Document comparison consumes certain system resources, especially when processing batches of files or large documents. It is recommended to actively call the Dispose() method after each operation to release resources and avoid memory accumulation leading to program stuttering or crashes.

6.2 Unify Document Formats

Try to ensure both comparison files are in .docx format. Avoid mixing .doc and .docx formats, which may trigger parsing exceptions or inaccurate comparison results.

6.3 Standardize Revision Author Information

The author parameter in the Compare method will be displayed in revision records. In formal business scenarios, fill in the actual operator or department name to facilitate subsequent responsibility verification and change traceability.

7. Summary

With Spire.Doc for .NET, developers can implement fully automated Word document comparison with minimal code. It supports both intuitive visual revision file generation and fine-grained structured difference data extraction, completely solving the low efficiency and high error rate of manual comparison.

This comparison capability can not only meet basic document matching needs, but also serve as a core foundation for developing intelligent document management platforms, automated office systems and compliance audit systems. Beyond document comparison, Spire.Doc also supports document editing, format conversion, merging, splitting, watermarking and a wealth of other functions, covering most secondary development requirements for Word documents.

How to Compare Word Documents for Differences Using C#

jelizaveta — Thu, 13 Aug 2026 01:25:25 +0000

1. Overview of Spire.Doc for .NET

2. Environment Setup: Install the Component

Install-Package Spire.Doc

3. Basic Usage: Generate Visual Revision Documents

using Spire.Doc;

namespace CompareDocuments
{
    class Program
    {
        static void Main(string[] args)
        {
            // Load original baseline document
            Document originalDoc = new Document("original.docx");

            // Load modified document for comparison
            Document revisedDoc = new Document("revised.docx");

            // Compare documents and set revision author
            originalDoc.Compare(revisedDoc, "John");

            // Save comparison results with revision marks to a new file
            originalDoc.SaveToFile("Differences.docx", FileFormat.Docx2013);

            // Release resources to avoid memory occupation
            originalDoc.Dispose();
        }
    }
}

4. Advanced Usage: Extract Structured Difference Details

using Spire.Doc;
using Spire.Doc.Fields;
using System;

namespace GetDifferencesInList
{
    class Program
    {
        static void Main(string[] args)
        {
            // Load original and revised documents
            Document originalDoc = new Document("original.docx");
            Document revisedDoc = new Document("revised.docx");

            // Execute comparison to generate revision data
            originalDoc.Compare(revisedDoc, "Author");

            // Parse all revision records
            DifferRevisions revisions = new DifferRevisions(originalDoc);

            // Obtain insertion and deletion revision collections
            var insertRevisions = revisions.InsertRevisions;
            var deleteRevisions = revisions.DeleteRevisions;

            int insertCount = 0;
            int deleteCount = 0;

            // Traverse and output all added content
            Console.WriteLine("List of Added Content");
            for (int i = 0; i < insertRevisions.Count; i++)
            {
                if (insertRevisions[i] is TextRange textRange)
                {
                    insertCount++;
                    Console.WriteLine($"Insert #{insertCount}: {textRange.Text.Trim()}");
                }
            }

            Console.WriteLine("=====================");

            // Traverse and output all deleted content
            Console.WriteLine("List of Deleted Content");
            for (int i = 0; i < deleteRevisions.Count; i++)
            {
                if (deleteRevisions[i] is TextRange textRange)
                {
                    deleteCount++;
                    Console.WriteLine($"Delete #{deleteCount}: {textRange.Text.Trim()}");
                }
            }

            Console.ReadKey();
        }
    }
}

5. Core Application Scenarios & Advantages

5.1 Legal Contract Review

5.2 Team Technical Document Collaboration

5.3 Document Version Iteration Management

5.4 Industry Compliance Auditing

6. Development Tips & Performance Optimization

Spire.Doc delivers stable compatibility and processing performance even for large Word files. To ensure program stability, pay attention to the following key points during development:

6.1 Standardize Memory Management

6.2 Unify Document Formats

Try to ensure both comparison files are in .docx format. Avoid mixing .doc and .docx formats, which may trigger parsing exceptions or inaccurate comparison results.

6.3 Standardize Revision Author Information

7. Summary

How to Extract Text and Images from Word Documents Using Java

jelizaveta — Tue, 11 Aug 2026 01:31:40 +0000

Parsing Word documents is a common yet challenging task in Java enterprise development. Use cases range from document content archiving and structured data extraction to batch asset exporting. While Apache POI has long been the go-to solution, it often falls short with its verbose APIs, poor image extraction support, and compatibility issues with newer docx formats—problems that can turn a simple task into a debugging nightmare.

Spire.Doc for Java offers a compelling alternative. This lightweight, high-performance library requires no Office installation and excels at extracting text, images, tables, and more with remarkable precision. Its intuitive API and robust parsing engine make it an ideal choice for most enterprise-grade development scenarios.

In this tutorial, we'll walk through:

Setting up Spire.Doc via Maven
Extracting full-text content from Word documents and exporting it as TXT
Batch exporting embedded images as PNG files

Each example comes with complete, runnable code and detailed explanations—perfect for developers of all experience levels. Let's dive in!

1. Technical Overview and Environment Setup

1.1 Component Advantages

Spire.Doc for Java is a professional-grade Word processing library that supports full parsing of both .doc and .docx formats. Its core advantages include:

No Office dependency — Works without installing Microsoft Office
Clean, intuitive API — Minimal boilerplate, maximum productivity
High parsing accuracy — Preserves formatting and structure faithfully
Batch processing support — Handle multiple documents efficiently

These features effectively resolve common pain points like garbled text, image loss, and formatting corruption frequently encountered with native POI-based solutions.

1.2 Maven Dependency Configuration

First, add the Spire.Doc for Java repository and dependency to your project's pom.xml file:

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

Once configured, refresh your Maven project to automatically download the dependency package, and you're ready to begin document parsing development.

2. Example 1: Extracting All Text from Word and Exporting to TXT

Spire.Doc provides the minimalist getText() method to retrieve all plain text content from a document in one go, automatically filtering out images, formatting symbols, controls, and other non-text elements. It also supports persisting the extracted text as a TXT file for convenient content archiving.

Complete Code Implementation

import com.spire.doc.Document;
import java.io.FileWriter;
import java.io.IOException;

public class ExtractText {
    public static void main(String[] args) throws IOException {
        // 1. Create document object and load local Word document
        Document document = new Document();
        document.loadFromFile("sample1.docx");

        // 2. Extract all text content from the document
        String text = document.getText();

        // 3. Write the text to a local TXT file
        writeStringToTxt(text, "ExtractedText.txt");
        System.out.println("Word text extraction complete, saved to ExtractedText.txt");
    }

    /**
     * Utility method to write text content to a TXT file
     * @param content The extracted text content
     * @param txtFileName The output file name
     * @throws IOException IO exception
     */
    public static void writeStringToTxt(String content, String txtFileName) throws IOException {
        // Write to file in append mode
        FileWriter fWriter = new FileWriter(txtFileName, true);
        try {
            fWriter.write(content);
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            // Force flush the stream and close resources to avoid memory leaks
            try {
                fWriter.flush();
                fWriter.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
}

Code Walkthrough

Initialize the Document object — Create a new Document instance and load the target Word file using loadFromFile(), which supports both relative and absolute paths.
Extract text content — Call getText() to quickly parse the full document text. This method automatically preserves the original text layout logic while stripping away non-text elements.
Persist to file — A custom utility method writes the extracted content to a TXT file in append mode. The finally block ensures the stream is properly flushed and closed, preventing IO resource leaks.

3. Example 2: Batch Extracting Embedded Images from Word and Exporting as PNG

Images in Word documents are nested within document nodes and cannot be retrieved via a simple one-line API call. Spire.Doc supports traversing the document's tree structure to precisely identify all image nodes, batch extract them, and export in PNG format—compatible with all embedded images in body text, paragraphs, headers, footers, and text boxes.

Complete Code Implementation

import com.spire.doc.*;
import com.spire.doc.documents.*;
import com.spire.doc.fields.*;
import com.spire.doc.interfaces.*;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.*;
import java.util.*;

public class ExtractImage {
    public static void main(String[] args) throws IOException {
        // 1. Load the Word document
        Document document = new Document();
        document.loadFromFile("sample2.docx");

        // 2. Initialize a queue to traverse the document tree nodes
        Queue<ICompositeObject> nodes = new LinkedList<>();
        nodes.add(document);
        List<BufferedImage> images = new ArrayList<>();

        // 3. Deep traverse the document to filter image nodes
        while (nodes.size() > 0) {
            ICompositeObject node = nodes.poll();
            for (int i = 0; i < node.getChildObjects().getCount(); i++) {
                IDocumentObject child = node.getChildObjects().get(i);
                // Recursively add composite nodes for continued deep traversal
                if (child instanceof ICompositeObject) {
                    nodes.add((ICompositeObject) child);
                }
                // Identify image nodes and collect images
                else if (child.getDocumentObjectType() == DocumentObjectType.Picture) {
                    DocPicture picture = (DocPicture) child;
                    images.add(picture.getImage());
                }
            }
        }

        // 4. Create output directory and batch save images
        File outputDir = new File("output");
        if (!outputDir.exists()) {
            outputDir.mkdirs();
        }
        for (int i = 0; i < images.size(); i++) {
            File file = new File(String.format("output/extractImage-%d.png", i));
            ImageIO.write(images.get(i), "PNG", file);
        }
        System.out.println("Image extraction complete, extracted " + images.size() + " images");
    }
}

Code Walkthrough

Load the document — As in the previous example, create a Document instance and load the target Word file.
Set up traversal structures — A Queue manages the document nodes for deep traversal, while a List collects all extracted images.
Traverse and filter — The algorithm performs a breadth-first traversal of the document tree:
- When encountering a composite node (containing child elements), it's added to the queue for further traversal.
- When a picture node is identified via DocumentObjectType.Picture, the image data is extracted and stored.
Export images — The output directory is created if it doesn't already exist. Each image is then written as a PNG file with an ordered, predictable filename for easy management.

4. Runtime Considerations and Common Issues

To ensure smooth execution, keep the following points in mind:

Issue	Recommendation
Document path errors	Place test documents in the project root directory during development. For production, use absolute paths to avoid `FileNotFoundException`.
Dependency download failures	If Maven cannot pull the dependency, manually download the JAR from the official repository and import it into your project as a local library.
Missing or blank images	The traversal logic covers all document nodes, ensuring compatibility with complex layouts, nested structures, and mixed text-image content. No image loss or blank output should occur.
High memory usage during batch processing	When processing multiple large documents, manually release resources after each document using `document.dispose()` to prevent memory leaks.

5. Summary

This article demonstrated two core functionalities—full-text extraction and batch image export from Word documents—using the Spire.Doc for Java component. Compared to traditional POI-based approaches, this solution offers:

Cleaner, more maintainable code — Minimal boilerplate and intuitive method calls
Superior compatibility — Handles both legacy .doc and modern .docx formats flawlessly
Higher parsing stability — Preserves content integrity without garbled text or image loss
Production-ready performance — Suitable for enterprise-scale batch processing

This solution can be quickly adopted in a wide range of business scenarios, including document archiving systems, content search engines, asset extraction pipelines, and office automation workflows. Developers can easily extend the functionality presented here—for example, extracting text from specific sections, customizing output image formats, or building batch traversal pipelines for large document collections.

With Spire.Doc for Java, Word document processing no longer needs to be a headache. Start building your document parsing solution today with the code and techniques covered in this guide.

How to Convert HTML File and String to Image in Java

jelizaveta — Thu, 06 Aug 2026 01:28:02 +0000

Converting HTML content to image format is a common functional requirement in many Java projects. Whether for dynamic report generation, email template previews, or content screenshot services, this technology plays an indispensable role. This article introduces how to implement HTML-to-image conversion in Java through two different technical approaches, helping developers choose flexibly based on their actual scenarios.

Technology Selection

In the Java ecosystem, there are multiple solutions for converting HTML to images. This article adopts a mature document processing library, Spire.Doc for Java, which provides comprehensive HTML rendering capabilities. Its main advantages include:

No dependency on browser engines : Runs stably on the server side, avoiding browser compatibility issues
Support for rich HTML tags : Covers common elements such as tables, images, and lists
Precise rendering control : Allows free configuration of page margins, image formats, resolution, and other parameters
Memory-friendly management : Provides resource release mechanisms, suitable for batch processing and large-file scenarios

Environment Configuration

First, add the Spire.Doc Maven dependency to your project's pom.xml:

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.doc</artifactId>
        <version>14.7.4</version>
    </dependency>
</dependencies>

Method 1: Direct Conversion from HTML File

The first method is suitable for scenarios where HTML files already exist, using the loadFromFile method to load and convert directly:

Document document = new Document();
document.loadFromFile("Input.html", FileFormat.Html, XHTMLValidationType.None);

The advantage of this approach is its simplicity and intuitiveness, making it ideal for processing static HTML files. The XHTMLValidationType.None parameter allows us to skip strict XHTML validation, increasing compatibility with various HTML formats.

Method 2: Conversion from HTML String

When HTML content comes from databases, network requests, or is dynamically generated, using the string approach offers greater flexibility:

Document document = new Document();
Section section = document.addSection();
IParagraph paragraph = section.addParagraph();

String htmlString = new String(Files.readAllBytes(Paths.get("Input.html")), "UTF-8");
paragraph.appendHTML(htmlString);

This method appends HTML content as a string to a document paragraph, making it suitable for handling dynamic content or scenarios that require concatenating multiple HTML fragments.

Core Conversion Workflow

Both methods share the same core conversion logic:

1. Page Setup

section.getPageSetup().getMargins().setAll(2);

Set page margins to 2 pixels, ensuring content doesn't cling to the edges and improving image readability.

2. Convert to Images

BufferedImage[] images = document.saveToImages(ImageType.Bitmap);

The saveToImages method converts each page of the document to a BufferedImage object, returning an array of images. Using the ImageType.Bitmap parameter yields high-quality bitmap output.

3. Save Image Files

for (int index = 0; index < images.length; index++) {
    String fileName = String.format("image_%d.png", index);
    ImageIO.write(images[index], "PNG", new File(fileName));
}

Iterate through the image array and use the ImageIO.write method to save each BufferedImage as a PNG file.

4. Resource Release

document.dispose();

Promptly release document resources to avoid memory leaks, which is especially important when processing large volumes of documents.

Practical Application Scenarios

1. Report Generation

Convert data report HTML previews to images for easy embedding in emails, PPTs, or documents.

2. Webpage Screenshot Services

Provide API services that convert specified web content to images for other systems to call.

3. Content Archiving

Convert dynamically generated HTML pages to images for long-term archiving, avoiding content display failures caused by frontend technology changes.

4. Social Media Sharing

Generate share card images containing rich text content to enhance the social media sharing experience.

Performance Optimization Recommendations

Reuse Document objects during batch processing : Reduce object creation overhead
Use appropriate image formats : PNG for high quality requirements, JPEG for file size-sensitive scenarios
Control image resolution : Indirectly control output image dimensions by setting page size
Asynchronous processing : Consider using thread pools for asynchronous execution when handling large batch conversion tasks

Important Considerations

Font support : Ensure the system has fonts used in HTML installed; otherwise, garbled characters may appear
Complex CSS support : Spire.Doc supports CSS2.1 well, but some CSS3 features may not be supported
Image resources : Image references in HTML require full paths or Base64 encoding
Cross-platform compatibility : Test on different operating systems to ensure rendering consistency

Conclusion

With Spire.Doc for Java, we can easily implement HTML-to-image conversion, whether from files or string sources. These two approaches cover most practical application scenarios, providing developers with flexible options. In real-world projects, choose the appropriate method based on specific requirements, pay attention to performance optimization and exception handling, and you can build stable and efficient HTML-to-image conversion services.

As content presentation demands continue to diversify, HTML-to-image technology will play an increasingly important role across more domains. Mastering this skill will provide strong support for solving many practical problems you may encounter.

Convert CSV to PDF with Python with Beautiful Table Formatting

jelizaveta — Tue, 04 Aug 2026 03:47:03 +0000

CSV files store tabular data in plain text and are highly versatile, but in formal settings—such as delivering data reports to clients, archiving project documents, or printing materials—their shortcomings become apparent: no formatting, uneven column widths, messy pagination, and a poor reading experience.

PDF perfectly compensates for these deficiencies. It has fixed layout and displays consistently across platforms, making it the preferred format for formal documents. This article introduces a straightforward approach: using the Spire.XLS for Python library to load a CSV file as a workbook, adjust table styling, and export it as a well-formatted PDF document. The entire process requires just a dozen lines of code, with no need to install Microsoft Excel.

Preparations

Before you start coding, install the required dependency library:

pip install Spire.XLS

Spire.XLS for Python is a powerful Excel manipulation library that supports reading, writing, conversion, and many other operations, without relying on any local Excel components.

Complete Code Implementation

Below is a complete conversion script covering the three core steps: loading, styling, and exporting:

from spire.xls import *
from spire.xls.common import *

# Create a Workbook object
workbook = Workbook()

# Load the CSV file (parameters: file path, delimiter, start row, start column)
workbook.LoadFromFile("sample.csv", ",", 1, 1)

# Set page scaling to ensure content fits on one page
workbook.ConverterSetting.SheetFitToPage = True

# Get the first worksheet
sheet = workbook.Worksheets[0]

# Auto-fit each column to prevent content from being truncated
i = 1
while i < sheet.Columns.Length:
    sheet.AutoFitColumn(i)
    i += 1

# Export to PDF
workbook.SaveToFile("CSVToPDF.pdf", FileFormat.PDF)
workbook.Dispose()

Key Steps Explained

1. Loading the CSV File

Workbook is the core class for operations. The LoadFromFile method not only takes the file path but also allows you to specify the delimiter, starting row, and starting column for reading. For example, ",", 1, 1 means using a comma as the delimiter and starting reading from the first row and first column. If your CSV file uses tabs or semicolons as delimiters, simply replace with "\t" or ";".

2. Fitting Everything on One Page

workbook.ConverterSetting.SheetFitToPage = True is an easily overlooked yet critical setting. Without this, when the table has many columns, the exported PDF may split the content across multiple pages, requiring you to flip back and forth while reading—which is quite inconvenient. When enabled, the PDF page automatically scales to ensure all columns are fully displayed on a single page.

3. Auto-Fitting Column Widths

By calling sheet.AutoFitColumn(i) in a loop, each column's width is automatically adjusted based on the longest text content in that column. This prevents text from overlapping or displaying as "####", and makes the table look cleaner and more professional.

4. Exporting to PDF

Finally, call SaveToFile with FileFormat.PDF specified to generate the PDF file. The Dispose method is used to release resources—a good habit to cultivate.

Further Styling the Table

The example above already meets basic needs, but if you want the PDF to look more polished, Spire.XLS offers additional customization options. For example, you can set fonts, font sizes, alignment, or adjust page orientation:

# Set global font and font size
sheet.AllocatedRange.Style.Font.FontName = "Arial"
sheet.AllocatedRange.Style.Font.Size = 14

# Set horizontal center alignment
sheet.AllocatedRange.Style.HorizontalAlignment = HorizontalAlignType.Center

# Adjust page orientation to landscape
sheet.PageSetup.Orientation = PageOrientationType.Landscape

These settings make the exported PDF more suitable for formal documentation requirements.

Use Cases

This solution is particularly well-suited for the following scenarios:

Batch report generation : Periodically export CSVs from databases and automatically convert them to PDFs for archiving.
Data delivery : Provide clients or partners with fixed-format data documents to avoid layout issues caused by different software versions.
Servers without Excel : Spire.XLS does not depend on local Excel and can run stably on Linux servers.

Summary

With Spire.XLS for Python, you can convert CSV to PDF in just a dozen lines of code while maintaining flexible control over table styling. The combination of SheetFitToPage and AutoFitColumn is key to ensuring a clean and polished output page. If you're troubled by CSV's "plain" appearance, give this solution a try.

How to Convert Word to PDF in JavaScript (Complete Guide)

jelizaveta — Fri, 31 Jul 2026 01:41:46 +0000

In modern web applications, document processing capabilities are increasingly becoming essential. Whether generating reports, exporting contracts, or processing user-uploaded documents, Word-to-PDF conversion is one of the most common requirements. This article explores how to achieve high-quality Word to PDF conversion in React applications using the Spire.Doc for JavaScript library.

Why Choose Spire.Doc for JavaScript?

There are many options for document conversion on the front end, but Spire.Doc for JavaScript offers several standout advantages:

No backend server required : All conversion happens on the client side, protecting user data privacy
High-quality rendering : Perfectly preserves the original document's formatting, fonts, and layout
Rich feature support : Not only supports conversion but also creating, editing, and manipulating Word documents
Cross-platform compatibility : Built on WebAssembly, runs smoothly in major browsers

Project Initialization

First, install Spire.Office in your React project:

npm i spire.office

Core Implementation Breakdown

1. Loading the WASM Module

Spire.Doc runs on WebAssembly and requires loading the core module first. Here, React's useEffect is used to load it asynchronously when the component mounts:

useEffect(() => {
  (async () => {
    try {
      const publicUrl = process.env.PUBLIC_URL || '';
      const spireModule = await import(/* webpackIgnore: true */ `${publicUrl}/spire.doc.js`);
      const rawModule = spireModule.default || spireModule;
      window.wasmModule = typeof rawModule === 'function'
        ? await rawModule({ locateFile: p => p.endsWith('.wasm') ? `${publicUrl}/${p}` : p })
        : rawModule;
      setWasmModule(window.wasmModule);
    } catch (error) {
      console.error('Failed to load spire.doc.js WASM module:', error);
    }
  })();
}, []);

Key points explained:

webpackIgnore: true ensures webpack does not process this dynamic import, avoiding resource path errors
The locateFile function specifies the loading path for WASM files
After successful module loading, it's stored in state to control button availability

2. Font Management

Fonts are the most common point of failure in document conversion. Spire.Doc needs fonts loaded into the virtual file system (VFS) to ensure correct PDF rendering:

// Load Times New Roman font family
await window.spire.FetchFileToVFS('times.ttf', '/Library/Fonts/', `${process.env.PUBLIC_URL}/static/font/`);
await window.spire.FetchFileToVFS('timesbd.ttf', '/Library/Fonts/', `${process.env.PUBLIC_URL}/static/font/`);
await window.spire.FetchFileToVFS('timesbi.ttf', '/Library/Fonts/', `${process.env.PUBLIC_URL}/static/font/`);
await window.spire.FetchFileToVFS('timesi.ttf', '/Library/Fonts/', `${process.env.PUBLIC_URL}/static/font/`);

Best practices:

Place commonly used font files in the public/static/font/ directory
Selectively load fonts based on those actually used in the document to reduce load time
For Chinese documents, Chinese fonts (such as SimSun, SimHei, etc.) need to be loaded

3. Document Conversion Core Workflow

The complete conversion process includes the following steps:

// 1. Load Word document into VFS
await window.spire.FetchFileToVFS(inputFileName, '', `${process.env.PUBLIC_URL}/static/data/`);

// 2. Create Document instance and load the document
const doc = new wasmModule.Document();
doc.LoadFromFile(inputFileName);

// 3. Configure conversion parameters
let parameters = new wasmModule.ToPdfParameterList();
parameters.IsEmbeddedAllFonts = true;  // Embed all fonts for consistent display across devices

// 4. Execute conversion and save
const outputFileName = 'ToPDF.pdf';
doc.SaveToFile({ fileName: outputFileName, paramList: parameters });

// 5. Read the generated file
const modifiedFileArray = window.dotnetRuntime.Module.FS.readFile(outputFileName);
const modifiedFile = new Blob([modifiedFileArray], { type: 'application/pdf' });

4. File Download and Resource Cleanup

After generating the PDF, create a download link and clean up resources:

// Create download
const url = URL.createObjectURL(modifiedFile);
const a = document.createElement('a');
a.href = url;
a.download = outputFileName;
document.body.appendChild(a);
a.click();

// Clean up resources
document.body.removeChild(a);
URL.revokeObjectURL(url);
doc.Dispose();  // Release document object

Complete Component Example

Combining all the above steps gives us the complete React component:

import React, { useState, useEffect } from 'react';

function App() {
  const [wasmModule, setWasmModule] = useState(null);

  useEffect(() => {
    // WASM loading logic...
  }, []);

  const convertWordToPdf = async () => {
    // Conversion logic...
  };

  return (
    <div style={{ textAlign: 'center', height: '300px' }}>
      <h1>Convert Word to PDF Using JavaScript in React</h1>
      <button onClick={convertWordToPdf} disabled={!wasmModule}>
        Generate
      </button>
    </div>
  );
}

export default App;

Performance Optimization Recommendations

Font caching : Cache commonly used fonts in IndexedDB to avoid repeated loading
Progress indicators : Use loading animations or progress bars for large file conversions to improve user experience
Error handling : Comprehensive try-catch blocks with user-friendly error messages
Memory management : Call Dispose() promptly after conversion to release resources

Common Issues and Solutions

Q: Converted PDF shows garbled Chinese text?
A: Ensure the corresponding Chinese font files are loaded and set IsEmbeddedAllFonts = true in the conversion parameters.

Q: WASM module fails to load?
A: Check that spire.doc.js and spire.doc.wasm exist in the public directory and that the path configuration is correct.

Q: Browser freezes when converting large files?
A: Use Web Workers to offload the conversion task to a background thread.

Summary

With Spire.Doc for JavaScript, we can achieve professional-grade Word to PDF conversion entirely in a front-end environment. The solution provided in this article is not only concise in code but also includes best practices for font management, error handling, and resource cleanup, ready for production deployment.

This client-side conversion approach is particularly suitable for:

Enterprise applications that need to protect data privacy
Offline-first web applications
Scenarios where reducing server load is desired

We hope this article helps you successfully implement document conversion functionality in your projects. If you have any questions or suggestions, feel free to discuss in the comments!

Merging Multiple Word Documents into a Single PDF with C#

jelizaveta — Tue, 28 Jul 2026 01:10:10 +0000

Merging multiple Word documents into a single PDF file makes it convenient for distribution, printing, or archiving. This article introduces how to use the Spire.Doc for .NET library to easily merge all Word documents in a specified folder and export them to PDF with just a few lines of concise C# code.

As a professional .NET Word component, Spire.Doc for .NET allows developers to efficiently create, edit, convert, and print Word documents without installing Microsoft Office, offering excellent stability and scalability.

Preparation: Install Spire.Doc

First, install the Spire.Doc library in your .NET project. It is recommended to install it via the NuGet Package Manager for quick and convenient setup.

You can search for Spire.Doc in Visual Studio's "Manage NuGet Packages" and install it, or execute the following command in the "Package Manager Console":

PM> Install-Package Spire.Doc

Code Implementation: Merging and Conversion

The core logic is straightforward: create a new Document object to hold the final merged content; read all Word files in the folder; load the first document as the base; then loop through and insert the remaining documents; and finally save the result as a PDF.

Here is the complete code example:

using System.IO;
using System.Linq;
using Spire.Doc;

namespace MergeWordFolder
{
    class Program
    {
        static void Main(string[] args)
        {
            // 1. Create the target document container
            Document mergedDocument = new Document();

            // 2. Get all Word documents in the specified folder
            string folderPath = @"Documents"; // Replace with your folder path
            string[] files = Directory.GetFiles(folderPath, "*.docx")
                                      .OrderBy(f => f)
                                      .ToArray();

            // Check if there are any files
            if (files.Length == 0)
            {
                Console.WriteLine("No .docx files found in the folder.");
                return;
            }

            // 3. Load the first document as the base
            mergedDocument.LoadFromFile(files[0], FileFormat.Docx);

            // 4. Insert the remaining documents sequentially
            for (int i = 1; i < files.Length; i++)
            {
                // The InsertTextFromFile method appends the entire content of a document to the end of the current document
                mergedDocument.InsertTextFromFile(files[i], FileFormat.Docx);
            }

            // 5. Save the merged document as PDF
            mergedDocument.SaveToFile("MergedDocument.pdf", FileFormat.PDF);

            Console.WriteLine("Merge complete! MergedDocument.pdf has been generated.");
        }
    }
}

Code Breakdown

Create the document object : Document mergedDocument = new Document(); instantiates a blank Word document object that will serve as the final container for all merged content.
Get the file list : Directory.GetFiles(folderPath, "*.docx") retrieves all files with the .docx extension in the specified path. .OrderBy(f => f) ensures files are merged in alphabetical order by name, preventing order confusion. You can adjust the sorting logic as needed.
Load and insert :
- mergedDocument.LoadFromFile(files[0], FileFormat.Docx): Loads the first Word document into the blank container we created.
- mergedDocument.InsertTextFromFile(files[i], FileFormat.Docx): This is a highly efficient method. In the loop, it inserts the entire content of each subsequent Word document (including text, images, tables, headers, footers, etc.) directly to the end of mergedDocument.
Save as PDF : mergedDocument.SaveToFile("MergedDocument.pdf", FileFormat.PDF) is the final and most critical step. It outputs the merged Document object directly as a PDF file, achieving a one-stop operation from "merging" to "conversion."

Summary and Extensions

With the simple code above, we successfully avoid the tedious process of manually opening, copying, pasting, and then saving as PDF. The Spire.Doc library is highly efficient in handling such document merging tasks.

Beyond merging .docx files, this method offers strong extensibility. For example, if you need to merge .doc files, simply modify the search pattern in Directory.GetFiles and specify the corresponding FileFormat in the LoadFromFile and InsertTextFromFile methods.

Mastering PDF Splitting in Python: From Single Pages to Custom Range Extraction

jelizaveta — Thu, 23 Jul 2026 01:27:34 +0000

Have you ever encountered this scenario: you receive a PDF report that's hundreds of pages long, try to forward it to a colleague, but the email attachment exceeds the size limit and gets rejected? Or you only need a specific chapter but have to manually extract it page by page from hundreds of pages? These "bulky" files always cause headaches when sharing, printing, or archiving. The solution is actually quite simple—just split the PDF into multiple smaller files on demand, and the problem is solved.

This article will walk you through how to use the Spire.PDF for Python library to implement two core splitting modes with minimal code: one-click splitting into single-page PDFs and flexible splitting by custom page ranges .

Prerequisites: Environment Setup and Library Import

Spire.PDF for Python is a professional PDF manipulation component that runs completely independently of external programs like Adobe Acrobat, making it ideal for integration into servers or automated scripts.

Installation command:

pip install Spire.PDF

After installation, import the necessary modules at the top of your code file to get started.

Mode 1: Splitting Every Page into Individual Single-Page PDFs

If your business requirement is to save each page of a dozens-of-pages-long contract, bid document, or eBook as a separate PDF file, the Split() method is the most convenient choice.

from spire.pdf.common import *
from spire.pdf import *

# 1. Initialize and load the source PDF document
doc = PdfDocument()
doc.LoadFromFile("Sample.pdf")

# 2. Split: save each page as an independent single-page PDF
# {0} is a page number placeholder; the second parameter 1 specifies numbering starts from 1
doc.Split("Output/SplitDocument-{0}.pdf", 1)

# 3. Release resources
doc.Close()

Method explanation:

The full signature of the Split() method is Split(string fileName, int startNumber), and its function is to fixedly split every page of the PDF into an independent single-page PDF file —this behavior cannot be changed via parameters.

The two parameters mean the following:

fileName : The output file path and naming template. The {0} inside is a placeholder that will be automatically replaced with the actual page number when saving.
startNumber : Specifies the starting number for the {0} placeholder. It only affects the numbering in the file name and has no relation to the splitting logic .

Mode 2: On-Demand Splitting by Selecting Page Ranges

Sometimes we don't need to split every page but rather want to divide a PDF into logical parts. For example: Part 1 (cover) , Part 2 (main text, chapters 1-3) , Part 3 (appendix) .

In this case, we can create multiple PdfDocument objects and use the InsertPageRange() method to precisely extract specific pages from the source document.

from spire.pdf.common import *
from spire.pdf import *

# Load the source document
doc = PdfDocument()
doc.LoadFromFile("Sample.pdf")

# Create three blank PDF objects to hold the split content
newDoc_1 = PdfDocument()
newDoc_2 = PdfDocument()
newDoc_3 = PdfDocument()

# 1. Extract page 1 (cover)
# Note: page indices start from 0, so page 1 corresponds to index 0
newDoc_1.InsertPage(doc, 0)

# 2. Extract pages 2 to 4 (beginning of the main text)
# InsertPageRange parameters: (source_document, start_index, end_index)
newDoc_2.InsertPageRange(doc, 1, 3)

# 3. Extract pages 5 to the last page (the remainder)
# doc.Pages.Count gets the total page count; subtract 1 to get the last page's index
newDoc_3.InsertPageRange(doc, 4, doc.Pages.Count - 1)

# Save the three split documents separately
newDoc_1.SaveToFile("Output1/Split-1.pdf")
newDoc_2.SaveToFile("Output1/Split-2.pdf")
newDoc_3.SaveToFile("Output1/Split-3.pdf")

# Close all document objects to release memory
doc.Close()
newDoc_1.Close()
newDoc_2.Close()
newDoc_3.Close()

Page index rules (very important):

In Spire.PDF, page numbering follows the common programming convention of starting from 0 . That is, doc.Pages[0] represents the first page of the PDF. Understanding this is crucial for accurately extracting ranges:

InsertPage(doc, 0): Inserts page 1.
InsertPageRange(doc, 1, 3): Inserts pages 2 through 4 (inclusive).
InsertPageRange(doc, 4, doc.Pages.Count - 1): Starts from page 5 all the way to the physical last page.

The advantage of this splitting approach is its extreme flexibility—you can combine pages according to any rules, or even extract pages from different source files and merge them into a new PDF (using the cross-document capability of InsertPage).

Extension: Splitting by Fixed Page Groups

It's worth noting that the Split() method cannot fulfill the requirement of "merging every N pages into one PDF" (e.g., merging every 2 pages into a single file). If you need such grouped splitting, you must use InsertPageRange with a loop to implement it manually:

# Example: merge every 2 pages into one PDF
group_size = 2
for i in range(0, doc.Pages.Count, group_size):
    new_doc = PdfDocument()
    end_index = min(i + group_size - 1, doc.Pages.Count - 1)
    new_doc.InsertPageRange(doc, i, end_index)
    new_doc.SaveToFile(f"Output/Group-{i // group_size + 1}.pdf")
    new_doc.Close()

This code splits and saves the source document in groups of 2 pages each; if the last group has fewer than 2 pages, it saves the actual number of pages.

Recommendation for Choosing Between the Two Modes

Scenario	Recommended Method
Need to split every page into separate single-page PDFs	`Split()` for the simplest code
Need to split by chapters, workgroups, or custom ranges	`InsertPage()`/`InsertPageRange()`
Need to split by fixed page groups (e.g., merge every 3 pages into one file)	Loop + `InsertPageRange()`

Conclusion

As demonstrated by the above examples, with Spire.PDF for Python we can accomplish complex PDF splitting tasks with just over a dozen lines of core code. Whether it's batch processing archived files or integrating document management functionality into a system, this solution can significantly save development time.

We hope this article helps you efficiently solve PDF splitting challenges! If you encounter other issues in practice, feel free to explore them further.

How to Convert Excel to Markdown and Back in C#

jelizaveta — Tue, 21 Jul 2026 01:10:59 +0000

Excel is a powerful tool for data analysis and management, but its proprietary formats (such as XLS and XLSX) often face compatibility issues when shared across platforms. Markdown, as a lightweight markup language, is widely used in technical documentation, README files, and blog posts due to its simplicity and readability. If we could convert data from Excel into Markdown tables embedded in documents, or extract table data from Markdown into Excel for analysis, it would undoubtedly greatly improve work efficiency.

This article introduces how to use Spire.XLS for .NET—a powerful Excel manipulation library—to easily achieve bidirectional conversion between Excel and Markdown in C#.

About Spire.XLS for .NET

Spire.XLS for .NET is a professional Excel .NET API that enables developers to create, read, write, convert, and print Excel files in various .NET applications such as C#, VB.NET, ASP.NET, and .NET Core. Most conveniently, it is completely independent and does not require Microsoft Excel or Office to be installed.

Environment Preparation

The easiest way to install Spire.XLS is via NuGet:

Install-Package Spire.XLS

1. Excel to Markdown

Converting an Excel file to Markdown format requires very concise core code—just four steps: create a Workbook object, load the Excel file, call the SaveToMarkdown() method to save, and dispose of resources.

using Spire.Xls;

namespace ConvertExcelToMarkdown
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Workbook workbook = new Workbook();
            // Supports loading .xls or .xlsx formats
            workbook.LoadFromFile("input.xlsx");
            // Save as a Markdown file
            workbook.SaveToMarkdown("output.md");
            workbook.Dispose();
        }
    }
}

The SaveToMarkdown() method converts each non‑empty worksheet in the workbook into a separate Markdown table, and prepends the worksheet name as a heading before each table. With just a few lines of code, you can embed structured data into technical documentation or blog posts.

2. Markdown to Excel

The reverse conversion is equally simple. Spire.XLS provides the LoadFromMarkdown() method, which can directly load a Markdown file and parse it into an Excel workbook structure.

using Spire.Xls;

namespace MarkdownToExcel
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Workbook workbook = new Workbook();
            // Load a Markdown file
            workbook.LoadFromMarkdown("input.md");
            // Optional: fit worksheet content to one page
            workbook.ConverterSetting.SheetFitToPage = true;
            // Export to Excel 2016 format
            workbook.SaveToFile("output.xlsx", ExcelVersion.Version2016);
            workbook.Dispose();
        }
    }
}

The LoadFromMarkdown() method parses the Markdown content (including text and tables) and converts it into an Excel workbook structure. The SaveToFile() method then exports it as a standard Excel file. This is very useful for scenarios where you need to extract table data from Markdown for further analysis or processing.

3. Advanced Configuration

When converting Excel to Markdown, you can customize export options. For example, you can set whether images are saved using relative paths, whether hyperlinks are formatted as Markdown reference‑style links, and more:

MarkdownOptions options = new MarkdownOptions();
options.SavePicInRelativePath = true;
options.SaveHyperlinkAsRef = true;
workbook.SaveToMarkdown("output.md", options);

Conclusion

With Spire.XLS for .NET, C# developers can implement bidirectional conversion between Excel and Markdown with minimal code. Whether you need to quickly publish Excel data as technical documentation or extract table data from Markdown into Excel for analysis, this library provides a concise and efficient solution. Its independence from Office installation and support for multiple .NET frameworks make it ideal for integration into various .NET applications.

If you are looking for a lightweight way to bridge the data channel between Excel and Markdown, give Spire.XLS for .NET a try.

Implementing Online Word Document Editing in React with Spire.WordJS

jelizaveta — Fri, 17 Jul 2026 01:25:16 +0000

Amid the wave of digital transformation, more and more enterprises and developers are moving document processing capabilities to pure front-end architectures to improve application responsiveness, security, and usability. Traditional Word document editing often relies on local Office software or complex back-end services. However, with the maturation of web technologies, creating, editing, and exporting Word documents directly in the browser has become a reality.

This article introduces Spire.WordJS, a powerful front-end document editing control, and walks you through integrating it into a React project to quickly build a fully functional online Word document editor.

What is Spire.WordJS?

Spire.WordJS is a pure front-end online Word document editor component from E-ICEBLUE. Built on WebAssembly technology, it requires no installation of Microsoft Office and no back-end dependencies , enabling a complete document processing workflow—from opening and editing to exporting—entirely within the browser.

As a core component of the Spire.OfficeJS suite, Spire.WordJS covers viewing, editing, creating, and converting capabilities for Word, Excel, PowerPoint, PDF, and other formats.

Key Features

1. Visual Editing for Team Efficiency

Real-time display of editor cursors and comments, along with built-in comment resolution workflows, makes team collaboration more efficient.

2. High-Fidelity Word Compatibility

Using a mature parsing engine, it preserves the original document’s layout, styles, tables, headers, footers, and footnotes to the greatest extent possible, ensuring documents open without the need for additional manual adjustments.

3. Advanced Formatting Editor

Offers rich style settings, including headings, body text, quotes, and support for custom style templates, enabling one-click application of corporate templates.

4. Enterprise-Grade Security and Permission Management

Supports role‑based access control, allowing users to be assigned read‑only, edit, or comment permissions; also supports static file encryption storage.

5. Intelligent Document Annotation and Markup

Supports highlighting, underlining, strikethrough, comments, and tag management, making it easy for teams to mark key content during review or proofreading.

6. Rich Table and Graphic Editing

Allows insertion and editing of tables, images, and graphical objects, with adjustable sizes, styles, and layouts.

7. Cross-Platform Access and Cloud Storage

Supports both web and desktop access, enabling cloud storage and synchronization of documents.

Why Choose Spire.WordJS?

Enterprise‑grade Compatibility – Highly compatible with Microsoft Office, maximizing the preservation of document formatting and styles.
No Installation, Ready to Use – Pure web experience, supporting all major browsers.
Extensible APIs and Integration Capabilities – Provides comprehensive REST APIs and SDKs for easy integration into existing systems.
High Availability and Security Compliance – Supports multi‑region deployment and automated backup strategies.
Flexible Solutions and Customization – Offers various licensing and usage plans with on‑demand customization.

Integrating Spire.WordJS in React

Now, let’s go step by step through integrating Spire.WordJS into a React project.

Step 1: Install Node.js

First, download and install Node.js. After installation, verify the versions in the command line:

node -v
npm -v

Step 2: Create a React Project with Vite

Run the following command in your desired directory to create the project:

npm create vite@latest my-officejs-app -- --template react

Step 3: Install Dependencies

Navigate to the project directory and install the routing library:

cd my-officejs-app
npm install react-router-dom

Step 4: Integrate Spire.OfficeJS

Download the Spire.OfficeJS product package.

Windows environment : Double‑click to run the run_genallfonts.bat file inside the extracted package.

Linux environment : Run sh run_genallfonts.sh start.

After execution, a fontsweb folder will appear inside the web directory.

Inside the React project’s public folder, create a new folder named spire.cloud and copy the entire web folder (including fontsweb) into it.

Step 5: Build the File Upload and Editor Pages

App.jsx – Routing and State Management

import { createContext, useContext, useState } from 'react';
import { createBrowserRouter, RouterProvider } from 'react-router-dom';
import Home from './Home';
import Editor from './Editor';

const FileContext = createContext();
export const useFileStore = () => useContext(FileContext);

function FileProvider({ children }) {
  const [file, setFile] = useState(null);
  const [fileUint8Data, setFileUint8Data] = useState(null);
  return (
    <FileContext.Provider value={{ file, setFile, fileUint8Data, setFileUint8Data }}>
      {children}
    </FileContext.Provider>
  );
}

const router = createBrowserRouter([
  { path: '/', element: <Home /> },
  { path: '/editor', element: <Editor /> },
]);

function App() {
  return (
    <FileProvider>
      <RouterProvider router={router} />
    </FileProvider>
  );
}

export default App;

Home.jsx – File Upload Functionality

Implements drag‑and‑drop upload, local file selection, and conversion of the file to Uint8Array using FileReader:

import { useRef, useEffect } from 'react';
import { useFileStore } from './App';
import { useNavigate } from 'react-router-dom';

function Home() {
  const { setFile, setFileUint8Data } = useFileStore();
  const navigate = useNavigate();
  const fileInput = useRef();

  useEffect(() => {
    // Prevent default drag‑and‑drop behavior
    ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(eventName => {
      document.addEventListener(eventName, preventDefaults, false);
    });
    document.addEventListener('drop', handleDrop, false);
  }, []);

  const preventDefaults = (e) => {
    e.preventDefault();
    e.stopPropagation();
  };

  const handleDrop = async (e) => {
    const file = e.dataTransfer?.files[0];
    if (!file) return;
    const uint8Data = await readFileAsUint8Array(file);
    setFile(file);
    setFileUint8Data(uint8Data);
    navigate('/editor');
  };

  const readFileAsUint8Array = (file) => {
    return new Promise((resolve, reject) => {
      const reader = new FileReader();
      reader.onload = () => {
        const arrayBuffer = reader.result;
        resolve(new Uint8Array(arrayBuffer));
      };
      reader.onerror = reject;
      reader.readAsArrayBuffer(file);
    });
  };

  return (
    <div>
      <h2>File Upload</h2>
      <p>Drag and drop a file into the browser or</p>
      <input type="file" ref={fileInput} onChange={handleDrop} />
    </div>
  );
}

export default Home;

Note : FileReader is used to read local files, and Uint8Array is the binary format expected by OfficeJS’s WebAssembly.

Editor.jsx – Integrating the Editor

import { useRef, useEffect } from 'react';
import { useFileStore } from './App';
import { useNavigate } from 'react-router-dom';

function Editor() {
  const { file, fileUint8Data } = useFileStore();
  const navigate = useNavigate();
  const config = useRef({});
  const originUrl = window.location.origin;

  useEffect(() => {
    if (!file) {
      navigate('/');
      return;
    }
    loadScript();
  }, []);

  const loadScript = () => {
    const script = document.createElement('script');
    script.setAttribute('src', '/spire.cloud/web/editors/spireapi/SpireCloudEditor.js');
    script.onload = initEditor;
    document.head.appendChild(script);
  };

  const initEditor = () => {
    initConfig();
    const editor = new SpireCloudEditor.OpenApi('iframeEditor', config.value);
    window.Api = editor.GetOpenApi();
  };

  const initConfig = () => {
    config.value = {
      fileAttrs: {
        fileInfo: {
          name: file.name,
          ext: getFileExtension(),
          primary: String(new Date().getTime()),
          creator: 'User',
          createTime: new Date().toLocaleString()
        },
        sourceUrl: originUrl + '/files/' + file.name,
        createUrl: originUrl + '/open',
        mergeFolderUrl: '',
        fileChoiceUrl: '',
        templates: {}
      },
      user: {
        id: 'uid-1',
        name: 'User',
        canSave: true
      },
      editorAttrs: {
        editorMode: 'edit',
        editorWidth: '100%',
        editorHeight: '100%',
        editorType: 'document',
        platform: 'desktop',
        viewLanguage: 'zh',
        isReadOnly: false,
        canChat: true,
        canComment: true,
        canReview: true,
        canDownload: true,
        canEdit: true,
        canForcesave: true,
        embedded: {
          saveUrl: '',
          embedUrl: '',
          shareUrl: '',
          toolbarDocked: 'top'
        },
        useWebAssemblyDoc: true,
        useWebAssemblyExcel: true,
        useWebAssemblyPpt: true,
        spireDocJsLicense: '',
        spireXlsJsLicense: '',
        spirePresentationJsLicense: '',
        spirePdfJsLicense: '',
        serverless: {
          useServerless: true,
          baseUrl: originUrl,
          fileData: fileUint8Data
        },
        events: {
          onSave: onFileSave
        },
        plugins: {
          pluginsData: []
        }
      }
    };
  };

  const getFileExtension = () => {
    const filename = file.name.split(/[\\/]/).pop();
    return filename.substring(filename.lastIndexOf('.') + 1).toLowerCase() || '';
  };

  const onFileSave = (data) => {
    console.log('Save data:', data);
    // Implement save logic here: send to server or download file, etc.
  };

  return <div id="iframeEditor"></div>;
}

export default Editor;

Configuration notes :

editorType: Set to "document" for a Word document editor.
viewLanguage: Can be "zh" or "en".
useWebAssemblyDoc: Enables WebAssembly for better performance.
serverless: Serverless mode uses file data directly without a back‑end server.

main.jsx – Entry Configuration

import { StrictMode } from 'react';
import { createRoot } from 'react-dom/client';
import App from './App.jsx';

createRoot(document.getElementById('root')).render(<App />);

Note : StrictMode causes the editor to render twice; it is recommended to disable it in production.

vite.config.js – Port Configuration

import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';

export default defineConfig({
  server: {
    host: '0.0.0.0',
    port: 8050
  },
  plugins: [react()]
});

Step 6: Run the Project

npm run dev

Visit http://localhost:8050 to experience the online Word document editing functionality.

Conclusion

Through the steps above, we have successfully integrated Spire.WordJS into a React project and built a fully functional online Word document editor. The entire process requires no installation of Microsoft Office and no complex back‑end services .

With its high‑fidelity compatibility, rich editing features, enterprise‑grade security controls, and flexible integration capabilities , Spire.WordJS provides developers with a lightweight, efficient, and easy‑to‑integrate document processing solution. Whether you are building an online document platform, knowledge base, educational platform, or various management back‑ends, Spire.WordJS helps you quickly implement document editing capabilities.

Retrieving and Replacing Fonts in Word Documents with Python

jelizaveta — Wed, 15 Jul 2026 01:24:53 +0000

Font management is a recurring challenge when working with Word documents. Whether you need to audit which fonts are used across a file or consistently replace one font with another, manual handling is not only time‑consuming but also error‑prone. By using the Spire.Doc for Python library, you can programmatically inspect and selectively modify font information inside Word documents with just a few lines of code, greatly streamlining the process. This article walks through two concrete examples, explaining the underlying principles and practical tips in detail.

1. Why Choose Spire.Doc for Python

Spire.Doc for Python is a professional‑grade library for Word document manipulation that requires no Microsoft Office installation. It lets you create, modify, convert, and extract content entirely within Python. Its object model closely mirrors Word’s internal structure: a Documentcontains multipleSectionobjects; eachSectionhas aBody; each BodyholdsParagraphelements; and each paragraph consists of child objects such asTextRange, images, and tables. Font attributes—name (FontName), size (FontSize), color (TextColor), and more—are stored in the CharacterFormatproperty of eachTextRange. This hierarchical design provides a clear and logical path for traversing and updating font settings.

2. Scenario 1: Extracting All Font Information from a Document

The first example scans an entire Word document, extracts the font name, size, and color for every text fragment, deduplicates the results, and writes them to a text file. This is especially useful for document consistency reviews and font compliance audits.

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

# Helper to write a list of strings to a text file
def WriteAllText(fname:str, text:List[str]):
    fp = open(fname, "w", encoding="utf-8")
    for s in text:
        fp.write(s)


# Custom class to represent a font identity (name + size)
class FontInfo:
    def __init__(self):
        self._m_name = ''
        self._m_size = None

    def __eq__(self, other):
        if isinstance(other, FontInfo):
            return self._m_name == other.get_name() and self._m_size == other.get_size()
        return False

    def get_name(self):
        return self._m_name

    def set_name(self, value):
        self._m_name = value

    def get_size(self):
        return self._m_size

    def set_size(self, value):
        self._m_size = value


# Prepare variables
fontInformations = ""
font_infos = []

# Load the document
document = Document()
document.LoadFromFile("/sample.docx")

# Iterate over sections, paragraphs, and child objects
for i in range(document.Sections.Count):
    section = document.Sections.get_Item(i)

    for j in range(section.Body.Paragraphs.Count):
        paragraph = section.Body.Paragraphs.get_Item(j)

        for k in range(paragraph.ChildObjects.Count):
            obj = paragraph.ChildObjects.get_Item(k)

            # Only process text ranges
            if isinstance(obj, TextRange):
                txtRange = obj if isinstance(obj, TextRange) else None

                fontName = txtRange.CharacterFormat.FontName
                fontSize = txtRange.CharacterFormat.FontSize
                textColor = txtRange.CharacterFormat.TextColor.Name

                # Deduplicate by name+size (color is not a distinguishing factor for the font itself)
                fontInfo = FontInfo()
                fontInfo.set_name(fontName)
                fontInfo.set_size(fontSize)
                if fontInfo not in font_infos:
                    font_infos.append(fontInfo)                  
                    line = "Font name: {0:s}, Size: {1:f}, Color: {2:s}".format(
                        fontInfo.get_name(), fontInfo.get_size(), textColor
                    )
                    fontInformations += line + '\r'

# Save the results
WriteAllText("/retrieved_fonts.txt", fontInformations)
document.Dispose()

Key Implementation Steps

Load and initialise – document.LoadFromFile("/sample.docx").
Three‑level traversal – loop through Sections, then Paragraphs, then ChildObjects.
Filter for text ranges – use isinstance(obj, TextRange) to isolate elements that carry font formatting.
Extract attributes – from txtRange.CharacterFormat, read FontName (string), FontSize (float, in points), and TextColor.Name (colour name).
Custom deduplication – the FontInfo class overrides __eq__ to treat a combination of name and size as unique. Only new entries are appended to the output string.
Write to file – the WriteAllText helper saves the accumulated string.

Design Considerations

Why deduplicate by name and size only? Colour is not an inherent font property; the same font can appear in multiple colours. Including colour would inflate the results unnecessarily. This approach focuses on the font’s core identity.
Error handling – though not shown, it is wise to guard against FontSize being None (e.g., with WordArt or special styles).
Performance – the nested loops are efficient for typical documents. For files with tables or text boxes, you would need to extend the traversal to those containers as well.

A sample output might look like:

Font name: SimSun, Size: 12.000000, Color: Black
Font name: Arial, Size: 10.500000, Color: Red
...

3. Scenario 2: Targeted Replacement of a Specific Font

The second example is more focused: it replaces every occurrence of “FangSong” (Imitation Song) with “LiSu” (Clerical Script) throughout the document. This is a common task when unifying brand styles or adapting to local typographic conventions.

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

document = Document()
document.LoadFromFile("/sample.docx")

for i in range(document.Sections.Count):
    section = document.Sections.get_Item(i)

    for j in range(section.Body.Paragraphs.Count):
        paragraph = section.Body.Paragraphs.get_Item(j)

        for k in range(paragraph.ChildObjects.Count):
            obj = paragraph.ChildObjects.get_Item(k)

            if isinstance(obj, TextRange):
                txtRange = obj if isinstance(obj, TextRange) else None
                fontName = txtRange.CharacterFormat.FontName

                if fontName == "FangSong":
                    txtRange.CharacterFormat.FontName = "LiSu"

document.SaveToFile("/replaced_font.docx", FileFormat.Docx)
document.Dispose()

How It Works

Traverse the document in the same three‑level manner.
Identify each TextRange and retrieve its current font name.
Conditional replacement – if the font name equals "FangSong", assign "LiSu" to FontName.
Save the modified document under a new name.

Extensions and Precautions

Partial replacement – if you only want to replace fonts in certain paragraphs or styles, add extra filters (e.g., by paragraph style or section) inside the loop.
Font availability – the target font (“LiSu”) must be installed on the system or embedded in the document; otherwise, Word will substitute a fallback. For production use, prefer common fonts like “SimSun” or “Times New Roman”, or embed the fonts beforehand.
Format retention – replacing the font does not affect other formatting such as bold, italic, or colour, because the CharacterFormat properties are independent.

4. Comparison and Combined Workflow

Aspect	Retrieving Fonts	Replacing Fonts
Primary goal	Auditing and analysis	Standardisation and conversion
Data flow	Document → external text file	Document → new document
Implementation complexity	Requires custom deduplication logic	Simple conditional update
Performance overhead	List membership checks (can be optimised with a set)	Negligible

These two scripts complement each other. You can run the retrieval first to get an overview of current font usage, decide which fonts to replace, and then apply the replacement. For finer control—say, replacing only a specific font at a certain size—you can merge the logic and check both FontName and FontSize during replacement.

5. Optimisation and Best Practices

Use a set for deduplication – if you don’t need colour, you can store (fontName, fontSize) tuples in a set, eliminating the custom class.
Add exception handling – wrap LoadFromFile and SaveToFile in try...except blocks to handle file permission or format issues gracefully.
Batch processing – encapsulate the core logic in a function and call it for a list of file paths.
Dispose of resources – always call document.Dispose(), especially when processing many documents in a loop, to avoid memory leaks.

6. Conclusion

With Spire.Doc for Python, we have built two essential font‑management tools in under a hundred lines of code. The library’s clear object model and straightforward API make it an excellent fit for automated workflows. Whether you are checking font compliance in financial reports or updating templates across a large corpus, this approach significantly reduces manual effort and improves accuracy. Readers are encouraged to extend the code to handle additional scenarios—such as table cells, headers, footers, or specific paragraph styles—to build even more powerful document governance solutions. Ultimately, the value of these techniques lies in solving real‑world problems, and the combination of Python and Spire.Doc delivers that promise effectively.

C# Generating Word Documents from Templates: Replacing Text and Image Placeholders

jelizaveta — Thu, 09 Jul 2026 09:58:13 +0000

In office automation development, one of the most common requirements is to batch-generate Word documents (such as contracts, reports, resumes, notices, etc.) from fixed templates. This article demonstrates how to use the Spire.Doc for .NET component to load a template file, replace text placeholders with real data, support replacing placeholders with images, and ultimately produce a complete Word document.

Why Choose Spire.Doc?

Spire.Doc is a powerful .NET Word component that allows you to create, read, edit, and convert Word documents without installing Microsoft Office. It provides a rich set of APIs – especially the Document.Replace() method for fast text substitution, and in combination with FindString() and DocPicture, it flexibly enables image insertion, making it ideal for template‑filling scenarios.

Implementation Steps

The following complete console application example demonstrates how to replace placeholders like #name# and #gender# with actual content, and replace #photo# with an image.

1. Import Namespaces and Initialize the Document

using Spire.Doc;
using Spire.Doc.Documents;
using Spire.Doc.Fields;
using System.Drawing;

Create a Document object and load the template file (.docx):

Document document = new Document();
document.LoadFromFile("Template.docx");

2. Text Placeholder Replacement

Build a dictionary where keys are placeholders (e.g., #name#) and values are the actual data. Here we localize the sample content to an English context:

Dictionary<string, string> replaceDict = new Dictionary<string, string>
{
    { "#name#", "Zhang San" },
    { "#gender#", "Male" },
    { "#birthdate#", "January 15, 1990" },
    { "#address#", "Pudong New Area, Shanghai" },
    { "#city#", "Shanghai" },
    { "#state#", "Municipality" },
    { "#postal#", "200120" },
    { "#country#", "China" }
};

Iterate through the dictionary and call document.Replace(placeholder, replacement, true, true) to perform a full‑document replacement. The two Boolean parameters specify whether to match case and whole words, respectively; set them as needed.

3. Image Placeholder Replacement

Text replacement cannot handle images, so we need a separate method ReplaceTextWithImage. Its core logic is:

Load the image with Image.FromFile();
Create a DocPicture object and load the image into it;
Locate the #photo# placeholder using document.FindString(), obtaining the TextRange;
Retrieve the index of that TextRange within its paragraph’s child objects, insert the picture at the same position, and then remove the placeholder text.

static void ReplaceTextWithImage(Document document, string stringToReplace, string imagePath)
{
    Image image = Image.FromFile(imagePath);
    DocPicture pic = new DocPicture(document);
    pic.LoadImage(image);

    TextSelection selection = document.FindString(stringToReplace, false, true);
    TextRange range = selection.GetAsOneRange();
    int index = range.OwnerParagraph.ChildObjects.IndexOf(range);

    range.OwnerParagraph.ChildObjects.Insert(index, pic);
    range.OwnerParagraph.ChildObjects.Remove(range);
}

Call it with the image path:

ReplaceTextWithImage(document, "#photo#", "portrait.png");

4. Save and Release

Finally, save the document as a new file and release resources:

document.SaveToFile("ReplacePlaceholders.docx", FileFormat.Docx);
document.Dispose();

Complete Code

using Spire.Doc;
using Spire.Doc.Documents;
using Spire.Doc.Fields;
using System.Drawing;

namespace CreateWordByReplacingTextPlaceholders
{
    class Program
    {
        static void Main(string[] args)
        {
            Document document = new Document();
            document.LoadFromFile("Template.docx");

            Dictionary<string, string> replaceDict = new Dictionary<string, string>
            {
                { "#name#", "Zhang San" },
                { "#gender#", "Male" },
                { "#birthdate#", "January 15, 1990" },
                { "#address#", "Pudong New Area, Shanghai" },
                { "#city#", "Shanghai" },
                { "#state#", "Municipality" },
                { "#postal#", "200120" },
                { "#country#", "China" }
            };

            foreach (var kvp in replaceDict)
            {
                document.Replace(kvp.Key, kvp.Value, true, true);
            }

            ReplaceTextWithImage(document, "#photo#", "portrait.png");

            document.SaveToFile("ReplacePlaceholders.docx", FileFormat.Docx);
            document.Dispose();
        }

        static void ReplaceTextWithImage(Document document, string stringToReplace, string imagePath)
        {
            Image image = Image.FromFile(imagePath);
            DocPicture pic = new DocPicture(document);
            pic.LoadImage(image);

            TextSelection selection = document.FindString(stringToReplace, false, true);
            TextRange range = selection.GetAsOneRange();
            int index = range.OwnerParagraph.ChildObjects.IndexOf(range);

            range.OwnerParagraph.ChildObjects.Insert(index, pic);
            range.OwnerParagraph.ChildObjects.Remove(range);
        }
    }
}

Notes and Extensions

Template Design : In the Word template, placeholders must exactly match the strings in the code (including case and special symbols). It is recommended to use obvious markers like # or {{}} to avoid unintended replacements.
Image Handling : The ReplaceTextWithImage method assumes that the placeholder exists independently within a paragraph. If the placeholder shares a line with other text, inserting an image may affect layout; you can adjust the insertion position according to your business logic.
Performance Optimization : For bulk document generation, you may reuse the Document object or work with memory streams.
Fonts and Styles : After text replacement, the new content inherits the style of the original placeholder. If custom styling is needed, you can manipulate the CharacterFormat property of the TextRange.

Summary

With the concise APIs provided by Spire.Doc, we have implemented data population for Word templates in just a few dozen lines of code, supporting both text and images. This approach greatly improves the efficiency and accuracy of document generation, making it well‑suited for enterprise‑level reporting, certificate printing, bulk correspondence, and more. Developers only need to focus on template design and data sources; the rest is handled by the code.

If you are looking for a lightweight, Office‑independent solution for Word manipulation, Spire.Doc is certainly worth trying. We hope this article helps you get started quickly and adds automated document generation capabilities to your projects.