DEV Community: Jeremy K.

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.

Merging Excel Files with Python: Preserve All Formatting & Formulas

Jeremy K. — Tue, 24 Mar 2026 02:29:35 +0000

If you work with Excel files daily, you know how tedious it is to combine dozens of scattered spreadsheets. Weekly store sales reports, departmental expense details, and other structured data—manually copying and pasting rows is time-consuming, error-prone, and downright frustrating for files with merged cells or complex formulas.

Previously, I relied on pandas for Excel merging, but it lacks robust support for native Excel formatting. Formulas break, styles disappear, and merged cells are often lost in the process. Then I discovered Free Spire.XLS for Python: a free library that perfectly preserves Excel’s original formatting, formulas, merged cells, and layouts. In this guide, I’ll share two efficient, production-ready methods to merge Excel files automatically.

Solution Overview

Free Spire.XLS for Python is a standalone Python library for reading and writing Excel files—no Microsoft Excel installation required. The free edition handles most daily merging tasks, and we’ll cover two widely used workflows:

Independent Worksheet Mode: Import every worksheet from each source file as a separate tab in the final workbook. Ideal for tracking data by its original file source.
Data Append Mode: Combine all source data into a single worksheet. Perfect for aggregating identical structured datasets (e.g., monthly sales reports).

Environment Setup

Ensure you have Python 3.7 or later installed, then install the library via pip:

pip install Spire.Xls.Free

Important Limitation: For .xls files, the free version restricts processing to 5 worksheets per file and 200 rows per worksheet.

Mode 1: One File = One Worksheet Set

This mode retains the full original structure of each file, with separate worksheets for easy source identification. Use it for reports from different departments, regions, or teams.

Full Code

import os
from spire.xls import *

# Path to the folder containing Excel files to merge
input_folder = './sample_files'
# Output path for the merged workbook
output_file = 'merged_workbook.xlsx'

merged_workbook = None

# Iterate through all files in the target folder
for filename in os.listdir(input_folder):
    # Filter for Excel file formats only
    if filename.endswith(('.xlsx', '.xls')):
        file_path = os.path.join(input_folder, filename)

        # Load the source Excel file
        source_workbook = Workbook()
        source_workbook.LoadFromFile(file_path)

        # Use the first file as the base workbook
        if merged_workbook is None:
            merged_workbook = source_workbook
        # Copy all worksheets from subsequent files to the merged workbook
        else:
            for i in range(source_workbook.Worksheets.Count):
                worksheet = source_workbook.Worksheets.get_Item(i)
                merged_workbook.Worksheets.AddCopy(worksheet, WorksheetCopyType.CopyAll)

# Save the final merged workbook
merged_workbook.SaveToFile(output_file, ExcelVersion.Version2016)

Key Details

The first file acts as a template to preserve its original worksheet order.
AddCopy(..., CopyAll) duplicates everything: cell styles, merged cells, charts, and formulas.
Worksheet names auto-format to FileName_WorksheetName to prevent duplicates (customize the naming logic if needed).

Mode 2: All Data Combined into One Worksheet

This mode aggregates identically structured Excel files into a single master sheet (e.g., consolidating monthly transaction data). By default, we keep the header row from the first file and append only data rows from all other files.

Full Code

import os
from spire.xls import *

# Path to the folder with source Excel files
input_folder = './excel_worksheets'
# Output path for the consolidated file
output_file = 'merged_into_one_sheet.xlsx'

# Create a blank workbook for merging
merged_workbook = Workbook()
merged_sheet = merged_workbook.Worksheets[0]

# Track the next row to write data (Excel rows start at 1)
current_row = 1

# Process all Excel files in the folder
for filename in os.listdir(input_folder):
    if filename.endswith(('.xlsx', '.xls')):
        file_path = os.path.join(input_folder, filename)

        # Load and read the source file
        workbook = Workbook()
        workbook.LoadFromFile(file_path)
        worksheet = workbook.Worksheets[0]

        # Copy the used cell range to the merged sheet
        source_range = worksheet.Range
        target_range = merged_sheet.Range[current_row, 1]
        source_range.Copy(target_range)

        # Update row position for the next dataset
        current_row += worksheet.LastRow

# Save the consolidated workbook
merged_workbook.SaveToFile(output_file, ExcelVersion.Version2016)

Critical Notes

Range.Copy() preserves cell values and formulas while maintaining formatting.
current_row ensures seamless, non-overlapping data appending.
Header Fix: The code above copies headers for all files. To keep only one header, replace the data range for subsequent files with:

  source_range = worksheet.Range[2, 1]  # Start copying from row 2 (skip header)

Final Thoughts

These two Python solutions automate Excel merging without needing Microsoft Excel, eliminating manual errors and saving hours of repetitive work. The Free Spire.XLS library’s native Excel support makes it far more reliable than pandas for formatting-sensitive tasks. Adapt the code to your workflow and integrate it into your daily data processing routine.

Copying Word Document Content in C#

Jeremy K. — Tue, 17 Mar 2026 03:33:50 +0000

In daily office work or enterprise-level document processing, we often need to copy content from Word documents — for example, merging core chapters from multiple documents, extracting specified paragraphs or tables, and backing up key parts of a document. Manual copying is not only inefficient but also prone to formatting loss. Automating the copy process via code ensures complete formatting retention and supports batch processing, greatly improving work efficiency.

This article uses the free library Free Spire.Doc for .NET to detail how to copy Word content in C#, covering common scenarios including copying an entire document, copying specified paragraphs, and copying content from a specified section. The library does not require Microsoft Office to be installed and provides a simple and easy-to-use API.

Installation Command (NuGet Package Manager Console):

Install-Package FreeSpire.Doc

1. Basic Scenario: Copy the Entire Word Document

This is the most direct scenario, such as copying all content (text, images, tables, formatting, etc.) from a source document completely into a new or existing document. The Clone() method can be used to achieve a deep copy.

using System;
using Spire.Doc;

namespace CopyWholeWordContent
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                // 1. Load the source document
                Document sourceDoc = new Document();
                sourceDoc.LoadFromFile(@"C:\Users\Administrator\Desktop\SourceDocument.docx");

                // 2. Clone the source document (create an independent copy)
                Document targetDoc = sourceDoc.Clone();

                // 3. Save the target document
                targetDoc.SaveToFile("CopiedFullDocumentContent.docx", FileFormat.Docx);

                // Release resources
                sourceDoc.Close();
                targetDoc.Close();

                Console.WriteLine("Full document content copied successfully!");
                // Optional: Open the generated document to view the result
                System.Diagnostics.Process.Start("CopiedFullDocumentContent.docx");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Copy failed: {ex.Message}");
            }
        }
    }
}

Key Notes:

The Clone() method fully copies all content and formatting of the document to create an independent new document. Modifications to the copy will not affect the source document.
try-catch exception handling is added to catch common issues such as invalid file paths, insufficient permissions, and corrupted documents, enhancing program robustness.
The Close() method releases resources promptly to avoid file locking.

2. Advanced Scenario: Copy Specified Paragraph

Sometimes we only need to extract certain paragraphs (such as abstracts or conclusions) from a document and append them to the end of another document. The following code shows how to extract a paragraph at a specified index from the source document, preserve its full formatting (font, size, color, etc.), and add it to the last section of the target document.

using System;
using Spire.Doc;
using Spire.Doc.Documents;

namespace CopySpecificParagraphs
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                // 1. Load the source document
                Document sourceDoc = new Document();
                sourceDoc.LoadFromFile(@"C:\Users\Administrator\Desktop\source.docx");

                // 2. Extract the paragraph at the specified index from the source document (zero-based index; here the 9th paragraph)
                Paragraph para = sourceDoc.Sections[0].Paragraphs[8];

                // 3. Load the target document (existing document)
                Document targetDoc = new Document();
                targetDoc.LoadFromFile(@"C:\Users\Administrator\Desktop\target.docx");

                // 4. Get the last section of the target document (add the paragraph to the end of this section)
                Section lastSection = targetDoc.LastSection;

                // 5. Clone and add the specified paragraph (Clone() creates an independent copy)
                lastSection.Paragraphs.Add((Paragraph)para.Clone());

                // 6. Save the target document
                targetDoc.SaveToFile("CopyParagraphs.docx", FileFormat.Docx2016);

                // 7. Release resources
                sourceDoc.Dispose();
                targetDoc.Dispose();

                Console.WriteLine("Specified paragraph copied successfully!");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Copy failed: {ex.Message}");
            }
        }
    }
}

Key Notes:

Index Note: Sections and paragraphs in a Word document use zero-based indexing. Sections[0] represents the first section, and Paragraphs[8] represents the 9th paragraph in that section. Adjust the index according to your actual document.
Insertion Position: Use LastSection to get the last section of the target document and append the paragraph to the end of the document. To insert at a specified position, use Sections[index] to locate the target section.
Clone() Method: The core method that creates an independent copy of the paragraph, preventing subsequent changes to the source document from affecting the copied content.
Exception handling covers common errors such as index out of range and file not found.

3. Advanced Scenario: Copy a Specified Section

When you need to copy an entire section (including all elements such as paragraphs, tables, images, etc.) to the target document, you can achieve fine-grained control by iterating through the child objects of the section. This method is more flexible than copying the entire section directly and allows you to skip certain elements as needed.

using System;
using Spire.Doc;
using Spire.Doc.Documents;

namespace CopySpecificSection
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                // 1. Load the source document
                Document sourceDoc = new Document();
                sourceDoc.LoadFromFile(@"C:\Users\Administrator\Desktop\source.docx");

                // 2. Extract the specified section from the source document (example: extract the 1st section, index 0)
                Section sourceSection = sourceDoc.Sections[0];

                // 3. Load the target document
                Document targetDoc = new Document();
                targetDoc.LoadFromFile(@"C:\Users\Administrator\Desktop\target.docx");

                // 4. Get the last section of the target document (add content to the end of this section)
                Section lastSection = targetDoc.LastSection;

                // 5. Iterate through all child objects in the source section body (paragraphs, tables, images, etc.), clone and add them to the target section
                foreach (DocumentObject obj in sourceSection.Body.ChildObjects)
                {
                    lastSection.Body.ChildObjects.Add(obj.Clone());
                }

                // 6. Save the document and release resources
                targetDoc.SaveToFile("CopySection.docx", FileFormat.Docx2019);
                sourceDoc.Dispose();
                targetDoc.Dispose();

                Console.WriteLine("Specified section content copied successfully!");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Copy failed: {ex.Message}");
            }
        }
    }
}

Code Explanation:

sourceSection.Body.ChildObjects: The Body property of a section contains all visible content of that section (paragraphs, tables, images, etc.), and the ChildObjects collection provides access to these elements.
Loop & Clone: Each child object is cloned and added to the ChildObjects collection of the target section, preserving the format and content of each element completely.
Exception handling ensures program stability.

4. Summary and Notes

Using the three methods above, you can flexibly handle various Word document copying tasks without manual operations, greatly improving processing efficiency. Please note the following points:

File Paths: Replace the file paths in the code with your actual paths. Absolute paths are recommended, or ensure relative paths are correct.
Index Out of Range: When extracting specified paragraphs or sections, make sure the index is within a valid range to avoid exceptions.
Resource Release: Call Dispose() or Close() in time after operations to release resources and avoid file locking.
Format Preservation: The Clone() method is key to retaining the original format. Do not directly reference the original object.
Batch Processing: The above code can be slightly modified to loop through multiple documents for batch copying.

Java: Convert Excel to HTML (Complete Guide with Examples)

Jeremy K. — Tue, 10 Mar 2026 02:11:55 +0000

Introduction

In modern web application development, presenting Excel-based reports as web-accessible content is a common requirement—whether for real-time online preview, system embedding, or cross-platform sharing. This guide provides a streamlined, production-ready approach to converting Excel files (.xls/.xlsx) to HTML in Java using Free Spire.XLS for Java (a free, lightweight library). No Microsoft Office installation is required, and the solution supports core use cases like full workbook conversion, targeted worksheet export, and inline image embedding—with clean, maintainable code.

Environment Setup

1. Add Dependencies (Maven)

Integrate the library into your Maven project by adding the following repository and dependency to your pom.xml:

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

<dependency>
    <groupId>e-iceblue</groupId>
    <artifactId>spire.xls.free</artifactId>
    <version>16.3.1</version>
    <scope>compile</scope>
</dependency>

Basic Conversion: Full Workbook to HTML

This method converts an entire Excel workbook to HTML while preserving critical formatting (cell styles, merged cells, images, and multiple worksheets).

Code Implementation

import com.spire.xls.FileFormat;
import com.spire.xls.Workbook;

public class FullWorkbookToHtml {
    public static void main(String[] args) {
        // Initialize workbook and load Excel file
        Workbook workbook = new Workbook();
        try {
            workbook.loadFromFile("sample.xlsx");

            // Save entire workbook as HTML
            workbook.saveToFile("output/full_workbook.html", FileFormat.HTML);
            System.out.println("Full workbook converted to HTML successfully!");
        } catch (Exception e) {
            // Basic error handling for file operations
            e.printStackTrace();
        }
    }
}

Key Notes

The generated HTML includes tab navigation for switching between worksheets (visible at the bottom of the browser).
Supports both legacy .xls and modern .xlsx file formats.
Added basic exception handling to catch file I/O errors (best practice for production code).

Advanced Conversion: Targeted Worksheet + Inline Images

For use cases where only a specific worksheet (e.g., "Sales Report") needs to be exported—and images should be embedded directly in the HTML (no external links)—use the HTMLOptions class to configure inline image embedding (base64 encoding).

Code Implementation

import com.spire.xls.Workbook;
import com.spire.xls.Worksheet;
import com.spire.xls.core.spreadsheet.HTMLOptions;

public class SingleSheetToHtmlWithImages {
    public static void main(String[] args) {
        Workbook workbook = new Workbook();
        try {
            // Load the target Excel file
            workbook.loadFromFile("product.xlsx");

            // Select the first worksheet (0-indexed)
            Worksheet targetSheet = workbook.getWorksheets().get(0);

            // Configure HTML options for inline images
            HTMLOptions htmlOptions = new HTMLOptions();
            htmlOptions.setImageEmbedded(true); // Encode images to base64 and embed in HTML

            // Export the selected worksheet to HTML
            targetSheet.saveToHtml("output/single_sheet.html", htmlOptions);
            System.out.println("Single worksheet converted with inline images!");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Key Benefits

setImageEmbedded(true) encodes images to base64 and embeds them directly in the HTML—no external image files to manage or share.
The 0-indexed worksheet selection aligns with Java’s standard collection indexing (clearer for developers).

Troubleshooting Common Issues

1. Font Rendering Issues

The generated HTML relies on the browser’s font parsing and the host system’s installed fonts.

Fix: On Linux servers (a common deployment environment), install core fonts (e.g., fonts-dejavu, fonts-liberation) via the package manager (e.g., apt install fonts-dejavu for Debian/Ubuntu).
Best Practice: Use web-safe fonts (e.g., Arial, Calibri) in your Excel templates to ensure consistency.

2. Missing Images in HTML

Verify setImageEmbedded(true) is enabled (critical for inline images).
Check that Excel images are embedded objects (not linked to external files—linked images cannot be embedded).
Ensure the Excel file path is correct (avoid relative path issues in production).

3. Large HTML File Sizes (High Data Volume)

Preprocess: Filter or truncate unnecessary data in Excel before conversion (e.g., remove empty rows/columns).

Summary

This guide provides production-ready Java solutions for Excel-to-HTML conversion using Free Spire.XLS for Java:

No Office Dependency: The library works independently of Microsoft Office, making it ideal for server-side deployment.
Flexible Conversion: Support for full workbooks or targeted worksheets, with inline image embedding for self-contained HTML files.
Production-Ready: Added error handling and troubleshooting tips to avoid common pitfalls in real-world use.

Limitation Note: The free version of Spire.XLS for Java has a worksheet limit, which is sufficient for most small-to-medium scale use cases.

Extract Text from PDF Files Using C#

Jeremy K. — Mon, 02 Mar 2026 08:24:03 +0000

Extracting text from PDF files is a common and critical requirement in daily office workflows and software development. Manual copy-pasting is not only time-intensive but also wildly inefficient when scaling to large document volumes. Traditional automation approaches often rely on external components like Adobe Reader: these solutions are cumbersome to deploy, and they fail entirely when handling encrypted PDFs.

This guide walks you through using Free Spire.PDF for .NET—a free, standalone library—to extract text from PDFs with high accuracy and reliability, no PDF reader installation required. We’ll start with a comparison of extraction methods, then cover environment setup, core implementation code, advanced techniques, and provide fully runnable examples to get you up and running fast.

PDF Text Extraction: Solution Comparison

Comparison Metric	Traditional Methods	Free Spire.PDF for .NET
Dependency Requirements	Requires third-party software (e.g., Adobe Reader)	Fully self-contained kernel with zero external dependencies
Encrypted PDF Support	Cannot process password-protected PDFs	Natively supports encrypted PDFs (user/owner password)
Development Complexity	Requires COM component integration (verbose code ★★★★☆)	Clean, intuitive pure .NET APIs (minimal code ★★☆)
Documentation & Support	Disjointed, incomplete official documentation	Comprehensive, well-structured API documentation

Step-by-Step Guide: Extract PDF Text in 3 Simple Steps

1. Environment Setup

First, create a .NET Console Application (compatible with .NET Framework 4.6.1+ or .NET Core 3.1+). Install the Free Spire.PDF library via NuGet—this is the only dependency you’ll need.

Open the Package Manager Console in Visual Studio and run:

Install-Package FreeSpire.PDF

Important Note: The free version has a page limit (max 10 pages per PDF), making it ideal for personal use or small-scale projects.

2. Core Code: Extract Text from a Single PDF Page

The code below loads a PDF, extracts text from a specific page, and saves the output to a TXT file.

using System.IO;
using Spire.Pdf;
using Spire.Pdf.Texts;

namespace PdfTextExtraction
{
    class Program
    {
        static void Main(string[] args)
        {
            // Initialize PDF document object
            PdfDocument pdfDoc = new PdfDocument();

            // Load target PDF file (replace with your file path)
            pdfDoc.LoadFromFile("Sample.pdf");

            // Get the 2nd page (0-indexed Pages collection)
            PdfPageBase targetPage = pdfDoc.Pages[1];

            // Create text extractor for the target page
            PdfTextExtractor textExtractor = new PdfTextExtractor(targetPage);

            // Configure extraction options (extract all text on the page)
            PdfTextExtractOptions extractOptions = new PdfTextExtractOptions
            {
                IsExtractAllText = true // Extract full page text (disable for partial extraction)
            };

            // Execute text extraction
            string extractedText = textExtractor.ExtractText(extractOptions);

            // Save extracted text to a TXT file
            File.WriteAllText("Extracted_Page_Text.txt", extractedText);

            // Clean up resources (critical for memory management)
            pdfDoc.Close();
        }
    }
}

Key Component Explanations

PdfTextExtractor: Binds to a specific PDF page and handles text extraction logic.
PdfTextExtractOptions: Defines extraction scope (e.g., full page, rectangular region).
ExtractText(): Executes extraction and returns the page’s text as a string (core method).

3. Advanced Extraction Techniques

1. Process Password-Protected PDFs

To load an encrypted PDF, pass the password (user or owner password) directly to the LoadFromFile method:

// Load encrypted PDF with password
pdfDoc.LoadFromFile("EncryptedDocument.pdf", "your_password_here");

2. Extract Text from All PDF Pages

Iterate through all pages in the document and merge extracted text into a single file:

using System.Text;

// Initialize StringBuilder to store text from all pages
StringBuilder fullDocumentText = new StringBuilder();

// Loop through every page in the PDF
foreach (PdfPageBase page in pdfDoc.Pages)
{
    PdfTextExtractor pageExtractor = new PdfTextExtractor(page);
    PdfTextExtractOptions options = new PdfTextExtractOptions { IsExtractAllText = true };

    // Append text from current page (add line break for readability)
    fullDocumentText.AppendLine(pageExtractor.ExtractText(options));
}

// Save merged text to file
File.WriteAllText("Full_Document_Text.txt", fullDocumentText.ToString());

3. Extract Text from a Specific Rectangular Region

Target text in a defined area (units: points; 1 point = 1/72 inch) using ExtractArea:

PdfTextExtractOptions areaOptions = new PdfTextExtractOptions();
// Define region: Left = 50pt, Top = 100pt, Width = 400pt, Height = 300pt
areaOptions.ExtractArea = new System.Drawing.RectangleF(50, 100, 400, 300);

// Extract text from the defined area
string areaText = textExtractor.ExtractText(areaOptions);

Recommended Workflow Extensions

PDF text extraction is rarely the final step—integrate these features to build end-to-end data processing pipelines:

Styled Text Extraction: Use PdfTextFinder to locate text by style (font, color, size) for extracting titles, keywords, or highlighted content.
Table Data Extraction: Extract structured table data (as DataTable or 2D array) with PdfTableExtractor (avoids manual parsing of tabular text).
OCR for Scanned PDFs: Pair Free Spire.PDF with Spire.OCR to extract text from image-based (scanned) PDFs via Optical Character Recognition (OCR).

Summary

Free Spire.PDF for .NET eliminates the limitations of traditional PDF text extraction methods in the .NET ecosystem:

It is lightweight and dependency-free (no Adobe Reader or external tools required).
Its intuitive .NET APIs reduce development complexity and speed up implementation.
It supports advanced use cases (encrypted PDFs, region extraction, table parsing) to meet diverse business needs.

Whether you’re building small-scale automation tools or enterprise-grade document processing systems, Free Spire.PDF for .NET provides a reliable, cost-effective solution for PDF text extraction.

Converting PowerPoint (PPT/PPTX) to HTML in C#

Jeremy K. — Tue, 24 Feb 2026 07:09:08 +0000

Converting PowerPoint (PPT/PPTX) files to HTML is a common requirement in enterprise workflows, online course delivery, and similar use cases. HTML offers key advantages: cross-platform compatibility, no need for specialized software to open, and seamless integration into web pages. This guide walks you through a practical, reliable method to achieve this conversion using C# and the Free Spire.Presentation for .NET library.

Prerequisites

Free Spire.Presentation for .NET is a free, lightweight PowerPoint processing library that enables PPT file manipulation without dependencies on Microsoft Office or the PowerPoint client. Its core capabilities include reading, editing, and converting PowerPoint files to formats like HTML, PDF, and images.

Note: The free version has a page limit and is best suited for basic conversion needs in small-scale projects.

Installation Steps

We recommend installing the library via the NuGet Package Manager (the most straightforward method for C# projects):

Open Visual Studio and create a new C# project (e.g., Console App, ASP.NET Core Web App, or Windows Forms App);
Right-click your project in the Solution Explorer → select Manage NuGet Packages;
Navigate to the Browse tab, search for "FreeSpire.Presentation", and click Install; (Alternatively, run this command in the NuGet Package Manager Console):

Install-Package FreeSpire.Presentation

C# Code Examples: PPT to HTML Conversion

1. Basic Conversion (Single File)

This code converts a single PPT/PPTX file to HTML with full exception handling to ensure robustness and error visibility:

using System;
using Spire.Presentation;

namespace PptToHtmlConverter
{
    class Program
    {
        static void Main(string[] args)
        {
            // Define source PPT path and target HTML path
            string pptFilePath = @"D:\Demo.pptx";
            string htmlFilePath = @"D:\output.html";

            try
            {
                // 1. Create a Presentation instance and load the PPT file
                using (Presentation presentation = new Presentation())
                {
                    presentation.LoadFromFile(pptFilePath);

                    // 2. Convert to HTML (core method)
                    // FileFormat.Html specifies the output format as HTML
                    presentation.SaveToFile(htmlFilePath, FileFormat.Html);
                }

                Console.WriteLine("PPT converted to HTML successfully! Output path: " + htmlFilePath);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Conversion failed: " + ex.Message);
            }
        }
    }
}

Key Code Explanation

Presentation: The core class of Free Spire.Presentation that encapsulates all content of a PPT document (slides, text, images, shapes, etc.);
LoadFromFile(): Loads a local PowerPoint file (supports both .ppt and .pptx formats);
SaveToFile(): Saves the PPT to a specified format—FileFormat.Html is the critical enum value for HTML conversion;
using statement: Automatically disposes of the Presentation instance to prevent memory leaks (critical for long-running applications).

2. Convert a Specific Slide to HTML

In real-world scenarios, you may only need to convert one slide (not the entire presentation). Use the Slides collection to target and convert individual slides:

using System;
using Spire.Presentation;

namespace ConvertPowerPointSlideToHtml
{
    class Program
    {
        static void Main(string[] args)
        {
            // Source PPT path and target HTML path
            string pptFilePath = @"D:\Demo.pptx";
            string htmlFilePath = @"D:\slide.html";

            try
            {
                // Use 'using' to auto-dispose resources and avoid memory leaks
                using (Presentation presentation = new Presentation())
                {
                    // Load the PPT file
                    presentation.LoadFromFile(pptFilePath);

                    // Get the target slide (indexes start at 0: [0] = 1st slide, [1] = 2nd slide, etc.)
                    ISlide targetSlide = presentation.Slides[0];

                    // Save the specific slide to HTML
                    targetSlide.SaveToFile(htmlFilePath, FileFormat.Html);

                    Console.WriteLine("Specific slide converted to HTML successfully! Output path: " + htmlFilePath);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Conversion failed: " + ex.Message);
            }
        }
    }
}

Key Code Explanation

Slides[]: A zero-indexed collection of all slides in the presentation (e.g., Slides[0] = 1st slide, Slides[2] = 3rd slide);
ISlide: An interface representing a single slide, containing all slide-specific content (text, images, shapes, etc.);
targetSlide.SaveToFile(): Converts only the selected slide (not the full presentation)—ideal for on-demand conversion use cases (e.g., displaying a single slide in a web app).

3. Batch Convert PowerPoint Files to HTML

To convert all PPT/PPTX files in a directory (batch processing), use the following extended code:

using System;
using System.IO;
using System.Linq;
using Spire.Presentation;

namespace PptToHtmlConverter
{
    class BatchConverter
    {
        static void Main(string[] args)
        {
            // Source PPT directory and target HTML directory
            string pptDirectory = @"D:\PPTs";
            string htmlDirectory = @"D:\HTMLs";

            // Create target directory if it doesn't exist
            if (!Directory.Exists(htmlDirectory))
            {
                Directory.CreateDirectory(htmlDirectory);
            }

            // Get all PPT/PPTX files in the source directory (top-level only)
            string[] pptFiles = Directory.GetFiles(pptDirectory, "*", SearchOption.TopDirectoryOnly)
                                         .Where(f => f.EndsWith(".ppt", StringComparison.OrdinalIgnoreCase) 
                                                  || f.EndsWith(".pptx", StringComparison.OrdinalIgnoreCase))
                                         .ToArray();

            foreach (string pptFile in pptFiles)
            {
                try
                {
                    // Generate target HTML filename (same as the PPT file)
                    string fileName = Path.GetFileNameWithoutExtension(pptFile);
                    string htmlFile = Path.Combine(htmlDirectory, $"{fileName}.html");

                    using (Presentation presentation = new Presentation())
                    {
                        presentation.LoadFromFile(pptFile);
                        presentation.SaveToFile(htmlFile, FileFormat.Html);
                    }

                    Console.WriteLine($"Converted successfully: {pptFile} → {htmlFile}");
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Failed to convert {pptFile}: {ex.Message}");
                }
            }

            Console.WriteLine("Batch conversion completed!");
        }
    }
}

Key Code

StringComparison.OrdinalIgnoreCase: Makes file extension checks case-insensitive (handles .PPT, .Pptx, etc.);
Directory.CreateDirectory: Ensures the target folder exists (prevents "directory not found" errors);
Path.Combine: Safely constructs file paths (avoids issues with slashes/backslashes across Windows/macOS/Linux).

Summary

This guide provides a lightweight, production-ready solution for converting PowerPoint to HTML in C#. The core workflow is:

Load the PPT file using the Presentation class;
Convert to HTML via SaveToFile() with FileFormat.Html (for full presentations) or ISlide.SaveToFile() (for individual slides);
Add exception handling and resource disposal (via using statements) for robustness.

Developers can choose this solution or other alternatives (such as Aspose.Slides, OpenXML combined with third-party HTML conversion tools) according to the project requirements.

Deleting Blank Rows and Columns in Excel via Python

Jeremy K. — Fri, 13 Feb 2026 02:41:18 +0000

Manually removing blank rows and columns from large Excel files is tedious and error‑prone. By combining Python with the Free Spire.XLS for Python library, you can automate this cleaning process in just a few lines of code. Unlike traditional approaches that loop through every cell, Free Spire.XLS offers the IsBlank property – a direct, efficient way to identify empty rows and columns.

1. Environment Setup

Free Spire.XLS for Python is a lightweight, standalone library that does not require Microsoft Excel to be installed. It supports both .xls and .xlsx formats.

Install it via pip:

pip install Spire.XLS.Free

Note: The free edition is limited to small workloads.

2. How to Delete Blank Rows & Columns

The following script loads an Excel file, deletes all completely blank rows and columns from the first worksheet, and saves the result.

from spire.xls import Workbook, ExcelVersion

# Load the workbook
workbook = Workbook()
workbook.LoadFromFile("Input.xlsx")

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

# Delete blank rows (iterate backwards)
for i in range(sheet.Rows.Length - 1, -1, -1):
    if sheet.Rows[i].IsBlank:
        sheet.DeleteRow(i + 1)      # Note: DeleteRow uses 1‑based index

# Delete blank columns (iterate backwards)
for j in range(sheet.Columns.Length - 1, -1, -1):
    if sheet.Columns[j].IsBlank:
        sheet.DeleteColumn(j + 1)   # DeleteColumn uses 1‑based index

# Save and clean up
workbook.SaveToFile("Cleaned.xlsx", ExcelVersion.Version2016)
workbook.Dispose()

Key points explained

sheet.Rows.Length / sheet.Columns.Length

Returns the total row/column count (including blanks) – used as the iteration boundary.
IsBlank property

Returns True only if every cell in the row/column is truly empty (no data, no formula, no space characters).
Reverse iteration

Deleting forward shifts indices; backward iteration prevents skipping rows/columns.
Index offset trap

Rows[i] is 0‑based, but DeleteRow(i+1) is 1‑based. Always add 1.
workbook.Dispose()

Releases unmanaged resources – especially important when processing many files.

3. Important Considerations

a. What `IsBlank` considers “blank”

✅ Cells with absolutely no content.
❌ Cells that contain:
- Space characters (" ")
- Empty strings ("") from formulas
- Null values (#NULL!, etc.) These are not blank according to IsBlank.

Workaround: To treat cells with only spaces as blank, strip whitespace:

if sheet.Rows[i].Cells[col_index].Text.strip() == "":
    # treat as blank

b. Processing multiple worksheets

Wrap the deletion logic in a loop to clean every sheet:

for sheet in workbook.Worksheets:
    # ... deletion code for rows and columns ...

c. Performance tip

IsBlank is highly optimized – it does not iterate through cells internally. Use it instead of manual cell‑by‑cell checks whenever possible.

4. Extended Usage Scenarios

4.1 Batch process all Excel files in a folder

Define a reusable function and apply it to every .xlsx / .xls file in a directory.

import os
from spire.xls import Workbook, ExcelVersion

def clean_excel_file(input_path, output_path):
    """Remove blank rows/columns from all worksheets in a file."""
    workbook = Workbook()
    workbook.LoadFromFile(input_path)

    for sheet in workbook.Worksheets:
        # Delete blank rows
        for i in range(sheet.Rows.Length - 1, -1, -1):
            if sheet.Rows[i].IsBlank:
                sheet.DeleteRow(i + 1)
        # Delete blank columns
        for j in range(sheet.Columns.Length - 1, -1, -1):
            if sheet.Columns[j].IsBlank:
                sheet.DeleteColumn(j + 1)

    workbook.SaveToFile(output_path, ExcelVersion.Version2016)
    workbook.Dispose()

def batch_clean_folder(folder_path):
    """Clean all Excel files in the given folder."""
    for filename in os.listdir(folder_path):
        if filename.endswith(('.xlsx', '.xls')):
            input_full = os.path.join(folder_path, filename)
            output_full = os.path.join(folder_path, f"cleaned_{filename}")
            clean_excel_file(input_full, output_full)
            print(f"Processed: {filename}")

# Example usage
batch_clean_folder("data")

4.2 Delete rows where a specific column is blank

Sometimes you only want to delete a row if a certain column (e.g., column A) is empty. Replace the blank‑row check with a targeted cell test:

# Inside the worksheet loop:
for i in range(sheet.Rows.Length - 1, -1, -1):
    # Column index 0 = column A
    cell_value = sheet.Rows[i].Cells[0].Text.strip()
    if cell_value == "":
        sheet.DeleteRow(i + 1)

You can easily adapt this to check multiple columns or use more complex conditions.

5. Summary

Free Spire.XLS for Python provides a clean, efficient way to delete empty rows and columns via the IsBlank property. Combined with reverse iteration, the code is robust and easy to maintain.

This approach is ideal for:

Automated data cleaning pipelines
Preprocessing reports before analysis
Archiving legacy Excel files without manual scrubbing

By extending the core logic with the batch and conditional deletion patterns above, you can handle a wide range of real‑world Excel cleaning tasks with minimal effort.

Convert TXT to PDF Using C#

Jeremy K. — Tue, 10 Feb 2026 02:04:34 +0000

In everyday development and office workflows, converting plain text (TXT) files to PDF is a common requirement. PDFs offer cross-platform compatibility, fixed formatting, and tamper resistance, while TXT files prioritize lightweight content storage. Converting between these formats balances content readability with document standardization and portability. This article walks through an efficient way to convert TXT to PDF using C# and a free .NET library.

I. Prerequisites

1. Core Library Overview

Free Spire.PDF for .NET is a robust free PDF manipulation library that supports essential PDF operations: creation, editing, merging, and conversion. The free edition has minor processing limits (e.g., a maximum page count per conversion), but it is fully adequate for standard TXT-to-PDF tasks.

2. Environment Setup

Development Environment: Visual Studio 2022+ or any .NET-compatible IDE.
Library Installation: Install FreeSpire.PDF via the NuGet Package Manager. Run this command in the Package Manager Console:

  Install-Package FreeSpire.PDF

II. Step-by-Step TXT-to-PDF Conversion

The conversion process follows these core steps:

Read the content of the TXT file
Create a PDF document and a blank page
Configure text font and styling
Define text layout rules
Render text to the PDF and save the file

Complete Code

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

namespace ConvertTextToPdf
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                // 1. Read TXT file content (UTF-8 encoding to avoid Chinese garbling)
                string txtFilePath = "Input.txt";
                string textContent = File.ReadAllText(txtFilePath, System.Text.Encoding.UTF8);

                // 2. Initialize PDF document and add a default A4 page
                PdfDocument pdfDocument = new PdfDocument();
                PdfPageBase pdfPage = pdfDocument.Pages.Add();

                // 3. Set font for text rendering (Helvetica, 11pt)
                PdfFont pdfFont = new PdfFont(PdfFontFamily.Helvetica, 11);

                // 4. Configure layout: auto-fit page + auto-paginate overflow content
                PdfTextLayout textLayout = new PdfTextLayout
                {
                    Break = PdfLayoutBreakType.FitPage,
                    Layout = PdfLayoutType.Paginate
                };

                // 5. Set text format: justified alignment + 20px line spacing
                PdfStringFormat textFormat = new PdfStringFormat
                {
                    Alignment = PdfTextAlignment.Justify,
                    LineSpacing = 20f
                };

                // 6. Create text widget with content, font, and color
                PdfTextWidget textWidget = new PdfTextWidget(textContent, pdfFont, PdfBrushes.Black)
                {
                    StringFormat = textFormat
                };

                // 7. Define render area (10px left/right margins, 25px top/5px bottom margins)
                RectangleF renderBounds = new RectangleF(
                    x: 10, y: 25,
                    width: pdfPage.Canvas.ClientSize.Width - 20,
                    height: pdfPage.Canvas.ClientSize.Height - 30
                );

                // 8. Render text to PDF page
                textWidget.Draw(pdfPage, renderBounds, textLayout);

                // 9. Save PDF and clean up resources
                pdfDocument.SaveToFile("TextToPdf.pdf", FileFormat.PDF);
                pdfDocument.Close();

                Console.WriteLine("TXT converted to PDF successfully!");
            }
            catch (IOException ex)
            {
                Console.WriteLine($"File operation error: {ex.Message}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Conversion failed: {ex.Message}");
            }
        }
    }
}

Key Code Explanations

TXT Content Reading

File.ReadAllText with explicit UTF-8 encoding prevents special character garbling caused by inconsistent system default encodings.
PDF Page Creation

PdfDocument.Pages.Add() adds an A4 page by default. To customize page size, use overloaded methods (e.g., PdfDocument.Pages.Add(PdfPageSize.A3)).
Text Style & Layout
- Font: PdfFont defines font family, size, and style (e.g., bold/italic).
- Layout: PdfLayoutType.Paginate automatically creates new pages when text exceeds the current page bounds.
- Format: PdfStringFormat controls alignment, line spacing, and other typographic settings for better readability.
- Render Area: RectangleF sets a margin-bound drawable area to improve document aesthetics.
Rendering & Saving

PdfTextWidget binds text content to styling rules and renders it to the PDF via the Draw() method. SaveToFile() finalizes and saves the PDF file.

This C# implementation converts TXT to PDF with minimal code, no dependencies on Microsoft Office or third-party CLI tools. It is ideal for integration into small-to-medium .NET projects to meet routine document format conversion needs.

Resize PDF Page Sizes in C#

Jeremy K. — Thu, 05 Feb 2026 03:41:20 +0000

Resizing PDF pages is a frequent requirement in document processing workflows. Common use cases include scaling A4 PDFs to fit A3 print media, creating narrow custom layouts for mobile viewing, and standardizing page dimensions across multi-source PDF files. This tutorial demonstrates how to change PDF page sizes programmatically with C# using the free .NET library - Free Spire.PDF for .NET.

I. Install the Free .NET Library

The NuGet Package Manager offers the most straightforward installation path:

In Visual Studio, right-click your project → select Manage NuGet Packages → search for Free Spire.PDF → complete the installation.
Alternatively, run this command in the NuGet Package Manager Console:

Install-Package FreeSpire.PDF

Note: Free Spire.PDF for .NET imposes a 10-page processing limit, making it ideal for small-to-medium PDF documents only.

II. Core Approach to Change PDF Page Sizes

This guide uses a "new PDF document + original page template rendering" strategy to adjust page sizes. Its key advantage is leveraging the OnePage setting of PdfTextLayout, which automatically scales content to fit the new page dimensions and eliminates content cropping or misalignment caused by direct page size modification.

PDF pages use points (pt) as the standard unit, with common conversions as follows:

1 inch = 72 points
A4 (210mm × 297mm) = 595.28 pt × 841.89 pt
A3 (297mm × 420mm) = 841.89 pt × 1190.55 pt

Free Spire.PDF simplifies unit conversion with the built-in PdfUnitConvertor class, supporting seamless translation between inches, millimeters, centimeters, and points.

Scenario 1: Convert PDF to Standard Preset Page Sizes (e.g., A1)

This method is designed for batch-resizing PDFs to industry-standard formats (A1–A4, Letter, Legal, etc.). Use the predefined PdfPageSize enumeration to set dimensions directly, no manual unit conversion required.

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

namespace ChangePageSizeToStandardPaperSize
{
    class Program
    {
        static void Main(string[] args)
        {            
            // 1. Load the source PDF document
            PdfDocument originPdf = new PdfDocument();
            originPdf.LoadFromFile("Sample.pdf"); // Replace with your source file path

            // 2. Initialize a new PDF for resized output
            PdfDocument newPdf = new PdfDocument();

            // 3. Iterate through all pages and resize individually
            foreach(PdfPageBase page in originPdf.Pages)
            { 
                // 3.1 Add an A1-sized page with zero margins
                PdfPageBase newPage = newPdf.Pages.Add(PdfPageSize.A1, new PdfMargins(0));

                // 3.2 Enable one-page fitting to scale content automatically
                PdfTextLayout layout = new PdfTextLayout();
                layout.Layout = PdfLayoutType.OnePage;

                // 3.3 Create a template from the original page and draw to the new page
                PdfTemplate template = page.CreateTemplate();
                template.Draw(newPage, new PointF(0, 0), layout);
            }

            // 4. Save the resized PDF
            newPdf.SaveToFile("Standard_Size.pdf");

            // 5. Release file resources
            originPdf.Close();
            newPdf.Close();
        }
    }
}

Code Breakdown:

PdfDocument: Separate instances for source and output files prevent accidental data loss from direct edits.
PdfPageSize.A1: Predefined constant for standard paper sizes, supporting A0–A4, Letter, Legal, and more.
PdfTextLayout: Setting Layout = PdfLayoutType.OnePage is critical—it dynamically scales original content to fit the new page perfectly.
PdfTemplate: Encapsulates the original page content as a reusable template, enabling clean, distortion-free rendering to the new dimensions.

Scenario 2: Set Custom Page Sizes to a PDF

Use this workflow for non-standard dimensions (e.g., 6.5 × 8.5 inches). The PdfUnitConvertor class automates inch-to-point conversion, removing manual calculation errors.

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

namespace ChangePageSizeToCustomPaperSize
{
    class Program
    {
        static void Main(string[] args)
        {
            // 1. Load the source PDF
            PdfDocument originPdf = new PdfDocument();
            originPdf.LoadFromFile("Sample.pdf"); // Replace with your file path

            // 2. Create a new PDF for custom-sized output
            PdfDocument newPdf = new PdfDocument();

            // 3. Initialize unit converter for inch-to-point translation
            PdfUnitConvertor unitCvtr = new PdfUnitConvertor();
            // 3.1 Convert custom dimensions to points
            float width = unitCvtr.ConvertUnits(6.5f, PdfGraphicsUnit.Inch, PdfGraphicsUnit.Point);
            float height = unitCvtr.ConvertUnits(8.5f, PdfGraphicsUnit.Inch, PdfGraphicsUnit.Point);
            // 3.2 Package custom size into a SizeF object
            SizeF customSize = new SizeF(width, height);

            // 4. Render each source page to a custom-sized new page
            foreach (PdfPageBase page in originPdf.Pages)
            {
                // 4.1 Add a custom-sized page with zero margins
                PdfPageBase newPage = newPdf.Pages.Add(customSize, new PdfMargins(0));

                // 4.2 Enable full-page content scaling
                PdfTextLayout layout = new PdfTextLayout();
                layout.Layout = PdfLayoutType.OnePage;

                // 4.3 Draw the original page template to the new page
                PdfTemplate template = page.CreateTemplate();
                template.Draw(newPage, new PointF(0, 0), layout);
            }

            // 5. Save the custom-sized PDF
            newPdf.SaveToFile("Custom_Size.pdf");

            // 6. Clean up resources
            originPdf.Close();
            newPdf.Close();
        }
    }
}

Code Breakdown:

PdfUnitConvertor: Built-in utility supporting conversions between Inch, Millimeter, Point, and Centimeter.
ConvertUnits: Accepts three parameters (value, source unit, target unit) to eliminate manual math and reduce human error.
SizeF: Wraps custom width/height values for direct use in Pages.Add, supporting any non-standard page dimension.

III. Key Considerations

Unit Consistency: Always use points for width/height values to avoid sizing discrepancies from mixed units.
Content Scaling: PdfLayoutType.OnePage maintains native aspect ratio during auto-scaling. For manual scaling control, combine with the ScaleTransform method.
Compatibility: Generated PDFs work with major readers (Adobe Acrobat, Chrome, Edge, etc.). Validate layout integrity for complex files with forms or annotations post-conversion.
Resource Management: Always call Close() on PdfDocument instances to release file locks and prevent save failures.

This code-only solution requires no external tools and integrates seamlessly into .NET document-processing systems. It delivers reliable, high-quality PDF resizing for small-to-medium workloads, balancing simplicity and performance for production use cases.

Setting Background Color and Images for Word in C#

Jeremy K. — Tue, 03 Feb 2026 03:27:43 +0000

In .NET development, automating Word document formatting is a frequent requirement, and customizing document backgrounds (color or image) is a foundational task to improve visual presentation. Free Spire.Doc for .NET is a free, lightweight component for Word document manipulation that eliminates dependencies on Microsoft Office, enabling developers to create, edit, and format Word files seamlessly.
This guide walks through how to use Free Spire.Doc to set background colors and images for Word documents in C#.

1. Environment Setup

Free Spire.Doc for .NET is easiest to install via the NuGet Package Manager:

Open Visual Studio and create a .NET project (e.g., Console App, ASP.NET Core, or Windows Forms).
Right-click the project > Manage NuGet Packages > Search for FreeSpire.Doc > Install the latest stable version.
Alternatively, install via the NuGet Package Manager Console:

Install-Package FreeSpire.Doc

2. Set a Solid Color Background for Word Documents

Free Spire.Doc exposes the Document.Background property to manage document backgrounds. To set a solid color:

Define the background type as Color via Background.Type.
Assign a specific color using Background.Color.

Complete Code Example

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

namespace WordBackgroundSetup
{
    class Program
    {
        static void Main(string[] args)
        {
            // Initialize a Document instance
            Document document = new Document();

            // Load an existing Word document (update the path to your file)
            document.LoadFromFile("Test.docx"); 

            // Configure background type as solid color
            document.Background.Type = BackgroundType.Color;

            // Set background color
            document.Background.Color = Color.AliceBlue; 

            // Save the modified document
            document.SaveToFile("SolidColorBackground.docx", FileFormat.Docx);

            // Clean up resources
            document.Close();
        }
    }
}

3. Set a Background Image for Word Documents

To use an image as the document background:

Set Background.Type to Picture.
Load and assign the image via the Background.Picture property.

Complete Code Example

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

namespace WordBackgroundSetup
{
    class Program
    {
        static void Main(string[] args)
        {
            // Wrap in try/catch to handle common file/image errors
            try
            {
                Document document = new Document();
                document.LoadFromFile("Test.docx");

                // Set background type to image
                document.Background.Type = BackgroundType.Picture;

                // Load and assign the background image (update path to your image)
                document.Background.Picture = Image.FromFile("background.jpg");

                // Save the document with image background
                document.SaveToFile("ImageBackground.docx", FileFormat.Docx);

                Console.WriteLine("Background image applied successfully!");
            }
            catch (FileNotFoundException ex)
            {
                Console.WriteLine($"Error: File not found - {ex.FileName}");
            }
            catch (ArgumentException ex)
            {
                Console.WriteLine($"Error: Invalid image format or path - {ex.Message}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Unexpected error: {ex.Message}");
            }
            finally
            {
                // Ensure resources are released
                document?.Close();
            }
        }
    }
}

Key Considerations

Supported Image Formats: JPG, PNG, BMP, and GIF are all compatible. For optimal results, use images sized to match the document page (A4: 210×297mm) to avoid stretching/distortion.
Display Behavior: Background images default to a tiled layout—stretch mode is not natively supported. To achieve a stretched effect, resize the image programmatically with System.Drawing before assigning it as the background.
Path Best Practices: Always use absolute file paths (e.g., C:\Documents\background.png) instead of relative paths to prevent file lookup failures (especially in web/applications with dynamic working directories).
Resource Management: Call document.Close() or wrap the Document instance in a using statement to release unmanaged resources (critical for long-running applications).

Summary

This guide demonstrates how to quickly customize Word document backgrounds in C# using Free Spire.Doc for .NET. While the free version has page limitations, it delivers full functionality for basic document formatting tasks—making it an ideal choice for small to medium-scale .NET projects. The component’s intuitive API eliminates the need for Microsoft Office installation, streamlining document automation workflows.

Convert Excel to TXT in Python

Jeremy K. — Fri, 30 Jan 2026 02:48:58 +0000

In data processing workflows, converting Excel files to plain text (TXT) format is a frequent and essential task. Manual copy-pasting—the traditional approach—is not only inefficient but also highly error-prone, especially with large datasets or incompatible formatting. This guide demonstrates how to implement fast, dependency-free Excel-to-TXT conversion using Spire.XLS for Python, boosting data processing efficiency and flexibility.

Installation Instructions

Full version: pip install spire.Xls

Free version: pip install spire.Xls.Free

Basic: Convert a Single Excel Worksheet to TXT

Below is a step-by-step guide to converting the first worksheet of an Excel file to a TXT file, with clear configuration for delimiters and encoding:

1. Load and Read the Excel File

Initialize a Workbook object to load your Excel file (supports .xlsx, .xls, and other common formats):

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

# Initialize Workbook and load the target Excel file
workbook = Workbook()
workbook.LoadFromFile("sample.xlsx")

2. Execute Conversion and Save the TXT File

Extract the target worksheet and save it as a TXT file with configurable delimiters and encoding:

# Select the first worksheet (0-indexed)
target_sheet = workbook.Worksheets[0]

# Save worksheet to TXT: (output path, delimiter, encoding)
target_sheet.SaveToFile("output.txt", "\t", Encoding.get_UTF8())

Key Parameters:

Delimiter (tab \t): Defines the separator for columnar data in the TXT file. Tabs (\t) are recommended for readability; commas work for CSV-compatible TXT.
Encoding (Encoding.get_UTF8()): Specifies the text file encoding. UTF-8 is mandatory for proper display of non-ASCII characters (e.g., Chinese, special symbols).

Advanced: Export Multiple Worksheets to Separate TXT Files

For Excel files with multiple worksheets, use the following reusable function to export each worksheet as a uniquely named TXT file (avoids overwriting and improves traceability):

from spire.xls import *
from spire.xls.common import *
import os  # Added for cross-platform path handling

def excel_sheets_to_txt(input_file: str, output_folder: str, delimiter: str = "\t") -> None:
    """
    Convert all worksheets in an Excel file to separate TXT files.

    Args:
        input_file: Path to the source Excel file (e.g., "data.xlsx")
        output_folder: Path to save TXT files (created if non-existent)
        delimiter: Separator for TXT columns (default: tab "\t")
    """
    # Create output folder if it doesn't exist
    os.makedirs(output_folder, exist_ok=True)

    # Initialize Workbook and load Excel file
    workbook = Workbook()
    workbook.LoadFromFile(input_file)

    # Iterate through all worksheets (0-indexed)
    for idx in range(workbook.Worksheets.Count):
        sheet = workbook.Worksheets[idx]

        # Generate unique filename (e.g., "sheet_1_SalesData.txt")
        output_filename = f"sheet_{idx+1}_{sheet.Name}.txt"
        output_path = os.path.join(output_folder, output_filename)

        # Save worksheet to TXT with UTF-8 encoding
        sheet.SaveToFile(output_path, delimiter, Encoding.get_UTF8())

# Example usage
excel_sheets_to_txt(input_file="multi_sheet_data.xlsx", output_folder="txt_outputs")

Integrating Excel-to-TXT Conversion into Automated Workflows

Excel-to-TXT conversion is more than a simple format change—it is a critical enabler for end-to-end data automation. With Spire.XLS for Python, you can seamlessly build these high-value use cases:

1. Automated Report Generation

Extract structured data from Excel templates to generate lightweight TXT report summaries. TXT files are ideal for:

Embedding in automated email notifications (small file size, universal compatibility)
Integrating with legacy systems that only support plain-text inputs

2. Data Cleaning & Preprocessing

Convert complex Excel files (with merged cells, formulas, or formatting) to standardized TXT files, which serve as a reliable input source for big data tools like:

Apache Spark/Hadoop (for distributed data processing)
SQL databases (via bulk import utilities)
Python data analysis libraries (Pandas, NumPy)

3. Configuration Management

Export system configurations, parameter tables, or lookup lists from Excel to TXT format for:

Direct reading by shell/Python scripts (no Excel parsing dependencies)
Version control (Git/SVN) – TXT files have minimal merge conflicts vs. binary Excel files
Cross-team collaboration (universal readability across OS and tools)

Key Takeaways

This guide provides a production-ready approach to convert Excel to TXT with Python:

The core workflow (load → select worksheet → save) is lightweight and scalable for small to large datasets.
The advanced function adds robustness (folder creation, unique filenames) for enterprise-level automation.
Integrating this conversion into workflows eliminates manual errors and unlocks seamless integration with data pipelines, reporting tools, and configuration management systems.

By adopting these methods, you can streamline data processing workflows and ensure consistent, reliable conversion of Excel data to universally compatible TXT format.

Convert Markdown to Word in Python

Jeremy K. — Mon, 26 Jan 2026 06:21:30 +0000

In today's technical documentation workflows, Markdown has emerged as the go-to format for developers and technical writers, owing to its streamlined syntax and seamless compatibility with version control systems. Yet, in enterprise settings, Word documents remain the gold standard for formal reports, client deliverables, and standardized documentation.

This article will walk you through how to quickly convert Markdown to Word using Free Spire.Doc for Python—a free, lightweight Python library for document processing. We’ll cover practical use cases including basic single-file conversion and batch processing, with step-by-step guidance that even beginners can follow with ease.

I. Tool Overview

Free Spire.Doc for Python is a free, standalone Python library designed for Word document manipulation. It eliminates the need for Microsoft Word installation, supporting full lifecycle operations for Word documents: creation, editing, formatting, and conversion.

A standout feature of this library is its built-in Markdown parsing engine, which enables efficient conversion of Markdown files to Doc/Docx formats. It fully supports common Markdown syntax elements, including:

Headings (Levels 1–6)
Ordered/unordered lists and nested lists
Text formatting (bold, italic, inline code)
Hyperlinks and images
Code blocks and blockquotes

II. Environment Setup

To get started, you need to configure your Python environment and install the library with two simple steps:

Install Python
Ensure you have Python 3.6 or a later version installed on your local machine. You can download the official installer from the Python website and follow the on-screen instructions to complete setup.
Install Free Spire.Doc for Python
Open your terminal or command prompt, then run the following pip command to install the library:

   pip install Spire.Doc.Free

III. Basic Conversion: Convert a Single Markdown File to Word

We’ll explore two common scenarios for single-file conversion, with reusable code snippets for each use case.

Scenario 1: Convert Markdown Text Directly to Word

Ideal for short Markdown content that does not require separate file storage. The core implementation code is provided below:

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

# 1. Define Markdown text with common syntax elements
markdown_text = """
# Level 1 Heading: Markdown to Word Conversion Test
## Level 2 Heading: Feature Demonstration
### Level 3 Heading: Basic Syntax Support

#### 1. Paragraphs and Text Formatting
This is a regular paragraph supporting **bold text**, *italic text*, `inline code snippets`, and [external hyperlinks](https://www.google.com/).

#### 2. List Elements
- Unordered list item 1
- Unordered list item 2
  - Nested sub-list item

1. Ordered list item 1
2. Ordered list item 2

"""

# 2. Write Markdown text to a temporary .md file
markdown_path = "input.md"
with open(markdown_path, 'w', encoding='utf-8') as f:
    f.write(markdown_text)

# 3. Initialize a Document object (core component for Word operations)
doc = Document()

# 4. Load the Markdown file with specified format
doc.LoadFromFile(markdown_path, FileFormat.Markdown)

# 5. Save the converted content as a Word document
output_path = "MarkdownToWord.docx"
doc.SaveToFile(output_path, FileFormat.Docx)

# 6. Release resources to prevent memory leaks
doc.Close()

print(f"Conversion successful! Word document saved to: {output_path}")

Scenario 2: Convert an Existing Markdown File to Word

Perfect for converting pre-saved .md files (e.g., test.md). The code is more concise as it skips the text-writing step:

from spire.doc import Document
from spire.doc import FileFormat

# 1. Initialize Document object
doc = Document()

# 2. Load the existing Markdown file
markdown_file_path = "test.md"
doc.LoadFromFile(markdown_file_path, FileFormat.Markdown)

# 3. Save as Word document (supports both .doc and .docx formats)
output_path = "MarkdownToWord.docx"
doc.SaveToFile(output_path, FileFormat.Docx)

# 4. Release resources
doc.Close()

print(f"File conversion completed! Path: {output_path}")

Key Code Explanations

To help you understand the underlying logic, here’s a breakdown of the core functions:

Document(): Creates an empty Word document object, serving as the foundation for all subsequent operations (loading, editing, saving).
LoadFromFile(file_path, FileFormat.Markdown): Loads and parses the target Markdown file. The second parameter explicitly specifies the input format to ensure accurate parsing.
SaveToFile(output_path, FileFormat): Exports the parsed content to a Word file. You can switch between FileFormat.Docx (modern format) and FileFormat.Doc (legacy format) as needed.
Close(): Releases memory occupied by the document object, a critical step to avoid resource leaks in long-running applications.

IV. Advanced Extension: Batch Convert Multiple Markdown Files

Free Spire.Doc for Python also supports batch processing, allowing you to convert all .md files in a folder to Word documents in one go. This is especially useful for processing large volumes of technical documentation.

import os
from spire.doc import Document
from spire.doc import FileFormat

# 1. Configure source and output directories
md_folder = "./markdown_files"  # Folder containing Markdown files
output_folder = "./word_files"  # Folder to store converted Word files

# 2. Create output folder if it does not exist
if not os.path.exists(output_folder):
    os.makedirs(output_folder)

# 3. Traverse the source folder and convert .md files one by one
for filename in os.listdir(md_folder):
    if filename.lower().endswith(".md"):  # Case-insensitive check for .md suffix
        # Construct full path for the Markdown file
        md_path = os.path.join(md_folder, filename)

        # Generate output filename (replace .md with .docx)
        output_filename = os.path.splitext(filename)[0] + ".docx"
        output_path = os.path.join(output_folder, output_filename)

        # 4. Execute conversion logic
        doc = Document()
        doc.LoadFromFile(md_path, FileFormat.Markdown)
        doc.SaveToFile(output_path, FileFormat.Docx)
        doc.Close()

        print(f"Converted successfully: {filename} -> {output_filename}")

print("Batch conversion of all Markdown files is complete!")

V. Common Issues and Precautions

To ensure smooth conversion, pay attention to the following key points:

Syntax Compatibility Limitations
The library supports standard Markdown syntax, but niche extensions (e.g., Mermaid flowcharts, LaTeX mathematical formulas, or custom HTML blocks) may not render correctly.
Encoding Best Practices
If your Markdown files contain non-English characters (e.g., Chinese, Japanese), save the files in UTF-8 encoding to prevent garbled text in the converted Word documents.
Free Version Limitations
The free version of Free Spire.Doc for Python has a page limit for converted documents, which is sufficient for daily lightweight use (e.g., technical notes, short reports).

VI. Summary

In this article, we demonstrated how to convert Markdown to Word documents using Free Spire.Doc for Python—with solutions for both single-file and batch conversion scenarios.

Compared to cloud-based conversion tools or online services, this approach offers two key advantages:

Local Processing Security: All operations are performed locally, eliminating the risk of data leakage associated with uploading sensitive documents to third-party platforms.
Beginner-Friendly: The Python API is intuitive and requires minimal code, making it accessible to users with basic programming skills.

Whether you’re a technical writer preparing formal deliverables or a developer automating documentation workflows, this tool provides a lightweight, efficient solution for Markdown-to-Word conversion.

DEV Community: Jeremy K.

Convert RTF to Word Documents in C#

Install the Library

Core Conversion Logic

Minimal Example

Complete Console Example

Advanced: Convert Using Streams

Important Considerations

Summary

Merging Excel Files with Python: Preserve All Formatting & Formulas

Solution Overview

Environment Setup

Mode 1: One File = One Worksheet Set

Full Code

Key Details

Mode 2: All Data Combined into One Worksheet

Full Code

Critical Notes

Final Thoughts

Copying Word Document Content in C#

1. Basic Scenario: Copy the Entire Word Document

2. Advanced Scenario: Copy Specified Paragraph

3. Advanced Scenario: Copy a Specified Section

4. Summary and Notes

Java: Convert Excel to HTML (Complete Guide with Examples)

Introduction

Environment Setup

1. Add Dependencies (Maven)

Basic Conversion: Full Workbook to HTML

Code Implementation

Key Notes

Advanced Conversion: Targeted Worksheet + Inline Images

Code Implementation

Key Benefits

Troubleshooting Common Issues

1. Font Rendering Issues

2. Missing Images in HTML

3. Large HTML File Sizes (High Data Volume)

Summary

Extract Text from PDF Files Using C#

PDF Text Extraction: Solution Comparison

Step-by-Step Guide: Extract PDF Text in 3 Simple Steps

1. Environment Setup

2. Core Code: Extract Text from a Single PDF Page

Key Component Explanations

3. Advanced Extraction Techniques

1. Process Password-Protected PDFs

2. Extract Text from All PDF Pages

3. Extract Text from a Specific Rectangular Region

Recommended Workflow Extensions

Summary

Converting PowerPoint (PPT/PPTX) to HTML in C#

Prerequisites

Installation Steps

C# Code Examples: PPT to HTML Conversion

1. Basic Conversion (Single File)

Key Code Explanation

2. Convert a Specific Slide to HTML

Key Code Explanation

3. Batch Convert PowerPoint Files to HTML

Key Code

Summary

Deleting Blank Rows and Columns in Excel via Python

1. Environment Setup

2. How to Delete Blank Rows & Columns

Key points explained

3. Important Considerations

a. What IsBlank considers “blank”

b. Processing multiple worksheets

c. Performance tip

4. Extended Usage Scenarios

4.1 Batch process all Excel files in a folder

4.2 Delete rows where a specific column is blank

5. Summary

Convert TXT to PDF Using C#

I. Prerequisites

1. Core Library Overview

2. Environment Setup

II. Step-by-Step TXT-to-PDF Conversion

Complete Code

a. What `IsBlank` considers “blank”