DEV Community: Jack9012

How to Add Watermarks to Excel in C#: Two Practical Approaches

Jack9012 — Tue, 29 Sep 2026 06:11:43 +0000

In scenarios such as report distribution, contract archiving, and confidential data sharing, adding a watermark to an Excel document is a simple and practical means of copyright identification. A watermark can be composed of either an image or text. Watermarks with wording such as "Confidential," "Internal Use Only," and "Do Not Distribute" are widely used across business contexts worldwide.

This article will demonstrate how to use a free .NET Excel library to add watermarks to Excel documents in C#, compare two implementation approaches—header image watermarks and background image watermarks—and supplement this with a piece of helper code for generating text watermark images, so that it can be used directly even when no ready-made watermark image is available.

Installation

The library can be brought into the project via NuGet.

NuGet Package Manager Console

  Install-Package FreeSpire.XLS

.NET CLI

  dotnet add package FreeSpire.XLS

After installation is complete, import the namespace Spire.Xls in the code to use it.

Comparison of the Two Watermark Solutions

An Excel watermark is not a true "watermark" object. It is essentially simulated through a header image or a worksheet background image, so the two solutions differ significantly in terms of printing, view, positioning, and other aspects.

Comparison Item	Header Image Watermark	Background Image Watermark
Print output	Printed along with the document	Does not appear in the print result
View visibility	Visible only in "Page Layout" or "Page Break Preview" mode, not in Normal view	Visible in all view modes
Position control	Header area margins need to be adjusted manually to center the image	Automatically fills the entire worksheet data area
Visual consistency	Affected by pagination; adjacent pages may be misaligned	The entire worksheet displays only the same image

Header Image Watermark

Advantages : The watermark appears in the document's final print output, making it suitable for scenarios that must be printed and archived.
Disadvantages : It is not visible in Excel's "Normal" view and can only be seen in "Page Layout" or "Page Break Preview"; to position the image exactly in the center of the page, the top and left margins of the image must be adjusted carefully.

Background Image Watermark

Advantages : The watermark image covers the entire worksheet, producing a consistent effect.
Disadvantages : The watermark does not appear in the print output.

Solution 1: Add an Image Watermark Through the Header

The following example iterates through all worksheets in the document and sets the same watermark image in the center position of the header.

using Spire.Xls;
using System.Drawing;

namespace AddWatermarkToExcelUsingHeader
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create a Workbook object
            Workbook workbook = new Workbook();

            // Load the Excel document
            workbook.LoadFromFile(@"C:\Users\Administrator\Desktop\Input.xlsx");

            // Load the watermark image
            Image image = Image.FromFile(@"C:\Users\Administrator\Desktop\confidential.png");

            // Iterate through all worksheets in the document
            for (int i = 0; i < workbook.Worksheets.Count; i++)
            {
                // Get the specified worksheet
                Worksheet worksheet = workbook.Worksheets[i];

                // Insert an image placeholder in the center of the header
                worksheet.PageSetup.CenterHeader = "&G";

                // Set the image in the center of the header
                worksheet.PageSetup.CenterHeaderImage = image;
            }

            // Save the resulting file
            workbook.SaveToFile("AddWatermark.xlsx", ExcelVersion.Version2016);

            // Release resources
            workbook.Dispose();
        }
    }
}

Note: &G is Excel's own header image placeholder. All text (such as the word "Confidential") should be baked directly into the image, rather than written into the CenterHeader string.

Solution 2: Set the Image as a Worksheet Background

The following example uses an image as a worksheet background watermark, which is suitable for screen-only viewing scenarios that require strong visibility.

using Spire.Xls;
using System.Drawing;

namespace AddWatermarkToExcelUsingBackground
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create a Workbook object
            Workbook workbook = new Workbook();

            // Load the Excel document
            workbook.LoadFromFile(@"C:\Users\Administrator\Desktop\Input.xlsx");

            // Load the watermark image
            Bitmap bitmapImage = new Bitmap(Image.FromFile(@"C:\Users\Administrator\Desktop\sample.png"));

            // Iterate through all worksheets in the document
            for (int i = 0; i < workbook.Worksheets.Count; i++)
            {
                // Get the specified worksheet
                Worksheet worksheet = workbook.Worksheets[i];

                // Set the image as the background of the worksheet
                worksheet.PageSetup.BackgroundImage = bitmapImage;
            }

            // Save the resulting file
            workbook.SaveToFile("AddWatermark.xlsx", ExcelVersion.Version2016);

            // Release resources
            workbook.Dispose();
        }
    }
}

Generation of Text Watermarks

In real-world business scenarios, watermarks are often dynamic text such as "Confidential" or "Internal Use Only," and there is no need for a designer to provide a PNG every time. You can use System.Drawing to draw a text watermark image with a transparent background in memory, and then reuse it with Solution 1 or Solution 2.

using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;

public static class WatermarkHelper
{
    /// <summary>
    /// Generates a text watermark image (transparent background, tilted -30°)
    /// </summary>
    /// <param name="text">Watermark text, such as "Confidential"</param>
    /// <param name="width">Canvas width</param>
    /// <param name="height">Canvas height</param>
    /// <returns>A Bitmap object with a transparent background</returns>
    public static Bitmap Create(string text, int width, int height)
    {
        Bitmap bmp = new Bitmap(width, height, PixelFormat.Format32bppArgb);

        using (Graphics g = Graphics.FromImage(bmp))
        {
            g.Clear(Color.Transparent);
            g.SmoothingMode = SmoothingMode.AntiAlias;
            g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit;

            using (Font font = new Font("Arial", 60, FontStyle.Bold))
            using (SolidBrush brush = new SolidBrush(Color.FromArgb(60, Color.Red)))
            {
                // Calculate the text size and center it
                SizeF size = g.MeasureString(text, font);

                // Translate to the center of the canvas, then rotate, so that the drawn text is centered
                g.TranslateTransform(width / 2f, height / 2f);
                g.RotateTransform(-30);

                g.DrawString(text, font, brush, -size.Width / 2f, -size.Height / 2f);
            }
        }

        return bmp;
    }
}

When calling it, simply pass the generated Bitmap directly to either of the two solutions above:

// Generate a text watermark image
Bitmap watermarkImage = WatermarkHelper.Create("Confidential", 800, 600);

// Use it as a worksheet background watermark
workbook.Worksheets[0].PageSetup.BackgroundImage = watermarkImage;

Font Consistency Recommendations

System.Drawing renders text using fonts installed on the system by default. In different environments (such as Linux servers or containerized deployments), font loss may occur, causing text to render incorrectly. In production environments, it is recommended to:

Package font files into the application;
Load private fonts through PrivateFontCollection and then pass them to the Font constructor;
Or render all potentially used watermark text into PNGs in advance and distribute them as static resources with the project.

Solution Selection Reference

Scenario	Recommended Solution
Reports need to be printed and archived, and documents need to be retained long-term	Solution 1: Header image watermark
Screen-only viewing, internal presentations, emphasis on intuitive visibility	Solution 2: Background image watermark

Summary

The free .NET Excel library itself does not directly provide a "watermark" object. Instead, it implements watermarks through two mechanisms: header images or worksheet background images. By passing any Image/Bitmap to CenterHeaderImage or BackgroundImage, watermark addition is complete; combined with a short piece of text drawing code, watermarks such as "Confidential" and "Internal Use Only" can be generated flexibly without relying on external assets.

In actual projects, it is recommended to encapsulate "image generation + watermark injection" into independent utility methods, exposing only a small number of parameters such as file path, watermark text, and visibility to the outside. This minimizes the cost of reuse when dealing with multiple business lines and multiple templates.

How to Change Page Margins of a PDF Using Python

Jack9012 — Wed, 23 Sep 2026 01:31:58 +0000

In document processing scenarios, we may encounter the need to adjust the blank edges (margins) of PDF files, such as reserving blank space for printing, cropping excess white edges, or unifying document layout formats. There are several PDF processing libraries in the Python ecosystem. This article uses Free Spire.PDF for Python to implement pure-code, watermark-free, and lightweight PDF margin increase and decrease operations.

This solution requires no complex dependencies. Through the core logic of creating a new PDF document, reconstructing page sizes, and redrawing pages using templates, it precisely controls the blank edges on all four sides (top, bottom, left, and right) of a PDF, and is suitable for single-page and multi-page PDF documents.

1. Setup the Environment

First, install the required third-party library. Free Spire.PDF for Python focuses on basic PDF editing, with a concise and easy-to-understand API, making it suitable for rapid development. Run the following pip command to complete the installation:

pip install spire.pdf

2. Overview of Implementation Principles

The core logic of the two margin adjustment methods in this article is the same; only the size calculation and drawing parameters differ:

Increase margins : Expand the PDF page size, keep the original page content centered, and use the newly added blank area as margins.
Decrease margins : Shrink the PDF page size, and crop the blank edges of the original page by offsetting the content drawing coordinates.

General workflow: Load the original PDF → Calculate the new page size → Iterate through pages to generate templates → Create new pages and redraw content → Save the new file and release resources.

3. Increase PDF Page Margins in Python

This scenario is suitable for situations where PDF content is too close to the edges, where printing whitespace needs to be added, or where document margin specifications need to be unified. Below is simplified, directly runnable code where you can customize the margin increments for the top, bottom, left, and right sides.

from spire.pdf.common import SizeF
from spire.pdf import PdfDocument

# 1. Load the original PDF document
original_pdf = PdfDocument()
original_pdf.LoadFromFile("sample.pdf")

# 2. Customize the margins to be added on all four sides
margin_top = 40
margin_bottom = 40
margin_left = 40
margin_right = 40

# 3. Calculate the new page size based on the first page size (applicable to all pages)
first_page = original_pdf.Pages[0]
new_page_width = first_page.Size.Width + margin_left + margin_right
new_page_height = first_page.Size.Height + margin_top + margin_bottom
new_page_size = SizeF(new_page_width, new_page_height)

# 4. Create a new PDF document and redraw all pages
new_pdf = PdfDocument()
for page_idx in range(original_pdf.Pages.Count):
    # Generate a template of the original page, preserving the complete content
    page_template = original_pdf.Pages[page_idx].CreateTemplate()
    # Add a new page with the custom size
    new_page = new_pdf.Pages.Add(new_page_size)
    # Draw the original content at the origin of the new page, automatically generating uniform whitespace
    page_template.Draw(new_page, 0.0, 0.0)

# 5. Save the file and release resources
new_pdf.SaveToFile("increase_pdf_margins.pdf")
original_pdf.Dispose()
new_pdf.Dispose()
print("PDF margin increase completed!")

Core explanation : By adding the four margin values to the original page width and height, the page size is expanded. The original content is fully preserved at the top-left corner of the page, and the remaining area automatically forms uniform blank margins.

4. Decrease PDF Page Margins in Python

This scenario is commonly used to remove excess default blank edges from PDFs, compress the visible document size, and make the content display close to the edges. The core is to shrink the page size while offsetting the content drawing coordinates in the opposite direction to crop excess whitespace.

from spire.pdf.common import SizeF, PdfMargins
from spire.pdf import PdfDocument

# 1. Load the original PDF document
original_pdf = PdfDocument()
original_pdf.LoadFromFile("sample.pdf")

# 2. Customize the blank margins to be cropped on all four sides
reduce_top = 20.0
reduce_bottom = 20.0
reduce_left = 20.0
reduce_right = 20.0

# 3. Calculate the new page size after cropping
first_page = original_pdf.Pages[0]
new_page_width = first_page.Size.Width - reduce_left - reduce_right
new_page_height = first_page.Size.Height - reduce_top - reduce_bottom
new_page_size = SizeF(new_page_width, new_page_height)

# 4. Create a new PDF document, redraw and crop page whitespace
new_pdf = PdfDocument()
for page_idx in range(original_pdf.Pages.Count):
    page_template = original_pdf.Pages[page_idx].CreateTemplate()
    # Add a new page with no margins
    new_page = new_pdf.Pages.Add(new_page_size, PdfMargins(0.0))
    # Offset the drawing coordinates in the opposite direction to crop the original blank edges
    page_template.Draw(new_page, -reduce_left, -reduce_top)

# 5. Save the file and release resources
new_pdf.SaveToFile("decrease_pdf_margins.pdf")
original_pdf.Dispose()
new_pdf.Dispose()
print("PDF margin cropping completed!")

Core explanation : Subtract the whitespace size to be cropped from the page size, and at the same time offset the content drawing coordinates to the left and upward, so that the original page's edge whitespace extends beyond the new page range, thereby achieving the white edge cropping effect.

5. Key Notes

Unit description : All margin values in the code use the standard PDF unit (points). 1 inch ≈ 72 points, and they can be freely converted and adjusted as needed.
Multi-page adaptation : The code uses a globally uniform margin rule, so all pages apply the same increase or decrease parameters, making it suitable for standardized document processing.
Resource release : The Dispose() method must be called to release document resources and avoid memory usage buildup.
Parameter threshold : When decreasing margins, the cropping value must not exceed the original page whitespace; otherwise, the content may be abnormally cropped.

6. Summary

With Free Spire.PDF for Python, custom adjustment of PDF margins can be implemented in a minimal and efficient way, without relying on Adobe software or complex PDF parsing algorithms. The two sets of code provided in this article respectively cover the two high-frequency scenarios of increasing whitespace and cropping white edges . The code is concise, with complete comments, and can be directly embedded into automated document processing scripts, office tools, and batch processing programs.

How to Extract Text and Images from PowerPoint Using C#

Jack9012 — Mon, 21 Sep 2026 01:38:20 +0000

In development scenarios, we may encounter the need for PowerPoint document content parsing, such as batch-extracting text from courseware and reports for archiving, or batch-exporting embedded images from presentations for asset organization.

The native .NET framework does not provide a built-in API for directly parsing PowerPoint files. Manually working with the OpenXML format results in redundant code, complex logic, and a large number of format compatibility issues. Free Spire.Presentation for .NET is a lightweight, free PowerPoint parsing library that supports the entire .NET version range and can quickly implement core features such as text reading, image extraction, and document parsing for PowerPoint files, greatly reducing development costs.

This article is based on .NET 10 syntax conventions and uses Free Spire.Presentation to implement two core features:

Batch-extract all text from every slide in a PowerPoint file and export it to a TXT file
Batch-extract all embedded images from a PowerPoint file and save them as local PNG files

Environment Preparation

Development Environment

Development framework: .NET 6+
Development tools: Visual Studio 2022 / Rider
Target files: .pptx presentation documents (compatible with mainstream PowerPoint formats)

Installing the NuGet Dependency

The project needs to reference the Free Spire.Presentation core package. Search for and install it in the NuGet Package Manager, or install it via the command line:

Install-Package FreeSpire.Presentation

This package is a free, open-source version that meets the development needs of daily non-commercial, batch PowerPoint parsing, with no forced watermark and no marketing bindings.

Extracting All Text from a PowerPoint File

Feature Description

Traverse all slides and all shape components in the PowerPoint file, filter for text container components, read the text content paragraph by paragraph, and finally combine all content and export it to a local TXT document. The code is streamlined using minimalist .NET 10 features such as top-level statements and implicit namespaces, making it more concise and readable.

Complete Code

using Spire.Presentation;
using System.Text;

// Initialize a PowerPoint document instance and load the target file
using Presentation presentation = new();
presentation.LoadFromFile("Island.pptx");

// Initialize the text concatenation container
StringBuilder textBuilder = new();

// Iterate through all slides
foreach (ISlide slide in presentation.Slides)
{
    // Iterate through all components on a single slide
    foreach (IShape shape in slide.Shapes)
    {
        // Filter for text shape components and read paragraph text
        if (shape is IAutoShape autoShape)
        {
            foreach (TextParagraph paragraph in autoShape.TextFrame.Paragraphs)
            {
                textBuilder.AppendLine(paragraph.Text);
            }
        }
    }
}

// Export the text to a local TXT file
File.WriteAllText("ExtractText.txt", textBuilder.ToString());

Explanation of the Core Logic

Automatic resource release : Uses the using variable declaration syntax supported by .NET 10, eliminating the need to manually call Dispose. The PowerPoint file resources are automatically released after the program finishes executing, avoiding file locking and memory leaks.
Type pattern matching : Uses is variable declaration pattern matching to complete type checking and casting in one step, replacing the traditional redundant approach of first checking the type and then casting. This is the recommended optimal syntax in .NET 10.
Layered traversal logic : The PowerPoint text storage hierarchy is Slide -> Shape -> TextParagraph. Through this three-level traversal, all text on a page (titles, body text, and note text) can be precisely captured.
Batch text export : Uses StringBuilder to efficiently concatenate text, avoiding the performance overhead of frequent string concatenation, and finally writes everything to a local file in one go.

Extracting All Embedded Images from a PowerPoint File

Feature Description

Directly read the global image resource collection of the PowerPoint document, batch-traverse all embedded images, export them uniformly as PNG image files, and automatically name and archive them, making it suitable for batch asset extraction scenarios.

Complete Code

using Spire.Presentation;
using Spire.Presentation.Collections;

// Initialize and load the PowerPoint document
using Presentation presentation = new();
presentation.LoadFromFile("Template.pptx");

// Get the collection of all embedded images in the PowerPoint file
ImageCollection imageCollection = presentation.Images;

// Iterate through the image collection and export in batches
for (int i = 0; i < imageCollection.Count; i++)
{
    // Name and save images by index to avoid duplicate file names
    string savePath = Path.Combine("Presentation", $"Images{i}.png");

    // Create the storage directory (automatically created if it does not exist)
    Directory.CreateDirectory(Path.GetDirectoryName(savePath)!);

    // Save the image locally
    imageCollection[i].Image.Save(savePath);
}

Explanation of the Core Logic

Global image reading : Unlike traversing slides page by page, this directly obtains all embedded images in the document through presentation.Images, eliminating the need to repeatedly traverse pages and resulting in higher execution efficiency.
Automatic directory creation : Adds directory checking logic to automatically detect whether the image storage folder exists and create it if it does not, avoiding save failures caused by missing directories and improving code robustness.
.NET 10 string optimization : Uses string interpolation instead of traditional string.Format, resulting in cleaner syntax and stronger readability. This is the recommended approach in newer versions of .NET.
Safe resource release : The using syntax manages the lifecycle of the PowerPoint instance, ensuring that resources are completely released after the file has been read.

Key Considerations

File format compatibility : This component only supports parsing .pptx files. Older .ppt formats must be converted before parsing.
Path conventions : The code uses relative paths by default. You can change them to absolute paths according to business needs to adapt to different runtime environments such as servers and desktops.
Special content compatibility : This solution can normally extract ordinary text and images. For WordArt, background fill images, and encrypted content, additional compatibility handling is required.
.NET version compatibility : The code in this article is based on minimalist .NET 10 syntax. If compatibility with lower .NET versions is needed, top-level statements can be changed to the traditional class and Main method style.

Conclusion

With the FreeSpire.Presentation library, we can quickly implement batch extraction of PowerPoint text and images using minimalist .NET 10 code, completely avoiding the complex logic of native OpenXML parsing.

The entire codebase is lightweight, free of redundancy, and does not depend on third-party software. It can be directly applied to business scenarios such as batch document parsing, content archiving, asset extraction, and office automation , making it an efficient solution for handling basic PowerPoint parsing needs on the .NET platform.

Adding Custom Text to PDF Documents with Python

Jack9012 — Thu, 17 Sep 2026 03:49:30 +0000

When processing documents, it is often necessary to append text to existing PDF files for purposes such as supplementary notes, explanatory labels, watermark text, and page number annotations. Python boasts an extensive collection of PDF processing libraries. Among them, Free Spire.PDF for Python stands out with its streamlined APIs, comprehensive style customization, and independence from local Adobe components. It enables efficient PDF text editing with support for personalized effects including custom fonts, colors, transparency, and text rotation.

This tutorial provides an objective and complete walkthrough of adding text to PDFs using Free Spire.PDF, covering basic executable code and advanced style customization to meet diverse PDF text editing requirements.

1. Environment Setup

1.1 Library Installation

First, install the Free Spire.PDF dependency via pip by running the following command:

pip install spire-pdf-free

This library supports Python 3.7 and above, and is cross-platform compatible with Windows, macOS and Linux. After installation, you may directly call its APIs to edit PDF files.

1.2 Overview of Core Modules

Below is a breakdown of key modules used in this practical project and their core functionalities:

PdfDocument : The core class for PDF file operations, responsible for loading, saving and closing documents
Font-related classes : PdfCjkStandardFont, PdfTrueTypeFont, PdfFont — designed for CJK fonts, custom system fonts, and built-in standard PDF fonts respectively
PdfSolidBrush & PdfRGBColor : Used to configure text drawing colors and brush styles
PointF : Defines the coordinate position for rendering text on PDF pages

2. Basic Implementation: Insert Plain Text into a PDF

This basic workflow loads an existing PDF file and inserts custom text at a specified coordinate on a target page, alongside basic font and color configuration. Below is fully runnable code with detailed comments.

from spire.pdf import PdfDocument, PdfFontStyle, PdfSolidBrush, PdfRGBColor, PointF, PdfCjkStandardFont, PdfCjkFontFamily

# Initialize a PDF document object and load the local PDF file
pdf = PdfDocument()
pdf.LoadFromFile("input.pdf")  

# Retrieve the first page of the PDF (index starts at 0)
page = pdf.Pages.get_Item(0) 

# Configure CJK font: Monotype Hei Medium, size 16, bold weight
font = PdfCjkStandardFont(PdfCjkFontFamily.MonotypeHeiMedium, 16.0, PdfFontStyle.Bold)

# Create a brush and set text color to light orange
brush = PdfSolidBrush(PdfRGBColor(255,200, 180)) 

# Define coordinates for text rendering (unit: point)
location = PointF(72.0, 300.0)

# Draw custom text at the specified position
page.Canvas.DrawString("This is newly added text.", font, brush, location)

# Save the modified PDF file
pdf.SaveToFile("AddedText.pdf")
# Close the document to release occupied resources
pdf.Close()

Core Workflow of the Code

Load document → Select target page → Configure font and color styles → Set rendering coordinates → Draw text → Save file and release resources. The workflow is concise and free of redundant logic.

3. Advanced Style Customization

Spire.PDF offers abundant text styling extensions to accommodate various layout scenarios, including multiple font types, custom colors, text transparency, and rotated text. Practical implementations of each feature are covered below.

3.1 Multi-Font & Custom Color Configuration

Three mainstream font initialization methods are available for CJK text, third-party system fonts, and built-in PDF standard fonts. Custom RGB colors of any shade are also supported.

# Method 1: Load system TrueType font (Calibri), italic, size 16, embed font into PDF
font1 = PdfTrueTypeFont("Calibri", 16.0, PdfFontStyle.Italic, True)

# Method 2: Use PDF built-in Times Roman standard font, italic, size 16
font2 = PdfFont(PdfFontFamily.TimesRoman, 16.0, PdfFontStyle.Italic)

# Create a brush with forest green text color
brush = PdfSolidBrush(PdfRGBColor(34, 139, 34))

Enabling font embedding ensures consistent font rendering across all devices when opening the PDF, making it ideal for documents shared cross-platform.

3.2 Adjust Text Transparency

The SetTransparency canvas method creates semi-transparent text, commonly used for subtle watermarks and light annotations. The transparency value ranges from 0.0 (fully transparent) to 1.0 (fully opaque).

# Set text to 40% opacity (transparency = 0.4)
page.Canvas.SetTransparency(0.4)

# Render semi-transparent text
page.Canvas.DrawString("Semi-transparent text", font, brush, PointF(100.0, 100.0))

3.3 Create Rotated Text

You may rotate the canvas coordinate system to render text at any tilt angle, perfect for diagonal watermarks and marginal notes. Negative values rotate counterclockwise, while positive values rotate clockwise.

# Rotate canvas 45 degrees counterclockwise
page.Canvas.RotateTransform(-45)

# Draw rotated text
page.Canvas.DrawString("Rotated text", font, brush, PointF(100.0, 100.0))

Note: Canvas rotation applies globally. Reset canvas transformations after drawing if you need to revert to the default orientation.

4. Key Development Notes

Resource Release : Always call the Close() method after completing PDF operations to free file handles and avoid file locks or memory leaks.
Coordinate System : PDF coordinates use points as units, with the top-left corner of a page serving as the origin. Adjust rendering coordinates based on page dimensions as needed.
CJK Text Compatibility : Prioritize PdfCjkStandardFont or system Chinese fonts for Chinese text to prevent garbled characters or missing font errors.
Combined Styling : Transparency, rotation and font styles can be combined freely to build complex text display effects.

5. Conclusion

Spire.PDF for Python delivers lightweight yet powerful PDF text editing capabilities, enabling developers to implement core features including basic text insertion, multi-font compatibility, custom color schemes, transparent text and rotated text with minimal code. Compared with traditional PDF libraries, its key advantages lie in intuitive APIs, full styling support, and native Chinese & English compatibility. It is well-suited for use cases such as automated PDF editing, batch document processing and watermark generation.

How to Convert Excel to Markdown and Vice Versa in C#

Jack9012 — Tue, 15 Sep 2026 01:54:16 +0000

In document development and interface data synchronization workflows, bidirectional format conversion between Excel spreadsheets and Markdown tables is frequently required. Excel excels at data editing, statistical recording and archiving, while Markdown is ideal for document display, knowledge bases and README documentation. Enabling two-way conversion between them drastically boosts office and development efficiency.

This tutorial leverages the Spire.XLS for .NET library to provide a complete, step-by-step pure C# implementation for Excel-to-Markdown and Markdown-to-Excel conversion. The code is concise with no redundant logic, compatible with the full range of platforms including .NET Framework, .NET Core, and .NET 5/6/7/8.

All code snippets in this tutorial contain no extraneous third-party dependencies or promotional logic and can be directly deployed into production projects.

1. Development Environment Setup

1.1 Project Environment Requirements

Development Tool: Visual Studio 2019 / 2022
Runtime Platform: .NET Core 3.1 and above / .NET 5 and above / .NET Framework 4.0 and above
Core Dependency: Spire.XLS for .NET

1.2 Install the NuGet Dependency

Spire.XLS is a professional Excel manipulation library that supports conversion between Excel and multiple formats such as Markdown, HTML and CSV. It operates independently without requiring Microsoft Office components to be installed.

In Visual Studio, right-click your project → Manage NuGet Packages, then search for and install the package:

Spire.Xls

Installation via the NuGet Package Manager Console is also supported.

2. Excel to Markdown Implementation

2.1 Fully Runnable Code

using Spire.Xls;

namespace ExcelToMarkdownDemo
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // Initialize workbook object
            Workbook workbook = new Workbook();

            // Load local Excel file (supports .xls and .xlsx formats)
            workbook.LoadFromFile("Input.xlsx");

            // Export Excel content to a Markdown file
            workbook.SaveToMarkdown("output.md");

            // Release resources to prevent memory leaks
            workbook.Dispose();
        }
    }
}

2.2 Line-by-Line Code Explanation

Workbook workbook = new Workbook(): Initializes the core Excel workbook object, which handles all file operations.
workbook.LoadFromFile("Input.xlsx"): Reads a local Excel file; absolute and relative file paths are both supported, with compatibility for legacy .xls and modern .xlsx formats.
workbook.SaveToMarkdown("output.md"): Core conversion method that automatically parses worksheet data, generates standard Markdown tables, and saves the result locally.
workbook.Dispose(): Releases memory and file resources occupied by the workbook. This mandatory step prevents program memory overflow and persistent file locks.

2.3 Conversion Output Overview

Running the code generates an output.md file automatically. All table headers and data rows from the source Excel file are mapped completely to Markdown table structures, with blank cells filled with appropriate placeholders. The standardized output works seamlessly with mainstream platforms including GitHub, Gitee and Yuque.

3. Markdown to Excel Full Implementation

This feature supports reverse conversion of standard Markdown table files into Excel files, with built-in page adaptation configurations. The generated Excel files feature clean layouts optimized for printing and data editing.

3.1 Fully Runnable Code

using Spire.Xls;

namespace MarkdownToExcelDemo
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // Initialize workbook object
            Workbook workbook = new Workbook();

            // Load Markdown table file
            workbook.LoadFromMarkdown("Input.md");

            // Enable page auto-fit to adjust content to page width
            workbook.ConverterSetting.SheetFitToPage = true;

            // Save as Excel 2016 format, compatible with most office software
            workbook.SaveToFile("output.xlsx", ExcelVersion.Version2016);

            // Release occupied resources
            workbook.Dispose();
        }
    }
}

3.2 Core Configuration & Code Breakdown

LoadFromMarkdown: Dedicated Markdown parsing method that accurately recognizes standard Markdown table syntax and maps content to Excel rows and columns automatically. Non-table Markdown content (headings, paragraphs, etc.) is ignored during parsing.
SheetFitToPage = true: Conversion optimization setting that resizes worksheet content to fit page dimensions, eliminating column overflow and improving readability and print quality.
ExcelVersion.Version2016: Specifies the target Excel file version, offering maximum compatibility with Office 2016 and all later releases. This value can be replaced with Version2013, Version2019, etc., based on project requirements.

4. Project Compatibility & Optimization Tips

4.1 Using Absolute File Paths

Absolute file paths are recommended for development and deployment to avoid missing file errors caused by relative path issues. Example:

string excelPath = @"D:\Files\Input.xlsx";
string mdPath = @"D:\Files\output.md";

4.2 Exception Handling Improvements

Add exception handling in production environments to resolve errors such as missing files or invalid file formats:

try
{
    Workbook workbook = new Workbook();
    workbook.LoadFromFile("Input.xlsx");
    workbook.SaveToMarkdown("output.md");
    workbook.Dispose();
}
catch (FileNotFoundException ex)
{
    Console.WriteLine($"File not found: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"Conversion failed: {ex.Message}");
}

4.3 Multi-Worksheet Support

Spire.XLS natively supports multi-worksheet conversion. Multiple worksheets from an Excel file are converted into segmented tables within the Markdown file in sequence. During reverse conversion, separate Markdown tables are imported into distinct Excel worksheets automatically.

5. Common Issues & Troubleshooting

Distorted table formatting after conversion : Ensure source files follow standard Excel/Markdown table syntax; remove merged cells and complex nested formatting.
File load failure prompts : Verify the file path validity, check if the target file is locked by another process, and confirm the file uses a supported format.
Excessive memory consumption : Always call the Dispose() method to release resources. For batch conversion tasks, instantiate and dispose the workbook object for each individual conversion cycle.

6. Conclusion

The Spire.XLS for .NET library enables efficient bidirectional conversion between Excel and Markdown with minimal code, without requiring a local Microsoft Office installation. It is lightweight, cross-platform and high-performance. This solution fits a wide range of business scenarios including automated document generation, backend data export, and knowledge base format synchronization. The codebase is concise, stable, and ready for direct integration into production-grade projects.

How to Parse Excel Data, Images, and Charts with Python

Jack9012 — Thu, 10 Sep 2026 02:56:15 +0000

Reading cell data, embedded images, and chart elements from Excel files is a common requirement in Python-based backend processing, automated report analysis, and data migration. Compared with conventional Excel processing libraries, the component introduced in this article provides a unified way to read text and numeric values, handle different cell data types, extract images, and export charts without requiring Microsoft Office or another desktop Office environment. This makes it suitable for server-side and automated processing scenarios.

In this article, we will use practical Python code examples to demonstrate four core Excel parsing capabilities and explain the key implementation details behind each approach.

The examples are based on Free Spire.XLS for Python , which provides a lightweight API for reading and writing Excel files. It supports parsing common elements in .xlsx files and offers a simple API with relatively low resource overhead, making it suitable for automated Excel data processing.

1. Install the Required Component

Free Spire.XLS for Python can be installed directly with pip and integrated into a Python environment without additional system-level configuration. The following command installs the package:

Install with pip

pip install spire.xls.free

Installation Notes

The package can be installed directly with pip without manually configuring additional system dependencies.
If multiple Python versions are installed on your system, use pip3 or python -m pip as appropriate to ensure that the package is installed in the environment used by your application.
Once installation is complete, import the library with import spire.xls. No manual environment-variable configuration is required.

After installation, you can use the APIs described below to read Excel data, extract embedded images, and export charts.

2. Read Cell Data from a Worksheet

For common Excel data-processing tasks, you can obtain the worksheet's allocated data range and then iterate through its rows and columns to read cell values in batches. Because this approach only processes the area occupied by data, it avoids unnecessarily scanning the entire worksheet and is suitable for automated table-data extraction.

Code Example

from spire.xls import *

# Create a workbook and load the Excel file
wb = Workbook()
wb.LoadFromFile("Input.xlsx")

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

# Get the allocated data range
locatedRange = sheet.AllocatedRange

# Iterate through all cells and print their values
for i in range(len(locatedRange.Rows)):
    for j in range(len(locatedRange.Rows[i].Columns)):
        print(locatedRange[i + 1, j + 1].Value + "  ", end='')
    print("")

Key Details

The AllocatedRange property automatically identifies the used range of the worksheet, avoiding the overhead of iterating through unused rows and columns.
Cell indexing starts at 1, which is consistent with Excel's row and column numbering and eliminates the need for additional index conversion.
The nested loops iterate through the rows and columns of the allocated range and retrieve each cell's value while preserving the original table structure.

3. Read Different Types of Cell Data

Excel cells can contain text, numbers, formulas, dates, Boolean values, and other types of data. Using the general Value property alone may not always provide enough control when you need to distinguish between these data types. Free Spire.XLS provides dedicated properties for retrieving specific types of cell content.

Code Example

# Get a cell by row and column
cell = sheet.Range[row, column]

# Read different types of cell data
text = cell.Text                    # Text content
number = cell.NumberValue           # Numeric value
formula = cell.Formula              # Original formula
formulaResult = cell.FormulaValue   # Calculated formula result
date = cell.DateTimeValue            # Date and time value
boolean = cell.BooleanValue          # Boolean value
value = cell.Value                   # General value
value2 = cell.Value2                 # Object-based value

Key Details

For formula cells, Formula and FormulaValue allow you to retrieve the original formula and its calculated result separately. This is useful when you need to validate formulas or process their results.
DateTimeValue provides the date and time represented by a cell in a form that can be processed directly, avoiding manual string parsing.
Value2returns the cell value as an object, preserving its underlying data type. For example, date and Boolean cells can be returned asdatetimeandbool objects, respectively.

Using these dedicated properties gives you more precise control over how different types of Excel data are handled in your application.

4. Extract Embedded Images from a Worksheet

Excel worksheets often contain embedded images such as screenshots, product images, receipts, and other business-related resources. While some Excel libraries focus primarily on tabular data, Free Spire.XLS provides access to the images embedded in a worksheet.

You can iterate through the worksheet's picture collection and save each image as a standard PNG file for further processing or local storage.

Code Example

from spire.xls import *

workbook = Workbook()
workbook.LoadFromFile("Input.xlsx")
sheet = workbook.Worksheets[0]

# Iterate through all pictures in reverse order and save them
for i in range(sheet.Pictures.Count - 1, -1, -1):
    pic = sheet.Pictures[i]
    pic.Picture.Save(
        "ExtractImages\\Image-{0:d}.png".format(i),
        ImageFormat.get_Png()
    )

Key Details

The picture collection is traversed in reverse order, which can help avoid index-related issues when working with collections that may change during processing.
You can customize the output directory and file naming convention. The example saves the extracted images as PNG files.
Pictures.Count returns the number of pictures contained in the worksheet, allowing you to determine how many embedded images need to be processed.

This approach is particularly useful when Excel files are used as containers for both structured data and image-based content.

5. Export Excel Charts as Images

Excel files can contain various types of charts, including column charts, line charts, and pie charts. Chart elements cannot be retrieved through ordinary cell-value APIs. Instead, they can be rendered as images and exported for offline use, reporting, or further processing.

Free Spire.XLS provides the SaveChartAsImage method, which can be used to obtain chart images from a worksheet.

Code Example

from spire.xls import *

workbook = Workbook()
workbook.LoadFromFile("Input.xlsx")
sheet = workbook.Worksheets[0]

# Convert all charts in the worksheet to image streams
image_streams = workbook.SaveChartAsImage(sheet)

# Save the chart images
for i, image_stream in enumerate(image_streams):
    image_stream.Save(f"Output/chart-{i}.png")

# Release workbook resources
workbook.Dispose()

Key Details

SaveChartAsImage retrieves the charts in the specified worksheet as image streams, so you do not need to locate and process each chart individually.
Saving the results through image streams provides a convenient way to handle multiple charts and export them as image files.
Dispose() explicitly releases the resources associated with the workbook. This is especially important when processing a large number of Excel files to reduce the risk of excessive memory usage and file-locking issues.

6. Summary

In this article, we explored four common Excel parsing tasks with Python:

Reading cell data from a worksheet
Retrieving different types of cell values
Extracting embedded images
Exporting Excel charts as images

The approach does not require Microsoft Office to be installed and can therefore be integrated into server-side scripts, automated data-processing workflows, data synchronization tools, and report-processing systems.

The main advantage of this approach is that it provides a relatively lightweight API for handling both structured worksheet data and embedded visual elements. With support for multiple cell data types, image extraction, chart export, and explicit resource management, it can be used as part of automated workflows that process Excel files in batches.

Find and Highlight Text in PDF Files with Python

Jack9012 — Tue, 08 Sep 2026 02:06:12 +0000

In document processing, data analysis, content review, and similar workflows, you may often need to search PDF files for specific text and highlight the matching content so that important information can be identified more quickly.

Python provides a wide range of PDF processing libraries that make this kind of automation relatively easy to implement. In this article, we will introduce two practical approaches for finding and highlighting text in PDF files: exact text matching and regular-expression-based matching.

1. Library and Environment Setup

In this tutorial, we will use Free Spire.PDF for Python to search for text and add highlight annotations to PDF documents.

The library provides convenient APIs for page traversal, exact text searching, regular expression matching, and custom highlight colors, so there is no need to manually work with low-level PDF structures.

One limitation to keep in mind is that the free version supports PDF documents with up to 10 pages . This is generally sufficient for lightweight testing, small documents, and simple document-processing tasks.

Before getting started, install the required package with pip:

pip install spire.pdf.free

2. Scenario 1: Find and Highlight Exact Text Across a PDF

This approach is suitable when you already know the exact keyword or phrase you want to locate. The program can iterate through every page in the PDF and highlight all occurrences of the target text.

For example, the following code searches for the text "cloud service" throughout the document and highlights every match.

Complete Code

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

# Create a PdfDocument object and load the PDF file
pdf = PdfDocument()
pdf.LoadFromFile("inpue.pdf")

# Iterate through all pages in the PDF document
for i in range(pdf.Pages.Count):
    page = pdf.Pages.get_Item(i)

    # Create a text finder for the current page
    pdfTextFinder = PdfTextFinder(page)

    # Set the search parameter to find exact matches
    pdfTextFinde.Options.Parameter = TextFindParameter.IgnoreCase

    # Find all occurrences of the target text on the page
    result = pdfTextFinder.Find("cloud service")

    # Highlight all matched text in cyan
    for find in result:
        find.HighLight(Color.get_Cyan())

# Save the processed PDF document
pdf.SaveToFile("output/result.pdf")

# Release document resources
pdf.Close()

How the Code Works

Load the PDF document A PdfDocument object is created, and the LoadFromFile() method is used to open the source PDF.
Iterate through each page The program loops through all pages in the document to ensure that matching text is not missed.
Search for the target text A PdfTextFinder object is created for each page. The Find() method performs an exact search and returns all matching text fragments.
Apply highlighting Each matching result is processed with the HighLight() method. In this example, cyan is used as the highlight color, but it can be replaced with another supported color.
Save and close the document Finally, the modified PDF is saved to a new file, and Close() is called to release the document resources.

3. Scenario 2: Highlight Text Using Regular Expressions

In many cases, the text you want to find does not have a fixed value but follows a consistent pattern.

Typical examples include:

Numbers
Percentages
Phone numbers
Dates
Email addresses

For these situations, regular expressions provide a more flexible way to search for matching text.

In the following example, we use a regular expression to find and highlight integers, decimal numbers, and percentages.

Complete Code

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

# Create a PdfDocument object and load the PDF file
pdf = PdfDocument()
pdf.LoadFromFile("input.pdf")

# Get the first page of the PDF
# Change the page index if you want to process another page
page = pdf.Pages.get_Item(0)

# Create a text finder for the page
pdfTextFinder = PdfTextFinder(page)

# Enable regular expression matching
pdfTextFinder.Options.Parameter = TextFindParameter.Regex

# Regular expression for integers, decimals, and percentages
# Examples: 10, 99.9, 50%
pattern = r'\d+(?:\.\d+)?%?'

# Find all text fragments that match the pattern
result = pdfTextFinder.Find(pattern)

# Highlight the matched text in deep pink
for find in result:
    find.HighLight(Color.get_DeepPink())

# Save the processed PDF document
pdf.SaveToFile("output/result.pdf")

# Release document resources
pdf.Close()

Key Points

Enable regular expression mode Set Options.Parameter to TextFindParameter.Regex to switch from standard text searching to regular-expression matching.
Define the matching pattern The regular expression:

   \d+(?:\.\d+)?%?

matches several common numeric formats, including integers, decimal numbers, and percentages.

You can replace it with another pattern to search for phone numbers, dates, email addresses, or other structured text.

Process a specific page This example searches only the first page of the PDF. If you need to search the entire document, you can combine this approach with the page loop used in the first example.
Customize the highlight color The highlight color can be changed by using another supported color value. This makes it possible to apply different visual styles for different types of matched content.

4. Common Issues and Optimization Tips

1. The PDF Cannot Be Saved

Make sure that the output directory already exists before saving the file.

If the output folder does not exist, Python may raise a file-path-related error.

You can create the directory automatically with:

import os

os.makedirs("output", exist_ok=True)

2. The PDF Exceeds the Page Limit

The free version supports PDF documents with up to 10 pages.

For longer documents, you can split the PDF into smaller files before performing the search and highlight operation.

3. Improving Search Accuracy

By default, the search operation may match text fragments containing the specified keyword.

If you need more precise matching, such as whole-word matching or case-sensitive searching, you can configure the corresponding options through the text finder's Options settings.

5. Conclusion

This article demonstrated two ways to find and highlight text in PDF documents with Python: exact text matching and regular-expression-based matching.

Exact matching works well when the target keyword is already known, while regular expressions are more suitable for structured or variable content such as numbers, percentages, dates, and other formatted data.

Both approaches require relatively little code and can be easily integrated into automated document-processing scripts. For small and short PDF files, they provide a straightforward way to identify important content, prepare documents for further data extraction, and reduce the amount of manual document review required.