Exporting a DataTable to Excel in C# is a common task in .NET development, such as generating reports, exporting logs, or preparing data for sharing across systems. By using a standalone component, developers can quickly export data and apply formatting to create professional, ready-to-use Excel files from DataTables without relying on complex setup or external dependencies.

To streamline this process, Spire.XLS for .NET offers a lightweight and fully independent library. In this article, you'll learn how to export a DataTable to Excel (.xlsx or .xls) in C#, apply formatting to improve readability, and address common export scenarios effectively.

Quick Navigation

• Install and Configure Spire.XLS
• Step-by-Step: Export DataTable to Excel
  • Create a Sample DataTable
  • Import DataTable and Save to Excel File
  • Export Excel File as Stream in ASP.NET
• Format and Style the Exported Excel File
• Common Issues and Solutions
• Conclusion
• Frequently Asked Questions

Install and Configure Spire.XLS

Before you start, make sure your project includes Spire.XLS for .NET.

Install Spire.XLS via NuGet

Run this command in the NuGet Package Manager Console:

Install-Package Spire.XLS

Spire.XLS works with .NET Framework, .NET Core, .NET 6/7+, and ASP.NET projects — no Microsoft Office installation required.

Step-by-Step: Export DataTable to Excel in C#

The following steps demonstrate how to export a DataTable to an Excel file using Spire.XLS, including data preparation, file generation, optional streaming, and output formatting.

1. Create a Sample DataTable

First, create a DataTable and add some sample rows:

DataTable dt = new DataTable("Employees");

// Insert columns
dt.Columns.Add("ID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));
dt.Columns.Add("Join Date", typeof(DateTime));
dt.Columns.Add("Salary", typeof(double));
dt.Columns.Add("Full-Time", typeof(bool));
dt.Columns.Add("Bonus Rate", typeof(decimal));

// Insert rows
dt.Rows.Add(1001, "Alice", "HR", new DateTime(2021, 5, 10), 55000.5, true, 0.05m);
dt.Rows.Add(1002, "Bob", "IT", new DateTime(2020, 11, 23), 72000.0, false, 0.03m);
dt.Rows.Add(1003, "Carol", "Finance", new DateTime(2019, 8, 15), 63000.75, true, 0.07m);
dt.Rows.Add(1004, "David", "Marketing", new DateTime(2022, 3, 8), 48800.0, true, 0.06m);

Tip: This is just sample data — you can bind any DataTable your app generates.

2. Import DataTable and Save to Excel File

Next, initialize the Excel workbook, import the DataTable into a worksheet, and save the file:

// Create a new workbook
Workbook workbook = new Workbook();
// Clear the default worksheets and add a new one
workbook.Worksheets.Clear();
Worksheet sheet = workbook.Worksheets.Add(dt.TableName);

// Import the DataTable starting at cell A1
sheet.InsertDataTable(dt, true, 1, 1);

// Save as XLSX (recommended)
workbook.SaveToFile("EmployeeData.xlsx", FileFormat.Version2016);

// Or save as XLS (older format)
workbook.SaveToFile("EmployeeData.xls", FileFormat.Version97to2003);

Explanation:

• Workbook is the container for your Excel file.
• InsertDataTable(dataTable, includeColumnHeaders, startRow, startColumn) maps the entire table to the Excel grid.
• SaveToFile() writes the file to disk in your chosen format.

Output Preview

Example of the exported Excel file:

3. Export Excel File as Stream in ASP.NET

When building a web app, you might want to export the file directly as a stream instead of saving to disk:

MemoryStream stream = new MemoryStream();
workbook.SaveToStream(stream, FileFormat.Version2013);
stream.Position = 0;

Return this MemoryStream in your ASP.NET controller to trigger a file download in the browser.

For additional tips on managing Excel files in C#, check out How to Create and Manipulate Excel Files in C#.

Format and Style the Exported Excel File

Formatting is optional but recommended for creating professional Excel files. Below is how you can format the exported content using Spire.XLS.

// Style the header row
CellRange header = sheet.Rows[0];
header.Style.Font.IsBold = true;
header.Style.Font.FontName = "Arial";
header.Style.Font.Size = 13;
header.Style.Color = Color.LightGray;
header.Style.Borders[BordersLineType.EdgeBottom].LineStyle = LineStyleType.Thick;

// Style the data rows
for (int i =  1; i < sheet.Rows.Length; i++)
{
    CellRange dataRow = sheet.Rows[i];
    dataRow.Style.Font.FontName = "Times New Roman";
    dataRow.Style.Font.Size = 11;
    dataRow.BorderInside();
}

// Format date column to display as date
CellRange dateColumn = sheet.Range[2, 4, sheet.Rows.Length + 1, 4];
dateColumn.Style.NumberFormat = "yyyy-mm-dd";

// Auto-fit columns
sheet.AllocatedRange.AutoFitColumns();

Key Properties and Methods:

• Style: Applies font, color, border, number formatting, etc. to cells.
• AutoFitColumns(): Automatically adjusts column width to fit content.
• NumberFormat: Sets how dates or numbers are displayed in Excel, e.g., "yyyy-mm-dd".
• BorderInside(): Adds internal borders to improve table readability.

Formatted Output Preview

Excel file with formatted header and date column:

For more advanced number formatting options, see how to set number format in Excel using C#.

Common Issues and Solutions

• File won’t open or shows corruption error

Ensure streams are closed properly and file extensions match the format.

• Special characters or non-English text look garbled

Confirm strings are UTF-8 encoded and use appropriate fonts.

• Columns too narrow

Use AutoFitColumns() to adjust widths automatically or use CellRange.ColumnWidth to set a fixed column width.

Conclusion

Exporting a DataTable to Excel in C# is straightforward with Spire.XLS. This approach lets you create .xlsx or .xls files easily without relying on Office, while giving you full control over the output layout for both desktop and web applications.

If needed, you can also request a free temporary license to unlock the full feature set for evaluation.

Frequently Asked Questions

Q1: How to convert DataTable to Excel in C#?

You can use sheet.InsertDataTable() from Spire.XLS to load a DataTable into a worksheet, then save it as an Excel file using workbook.SaveToFile().

Q2: Is there a free library to export a DataTable to Excel in C#?

Yes — Free Spire.XLS for .NET is a standalone library that lets you create and export Excel files directly in C# without needing to install Microsoft Office.

Q3: Can I export DataTable to Excel in ASP.NET?

Yes, the same logic can be applied in ASP.NET by generating the workbook in a controller and streaming it back as a downloadable file.

Q4: What's the difference between .xlsx and .xls export?

.xlsx is the newer Office Open XML format, compatible with Excel 2007 and later. .xls supports legacy Excel 97–2003 but is limited to 65,536 rows.

Reading emails using C# is a common task in enterprise applications where automatic email processing is needed. For example, customer support systems retrieve tickets from email inboxes, financial platforms extract PDF invoices from attachments, and workflow tools react to notification emails. These applications require access to message content, metadata (sender, subject, timestamp), and attachments.

In this article, we’ll walk through how to read emails in C# using IMAP and POP3, and access Gmail or Outlook mailboxes securely with OAuth 2.0. We'll use Spire.Email for .NET, a library that simplifies email client implementation by providing a unified API for IMAP, POP3, and SMTP. It supports both OAuth and password-based authentication, and allows parsing full MIME messages including headers, bodies, and attachments.

This article covers:

• Environment Setup
• Authenticate Email Access via OAuth
• Read Emails Using IMAP in C#
• Read Emails via POP3 in C#
• Extract Attachments and Plain Text
• Summary
• Frequently Asked Questions

Environment Setup

To follow this tutorial, you’ll need the following:

• A .NET development environment (e.g., Visual Studio)
• Spire.Email for .NET (Install via NuGet: Install-Package Spire.Email)
• Access to a Gmail or Outlook account with OAuth 2.0 enabled

Spire.Email for .NET supports standard email protocols—IMAP, POP3, and SMTP—and provides built-in functionality for MIME parsing, attachments, HTML rendering, and encoding handling.

You can also try Free Spire.Email for .NET if your project is small or for evaluation.

Authenticate Email Access via OAuth

Modern email providers such as Gmail and Outlook require OAuth 2.0 for secure and token-based access to IMAP and POP3 services. Gmail still supports app passwords for POP3 in some cases, but OAuth is the preferred and more secure method.

Here’s how to use MSAL.NET to acquire an access token for Outlook:

var app = PublicClientApplicationBuilder
    .Create("your-client-id")
    .WithDefaultRedirectUri()
    .Build();

string[] scopes = new[] { "https://outlook.office365.com/IMAP.AccessAsUser.All" };

AuthenticationResult result = await app
    .AcquireTokenInteractive(scopes)
    .ExecuteAsync();

string accessToken = result.AccessToken;

For Gmail, you can use Google.Apis.Auth or any OAuth 2.0 compliant method to retrieve a token with the https://mail.google.com/ scope. This token can then be passed to Spire.Email for authentication.

Read Emails Using IMAP in C# from Outlook and Gmail

To read emails from Outlook or Gmail in C#, IMAP is a widely used protocol that allows access to mailbox folders, message flags, and full message content. With Spire.Email for .NET, you can use the ImapClient class to connect securely to IMAP servers using OAuth tokens.

The following C# example demonstrates how to read emails from Outlook's IMAP server:

using Spire.Email;
using Spire.Email.IMap;
using System.Text;

class Program
{
    static void Main()
    {
        ImapClient client = new ImapClient();

        // Connect to IMAP server (Outlook)
        client.Host = "outlook.office365.com";
        client.Port = 993;
        client.ConnectionProtocols = ConnectionProtocols.Ssl;

        // Use OAuth 2.0
        client.UseOAuth = true;
        client.Username = "[email protected]";
        client.AccessToken = "your-access-token";

        client.Connect();
        client.Login();

        // Retrieve message count in the Inbox
        int messageCount = client.GetMessageCount("Inbox");
        StringBuilder messageDetails = new StringBuilder();

        for (int i = 0; i <= messageCount; i++)
        {
            MailMessage message = client.GetFullMessage(i);
            messageDetails.AppendLine("Message: " + i);
            messageDetails.AppendLine("Subject: " + message.Subject);
            messageDetails.AppendLine("From: " + message.From.Address);
            messageDetails.AppendLine("Date: " + message.Date);
            messageDetails.AppendLine("Body (HTML): " + message.BodyHtml);
        }

        File.WriteAllText("MessageInfo.txt", messageDetails.ToString());
        client.Disconnect();
    }
}

Technical Details

• ImapClient: Represents an IMAP client connection. It handles server communication and supports OAuth-based authentication via the UseOAuth property.
• Host and Port: Set the server address and port number. For Outlook, you can use "outlook.office365.com" and port 993 with SSL.
• AccessToken: Replace "your-access-token" with a valid token obtained via Microsoft or Google OAuth 2.0 flow.
• GetMessageCount("Inbox"): Retrieves the number of emails in the specified folder.
• GetFullMessage(i): Retrieves the full content of the message at the specified index as a MailMessage object.
• MailMessage: Represents an email message. Properties like Subject, From, Date, and BodyHtml allow structured access to message details.

The following screenshot shows the extracted email subject, sender, and HTML body saved from Outlook using IMAP:

By combining Spire.Email’s IMAP interface with OAuth security and flexible MIME parsing, you can reliably automate email reading in C# with full access to both content and context.

If you need examples of how to send emails, please refer to How to Send Emails Using C#.

Read Emails via POP3 in C#

If folder management and server-side search are not required, POP3 offers a simpler alternative to IMAP. The following example demonstrates how to read emails using POP3 with Spire.Email.

using Spire.Email;
using Spire.Email.Pop3;

Pop3Client popClient = new Pop3Client();
popClient.Host = "pop.gmail.com";
popClient.Port = 995;
popClient.EnableSsl = true;
popClient.Username = "[email protected]";
popClient.Password = "your-password";

// Or use OAuth
// popClient.UseOAuth = true;
// popClient.AccessToken = "your-access-token";

popClient.Connect();
popClient.Login();

for (int i = 1; i < popClient.GetMessageCount(); i++)
{
    MailMessage msg = popClient.GetMessage(i);
    Console.WriteLine("Message - " + i);
    Console.WriteLine("Subject: " + msg.Subject);
    Console.WriteLine("From: " + msg.From.Address);
}

popClient.Disconnect();

This screenshot displays the console output after fetching messages via POP3 from Gmail:

Unlike IMAP, POP3 downloads messages but does not maintain folder structure or message states on the server. Choose POP3 for simple retrieval scenarios.

Advanced Email Parsing in C#: Extract Attachments and Plain Text

In many cases, it's necessary to extract the plain-text content of an email for further processing, or to retrieve attachments for downstream use such as storage, analysis, or forwarding. The following C# example demonstrates how to access and save both the plain-text body and attachments using the MailMessage object.

MailMessage message = client.GetFullMessage(index);

// Retrieve plain text content
string plainText = message.BodyText;

// Extract attachments
foreach (Attachment attachment in message.Attachments)
{
    string path = Path.Combine("Attachments", attachment.ContentType.Name);
    Directory.CreateDirectory("Attachments");
    using (var fileStream = new FileStream(path, FileMode.Create, FileAccess.Write))
    {
        attachment.Data.Position = 0;
        attachment.Data.CopyTo(fileStream);
    }
}

Notes:

• Most emails contain both HTML and plain text bodies; use the format appropriate for your application.
• To skip embedded images (like inline logos), check that attachment.ContentDisposition.DispositionType != "Inline".

Below is a sample output showing saved attachments and extracted plain text from the retrieved email:

For more detailed operations such as managing email folders—creating, deleting, or moving messages—please refer to our guide on Email Folder Management in C#.

Summary

With Spire.Email for .NET, you can programmatically access Gmail or Outlook inboxes in C# using either IMAP or POP3. The library supports OAuth 2.0 authentication, parses both HTML and plain-text email bodies, and enables attachment extraction for downstream processing. Whether you're building an internal automation tool, an alerting system, or an email parser, Spire.Email provides the essential components for email integration in .NET applications.

If you'd like to explore all features without limitations, you can apply for a free temporary license.

Frequently Asked Questions

Can I use Spire.Email for sending emails too?

Yes. Spire.Email for .NET includes support for SMTP as well, allowing you to send HTML-formatted emails, add attachments, and configure encoding and headers.

Does Spire.Email work with other email providers?

Yes. As long as the provider supports standard IMAP, POP3, or SMTP protocols, and offers compatible authentication (OAuth or basic), it will work with Spire.Email.

How do I get the access token programmatically?

For Outlook, you can use Microsoft’s MSAL.NET; for Gmail, use Google.Apis.Auth or any other OAuth library that retrieves a valid token with mail access scopes. These tokens can then be passed to the email client for secure login.

Optical Character Recognition (OCR) technology bridges the physical and digital worlds by converting text within images into machine-readable data. For .NET developers, the ability to extract text from images in C# is essential for building intelligent document processing, automated data entry, and accessibility solutions.

In this article, we’ll explore how to implement OCR in C# using the Spire.OCR for .NET library, covering basic extraction, advanced features like coordinate tracking, and best practices to ensure accuracy and efficiency.

Table of Contents:

• Understanding OCR and Spire.OCR
• Setting Up Your OCR Environment
• Basic Recognition: Extract Text from Images in C#
• Advanced Extraction: Extract Text with Coordinates in C#
• Tips to Optimize OCR Accuracy
• FAQs (Supported Languages and Image Formats)
• Conclusion & Free License

Understanding OCR and Spire.OCR

What is OCR?

OCR technology analyzes images of text - such as scanned documents, screenshots, or photos - and converts them into text strings that can be edited, searched, or processed programmatically.

Why Spire.OCR Stands Out?

Spire.OCR for .NET is a powerful, developer-friendly library that enables highly accurate text recognition from images in C# applications. Key features include:

• Support for multiple languages (English, Chinese, Japanese, etc.).
• High accuracy recognition algorithms optimized for various fonts and styles.
• Text coordinate extraction for precise positioning.
• Batch processing capabilities.
• Compatibility with .NET Framework and .NET Core.

Setting Up Your OCR Environment

Before diving into the C# code for image to text OCR operations, configure your development environment first:

1. Install via NuGet:

Open the NuGet Package Manager in Visual Studio. Search for "Spire.OCR" and install the latest version in your project. Alternatively, use the Package Manager Console:

Install-Package Spire.OCR

2. Download OCR Models:

Spire.OCR relies on pre-trained models to recognize image text. Download the model files for your operating system:

• Windows x64
• Linux x64
• MacOS 10.15 and later

After downloading, extract to a directory (e.g., F:\OCR Model\win-x64)

Important Note: Remember to change the platform target of your solution to x64 as Spire.OCR only supports 64-bit platforms.

Basic Recognition: Extract Text from Images in C#

Let’s start with a simple example that demonstrates how to read text from an image using Spire.OCR.

C# code to get text from an image:

using Spire.OCR;
using System.IO;

namespace OCRTextFromImage
{
    internal class Program
    {
        static void Main(string[] args)
        {

            // Create an instance of the OcrScanner class
            OcrScanner scanner = new OcrScanner();

            // Create an instance of the ConfigureOptions class
            ConfigureOptions configureOptions = new ConfigureOptions();

            // Set the path to the OCR model
            configureOptions.ModelPath = "F:\\OCR Model\\win-x64";

            // Set the language for text recognition. (The default is English.)
            configureOptions.Language = "English";

            // Apply the configuration options to the scanner
            scanner.ConfigureDependencies(configureOptions);

            // Scan image and extract text
            scanner.Scan("sample.png");

            // Save the extracted text to a txt file
            string text = scanner.Text.ToString();
            File.WriteAllText("output.txt", text);
        }
    }
}

Code Explanation:

• OcrScanner: Core class for text recognition.
• ConfigureOptions: Sets OCR parameters:
  • ModelPath: Specifies the path to the OCR model files.
  • Language: Defines the recognition language (e.g., "English", "Chinese").
• Scan(): Processes image and extracts text using the configured settings.

Output:

This C# code processes an image file (sample.png) and saves the extracted text to a text file (output.txt) using File.WriteAllText().

Advanced Extraction: Extract Text with Coordinates in C#

In many cases, knowing the position of extracted text within an image is as important as the text itself - for example, when processing invoices, forms, or structured documents. Spire.OCR allows you to extract not just text but also the coordinates of the text blocks, enabling precise analysis.

C# code to extract text with coordinates from an Image:

using Spire.OCR;
using System.Collections.Generic;
using System.IO;

namespace OCRWithCoordinates
{
    internal class Program
    {
        static void Main(string[] args)
        {

            // Create an instance of the OcrScanner class
            OcrScanner scanner = new OcrScanner();

            // Create an instance of the ConfigureOptions class
            ConfigureOptions configureOptions = new ConfigureOptions();

            // Set the path to the OCR model
            configureOptions.ModelPath = "F:\\OCR Model\\win-x64";

            // Set the language for text recognition. (The default is English.)
            configureOptions.Language = "English";

            // Apply the configuration options to the scanner
            scanner.ConfigureDependencies(configureOptions);

            // Extract text from an image
            scanner.Scan("invoice.png");

            // Get the OCR result text
            IOCRText text = scanner.Text;

            // Create a list to store information
            List<string> results = new List<string>();

            // Iterate through each block of the OCR result text
            foreach (IOCRTextBlock block in text.Blocks)
            {
                // Add the text of each block and its location information to the list
                results.Add($"Block Text: {block.Text}");
                results.Add($"Coordinates: {block.Box}");
                results.Add("---------");
            }

            // Save the extracted text with coordinates to a txt file
            File.WriteAllLines("ExtractWithCoordinates.txt", results);
        }
    }
}

Critical Details

• IOCRText: Represents the entire OCR result.
• IOCRTextBlock: Represents a block of contiguous text (e.g., a paragraph, line, or word).
• IOCRTextBlock.Box: Contains the rectangular coordinates of the text block:
  • X (horizontal position)
  • Y (vertical position)
  • Width
  • Height

Output:

This C# code performs OCR on an image file (invoice.png), extracting both the recognized text and its position coordinates in the image, then saves this information to a text file (ExtractWithCoordinates.txt).

Tips to Optimize OCR Accuracy

To ensure reliable results when using C# to recognize text from images, consider these best practices:

• Use high-resolution images (300 DPI or higher).
• Preprocess images (e.g., resize, deskew) for better results.
• Ensure correct language settings correspond to the text in image.
• Store OCR models in a secure, accessible location.

FAQs (Supported Languages and Image Formats)

Q1: What image formats does Spire.OCR support?

A: Spire.OCR supports all common formats:

• PNG
• JPEG/JPG
• BMP
• TIFF
• GIF

Q2: What languages does Spire.OCR support?

A: Multiple languages are supported:

• English (default)
• Chinese (Simplified and Traditional)
• Japanese
• Korean
• German
• French

Q3: Can I use Spire.OCR in ASP.NET Core applications?

A: Yes. Supported environments:

• .NET Framework 2.0+
• .NET Standard 2.0+
• .NET Core 2.0+
• .NET 5

Q4: Can Spire.OCR extract text from scanned PDFs in C#?

A: The task requires the Spire.PDF integration to convert PDFs to images or extract images from scanned PDFs first, and then use the above C# examples to get text from the images.

Conclusion & Free License

Spire.OCR for .NET provides a powerful yet straightforward solution for extracting text from images in C# applications. Whether you’re building a simple tool to convert images to text or a complex system for processing thousands of invoices, by following the techniques and best practices outlined in this guide, you can integrate OCR functionality into your C# applications with ease.

Request a 30-day trial license here to get unlimited OCR capabilities and unlock valuable information trapped in visual format.

Markdown is a lightweight markup language widely used for writing formatted text using simple plain syntax. Favored by developers, writers, and technical content creators for its readability and ease of use, Markdown is perfect for drafting documents, notes, and technical content. However, Markdown files (.md) often need to be converted into other formats such as PDF for official distribution or Excel for data analysis and reporting.

In this comprehensive guide, you will learn how to convert Markdown files to PDF and Excel using C# and Spire.XLS for .NET — a powerful and easy-to-use library that supports direct Markdown loading and exporting to multiple formats. Whether you want to generate polished PDF documents or structured Excel spreadsheets, this tutorial covers everything you need.

Table of Contents

• Why Convert Markdown to PDF and Excel?
• Prerequisites (Library & Environment Setup)
• How to Convert Markdown to PDF in C# (Step-by-Step with Code)
• How to Convert Markdown to Excel in C# (Step-by-Step with Code)
• Complete C# Code Example: Convert Markdown to PDF and Excel in One Go
• Best Practices for Markdown Conversion
• Conclusion
• FAQs

Why Convert Markdown to PDF and Excel?

Markdown is great for writing, but it has limitations when sharing or processing documents:

• PDF files provide a fixed-layout, platform-independent format ideal for sharing polished reports, manuals, or official documentation. PDFs maintain the original style and layout regardless of device or software.
• Excel files are essential when Markdown contains tabular data that you want to analyze, manipulate, or integrate into business processes. Converting Markdown tables to Excel spreadsheets lets you utilize formulas, filters, charts, and data tools effectively.

By converting Markdown to these formats programmatically in C#, you can automate documentation workflows, batch-process files, and integrate with other .NET applications.

Prerequisites (Library & Environment Setup)

Before you start converting Markdown files, ensure your development environment meets the following requirements:

• .NET Framework or .NET Core installed.
• Spire.XLS for .NET: A comprehensive Excel library that supports loading Markdown and exporting to PDF and Excel formats.

Install Spire.XLS via NuGet

You can easily install Spire.XLS in your C# project via NuGet by opening the NuGet Package Manager and executing the following command:

Install-Package Spire.XLS

This package provides all the necessary classes and methods to load Markdown and export documents without relying on Microsoft Office automation.

How to Convert Markdown to PDF in C# (Step-by-Step with Code)

To convert a Markdown file to PDF in C#, follow the steps below:

Step 1: Load the Markdown File

Create a new instance of the Workbook class and load your Markdown file:

Workbook workbook = new Workbook();
workbook.LoadFromMarkdown("test.md");

This method parses the Markdown content, including text and tables, into an Excel workbook structure that Spire.XLS can manipulate.

Step 2: Customize Conversion Settings (Optional)

After loading the Markdown file, you can apply conversion settings to ensure the PDF output retains a clean and readable layout. For example, enabling the SheetFitToPage option ensures that the entire Markdown content fits within a single PDF page.

workbook.ConverterSetting.SheetFitToPage = true;

Step 3: Export as PDF

Save the workbook as a PDF file:

workbook.SaveToFile("output.pdf", FileFormat.PDF);

This generates a well-formatted PDF document preserving the Markdown layout and styling suitable for printing or sharing.

How to Convert Markdown to Excel in C# (Step-by-Step with Code)

After loading the Markdown file into the workbook, you can also export it to an Excel spreadsheet format:

workbook.SaveToFile("output.xls", ExcelVersion.Version97to2003);

You may also choose other Excel versions depending on your target compatibility:

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

The exported Excel file retains tables and structured data from your Markdown, allowing further analysis or manipulation.

Complete C# Code Example: Convert Markdown to PDF and Excel in One Go

Here’s the full example combining both PDF and Excel exports in a single run:

using Spire.Xls;

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

            // Load Markdown content
            workbook.LoadFromMarkdown("test.md");

            // Fit the sheet data to one page (optional)
            workbook.ConverterSetting.SheetFitToPage = true;

            // Export to PDF
            workbook.SaveToFile("output.pdf", FileFormat.PDF);

            // Export to xls (Excel 97-2003 format) 
            workbook.SaveToFile("output.xls", ExcelVersion.Version97to2003);

            // Export to xlsx (Excel 2016 format)
            workbook.SaveToFile("output.xlsx", ExcelVersion.Version2016);

            workbook.Dispose();
        }
    }
}

Best Practices for Markdown Conversion

• Use UTF-8 Encoding: Ensure your Markdown files use UTF-8 encoding, especially if they contain special or non-English characters. This ensures proper character display and avoids encoding errors during conversion.
• Maintain Clean and Well-Formatted Markdown Tables: To achieve accurate and reliable Excel conversions, structure your Markdown tables carefully. Use consistent pipe (|) delimiters and avoid malformed syntax to preserve table integrity in the output spreadsheet.
• Load Once, Export Multiple Formats: For optimal performance, load your Markdown content into the Workbook object a single time, then export it to various formats such as PDF and Excel. This reduces processing overhead and speeds up batch conversions.
• Assess Markdown Complexity: Spire.XLS effectively supports basic Markdown syntax, such as headings and tables. However, advanced features like embedded images or code blocks with syntax highlighting might require pre-processing or conversion through intermediate formats like HTML.
• Choose Appropriate Excel Export Versions: To maximize compatibility with your users’ software, select the Excel file format based on their environment. For example, use the .xls format for legacy Excel 97–2003 users, and .xlsx for Excel 2007 and later versions to ensure broad accessibility and full feature support.

Conclusion

Converting Markdown to PDF and Excel using C# and Spire.XLS is a fast, flexible, and reliable approach to modern document workflows. With minimal code, developers can automate the transformation of lightweight Markdown into professional PDFs for distribution and Excel spreadsheets for business analytics.

This method streamlines technical writing, reporting, and data handling tasks within .NET applications and enables seamless integration with other business processes.

FAQs

Q1: Can I batch convert multiple Markdown files using Spire.XLS in C#?

A1: Yes, you can loop through multiple Markdown files, load each one using Spire.XLS, and export them individually to PDF or Excel formats within the same C# project.

Q2: Is Microsoft Office required to use Spire.XLS for Markdown conversion?

A2: No, Spire.XLS is a standalone library and does not rely on Microsoft Office or Excel being installed on the machine.

Q3: Is Spire.XLS free to use?

A3: Spire.XLS offers a free version with some limitations. A commercial license is available for full features.

Get a Free License

To fully experience the capabilities of Spire.XLS for .NET without any evaluation limitations, you can request a free 30-day trial license.