With the help of Spire.Doc for .NET, developers can easily set bullet style for the existing word documents via invoke p.ListFormat.ApplyBulletStyle() method to format. This article will show you how to convert HTML list into word and set the bullet style for the word list in C#.

Firstly, please view the effective screenshot for the result word document:

Here comes to the steps:

Step 1: Create a new document and add a section to the document.

Document document = new Document();
Section section=document.AddSection();

Step 2: Add word list to the paragraph by appending HTML.

Paragraph paragraph = section.AddParagraph();
paragraph.AppendHTML("<ol><li>Version 1</li><li>Version 2</li><li>Version 3</li></ol>");

Step 3: Set the bullet style for the paragraph.

foreach (Paragraph p in section.Paragraphs)
{
    p.ApplyStyle(BuiltinStyle.Heading2);

    if (p.ListFormat.CurrentListLevel != null)
    {
        p.ListFormat.ApplyBulletStyle();
    }
}

Step 4: Save the document to file

document.SaveToFile("result.docx",FileFormat.Docx);

Full codes:

// Create a new Word document object
Document document = new Document();

// Add a section to the document
Section section = document.AddSection();

// Add a paragraph to the section
Paragraph paragraph = section.AddParagraph();

// Append HTML content to the paragraph 
paragraph.AppendHTML("
Version 1
Version 2
Version 3
");


// Loop through all paragraphs in the section
foreach (Paragraph p in section.Paragraphs)
{
    // Apply "Heading 2" built-in style to the paragraph
    p.ApplyStyle(BuiltinStyle.Heading2);

    // Check if the paragraph has listformat
    if (p.ListFormat.CurrentListLevel != null)
    {
        // Apply bullet style
        p.ListFormat.ApplyBulletStyle();
    }
}

// Save the document to a file in DOCX format
document.SaveToFile("result.docx", FileFormat.Docx);

// Dispose
document.Dispose();

Working with large Excel files often means merging rows, columns, or specific cell ranges to keep the data clean and easy to read. You can merge cells in Excel using C# or VB.NET with just a few lines of code and even center the content both horizontally and vertically for a professional look. Whether it’s combining entire rows, joining columns, or formatting a selected range, these examples show how to automate the process and improve your workflow.

• Merge Rows or Columns in Excel using C#
• Merge a Specific Cell Range in Excel
• Merge and Center Cells in Excel using VB.NET
• The Conclusion

If you often work with Excel files in .NET projects, handling tasks like merging cells, formatting data, or generating reports, you’ll want a tool that makes the process fast and reliable. Spire.XLS is a lightweight library that lets you create, read, and modify Excel files directly in C# or VB.NET—without relying on Microsoft Office. You can add it to your project in seconds via NuGet:

PM> Install-Package Spire.XLS

From there, you’re ready to start automating your Excel workflow.

Merge Rows or Columns in Excel using C#

Merging rows or columns in Excel is a common way to organize data and create professional-looking spreadsheets. For example, you can merge the first row across multiple columns to form a clear, centered table header. Using C# code, this process can be automated easily, saving time and ensuring consistency across large Excel files.

Here's the code example of merging the first row and centering it in Excel using C#:

using Spire.Xls;
namespace MergeCells
{

    class Program
    {

        static void Main(string[] args)
        {
            // Create a Workbook instance and load an Excel file
            Workbook workbook = new Workbook();
            workbook.LoadFromFile("\\Population.xlsx");

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

            // Merge the first row
            sheet.Rows[0].Merge();
            // Merge the first column
            //sheet.Columns[0].Merge();

            // Set the alignment to center horizontally and vertically
            sheet.Rows[0].Style.HorizontalAlignment = HorizontalAlignType.Center;
            sheet.Rows[0].Style.VerticalAlignment = VerticalAlignType.Center;

            // Save the Excel file
            workbook.SaveToFile("\\Mergerowsandcenter.xls");

        }
    }
}

Here's the preview of merging the first row in Excel:

Code steps explained:

• Create a Workbook object and read an Excel file.
• Get a worksheet.
• Merge a certain row using Worksheet.Rows[].Merge() method.
• Set the alignment to center horizontally and vertically by adjusting the Style.HorizontalAlignment and Style.VerticalAlignment properties.
• Save the modified Excel file.

The C# code above for merging rows in an Excel file can also be used to merge columns, which is indicated with comments in the code.

After merging cells to create a clean table header, you might sometimes need to undo the operation. You can easily unmerge cells in Excel in C# or VB.NET, restoring the original cell layout without affecting your data.

Merge a Specific Cell Range in Excel

Merging a specific cell range in Excel using C# is useful when you want to highlight a section of data, such as a summary row or a group of related columns. The process is very similar to merging entire rows or columns, and you can use the same Merge() method—applied to a CellRange object via Worksheet.Range[].Merge() method. By specifying the exact range to merge, you can create a clear, organized layout that improves readability and automates the operation across multiple sheets or files without manually adjusting each cell.

The code example below demonstrates how to merge the cell range "B6:E6" in an Excel worksheet using C#:

using Spire.Xls;
namespace MergeCells
{

    class Program
    {

        static void Main(string[] args)
        {
            // Create a Workbook instance and load an Excel file
            Workbook workbook = new Workbook();
            workbook.LoadFromFile("\\Population.xlsx");

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

            // Merge the particular cell range in Excel 
            sheet.Range["B6:E6"].Merge();

            // Save the Excel file
            workbook.SaveToFile("\\Mergecellrange.xls");

        }
    }
}

Here's the preview of merging a cell range in an Excel file using C#:

Merge and Center Cells in Excel using VB.NET

Just like in C#, you can merge and center cells in Excel using VB.NET to create clean table headers or highlight key data sections. The steps are very similar, and the same Merge() method applies to rows, columns, or specific cell ranges. If you want, you can even convert C# examples to VB.NET using our handy C# ↔ VB.NET code converter, making it easy to adapt existing code for your project.

Here's a code example of merging the first row and centering it in Excel using VB.NET:

Imports Spire.Xls

Namespace MergeCells

    Friend Class Program

        Private Shared Sub Main(args As String())
            ' Create a Workbook instance and load an Excel file
            Dim workbook As Workbook = New Workbook()
            workbook.LoadFromFile("E:\Administrator\Python1\input\Population.xlsx")

            ' Get the first worksheet
            Dim sheet As Worksheet = workbook.Worksheets(0)

            ' Merge the first row
            sheet.Rows(0).Merge()
            ' Merge the first column
            'sheet.Columns[0].Merge();

            ' Set the alignment to center horizontally and vertically
            sheet.Rows(0).Style.HorizontalAlignment = HorizontalAlignType.Center
            sheet.Rows(0).Style.VerticalAlignment = VerticalAlignType.Center

            ' Save the Excel file
            workbook.SaveToFile("\Mergerowsandcenter.xls")

        End Sub
    End Class
End Namespace

The Conclusion

By following these examples, you can merge cells in Excel using C#, whether it’s entire rows, columns, or specific ranges. With the help of Spire.XLS, you can merge cells in Excel files automatically without hassle and create clear, professional-looking spreadsheets. Start streamlining your workflow today and get a 30-day free license to try all features without restrictions.

Working with Excel data is a common requirement in .NET development. Developers often need to convert Excel files into a DataTable, which provides a structured way to manipulate data, perform LINQ queries, bind to UI controls, or import into a database.

Although this task is common, the implementation details are not always straightforward. Converting Excel data into a DataTable in C# can be achieved in several ways, but traditional approaches often depend on OLEDB drivers or involve lengthy OpenXML programming, both of which add unnecessary complexity and external dependencies. In this guide, we’ll use Spire.XLS for .NET to simplify the process of importing Excel data into a DataTable with C# code. The library provides built-in methods to load Excel files, export worksheets or specific ranges, and work with the data directly in a DataTable.

Quick Navigation

• What is a DataTable and Why Use It?
• Preparing the Environment
• Converting Excel to DataTable in C#
• Bonus: Exporting DataTable Back to Excel
• Handling Large Excel Files and Performance Tips
• Best Practices
• Conclusion
• FAQ

What is a DataTable and Why Use It?

A DataTable in C# is a memory-resident representation of structured data. It allows developers to:

• Store Excel data in tabular form.
• Perform filtering, sorting, and LINQ queries.
• Bind to UI components like DataGridView.
• Bulk insert into relational databases.

Compared with DataSet, a DataTable is lightweight and especially well-suited for working with a single worksheet or range of data.

Preparing the Environment

Before starting, install Spire.XLS for .NET in your project. The easiest way is through NuGet:

Install-Package Spire.XLS

Then, import the required namespaces in your C# code:

using Spire.Xls;
using System.Data;

Converting Excel to DataTable in C#

The following sections demonstrate how to load an Excel file and convert its contents into a DataTable using Spire.XLS. Unlike older methods that depend on OLEDB, this library works without Microsoft Office installation, making it reliable for both desktop and server-side applications.

Load an Excel File

Workbook workbook = new Workbook();
workbook.LoadFromFile("Sample.xlsx");

This creates a Workbook object from the specified Excel file, which you can then use to access individual worksheets.

Convert a Worksheet to DataTable

Worksheet sheet = workbook.Worksheets[0];
DataTable dataTable = sheet.ExportDataTable(sheet.AllocatedRange, true);

Here, the entire first worksheet is exported to a DataTable.

• sheet.AllocatedRange retrieves the used range of the worksheet.
• The true parameter means the first row will be treated as column headers.

This approach is useful when you want to import all data from a sheet directly into a DataTable, for example when binding to a DataGridView or performing bulk inserts into a database.

Convert a Specific Range to DataTable

DataTable partialTable = sheet.ExportDataTable(sheet.Range["A1:C10"], true);

This snippet converts only the range A1:C10 into a DataTable. It’s a practical choice when dealing with large Excel files, where only part of the sheet is needed for processing, or when extracting a specific report section.

Complete Example: Excel Worksheet to DataTable with C#

The following example demonstrates the entire workflow of loading an Excel file and converting it into a DataTable. After running this code, you can process the table further, such as querying, filtering, or inserting into a database.

using Spire.Xls;
using System.Data;

class Program
{
    static void Main()
    {
        // Load Excel file
        Workbook workbook = new Workbook();
        workbook.LoadFromFile("Sample.xlsx");

        // Convert first worksheet to DataTable
        Worksheet sheet = workbook.Worksheets[0];
        DataTable dataTable = sheet.ExportDataTable(sheet.AllocatedRange, true);

        // Print row count
        Console.WriteLine("Rows imported: " + dataTable.Rows.Count);

        // Print column names
        foreach (DataColumn col in dataTable.Columns)
        {
            Console.Write(col.ColumnName + "\t");
        }
        Console.WriteLine();

        // Print all rows
        foreach (DataRow row in dataTable.Rows)
        {
            foreach (var item in row.ItemArray)
            {
                Console.Write(item + "\t");
            }
            Console.WriteLine();
        }
    }
}

This code loads the first worksheet from an Excel file, exports its content into a DataTable, and prints the table to the console. The following screenshot shows an example of the output:

For scenarios where you need to read Excel data cell by cell, see our guide on reading Excel files in C#.

Bonus: Exporting DataTable Back to Excel in C#

In some cases, you may also need to write modified data from a DataTable back to Excel. This can be done easily:

Workbook wb = new Workbook();
Worksheet ws = wb.Worksheets[0];

// Assume dataTable is already populated
ws.InsertDataTable(dataTable, true, 1, 1);

wb.SaveToFile("Output.xlsx", ExcelVersion.Version2016);

This code inserts the DataTable starting at cell A1 and saves the file. It demonstrates the reverse workflow, ensuring smooth two-way data exchange between Excel and C#. For more details, you can check How to Export DataTable into Excel in C#.

Handling Large Excel Files and Performance Tips

When working with large Excel files, performance optimization is key. Here are a few best practices:

• Read only the required worksheets instead of loading all.
• Export specific ranges rather than entire sheets if possible.
• Use stream-based methods (LoadFromStream) to avoid file locks.
• Minimize memory usage by processing rows iteratively when handling very large DataTables.

Spire.XLS supports .xls, .xlsx, and .csv formats consistently, making it suitable across different scenarios.

Best Practices

When converting Excel to DataTable, keep in mind:

• Data type handling: Excel stores values as text by default. Convert them to int, decimal, or DateTime as needed.
• Null or empty cells: Always check for missing values to prevent runtime errors.
• Database integration: Before bulk inserting into SQL Server or another database, validate and sanitize the DataTable.

Conclusion

Converting Excel data into a DataTable is a common but critical task in .NET development. With Spire.XLS for .NET, you can achieve this efficiently without relying on OLEDB drivers or complex OpenXML parsing.

Whether you need to convert an entire worksheet, extract a specific range, or write data back to Excel, the process remains straightforward and reliable. Mastering this workflow ensures smoother integration between Excel data and your C# applications.

If you want to unlock the full feature set of Spire.XLS, you can apply for a free temporary license. For smaller projects, you can also use Free Spire.XLS for .NET.

FAQ

Q: How do I import data from Excel to DataTable in C#?

Use Worksheet.ExportDataTable() to directly convert worksheet data into a DataTable.

Q: Can I read Excel into DataTable without OLEDB?

Yes. Spire.XLS does not require OLEDB or Microsoft Office installation.

Q: How to read only a specific worksheet or range into a DataTable?

Pass the target Worksheet or Range to ExportDataTable().

Q: Can I export a DataTable back to Excel in C#?

Yes. Use Worksheet.InsertDataTable() and then save the file with SaveToFile().