Excel 常用于数据录入、整理和报表展示，而 JSON 则广泛应用于接口通信、前后端数据交互和系统集成。当数据需要在业务人员使用的 Excel 文件与程序使用的 JSON 格式之间流转时，就需要完成两种格式的相互转换。

本文将详细介绍如何使用 C# 和 Spire.XLS for .NET 库实现 Excel 转 JSON 和 JSON 转 Excel。内容涵盖导出整个工作簿、指定工作表和单元格区域为 JSON，自定义 JSON 输出格式，以及扁平或嵌套 JSON 数据写入 Excel 等常见场景，并提供可直接参考的代码示例。

目录

• 为什么要在 Excel 与 JSON 之间进行转换
• 开发环境准备与库安装
• C# Excel 转 JSON 基础示例
• Excel 转 JSON 自定义设置
  • 将指定工作表转换为 JSON
  • 将指定单元格区域转换为 JSON
  • 自定义 JSON 输出格式
• C# JSON 转 Excel 示例
• 实用技巧
• 常见问题解答
• 总结

为什么要在 Excel 与 JSON 之间进行转换？

在 .NET 应用程序中，Excel（.xlsx 或 .xls）与 JSON 之间的转换通常用于以下场景：

• 导入业务数据：将业务人员提交的 Excel 表格转换为后端程序可以处理的数据结构。
• 对接 API：将 Excel 中的表格数据整理为接口所需的 JSON 请求数据。
• 前后端数据传输：将服务端数据转换为 JSON，供网页、移动端或 JavaScript 应用使用。
• 迁移到文档数据库：将表格数据转换为适合 MongoDB、Cosmos DB 等数据库存储的 JSON。
• 生成 Excel 报表：将接口或业务系统返回的 JSON 数据整理为便于用户查看和分析的 Excel 报表。

开发环境准备与库安装

开始之前，请确保开发环境满足以下要求：

• Visual Studio（建议使用 2019 或更高版本）
• .NET 环境： .NET Framework 4.0+、.NET Core 3.1+ 或 .NET 5.0+
• NuGet 程序包：
  • Spire.XLS for .NET（15.11.3 或更高版本）
  • Newtonsoft.Json（用于 JSON 的序列化、反序列化和自定义格式）

安装所需的 NuGet 程序包

方法一：使用 .NET 程序包管理器控制台

在 Visual Studio 中打开项目，然后在“程序包管理器控制台”中执行以下命令：

Install-Package Spire.XLS
Install-Package Newtonsoft.Json

方法二：使用 .NET CLI

在终端环境中进行跨平台开发时，可在项目根目录执行以下命令：

dotnet add package Spire.XLS
dotnet add package Newtonsoft.Json

C# Excel 转 JSON 基础示例

从 Spire.XLS for .NET 15.11.3 版本开始，开发者可以调用 SaveToFile() 方法，直接将 Excel 文件导出为 JSON 文件。这种方式适合转换整个工作簿，并且不需要自定义 JSON 结构的场景。

实现步骤

1. 创建一个新的 Workbook 对象。
2. 调用 LoadFromFile() 方法加载 Excel 工作簿。
3. 调用 SaveToFile() 方法，并将输出格式指定为 FileFormat.Json。

完整代码示例

using System;
using Spire.Xls;

namespace ConvertExcelToJSON
{
    class Program
    {
        static void Main(string[] args)
        {
            string inputFile = @"Sample.xlsx";
            string outputFile = @"output.json";

            try
            {
                // 创建 Workbook 对象
                using (Workbook workbook = new Workbook())
                {
                    // 加载 Excel 文件
                    workbook.LoadFromFile(inputFile);

                    // 将整个工作簿保存为一个 JSON 文件
                    // 此功能需要 Spire.XLS 15.11.3 或更高版本
                    workbook.SaveToFile(outputFile, FileFormat.Json);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"转换过程中发生错误：{ex.Message}");
            }
        }
    }
}

输出的 JSON 文件：

转换后的 JSON 结构与 Excel 的对照关系如下：

• 工作表名称 → 对应 JSON 最外层对象中的键（Key）。
• 每个工作表中的数据 → 对应一个数组，数组中的每个对象表示一行数据。
• 表头行的单元格内容 → 默认作为每个数据对象的字段名称。

Excel 转 JSON 自定义设置

直接将整个工作簿保存为 JSON 非常高效，但在一些场景中，需要对转换范围或输出格式进行更精细的控制，例如只转换指定工作表、指定单元格区域，或者自定义 JSON 的输出结构。针对这些需求，Spire.XLS 提供了相应的处理方式。

将指定工作表转换为 JSON

如果只需要转换工作簿中的某一个工作表，可以先将目标工作表复制到一个新的工作簿中，再将新工作簿保存为 JSON。

实现步骤

1. 使用 LoadFromFile() 加载源工作簿。
2. 通过索引或名称获取目标工作表。
3. 创建一个新 Workbook 对象。
4. 调用 Worksheets.AddCopy()，将目标工作表复制到新工作簿。
5. 在新工作簿上调用 SaveToFile()，并指定输出格式为 FileFormat.Json。

完整代码示例

using System;
using Spire.Xls;

namespace ConvertWorksheetToJSON
{
    class Program
    {
        static void Main(string[] args)
        {
            string inputFile = @"Sample.xlsx";
            string outputFile = @"sheet_output.json";

            try
            {
                using (Workbook sourceWorkbook = new Workbook())
                {
                    sourceWorkbook.LoadFromFile(inputFile);

                    // 通过索引获取第一个工作表
                    // 也可以按名称获取：sourceWorkbook.Worksheets["sheetName"]
                    Worksheet targetSheet = sourceWorkbook.Worksheets[0];

                    using (Workbook newWorkbook = new Workbook())
                    {
                        // 删除新工作簿中默认创建的工作表
                        newWorkbook.Worksheets.Clear();

                        // 将目标工作表复制到新工作簿
                        newWorkbook.Worksheets.AddCopy(targetSheet);

                        // 将新工作簿保存为 JSON 文件
                        newWorkbook.SaveToFile(outputFile, FileFormat.Json);
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"转换过程中发生错误：{ex.Message}");
            }
        }
    }
}

将指定单元格区域转换为 JSON

如果只需要导出工作表中的部分数据，例如某个表格或指定区域，可以先将目标区域复制到一个新的工作簿中，再将新工作簿保存为 JSON。

实现步骤

1. 加载源工作簿。
2. 获取包含目标数据的工作表。
3. 定义需要导出的单元格区域，例如 worksheet.Range["A1:D3"]。
4. 创建一个新的 Workbook 对象。
5. 使用 Worksheet.Copy() 将目标区域复制到新工作簿的工作表中。
6. 调用 SaveToFile()，并指定 FileFormat.Json，将新工作簿保存为 .json 文件。

完整代码示例

using System;
using Spire.Xls;

namespace ConvertExcelToJSON
{
    class Program
    {
        static void Main(string[] args)
        {
            string inputFile = @"Sample.xlsx";
            string outputFile = @"range_output.json";

            try
            {
                using (Workbook sourceWorkbook = new Workbook())
                {
                    sourceWorkbook.LoadFromFile(inputFile);
                    Worksheet sourceWorksheet = sourceWorkbook.Worksheets[0];

                    // 定义需要导出的区域，例如 A1:D3
                    CellRange sourceRange = sourceWorksheet.Range["A1:D3"];

                    using (Workbook targetWorkbook = new Workbook())
                    {
                        // 删除默认工作表
                        targetWorkbook.Worksheets.Clear();

                        // 新建一个用于保存所选区域的工作表
                        Worksheet targetWorksheet = targetWorkbook.Worksheets.Add("RangeData");

                        // 定义与源区域大小一致的目标区域
                        CellRange destinationRange = targetWorksheet.Range["A1:D3"];

                        // 将单元格的值和样式复制到新工作簿
                        sourceWorksheet.Copy(sourceRange, destinationRange, true);

                        // 将新工作簿保存为 JSON
                        targetWorkbook.SaveToFile(outputFile, FileFormat.Json);
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"导出单元格区域时发生错误：{ex.Message}");
            }
        }
    }
}

自定义 JSON 输出格式

SaveToFile() 方法可以快速完成转换，但生成的 JSON 格式是固定的。如果需要更灵活地控制输出样式，可以使用 ExportDataTable() 方法将工作表数据导出为 DataTable，再使用 Newtonsoft.Json 进行序列化。通过这种方式，可以自定义属性名称、空值处理、日期格式和缩进方式等内容。

实现步骤

1. 加载 Excel 文件。
2. 获取目标工作表，并使用 ExportDataTable() 将数据导出为 DataTable。
3. 配置 JsonSerializerSettings，定义 camelCase 命名、空值处理、日期格式等规则。
4. 使用 JsonConvert.SerializeObject()，将 DataTable 按指定规则序列化为 JSON。
5. 将生成的 JSON 字符串保存到文件。

完整代码示例

using System;
using System.Data;
using System.IO;
using Spire.Xls;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;

namespace ConvertExcelToJSON
{
    class Program
    {
        static void Main(string[] args)
        {
            string excelFilePath = @"Sample.xlsx";
            string jsonOutputPath = "custom_output.json";

            try
            {
                using (Workbook workbook = new Workbook())
                {
                    workbook.LoadFromFile(excelFilePath);
                    Worksheet worksheet = workbook.Worksheets[0];

                    // 将表格数据转换为内存中的 DataTable
                    DataTable dataTable = worksheet.ExportDataTable(worksheet.AllocatedRange, true);

                    // 定义 JSON 序列化规则
                    JsonSerializerSettings settings = new JsonSerializerSettings
                    {
                        Formatting = Formatting.Indented, // 使用缩进，提高可读性
                        ContractResolver = new CamelCasePropertyNamesContractResolver(), // 使用 camelCase 命名
                        NullValueHandling = NullValueHandling.Ignore, // 忽略值为 null 的字段
                        DateFormatString = "yyyy-MM-dd" // 指定日期输出格式
                    };

                    // 根据规则将 DataTable 序列化为 JSON 字符串
                    string jsonResult = JsonConvert.SerializeObject(dataTable, settings);

                    // 将 JSON 字符串写入目标文件
                    File.WriteAllText(jsonOutputPath, jsonResult);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"自定义 JSON 序列化时发生错误：{ex.Message}");
            }
        }
    }
}

常用设置说明

注：CamelCasePropertyNamesContractResolver 主要针对英文属性名进行首字母小写转换，若 Excel 列名为中文则保持原样。

此外，还可以通过自定义 JsonConverter、调整日期处理规则或使用其他 ContractResolver，进一步控制 JSON 输出结果。更多信息可参阅 Newtonsoft.Json 文档。

C# JSON 转 Excel 示例

将 JSON 转换为 Excel 时，可以先把 JSON 数据反序列化为 DataTable，再将该表格插入 Excel 工作表。

实现步骤

1. 从文件、API 响应或字符串变量中读取 JSON 数据。
2. 使用 Newtonsoft.Json.JsonConvert.DeserializeObject<DataTable>()，将 JSON 转换为 DataTable。
3. 创建一个新的 Workbook 对象。
4. 使用 InsertDataTable() 将 DataTable 写入新工作簿的工作表中。
5. 设置表头和数据单元格的样式，提高可读性。
6. 将工作簿保存为 Excel 文件。

完整代码示例

using System;
using System.Data;
using System.Drawing;
using Spire.Xls;
using Newtonsoft.Json;

namespace ConvertJSONToExcel
{
    class Program
    {
        static void Main(string[] args)
        {
            // 示例 JSON 数组
            string jsonInput = @"
            [
                {""姓名"":""张三"",""年龄"":30,""部门"":""销售部"",""入职日期"":""2020-05-12"",""全职"":true},
                {""姓名"":""李四"",""年龄"":25,""部门"":""市场部"",""入职日期"":""2021-09-01"",""全职"":false},
                {""姓名"":""王五"",""年龄"":40,""部门"":""技术部"",""入职日期"":""2018-03-15"",""全职"":true},
                {""姓名"":""赵六"",""年龄"":35,""部门"":""财务部"",""入职日期"":""2019-07-20"",""全职"":true}
            ]";

            string excelOutputPath = "output.xlsx";

            try
            {
                // 将 JSON 数组反序列化为 DataTable
                DataTable dataTable = JsonConvert.DeserializeObject<DataTable>(jsonInput);

                using (Workbook workbook = new Workbook())
                {
                    Worksheet worksheet = workbook.Worksheets[0];

                    // 将 DataTable 插入工作表（包含列头）
                    worksheet.InsertDataTable(dataTable, true, 1, 1);

                    // 定义表头样式
                    CellStyle headerStyle = workbook.Styles.Add("HeaderStyle");
                    headerStyle.Font.IsBold = true;
                    headerStyle.Font.Size = 12;
                    headerStyle.Font.Color = Color.White;
                    headerStyle.Color = Color.DarkBlue;
                    headerStyle.HorizontalAlignment = HorizontalAlignType.Center;
                    headerStyle.VerticalAlignment = VerticalAlignType.Center;

                    // 将样式应用到表头行
                    int colCount = dataTable.Columns.Count;
                    worksheet.Range[1, 1, 1, colCount].CellStyleName = "HeaderStyle";

                    // 定义数据行样式
                    CellStyle dataStyle = workbook.Styles.Add("DataStyle");
                    dataStyle.HorizontalAlignment = HorizontalAlignType.Center;
                    dataStyle.VerticalAlignment = VerticalAlignType.Center;
                    dataStyle.Borders[BordersLineType.EdgeLeft].LineStyle = LineStyleType.Thin;
                    dataStyle.Borders[BordersLineType.EdgeRight].LineStyle = LineStyleType.Thin;
                    dataStyle.Borders[BordersLineType.EdgeTop].LineStyle = LineStyleType.Thin;
                    dataStyle.Borders[BordersLineType.EdgeBottom].LineStyle = LineStyleType.Thin;

                    // 将样式应用到数据行
                    int rowCount = dataTable.Rows.Count;
                    worksheet.Range[2, 1, rowCount + 1, colCount].CellStyleName = "DataStyle";

                    // 自动调整列宽
                    worksheet.AllocatedRange.AutoFitColumns();

                    // 将工作簿保存为 XLSX 文件
                    workbook.SaveToFile(excelOutputPath, ExcelVersion.Version2016);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"转换过程中发生异常：{ex.Message}");
            }
        }
    }
}

处理带根节点或嵌套结构的 JSON

直接反序列化为 DataTable 的方式更适合结构扁平的 JSON 数组。如果记录被包含在根对象中，或者数据中包含嵌套对象和数组，则需要先提取目标记录并将嵌套结构扁平化，再转换为 DataTable。

例如，下面的 JSON 字符串同时包含根对象和嵌套数据：

string jsonInput = @"
{
  ""状态"": ""成功"",
  ""数据"": [
    {
      ""订单编号"": ""DD20260001"",
      ""客户"": {
        ""编号"": 1001,
        ""姓名"": ""王芳"",
        ""会员等级"": ""黄金""
      },
      ""商品"": [
        {
          ""名称"": ""无线蓝牙耳机"",
          ""数量"": 2,
          ""单价"": 299.00
        },
        {
          ""名称"": ""手机保护壳"",
          ""数量"": 1,
          ""单价"": 39.90
        }
      ],
      ""下单时间"": ""2026-07-10"",
      ""已付款"": true
    },
    {
      ""订单编号"": ""DD20260002"",
      ""客户"": {
        ""编号"": 1002,
        ""姓名"": ""陈明"",
        ""会员等级"": ""普通""
      },
      ""商品"": [
        {
          ""名称"": ""机械键盘"",
          ""数量"": 1,
          ""单价"": 459.00
        }
      ],
      ""下单时间"": ""2026-07-12"",
      ""已付款"": false
    }
  ]
}";

可以通过以下方法提取 数据 数组，将嵌套字段转换为适合表格展示的扁平字段，并返回 DataTable：

using System;
using System.Data;
using System.Linq;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

private static DataTable ConvertNestedJsonToDataTable(string jsonInput)
{
    // JSON 根节点既可以是对象，也可以是数组
    JToken rootToken = JToken.Parse(jsonInput);

    // 支持根节点直接为数组，或数组位于根对象的 "数据" 属性中
    JArray records = rootToken as JArray
        ?? ((rootToken as JObject)?["数据"] as JArray)
        ?? throw new ArgumentException("JSON 中未找到有效的记录数组。", nameof(jsonInput));

    // 将嵌套对象和数组转换为适合表格展示的字段
    var flattenedRecords = records.Select(record => new
    {
        订单编号 = (string)record["订单编号"] ?? string.Empty,

        // 将 客户 对象拆分为独立列
        客户编号 = (int?)record["客户"]?["编号"],
        客户姓名 = (string)record["客户"]?["姓名"] ?? string.Empty,
        会员等级 = (string)record["客户"]?["会员等级"] ?? string.Empty,

        // 商品 是"数组套对象"，先把每个商品格式化成 "名称×数量" 的字符串，
        // 再用分号拼接成一列，同时把小计金额累加成 商品总额 列
        商品明细 = string.Join(
            "; ",
            (record["商品"] as JArray)?.Select(item =>
                $"{(string)item["名称"]}×{(int?)item["数量"]}")
            ?? Enumerable.Empty<string>()),

        商品总额 = (record["商品"] as JArray)?
            .Sum(item => ((decimal?)item["数量"] ?? 0) * ((decimal?)item["单价"] ?? 0)) ?? 0,

        下单时间 = (string)record["下单时间"] ?? string.Empty,
        已付款 = (bool?)record["已付款"] ?? false
    });

    // 将扁平化后的记录转换为 DataTable
    string flattenedJson =
        JsonConvert.SerializeObject(flattenedRecords);
    DataTable dataTable =
        JsonConvert.DeserializeObject<DataTable>(flattenedJson);

    if (dataTable == null || dataTable.Columns.Count == 0)
        throw new ArgumentException("JSON 中不包含可转换为表格的记录。", nameof(jsonInput));

    return dataTable;
}

上述字段映射是根据示例 JSON 的结构编写的。处理其他 JSON 结构时，需要根据实际的数据层级调整所选属性和输出列。

实用技巧

在 Excel 与 JSON 之间转换数据时，建议注意以下事项，以提高转换结果的准确性和可用性：

• 检查源数据结构：转换前确认 Excel 中包含有效的列标题和数据区域，或确认 JSON 中存在可转换的记录数组，避免因数据结构不完整而导致转换失败。
• 统一列名和字段命名：Excel 的列标题通常会成为 JSON 的字段名称。建议使用清晰、唯一且一致的列名，避免出现空标题、重复标题或不必要的空格。
• 明确空值处理规则：根据实际需求，决定将空单元格转换为 null、空字符串、默认值，还是省略对应字段，并在整个转换过程中保持处理规则一致。
• 正确保留数据类型：注意日期、数字、布尔值和文本等数据类型。对于员工编号、订单号等可能包含前导零的数据，应按文本处理，避免 00125 被转换为 125。
• 先处理嵌套 JSON：如果 JSON 中包含嵌套对象或数组，应先将所需数据展开为普通字段，再写入 Excel。对于结构较复杂的数据，也可以分别写入不同的工作表。
• 验证转换结果：转换完成后，应检查生成的 JSON 是否符合预期结构，并确认 Excel 中的列标题、行数、数据类型、空值和日期等内容是否准确保留。

常见问题解答

使用这些示例是否需要安装 Microsoft Excel？

不需要。Spire.XLS 是一个独立的 .NET 类库，可以读取、写入和转换 Excel 文件，不依赖 Microsoft Office 或 Excel Interop。

是否可以将旧版 .xls（Excel 97–2003）文件和新版 .xlsx 文件都转换为 JSON？

可以。LoadFromFile() 会自动识别文件格式，因此同一套代码既可以处理 .xls，也可以处理 .xlsx 文件。

是否可以将嵌套 JSON 转换为 Excel？

可以，但 JsonConvert.DeserializeObject<DataTable>() 更适合处理扁平的 JSON 数组。对于嵌套 JSON，应先将数据整理为简单的对象列表，再调用 InsertDataTable() 写入 Excel。

这种方法是否适用于 ASP.NET Core 或其他跨平台 .NET 应用？

适用。Spire.XLS 支持 .NET Framework、.NET Core 以及 .NET 5–10，因此这些代码可以运行在控制台应用、ASP.NET Core 服务，以及 Linux、macOS 等跨平台环境中。

总结

本文介绍了如何使用 C# 将整个 Excel 工作簿、指定工作表和单元格区域转换为 JSON，以及如何将 JSON 数据导入 Excel。结合 Spire.XLS 与 Newtonsoft.Json 库，开发者既可以处理简单的格式转换，也可以应对自定义 JSON 格式和嵌套数据处理等进阶场景。

获取免费许可证

如需完整体验 Spire.XLS for .NET 的功能，可以申请有效期为 30 天的免费临时许可证。