使用C#将Excel导出为DataTable的实战指南

在数据导入导出、报表生成和数据分析等场景中，经常需要将Excel文件中的数据读取到.NET应用程序中，通常以DataTable的形式进行处理。本文将详细介绍如何使用C#将Excel文件（包括.xlsx和.xls格式）导出为DataTable，涵盖多种常用的方法和库，从基础到进阶，帮助你根据具体需求选择最适合的方案。

一、常用库介绍

在C#中，处理Excel文件并读取为DataTable的常用库包括：

EPPlus：一个功能强大且易于使用的开源库，专门用于处理.xlsx文件（Excel 2007及以上）。它提供了丰富的API，支持读取、写入和操作Excel文件，且性能优异。
ClosedXML：另一个流行的开源库，专注于.xlsx文件的处理。它提供了直观的LINQ-like API，易于使用，适合快速开发。
NPOI：一个功能全面的开源库，支持.xls（Excel 97-2003）和.xlsx（Excel 2007及以上）格式。它基于Apache POI项目，功能强大但API相对复杂。
Microsoft.Office.Interop.Excel：通过COM接口与Microsoft Excel应用程序交互。功能强大，但依赖Excel安装，性能较低，且不适合服务器端应用。

推荐：对于大多数场景，EPPlus和ClosedXML是最受欢迎和易于使用的选择，特别是处理.xlsx文件时。如果需要兼容.xls格式，可以选择NPOI。尽量避免在生产环境中使用Interop.Excel，除非有特殊需求。

本文将以EPPlus和NPOI为例，演示如何将Excel文件导出为DataTable。

二、使用EPPlus将Excel导出为DataTable

1. 安装EPPlus

首先，通过NuGet包管理器安装EPPlus。你可以通过Visual Studio的NuGet包管理器UI或使用NuGet包管理器控制台进行安装。

使用NuGet包管理器控制台：

Install-Package EPPlus

注意：从EPPlus 5开始，库采用了新的许可证模式，社区版（免费）需要在项目中添加许可证上下文。详细信息请参考EPPlus官方文档。

2. 基本实现代码

以下示例展示了如何使用EPPlus将Excel文件（.xlsx）读取为DataTable。

using System;
using System.Data;
using System.IO;
using OfficeOpenXml; // EPPlus命名空间

public class ExcelToDataTableEPPlus
{
    /// <summary>
    /// 使用EPPlus将Excel文件读取为DataTable
    /// </summary>
    /// <param name="filePath">Excel文件路径</param>
    /// <param name="sheetName">工作表名称（可选，默认第一个工作表）</param>
    /// <param name="hasHeader">第一行是否为表头</param>
    /// <returns>包含Excel数据的DataTable</returns>
    public static DataTable ExcelToDataTable(string filePath, string sheetName = null, bool hasHeader = true)
    {
        // 检查文件是否存在
        if (!File.Exists(filePath))
        {
            throw new FileNotFoundException("Excel文件未找到。", filePath);
        }

        // 设置EPPlus的许可证上下文（社区版需要）
        ExcelPackage.LicenseContext = LicenseContext.NonCommercial; // 根据许可证类型设置

        DataTable dataTable = new DataTable();

        // 使用FileStream以只读方式打开文件
        using (FileStream stream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
        {
            using (ExcelPackage package = new ExcelPackage(stream))
            {
                // 获取工作表
                ExcelWorksheet worksheet = string.IsNullOrEmpty(sheetName)
                    ? package.Workbook.Worksheets[0] // 默认第一个工作表
                    : package.Workbook.Worksheets[sheetName];

                if (worksheet == null)
                {
                    throw new ArgumentException($"工作表 '{sheetName}' 未找到。", nameof(sheetName));
                }

                // 获取总行数和列数
                int rowCount = worksheet.Dimension.Rows;
                int colCount = worksheet.Dimension.Columns;

                if (rowCount == 0 || colCount == 0)
                {
                    return dataTable; // 空表格
                }

                // 添加列
                for (int col = 1; col <= colCount; col++)
                {
                    // 使用第一行作为列名（如果hasHeader为true）
                    string columnName = hasHeader && rowCount >= 1
                        ? worksheet.Cells[1, col].Text.Trim()
                        : $"Column{col}";

                    // 避免重复列名
                    if (dataTable.Columns.Contains(columnName))
                    {
                        columnName = $"{columnName}_{col}";
                    }

                    dataTable.Columns.Add(columnName);
                }

                // 确定数据起始行
                int startRow = hasHeader ? 2 : 1;

                // 添加行数据
                for (int row = startRow; row <= rowCount; row++)
                {
                    DataRow dataRow = dataTable.NewRow();
                    for (int col = 1; col <= colCount; col++)
                    {
                        object cellValue = worksheet.Cells[row, col].Value;
                        dataRow[col - 1] = cellValue != null ? cellValue.ToString() : DBNull.Value;
                    }
                    dataTable.Rows.Add(dataRow);
                }
            }
        }

        return dataTable;
    }
}

3. 使用示例

以下是如何使用上述方法的示例代码：

using System;
using System.Data;

class Program
{
    static void Main(string[] args)
    {
        string excelFilePath = @"C:\Path\To\Your\ExcelFile.xlsx"; // 替换为你的Excel文件路径
        string sheetName = "Sheet1"; // 可选，若为空则读取第一个工作表

        try
        {
            DataTable dataTable = ExcelToDataTableEPPlus.ExcelToDataTable(excelFilePath, sheetName, hasHeader: true);

            // 打印DataTable内容
            foreach (DataRow row in dataTable.Rows)
            {
                foreach (DataColumn col in dataTable.Columns)
                {
                    Console.Write($"{col.ColumnName}: {row[col]} \t");
                }
                Console.WriteLine();
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"发生错误: {ex.Message}");
        }
    }
}

4. 代码说明

LicenseContext：从EPPlus 5开始，需要设置许可证上下文。如果是非商业用途，可以使用LicenseContext.NonCommercial。商业用途需要购买许可证并使用LicenseContext.Commercial。
读取工作表：通过package.Workbook.Worksheets获取工作表集合，可以选择指定工作表名称或默认读取第一个工作表。
表头处理：通过hasHeader参数决定是否将第一行作为列名。如果为true，则第一行数据作为列名，数据从第二行开始；否则，列名自动生成（如Column1, Column2…）。
数据读取：遍历每一行和每一列，将单元格的值转换为字符串并添加到DataTable中。如果单元格值为null，则插入DBNull.Value。

5. 处理不同数据类型

上述示例将所有单元格值作为字符串处理。如果需要保留原始数据类型（如整数、日期等），可以根据单元格的数据类型进行转换。EPPlus提供了worksheet.Cells[row, col].Value的类型信息，可以根据需要进行处理。

示例：尝试转换数据类型

object cellValue = worksheet.Cells[row, col].Value;
if (cellValue != null)
{
    // 尝试解析为整数
    if (int.TryParse(cellValue.ToString(), out int intValue))
    {
        dataRow[col - 1] = intValue;
    }
    // 尝试解析为日期
    else if (DateTime.TryParse(cellValue.ToString(), out DateTime dateValue))
    {
        dataRow[col - 1] = dateValue;
    }
    // 其他类型或保持字符串
    else
    {
        dataRow[col - 1] = cellValue.ToString();
    }
}
else
{
    dataRow[col - 1] = DBNull.Value;
}

注意：根据具体需求，你可能需要更复杂的数据类型转换逻辑，确保数据的准确性和一致性。

三、使用NPOI将Excel导出为DataTable

1. 安装NPOI

通过NuGet包管理器安装NPOI。你可以通过Visual Studio的NuGet包管理器UI或使用NuGet包管理器控制台进行安装。

使用NuGet包管理器控制台：

Install-Package NPOI
Install-Package NPOI.OOXML
Install-Package NPOI.OpenXmlFormats

或者直接安装NPOI包，它通常包含所需的依赖项。

Install-Package NPOI

2. 基本实现代码

以下示例展示了如何使用NPOI将Excel文件（支持.xls和.xlsx）读取为DataTable。

using System;
using System.Data;
using System.IO;
using NPOI.SS.UserModel;
using NPOI.XSSF.UserModel; // For .xlsx
using NPOI.HSSF.UserModel; // For .xls

public class ExcelToDataTableNPOI
{
    /// <summary>
    /// 使用NPOI将Excel文件读取为DataTable
    /// </summary>
    /// <param name="filePath">Excel文件路径</param>
    /// <param name="sheetName">工作表名称（可选，默认第一个工作表）</param>
    /// <param name="hasHeader">第一行是否为表头</param>
    /// <returns>包含Excel数据的DataTable</returns>
    public static DataTable ExcelToDataTable(string filePath, string sheetName = null, bool hasHeader = true)
    {
        // 检查文件是否存在
        if (!File.Exists(filePath))
        {
            throw new FileNotFoundException("Excel文件未找到。", filePath);
        }

        DataTable dataTable = new DataTable();

        using (FileStream stream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
        {
            IWorkbook workbook;

            // 根据文件扩展名创建相应的Workbook
            string extension = Path.GetExtension(filePath).ToLower();
            if (extension == ".xlsx")
            {
                workbook = new XSSFWorkbook(stream);
            }
            else if (extension == ".xls")
            {
                workbook = new HSSFWorkbook(stream);
            }
            else
            {
                throw new ArgumentException("不支持的文件格式。仅支持 .xls 和 .xlsx 文件。", nameof(filePath));
            }

            // 获取工作表
            ISheet sheet = string.IsNullOrEmpty(sheetName)
                ? workbook.GetSheetAt(0) // 默认第一个工作表
                : workbook.GetSheet(sheetName);

            if (sheet == null)
            {
                throw new ArgumentException($"工作表 '{sheetName}' 未找到。", nameof(sheetName));
            }

            // 获取总行数
            int rowCount = sheet.LastRowNum + 1; // LastRowNum是从0开始的
            if (rowCount == 0)
            {
                return dataTable; // 空表格
            }

            // 获取表头行
            IRow headerRow = hasHeader ? sheet.GetRow(0) : null;
            int colCount = hasHeader ? (headerRow?.LastCellNum ?? 0) : 0;

            if (hasHeader && headerRow != null)
            {
                // 添加列
                for (int col = 0; col < headerRow.LastCellNum; col++)
                {
                    ICell cell = headerRow.GetCell(col);
                    string columnName = cell?.ToString().Trim() ?? $"Column{col + 1}";
                    
                    // 避免重复列名
                    if (dataTable.Columns.Contains(columnName))
                    {
                        columnName = $"{columnName}_{col + 1}";
                    }

                    dataTable.Columns.Add(columnName);
                }
            }
            else
            {
                // 自动生成列名
                colCount = 0;
                // 假设第一行有数据，根据第一行的单元格数确定列数
                IRow firstDataRow = sheet.GetRow(0);
                if (firstDataRow != null)
                {
                    colCount = firstDataRow.LastCellNum;
                    for (int col = 0; col < colCount; col++)
                    {
                        dataTable.Columns.Add($"Column{col + 1}");
                    }
                }
                else
                {
                    return dataTable; // 空表格
                }
            }

            // 确定数据起始行
            int startRow = hasHeader ? 1 : 0;

            // 遍历数据行
            for (int rowIdx = startRow; rowIdx < rowCount; rowIdx++)
            {
                IRow row = sheet.GetRow(rowIdx);
                if (row == null)
                {
                    continue; // 跳过空行
                }

                DataRow dataRow = dataTable.NewRow();
                for (int colIdx = 0; colIdx < dataTable.Columns.Count; colIdx++)
                {
                    ICell cell = row.GetCell(colIdx);
                    object cellValue = GetCellValue(cell);
                    dataRow[colIdx] = cellValue;
                }
                dataTable.Rows.Add(dataRow);
            }
        }

        return dataTable;
    }

    /// <summary>
    /// 获取单元格的值
    /// </summary>
    /// <param name="cell">单元格对象</param>
    /// <returns>单元格的值</returns>
    private static object GetCellValue(ICell cell)
    {
        if (cell == null)
        {
            return DBNull.Value;
        }

        switch (cell.CellType)
        {
            case CellType.String:
                return cell.StringCellValue;
            case CellType.Numeric:
                if (DateUtil.IsCellDateFormatted(cell))
                {
                    return cell.DateCellValue;
                }
                else
                {
                    return cell.NumericCellValue;
                }
            case CellType.Boolean:
                return cell.BooleanCellValue;
            case CellType.Formula:
                return cell.CellFormula;
            case CellType.Blank:
                return DBNull.Value;
            case CellType.Error:
                return cell.ErrorCellValue;
            default:
                return cell.ToString();
        }
    }
}

3. 使用示例

以下是如何使用上述方法的示例代码：

using System;
using System.Data;

class Program
{
    static void Main(string[] args)
    {
        string excelFilePath = @"C:\Path\To\Your\ExcelFile.xlsx"; // 替换为你的Excel文件路径
        string sheetName = "Sheet1"; // 可选，若为空则读取第一个工作表

        try
        {
            DataTable dataTable = ExcelToDataTableNPOI.ExcelToDataTable(excelFilePath, sheetName, hasHeader: true);

            // 打印DataTable内容
            foreach (DataRow row in dataTable.Rows)
            {
                foreach (DataColumn col in dataTable.Columns)
                {
                    Console.Write($"{col.ColumnName}: {row[col]} \t");
                }
                Console.WriteLine();
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"发生错误: {ex.Message}");
        }
    }
}

4. 代码说明

文件格式支持：NPOI支持.xls（HSSFWorkbook）和.xlsx（XSSFWorkbook）格式。根据文件扩展名创建相应的IWorkbook实例。
工作表选择：通过sheetName参数选择特定的工作表，若为空则默认读取第一个工作表。
表头处理：通过hasHeader参数决定是否将第一行作为列名。如果为true，则第一行数据作为列名，数据从第二行开始；否则，列名自动生成（如Column1, Column2…）。
数据读取：遍历每一行和每一列，通过GetCellValue方法获取单元格的值，并根据单元格类型进行相应处理。将值添加到DataTable中，若单元格为null，则插入DBNull.Value。
GetCellValue方法：根据单元格的类型（字符串、数字、布尔值、公式、空白、错误等），返回相应的值。对于日期类型的数字单元格，使用DateUtil.IsCellDateFormatted判断是否为日期格式。

5. 处理不同数据类型

与EPPlus类似，上述示例将大部分单元格值作为对象处理，可以根据需要进一步转换数据类型。NPOI提供了丰富的单元格类型信息，可以根据具体需求进行更精确的数据类型处理。

示例：尝试转换数据类型

private static object GetCellValue(ICell cell)
{
    if (cell == null)
    {
        return DBNull.Value;
    }

    switch (cell.CellType)
    {
        case CellType.String:
            return cell.StringCellValue;
        case CellType.Numeric:
            if (DateUtil.IsCellDateFormatted(cell))
            {
                return cell.DateCellValue;
            }
            else
            {
                // 尝试转换为整数或保留为double
                double numValue = cell.NumericCellValue;
                if (numValue == Math.Floor(numValue) && numValue <= int.MaxValue && numValue >= int.MinValue)
                {
                    return (int)numValue;
                }
                else
                {
                    return numValue;
                }
            }
        case CellType.Boolean:
            return cell.BooleanCellValue;
        case CellType.Formula:
            // 可以根据需要处理公式结果
            return cell.CellFormula;
        case CellType.Blank:
            return DBNull.Value;
        case CellType.Error:
            return cell.ErrorCellValue;
        default:
            return cell.ToString();
    }
}

注意：根据具体需求，你可能需要更复杂的数据类型转换逻辑，确保数据的准确性和一致性。

四、方法比较与选择建议

库名称	支持格式	是否需要Excel安装	性能	易用性	适合场景
EPPlus	`.xlsx`	否	高	高	主要处理`.xlsx`文件，功能丰富，易于使用，推荐用于大多数`.xlsx`场景
ClosedXML	`.xlsx`	否	高	高	类似EPPlus，提供LINQ-like API，适合快速开发
NPOI	`.xls` 和 `.xlsx`	否	中	中	需要兼容`.xls`和`.xlsx`，功能全面，但API相对复杂
Microsoft.Office.Interop.Excel	`.xls` 和 `.xlsx`	是	低	低	需要与Excel应用程序交互，不推荐用于服务器端或高性能场景

推荐选择：

主要处理.xlsx文件：选择EPPlus或ClosedXML，两者都易于使用且性能优异。EPPlus在社区中更为流行，文档丰富。
需要兼容.xls和.xlsx：选择NPOI，功能全面但API相对复杂。
需要与Excel应用程序交互：选择Microsoft.Office.Interop.Excel，但仅适用于有Excel安装的环境，且不推荐用于服务器端应用。

五、进阶功能与优化

1. 处理大文件

对于非常大的Excel文件，直接将整个文件加载到DataTable可能会导致内存消耗过高。可以考虑以下优化策略：

分页读取：仅读取需要的行数或分批读取数据。
流式读取：使用支持流式读取的库或方法，逐行处理数据。
使用数据流：结合数据库或其他存储方式，逐步导入数据。

注意：EPPlus和NPOI在处理大文件时性能表现良好，但仍需根据具体情况进行优化。

2. 数据类型转换

上述示例将大部分单元格值作为字符串或对象处理。根据具体需求，可以进一步将数据转换为适当的数据类型（如整数、日期、布尔值等），以提高数据处理的准确性和效率。

示例：在EPPlus中转换数据类型

// 在添加行数据时进行类型转换
for (int row = startRow; row <= rowCount; row++)
{
    DataRow dataRow = dataTable.NewRow();
    for (int col = 1; col <= colCount; col++)
    {
        object cellValue = worksheet.Cells[row, col].Value;
        if (cellValue != null)
        {
            // 尝试解析为整数
            if (int.TryParse(cellValue.ToString(), out int intValue))
            {
                dataRow[col - 1] = intValue;
            }
            // 尝试解析为日期
            else if (DateTime.TryParse(cellValue.ToString(), out DateTime dateValue))
            {
                dataRow[col - 1] = dateValue;
            }
            // 尝试解析为布尔值
            else if (bool.TryParse(cellValue.ToString(), out bool boolValue))
            {
                dataRow[col - 1] = boolValue;
            }
            // 其他情况保持字符串
            else
            {
                dataRow[col - 1] = cellValue.ToString();
            }
        }
        else
        {
            dataRow[col - 1] = DBNull.Value;
        }
    }
    dataTable.Rows.Add(dataRow);
}

3. 处理多个工作表

如果Excel文件中包含多个工作表，且需要将所有工作表的数据读取到多个DataTable中，可以遍历工作表并进行相应处理。

示例：读取所有工作表到多个DataTable

public static Dictionary<string, DataTable> ExcelToDataTables(string filePath, bool hasHeader = true)
{
    var tables = new Dictionary<string, DataTable>();

    using (FileStream stream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
    {
        using (ExcelPackage package = new ExcelPackage(stream))
        {
            foreach (var worksheet in package.Workbook.Worksheets)
            {
                DataTable dt = new DataTable(worksheet.Name);

                // 获取表头
                int colCount = worksheet.Dimension?.Columns ?? 0;
                if (hasHeader && worksheet.Dimension?.Rows >= 1)
                {
                    for (int col = 1; col <= colCount; col++)
                    {
                        string columnName = worksheet.Cells[1, col].Text.Trim();
                        if (string.IsNullOrEmpty(columnName))
                        {
                            columnName = $"Column{col}";
                        }
                        dt.Columns.Add(columnName);
                    }
                }
                else
                {
                    for (int col = 1; col <= colCount; col++)
                    {
                        dt.Columns.Add($"Column{col}");
                    }
                }

                // 获取数据起始行
                int startRow = hasHeader ? 2 : 1;
                int rowCount = worksheet.Dimension?.Rows ?? 0;

                for (int row = startRow; row <= rowCount; row++)
                {
                    DataRow dataRow = dt.NewRow();
                    for (int col = 1; col <= colCount; col++)
                    {
                        object cellValue = worksheet.Cells[row, col].Value;
                        dataRow[col - 1] = cellValue != null ? cellValue.ToString() : DBNull.Value;
                    }
                    dt.Rows.Add(dataRow);
                }

                tables.Add(worksheet.Name, dt);
            }
        }
    }

    return tables;
}

4. 异常处理与日志记录

在实际应用中，建议添加适当的异常处理和日志记录，以便在读取过程中出现问题时能够及时发现和处理。

示例：添加异常处理

try
{
    DataTable dataTable = ExcelToDataTableEPPlus.ExcelToDataTable(excelFilePath, sheetName, hasHeader: true);
    // 处理dataTable
}
catch (FileNotFoundException ex)
{
    Console.WriteLine($"文件未找到: {ex.Message}");
}
catch (ArgumentException ex)
{
    Console.WriteLine($"参数错误: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"发生未知错误: {ex.Message}");
}

六、完整示例：使用EPPlus读取Excel并显示数据

以下是一个完整的控制台应用程序示例，展示如何使用EPPlus将Excel文件读取为DataTable并打印其内容。

1. 创建控制台项目

使用Visual Studio或.NET CLI创建一个新的控制台应用程序项目。

2. 安装EPPlus

通过NuGet包管理器控制台安装EPPlus：

Install-Package EPPlus

3. 编写代码

Program.cs

using System;
using System.Data;
using System.IO;
using OfficeOpenXml;

namespace ExcelToDataTableExample
{
    class Program
    {
        static void Main(string[] args)
        {
            // 替换为你的Excel文件路径
            string excelFilePath = @"C:\Path\To\Your\ExcelFile.xlsx";
            string sheetName = "Sheet1"; // 可选，若为空则读取第一个工作表

            try
            {
                // 调用EPPlus方法读取Excel
                DataTable dataTable = ExcelToDataTableEPPlus.ExcelToDataTable(excelFilePath, sheetName, hasHeader: true);

                // 打印DataTable内容
                Console.WriteLine($"工作表 '{sheetName}' 的数据:");
                Console.WriteLine(new string('-', 50));

                // 打印列名
                foreach (DataColumn col in dataTable.Columns)
                {
                    Console.Write($"{col.ColumnName}\t");
                }
                Console.WriteLine();
                Console.WriteLine(new string('-', 50));

                // 打印行数据
                foreach (DataRow row in dataTable.Rows)
                {
                    foreach (DataColumn col in dataTable.Columns)
                    {
                        Console.Write($"{row[col]}\t");
                    }
                    Console.WriteLine();
                }

                Console.WriteLine("\n读取完成。");
            }
            catch (FileNotFoundException ex)
            {
                Console.WriteLine($"文件未找到: {ex.Message}");
            }
            catch (ArgumentException ex)
            {
                Console.WriteLine($"参数错误: {ex.Message}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"发生错误: {ex.Message}");
            }

            Console.ReadLine();
        }
    }

    public static class ExcelToDataTableEPPlus
    {
        public static DataTable ExcelToDataTable(string filePath, string sheetName = null, bool hasHeader = true)
        {
            if (!File.Exists(filePath))
            {
                throw new FileNotFoundException("Excel文件未找到。", filePath);
            }

            ExcelPackage.LicenseContext = LicenseContext.NonCommercial; // 根据许可证类型设置

            DataTable dataTable = new DataTable();

            using (FileStream stream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
            {
                using (ExcelPackage package = new ExcelPackage(stream))
                {
                    ExcelWorksheet worksheet = string.IsNullOrEmpty(sheetName)
                        ? package.Workbook.Worksheets[0]
                        : package.Workbook.Worksheets[sheetName];

                    if (worksheet == null)
                    {
                        throw new ArgumentException($"工作表 '{sheetName}' 未找到。", nameof(sheetName));
                    }

                    int rowCount = worksheet.Dimension.Rows;
                    int colCount = worksheet.Dimension.Columns;

                    if (rowCount == 0 || colCount == 0)
                    {
                        return dataTable;
                    }

                    for (int col = 1; col <= colCount; col++)
                    {
                        string columnName = hasHeader && rowCount >= 1
                            ? worksheet.Cells[1, col].Text.Trim()
                            : $"Column{col}";

                        if (dataTable.Columns.Contains(columnName))
                        {
                            columnName = $"{columnName}_{col}";
                        }

                        dataTable.Columns.Add(columnName);
                    }

                    int startRow = hasHeader ? 2 : 1;

                    for (int row = startRow; row <= rowCount; row++)
                    {
                        DataRow dataRow = dataTable.NewRow();
                        for (int col = 1; col <= colCount; col++)
                        {
                            object cellValue = worksheet.Cells[row, col].Value;
                            dataRow[col - 1] = cellValue != null ? cellValue.ToString() : DBNull.Value;
                        }
                        dataTable.Rows.Add(dataRow);
                    }
                }
            }

            return dataTable;
        }
    }
}