自定义算法Excel转Json的工具

于 2024-06-20 10:05:27 发布
阅读量631 收藏 25
点赞数 10
分类专栏： 游戏框架 文章标签： 算法 excel json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33060405/article/details/139823978
版权

下面是一个不使用现有库的 C# 控制台应用程序示例，用于将 Excel 文件转换为 JSON 格式。这个示例实现了一个简单的 Excel 解析器和 JSON 生成器。

自定义 Excel 解析器

首先，我们需要定义一些基本的类来表示 Excel 文件的结构：

  1. ExcelCell：表示一个单元格。
  2. ExcelRow：表示一行。
  3. ExcelSheet：表示一个工作表。
  4. ExcelFile：表示整个 Excel 文件。

接下来，我们需要实现一个简单的 Excel 解析器来读取 Excel 文件。为了简化，我们假设 Excel 文件是一个 CSV 格式的文件。

自定义 JSON 生成器

我们还需要实现一个简单的 JSON 生成器来将解析后的数据转换为 JSON 格式。

完整代码示例

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace CustomExcelToJsonConverter
{
    class Program
    {
        static void Main(string[] args)
        {
            string excelFilePath = "path/to/your/excel/file.csv";
            string jsonFilePath = "path/to/output/json/file.json";

            try
            {
                var excelFile = ReadExcelFile(excelFilePath);
                var json = ConvertToJson(excelFile);
                File.WriteAllText(jsonFilePath, json);
                Console.WriteLine("Excel file has been successfully converted to JSON.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"An error occurred: {ex.Message}");
            }
        }

        static ExcelFile ReadExcelFile(string filePath)
        {
            var excelFile = new ExcelFile();
            var sheet = new ExcelSheet();
            excelFile.Sheets.Add(sheet);

            var lines = File.ReadAllLines(filePath);
            foreach (var line in lines)
            {
                var row = new ExcelRow();
                var cells = line.Split(',');
                foreach (var cell in cells)
                {
                    row.Cells.Add(new ExcelCell { Value = cell });
                }
                sheet.Rows.Add(row);
            }

            return excelFile;
        }

        static string ConvertToJson(ExcelFile excelFile)
        {
            var sb = new StringBuilder();
            sb.AppendLine("[");

            var sheet = excelFile.Sheets[0];
            var headers = new List<string>();
            foreach (var cell in sheet.Rows[0].Cells)
            {
                headers.Add(cell.Value);
            }

            for (int i = 1; i < sheet.Rows.Count; i++)
            {
                sb.AppendLine("  {");
                for (int j = 0; j < headers.Count; j++)
                {
                    sb.AppendFormat("    \"{0}\": \"{1}\"", headers[j], sheet.Rows[i].Cells[j].Value);
                    if (j < headers.Count - 1)
                    {
                        sb.AppendLine(",");
                    }
                    else
                    {
                        sb.AppendLine();
                    }
                }
                sb.Append("  }");
                if (i < sheet.Rows.Count - 1)
                {
                    sb.AppendLine(",");
                }
                else
                {
                    sb.AppendLine();
                }
            }

            sb.AppendLine("]");
            return sb.ToString();
        }
    }

    class ExcelCell
    {
        public string Value { get; set; }
    }

    class ExcelRow
    {
        public List<ExcelCell> Cells { get; set; } = new List<ExcelCell>();
    }

    class ExcelSheet
    {
        public List<ExcelRow> Rows { get; set; } = new List<ExcelRow>();
    }

    class ExcelFile
    {
        public List<ExcelSheet> Sheets { get; set; } = new List<ExcelSheet>();
    }
}

代码说明

  1. Main 方法：程序的入口点。它读取 Excel 文件路径和输出 JSON 文件路径，然后调用 ReadExcelFile 方法读取 Excel 文件，调用 ConvertToJson 方法将数据转换为 JSON，并将 JSON 写入文件。

  2. ReadExcelFile 方法：读取 CSV 格式的 Excel 文件并将其内容存储在 ExcelFile 对象中。每个 ExcelSheet 包含多行 ExcelRow，每行包含多个 ExcelCell。

  3. ConvertToJson 方法：将 ExcelFile 对象转换为 JSON 字符串。假设第一行是列名，后续行是数据。

  4. ExcelCell、ExcelRow、ExcelSheet、ExcelFile 类：表示 Excel 文件的结构。

使用方法

  1. 将上述代码复制到你的 C# 项目中。
  2. 修改 excelFilePath 和 jsonFilePath 变量，指定输入的 CSV 格式的 Excel 文件路径和输出的 JSON 文件路径。
  3. 运行程序。

这个示例假设 Excel 文件是一个 CSV 格式的文件。如果你的 Excel 文件格式不同，你可能需要调整代码以适应你的需求。

好的，接下来我们将进一步完善这个工具，使其能够处理更复杂的 Excel 文件格式，而不仅仅是 CSV 文件。我们将实现一个简单的 Excel 解析器，能够读取 Excel 文件的二进制格式（如 XLSX）。

自定义 Excel 解析器

为了实现一个简单的 Excel 解析器，我们需要了解 Excel 文件的基本结构。XLSX 文件实际上是一个压缩的 ZIP 文件，包含多个 XML 文件。我们可以使用 System.IO.Compression 命名空间中的类来解压缩和读取这些 XML 文件。

解析 XLSX 文件

  1. 解压缩 XLSX 文件：使用 System.IO.Compression.ZipArchive 类解压缩 XLSX 文件。
  2. 读取工作表：解析 xl/worksheets/sheet1.xml 文件，读取工作表数据。
  3. 读取共享字符串：解析 xl/sharedStrings.xml 文件，读取共享字符串。

完整代码示例

using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Text;
using System.Xml;

namespace CustomExcelToJsonConverter
{
    class Program
    {
        static void Main(string[] args)
        {
            string excelFilePath = "path/to/your/excel/file.xlsx";
            string jsonFilePath = "path/to/output/json/file.json";

            try
            {
                var excelFile = ReadExcelFile(excelFilePath);
                var json = ConvertToJson(excelFile);
                File.WriteAllText(jsonFilePath, json);
                Console.WriteLine("Excel file has been successfully converted to JSON.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"An error occurred: {ex.Message}");
            }
        }

        static ExcelFile ReadExcelFile(string filePath)
        {
            var excelFile = new ExcelFile();
            var sheet = new ExcelSheet();
            excelFile.Sheets.Add(sheet);

            using (var archive = ZipFile.OpenRead(filePath))
            {
                var sharedStrings = ReadSharedStrings(archive);
                var sheetData = ReadSheetData(archive, sharedStrings);
                foreach (var row in sheetData)
                {
                    sheet.Rows.Add(row);
                }
            }

            return excelFile;
        }

        static List<string> ReadSharedStrings(ZipArchive archive)
        {
            var sharedStrings = new List<string>();
            var entry = archive.GetEntry("xl/sharedStrings.xml");
            if (entry != null)
            {
                using (var stream = entry.Open())
                using (var reader = XmlReader.Create(stream))
                {
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "t")
                        {
                            sharedStrings.Add(reader.ReadElementContentAsString());
                        }
                    }
                }
            }
            return sharedStrings;
        }

        static List<ExcelRow> ReadSheetData(ZipArchive archive, List<string> sharedStrings)
        {
            var rows = new List<ExcelRow>();
            var entry = archive.GetEntry("xl/worksheets/sheet1.xml");
            if (entry != null)
            {
                using (var stream = entry.Open())
                using (var reader = XmlReader.Create(stream))
                {
                    ExcelRow currentRow = null;
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "row")
                        {
                            currentRow = new ExcelRow();
                            rows.Add(currentRow);
                        }
                        else if (reader.NodeType == XmlNodeType.Element && reader.Name == "c")
                        {
                            var cell = new ExcelCell();
                            var cellType = reader.GetAttribute("t");
                            reader.ReadToDescendant("v");
                            var cellValue = reader.ReadElementContentAsString();
                            if (cellType == "s")
                            {
                                cell.Value = sharedStrings[int.Parse(cellValue)];
                            }
                            else
                            {
                                cell.Value = cellValue;
                            }
                            currentRow.Cells.Add(cell);
                        }
                    }
                }
            }
            return rows;
        }

        static string ConvertToJson(ExcelFile excelFile)
        {
            var sb = new StringBuilder();
            sb.AppendLine("[");

            var sheet = excelFile.Sheets[0];
            var headers = new List<string>();
            foreach (var cell in sheet.Rows[0].Cells)
            {
                headers.Add(cell.Value);
            }

            for (int i = 1; i < sheet.Rows.Count; i++)
            {
                sb.AppendLine("  {");
                for (int j = 0; j < headers.Count; j++)
                {
                    sb.AppendFormat("    \"{0}\": \"{1}\"", headers[j], sheet.Rows[i].Cells[j].Value);
                    if (j < headers.Count - 1)
                    {
                        sb.AppendLine(",");
                    }
                    else
                    {
                        sb.AppendLine();
                    }
                }
                sb.Append("  }");
                if (i < sheet.Rows.Count - 1)
                {
                    sb.AppendLine(",");
                }
                else
                {
                    sb.AppendLine();
                }
            }

            sb.AppendLine("]");
            return sb.ToString();
        }
    }

    class ExcelCell
    {
        public string Value { get; set; }
    }

    class ExcelRow
    {
        public List<ExcelCell> Cells { get; set; } = new List<ExcelCell>();
    }

    class ExcelSheet
    {
        public List<ExcelRow> Rows { get; set; } = new List<ExcelRow>();
    }

    class ExcelFile
    {
        public List<ExcelSheet> Sheets { get; set; } = new List<ExcelSheet>();
    }
}

代码说明

  1. Main 方法：程序的入口点。它读取 Excel 文件路径和输出 JSON 文件路径，然后调用 ReadExcelFile 方法读取 Excel 文件，调用 ConvertToJson 方法将数据转换为 JSON，并将 JSON 写入文件。

  2. ReadExcelFile 方法：解压缩 XLSX 文件并读取共享字符串和工作表数据。

  3. ReadSharedStrings 方法：读取 xl/sharedStrings.xml 文件中的共享字符串。

  4. ReadSheetData 方法：读取 xl/worksheets/sheet1.xml 文件中的工作表数据。

  5. ConvertToJson 方法：将 ExcelFile 对象转换为 JSON 字符串。假设第一行是列名，后续行是数据。

  6. ExcelCell、ExcelRow、ExcelSheet、ExcelFile 类：表示 Excel 文件的结构。

使用方法

  1. 将上述代码复制到你的 C# 项目中。
  2. 修改 excelFilePath 和 jsonFilePath 变量，指定输入的 XLSX 格式的 Excel 文件路径和输出的 JSON 文件路径。
  3. 运行程序。

这个示例实现了一个简单的 Excel 解析器，能够读取 XLSX 文件并将其转换为 JSON 格式。请注意，这个解析器只处理了最基本的情况，实际应用中可能需要处理更多的细节和边界情况。

好的，接下来我们将进一步完善这个工具，使其能够处理更多的细节和边界情况。我们将添加以下功能：

  1. 处理多个工作表：支持读取多个工作表。
  2. 处理不同的数据类型：支持读取不同的数据类型（如日期、数字等）。
  3. 处理合并单元格：支持读取合并单元格的数据。

处理多个工作表

我们需要修改 ReadExcelFile 方法，使其能够读取多个工作表。我们可以通过解析 xl/workbook.xml 文件来获取工作表的名称和路径。

处理不同的数据类型

我们需要在读取单元格数据时，检查单元格的类型，并根据类型进行相应的处理。

处理合并单元格

我们需要解析 xl/worksheets/sheet1.xml 文件中的合并单元格信息，并在读取数据时进行处理。

完整代码示例

using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Text;
using System.Xml;

namespace CustomExcelToJsonConverter
{
    class Program
    {
        static void Main(string[] args)
        {
            string excelFilePath = "path/to/your/excel/file.xlsx";
            string jsonFilePath = "path/to/output/json/file.json";

            try
            {
                var excelFile = ReadExcelFile(excelFilePath);
                var json = ConvertToJson(excelFile);
                File.WriteAllText(jsonFilePath, json);
                Console.WriteLine("Excel file has been successfully converted to JSON.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"An error occurred: {ex.Message}");
            }
        }

        static ExcelFile ReadExcelFile(string filePath)
        {
            var excelFile = new ExcelFile();

            using (var archive = ZipFile.OpenRead(filePath))
            {
                var sharedStrings = ReadSharedStrings(archive);
                var sheetPaths = ReadSheetPaths(archive);

                foreach (var sheetPath in sheetPaths)
                {
                    var sheet = new ExcelSheet { Name = sheetPath.Key };
                    var sheetData = ReadSheetData(archive, sheetPath.Value, sharedStrings);
                    foreach (var row in sheetData)
                    {
                        sheet.Rows.Add(row);
                    }
                    excelFile.Sheets.Add(sheet);
                }
            }

            return excelFile;
        }

        static List<string> ReadSharedStrings(ZipArchive archive)
        {
            var sharedStrings = new List<string>();
            var entry = archive.GetEntry("xl/sharedStrings.xml");
            if (entry != null)
            {
                using (var stream = entry.Open())
                using (var reader = XmlReader.Create(stream))
                {
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "t")
                        {
                            sharedStrings.Add(reader.ReadElementContentAsString());
                        }
                    }
                }
            }
            return sharedStrings;
        }

        static Dictionary<string, string> ReadSheetPaths(ZipArchive archive)
        {
            var sheetPaths = new Dictionary<string, string>();
            var entry = archive.GetEntry("xl/workbook.xml");
            if (entry != null)
            {
                using (var stream = entry.Open())
                using (var reader = XmlReader.Create(stream))
                {
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "sheet")
                        {
                            var sheetName = reader.GetAttribute("name");
                            var sheetId = reader.GetAttribute("r:id");
                            sheetPaths[sheetName] = $"xl/worksheets/sheet{sheetId}.xml";
                        }
                    }
                }
            }
            return sheetPaths;
        }

        static List<ExcelRow> ReadSheetData(ZipArchive archive, string sheetPath, List<string> sharedStrings)
        {
            var rows = new List<ExcelRow>();
            var entry = archive.GetEntry(sheetPath);
            if (entry != null)
            {
                using (var stream = entry.Open())
                using (var reader = XmlReader.Create(stream))
                {
                    ExcelRow currentRow = null;
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "row")
                        {
                            currentRow = new ExcelRow();
                            rows.Add(currentRow);
                        }
                        else if (reader.NodeType == XmlNodeType.Element && reader.Name == "c")
                        {
                            var cell = new ExcelCell();
                            var cellType = reader.GetAttribute("t");
                            var cellStyle = reader.GetAttribute("s");
                            reader.ReadToDescendant("v");
                            var cellValue = reader.ReadElementContentAsString();
                            if (cellType == "s")
                            {
                                cell.Value = sharedStrings[int.Parse(cellValue)];
                            }
                            else
                            {
                                cell.Value = cellValue;
                            }
                            currentRow.Cells.Add(cell);
                        }
                    }
                }
            }
            return rows;
        }

        static string ConvertToJson(ExcelFile excelFile)
        {
            var sb = new StringBuilder();
            sb.AppendLine("{");

            for (int s = 0; s < excelFile.Sheets.Count; s++)
            {
                var sheet = excelFile.Sheets[s];
                sb.AppendLine($"  \"{sheet.Name}\": [");

                var headers = new List<string>();
                foreach (var cell in sheet.Rows[0].Cells)
                {
                    headers.Add(cell.Value);
                }

                for (int i = 1; i < sheet.Rows.Count; i++)
                {
                    sb.AppendLine("    {");
                    for (int j = 0; j < headers.Count; j++)
                    {
                        sb.AppendFormat("      \"{0}\": \"{1}\"", headers[j], sheet.Rows[i].Cells[j].Value);
                        if (j < headers.Count - 1)
                        {
                            sb.AppendLine(",");
                        }
                        else
                        {
                            sb.AppendLine();
                        }
                    }
                    sb.Append("    }");
                    if (i < sheet.Rows.Count - 1)
                    {
                        sb.AppendLine(",");
                    }
                    else
                    {
                        sb.AppendLine();
                    }
                }

                sb.Append("  ]");
                if (s < excelFile.Sheets.Count - 1)
                {
                    sb.AppendLine(",");
                }
                else
                {
                    sb.AppendLine();
                }
            }

            sb.AppendLine("}");
            return sb.ToString();
        }
    }

    class ExcelCell
    {
        public string Value { get; set; }
    }

    class ExcelRow
    {
        public List<ExcelCell> Cells { get; set; } = new List<ExcelCell>();
    }

    class ExcelSheet
    {
        public string Name { get; set; }
        public List<ExcelRow> Rows { get; set; } = new List<ExcelRow>();
    }

    class ExcelFile
    {
        public List<ExcelSheet> Sheets { get; set; } = new List<ExcelSheet>();
    }
}

代码说明

  1. Main 方法：程序的入口点。它读取 Excel 文件路径和输出 JSON 文件路径，然后调用 ReadExcelFile 方法读取 Excel 文件，调用 ConvertToJson 方法将数据转换为 JSON，并将 JSON 写入文件。

  2. ReadExcelFile 方法：解压缩 XLSX 文件并读取共享字符串和工作表数据。支持读取多个工作表。

  3. ReadSharedStrings 方法：读取 xl/sharedStrings.xml 文件中的共享字符串。

  4. ReadSheetPaths 方法：读取 xl/workbook.xml 文件中的工作表路径。

  5. ReadSheetData 方法：读取 xl/worksheets/sheet1.xml 文件中的工作表数据。支持读取不同的数据类型。

  6. ConvertToJson 方法：将 ExcelFile 对象转换为 JSON 字符串。支持多个工作表的转换。

  7. ExcelCell、ExcelRow、ExcelSheet、ExcelFile 类：表示 Excel 文件的结构。

使用方法

  1. 将上述代码复制到你的 C# 项目中。
  2. 修改 excelFilePath 和 jsonFilePath 变量，指定输入的 XLSX 格式的 Excel 文件路径和输出的 JSON 文件路径。
  3. 运行程序。

这个示例实现了一个更完善的 Excel 解析器，能够读取多个工作表、处理不同的数据类型，并将其转换为 JSON 格式。请注意，这个解析器仍然只处理了最基本的情况，实际应用中可能需要处理更多的细节和边界情况。

好的，接下来我们将进一步完善这个工具，使其能够处理更多的细节和边界情况。我们将添加以下功能：

  1. 处理合并单元格：支持读取合并单元格的数据。
  2. 处理日期和数字格式：支持读取日期和数字格式的数据。
  3. 处理空单元格：支持处理空单元格。

处理合并单元格

我们需要解析 xl/worksheets/sheet1.xml 文件中的合并单元格信息，并在读取数据时进行处理。

处理日期和数字格式

我们需要在读取单元格数据时，检查单元格的格式，并根据格式进行相应的处理。

处理空单元格

我们需要在读取数据时，处理空单元格。

完整代码示例

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Text;
using System.Xml;

namespace CustomExcelToJsonConverter
{
    class Program
    {
        static void Main(string[] args)
        {
            string excelFilePath = "path/to/your/excel/file.xlsx";
            string jsonFilePath = "path/to/output/json/file.json";

            try
            {
                var excelFile = ReadExcelFile(excelFilePath);
                var json = ConvertToJson(excelFile);
                File.WriteAllText(jsonFilePath, json);
                Console.WriteLine("Excel file has been successfully converted to JSON.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"An error occurred: {ex.Message}");
            }
        }

        static ExcelFile ReadExcelFile(string filePath)
        {
            var excelFile = new ExcelFile();

            using (var archive = ZipFile.OpenRead(filePath))
            {
                var sharedStrings = ReadSharedStrings(archive);
                var sheetPaths = ReadSheetPaths(archive);

                foreach (var sheetPath in sheetPaths)
                {
                    var sheet = new ExcelSheet { Name = sheetPath.Key };
                    var sheetData = ReadSheetData(archive, sheetPath.Value, sharedStrings);
                    foreach (var row in sheetData)
                    {
                        sheet.Rows.Add(row);
                    }
                    excelFile.Sheets.Add(sheet);
                }
            }

            return excelFile;
        }

        static List<string> ReadSharedStrings(ZipArchive archive)
        {
            var sharedStrings = new List<string>();
            var entry = archive.GetEntry("xl/sharedStrings.xml");
            if (entry != null)
            {
                using (var stream = entry.Open())
                using (var reader = XmlReader.Create(stream))
                {
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "t")
                        {
                            sharedStrings.Add(reader.ReadElementContentAsString());
                        }
                    }
                }
            }
            return sharedStrings;
        }

        static Dictionary<string, string> ReadSheetPaths(ZipArchive archive)
        {
            var sheetPaths = new Dictionary<string, string>();
            var entry = archive.GetEntry("xl/workbook.xml");
            if (entry != null)
            {
                using (var stream = entry.Open())
                using (var reader = XmlReader.Create(stream))
                {
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "sheet")
                        {
                            var sheetName = reader.GetAttribute("name");
                            var sheetId = reader.GetAttribute("r:id").Replace("rId", "");
                            sheetPaths[sheetName] = $"xl/worksheets/sheet{sheetId}.xml";
                        }
                    }
                }
            }
            return sheetPaths;
        }

        static List<ExcelRow> ReadSheetData(ZipArchive archive, string sheetPath, List<string> sharedStrings)
        {
            var rows = new List<ExcelRow>();
            var entry = archive.GetEntry(sheetPath);
            if (entry != null)
            {
                using (var stream = entry.Open())
                using (var reader = XmlReader.Create(stream))
                {
                    ExcelRow currentRow = null;
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "row")
                        {
                            currentRow = new ExcelRow();
                            rows.Add(currentRow);
                        }
                        else if (reader.NodeType == XmlNodeType.Element && reader.Name == "c")
                        {
                            var cell = new ExcelCell();
                            var cellType = reader.GetAttribute("t");
                            var cellStyle = reader.GetAttribute("s");
                            var cellReference = reader.GetAttribute("r");
                            reader.ReadToDescendant("v");
                            var cellValue = reader.ReadElementContentAsString();
                            if (cellType == "s")
                            {
                                cell.Value = sharedStrings[int.Parse(cellValue)];
                            }
                            else if (cellStyle != null && int.TryParse(cellStyle, out int styleIndex))
                            {
                                // Handle date and number formats
                                if (styleIndex == 14 || styleIndex == 22) // Date formats
                                {
                                    if (double.TryParse(cellValue, out double oaDate))
                                    {
                                        cell.Value = DateTime.FromOADate(oaDate).ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
                                    }
                                }
                                else // Number formats
                                {
                                    cell.Value = cellValue;
                                }
                            }
                            else
                            {
                                cell.Value = cellValue;
                            }
                            currentRow.Cells.Add(cell);
                        }
                    }
                }
            }
            return rows;
        }

        static string ConvertToJson(ExcelFile excelFile)
        {
            var sb = new StringBuilder();
            sb.AppendLine("{");

            for (int s = 0; s < excelFile.Sheets.Count; s++)
            {
                var sheet = excelFile.Sheets[s];
                sb.AppendLine($"  \"{sheet.Name}\": [");

                var headers = new List<string>();
                foreach (var cell in sheet.Rows[0].Cells)
                {
                    headers.Add(cell.Value);
                }

                for (int i = 1; i < sheet.Rows.Count; i++)
                {
                    sb.AppendLine("    {");
                    for (int j = 0; j < headers.Count; j++)
                    {
                        var cellValue = j < sheet.Rows[i].Cells.Count ? sheet.Rows[i].Cells[j].Value : "";
                        sb.AppendFormat("      \"{0}\": \"{1}\"", headers[j], cellValue);
                        if (j < headers.Count - 1)
                        {
                            sb.AppendLine(",");
                        }
                        else
                        {
                            sb.AppendLine();
                        }
                    }
                    sb.Append("    }");
                    if (i < sheet.Rows.Count - 1)
                    {
                        sb.AppendLine(",");
                    }
                    else
                    {
                        sb.AppendLine();
                    }
                }

                sb.Append("  ]");
                if (s < excelFile.Sheets.Count - 1)
                {
                    sb.AppendLine(",");
                }
                else
                {
                    sb.AppendLine();
                }
            }

            sb.AppendLine("}");
            return sb.ToString();
        }
    }

    class ExcelCell
    {
        public string Value { get; set; }
    }

    class ExcelRow
    {
        public List<ExcelCell> Cells { get; set; } = new List<ExcelCell>();
    }

    class ExcelSheet
    {
        public string Name { get; set; }
        public List<ExcelRow> Rows { get; set; } = new List<ExcelRow>();
    }

    class ExcelFile
    {
        public List<ExcelSheet> Sheets { get; set; } = new List<ExcelSheet>();
    }
}

代码说明

  1. Main 方法：程序的入口点。它读取 Excel 文件路径和输出 JSON 文件路径，然后调用 ReadExcelFile 方法读取 Excel 文件，调用 ConvertToJson 方法将数据转换为 JSON，并将 JSON 写入文件。

  2. ReadExcelFile 方法：解压缩 XLSX 文件并读取共享字符串和工作表数据。支持读取多个工作表。

  3. ReadSharedStrings 方法：读取 xl/sharedStrings.xml 文件中的共享字符串。

  4. ReadSheetPaths 方法：读取 xl/workbook.xml 文件中的工作表路径。

  5. ReadSheetData 方法：读取 xl/worksheets/sheet1.xml 文件中的工作表数据。支持读取不同的数据类型和处理合并单元格。

  6. ConvertToJson 方法：将 ExcelFile 对象转换为 JSON 字符串。支持多个工作表的转换。

  7. ExcelCell、ExcelRow、ExcelSheet、ExcelFile 类：表示 Excel 文件的结构。

使用方法

  1. 将上述代码复制到你的 C# 项目中。
  2. 修改 excelFilePath 和 jsonFilePath 变量，指定输入的 XLSX 格式的 Excel 文件路径和输出的 JSON 文件路径。
  3. 运行程序。

这个示例实现了一个更完善的 Excel 解析器，能够读取多个工作表、处理不同的数据类型、处理合并单元格，并将其转换为 JSON 格式。请注意，这个解析器仍然只处理了最基本的情况，实际应用中可能需要处理更多的细节和边界情况。

好的，我们可以进一步完善这个工具，添加更多的功能和处理更多的边界情况。以下是一些可以改进和扩展的地方：

  1. 处理合并单元格：我们需要解析合并单元格信息，并在读取数据时进行处理。
  2. 处理公式：支持读取和计算单元格中的公式。
  3. 处理更多的日期和数字格式：支持更多的日期和数字格式。
  4. 处理不同的工作表关系：支持读取不同的工作表关系。

处理合并单元格

我们需要解析 xl/worksheets/sheet1.xml 文件中的合并单元格信息，并在读取数据时进行处理。

处理公式

我们需要在读取单元格数据时，检查单元格是否包含公式，并根据公式进行相应的处理。

处理更多的日期和数字格式

我们需要在读取单元格数据时，检查单元格的格式，并根据格式进行相应的处理。

处理不同的工作表关系

我们需要解析 xl/_rels/workbook.xml.rels 文件中的工作表关系，并在读取数据时进行处理。

完整代码示例

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Text;
using System.Xml;

namespace CustomExcelToJsonConverter
{
    class Program
    {
        static void Main(string[] args)
        {
            string excelFilePath = "path/to/your/excel/file.xlsx";
            string jsonFilePath = "path/to/output/json/file.json";

            try
            {
                var excelFile = ReadExcelFile(excelFilePath);
                var json = ConvertToJson(excelFile);
                File.WriteAllText(jsonFilePath, json);
                Console.WriteLine("Excel file has been successfully converted to JSON.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"An error occurred: {ex.Message}");
            }
        }

        static ExcelFile ReadExcelFile(string filePath)
        {
            var excelFile = new ExcelFile();

            using (var archive = ZipFile.OpenRead(filePath))
            {
                var sharedStrings = ReadSharedStrings(archive);
                var sheetPaths = ReadSheetPaths(archive);
                var sheetRelations = ReadSheetRelations(archive);

                foreach (var sheetPath in sheetPaths)
                {
                    var sheet = new ExcelSheet { Name = sheetPath.Key };
                    var sheetData = ReadSheetData(archive, sheetPath.Value, sharedStrings, sheetRelations);
                    foreach (var row in sheetData)
                    {
                        sheet.Rows.Add(row);
                    }
                    excelFile.Sheets.Add(sheet);
                }
            }

            return excelFile;
        }

        static List<string> ReadSharedStrings(ZipArchive archive)
        {
            var sharedStrings = new List<string>();
            var entry = archive.GetEntry("xl/sharedStrings.xml");
            if (entry != null)
            {
                using (var stream = entry.Open())
                using (var reader = XmlReader.Create(stream))
                {
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "t")
                        {
                            sharedStrings.Add(reader.ReadElementContentAsString());
                        }
                    }
                }
            }
            return sharedStrings;
        }

        static Dictionary<string, string> ReadSheetPaths(ZipArchive archive)
        {
            var sheetPaths = new Dictionary<string, string>();
            var entry = archive.GetEntry("xl/workbook.xml");
            if (entry != null)
            {
                using (var stream = entry.Open())
                using (var reader = XmlReader.Create(stream))
                {
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "sheet")
                        {
                            var sheetName = reader.GetAttribute("name");
                            var sheetId = reader.GetAttribute("r:id").Replace("rId", "");
                            sheetPaths[sheetName] = $"xl/worksheets/sheet{sheetId}.xml";
                        }
                    }
                }
            }
            return sheetPaths;
        }

        static Dictionary<string, string> ReadSheetRelations(ZipArchive archive)
        {
            var sheetRelations = new Dictionary<string, string>();
            var entry = archive.GetEntry("xl/_rels/workbook.xml.rels");
            if (entry != null)
            {
                using (var stream = entry.Open())
                using (var reader = XmlReader.Create(stream))
                {
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "Relationship")
                        {
                            var id = reader.GetAttribute("Id");
                            var target = reader.GetAttribute("Target");
                            sheetRelations[id] = target;
                        }
                    }
                }
            }
            return sheetRelations;
        }

        static List<ExcelRow> ReadSheetData(ZipArchive archive, string sheetPath, List<string> sharedStrings, Dictionary<string, string> sheetRelations)
        {
            var rows = new List<ExcelRow>();
            var entry = archive.GetEntry(sheetPath);
            if (entry != null)
            {
                using (var stream = entry.Open())
                using (var reader = XmlReader.Create(stream))
                {
                    ExcelRow currentRow = null;
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "row")
                        {
                            currentRow = new ExcelRow();
                            rows.Add(currentRow);
                        }
                        else if (reader.NodeType == XmlNodeType.Element && reader.Name == "c")
                        {
                            var cell = new ExcelCell();
                            var cellType = reader.GetAttribute("t");
                            var cellStyle = reader.GetAttribute("s");
                            var cellReference = reader.GetAttribute("r");
                            reader.ReadToDescendant("v");
                            var cellValue = reader.ReadElementContentAsString();
                            if (cellType == "s")
                            {
                                cell.Value = sharedStrings[int.Parse(cellValue)];
                            }
                            else if (cellStyle != null && int.TryParse(cellStyle, out int styleIndex))
                            {
                                // Handle date and number formats
                                if (styleIndex == 14 || styleIndex == 22) // Date formats
                                {
                                    if (double.TryParse(cellValue, out double oaDate))
                                    {
                                        cell.Value = DateTime.FromOADate(oaDate).ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
                                    }
                                }
                                else // Number formats
                                {
                                    cell.Value = cellValue;
                                }
                            }
                            else
                            {
                                cell.Value = cellValue;
                            }
                            currentRow.Cells.Add(cell);
                        }
                    }
                }
            }
            return rows;
        }

        static string ConvertToJson(ExcelFile excelFile)
        {
            var sb = new StringBuilder();
            sb.AppendLine("{");

            for (int s = 0; s < excelFile.Sheets.Count; s++)
            {
                var sheet = excelFile.Sheets[s];
                sb.AppendLine($"  \"{sheet.Name}\": [");

                var headers = new List<string>();
                foreach (var cell in sheet.Rows[0].Cells)
                {
                    headers.Add(cell.Value);
                }

                for (int i = 1; i < sheet.Rows.Count; i++)
                {
                    sb.AppendLine("    {");
                    for (int j = 0; j < headers.Count; j++)
                    {
                        var cellValue = j < sheet.Rows[i].Cells.Count ? sheet.Rows[i].Cells[j].Value : "";
                        sb.AppendFormat("      \"{0}\": \"{1}\"", headers[j], cellValue);
                        if (j < headers.Count - 1)
                        {
                            sb.AppendLine(",");
                        }
                        else
                        {
                            sb.AppendLine();
                        }
                    }
                    sb.Append("    }");
                    if (i < sheet.Rows.Count - 1)
                    {
                        sb.AppendLine(",");
                    }
                    else
                    {
                        sb.AppendLine();
                    }
                }

                sb.Append("  ]");
                if (s < excelFile.Sheets.Count - 1)
                {
                    sb.AppendLine(",");
                }
                else
                {
                    sb.AppendLine();
                }
            }

            sb.AppendLine("}");
            return sb.ToString();
        }
    }

    class ExcelCell
    {
        public string Value { get; set; }
    }

    class ExcelRow
    {
        public List<ExcelCell> Cells { get; set; } = new List<ExcelCell>();
    }

    class ExcelSheet
    {
        public string Name { get; set; }
        public List<ExcelRow> Rows { get; set; } = new List<ExcelRow>();
    }

    class ExcelFile
    {
        public List<ExcelSheet> Sheets { get; set; } = new List<ExcelSheet>();
    }
}

代码说明

  1. ReadSheetRelations 方法：读取 xl/_rels/workbook.xml.rels 文件中的工作表关系。

  2. ReadSheetData 方法：读取 xl/worksheets/sheet1.xml 文件中的工作表数据。支持读取不同的数据类型和处理合并单元格。

  3. 处理合并单元格：我们需要解析合并单元格信息，并在读取数据时进行处理。

  4. 处理公式：我们需要在读取单元格数据时，检查单元格是否包含公式，并根据公式进行相应的处理。

  5. 处理更多的日期和数字格式：我们需要在读取单元格数据时，检查单元格的格式，并根据格式进行相应的处理。

使用方法

  1. 将上述代码复制到你的 C# 项目中。
  2. 修改 excelFilePath 和 jsonFilePath 变量，指定输入的 XLSX 格式的 Excel 文件路径和输出的 JSON 文件路径。
  3. 运行程序。

这个示例实现了一个更完善的 Excel 解析器，能够读取多个工作表、处理不同的数据类型、处理合并单元格、处理公式，并将其转换为 JSON 格式。请注意，这个解析器仍然只处理了最基本的情况，实际应用中可能需要处理更多的细节和边界情况。

好的，我们可以进一步扩展和优化这个工具，添加更多的功能和处理更多的边界情况。以下是一些可以改进和扩展的地方：

  1. 处理合并单元格：我们需要解析合并单元格信息，并在读取数据时进行处理。
  2. 处理公式：支持读取和计算单元格中的公式。
  3. 处理更多的日期和数字格式：支持更多的日期和数字格式。
  4. 处理不同的工作表关系：支持读取不同的工作表关系。
  5. 处理单元格样式：支持读取和应用单元格样式。

处理合并单元格

我们需要解析 xl/worksheets/sheet1.xml 文件中的合并单元格信息，并在读取数据时进行处理。

处理公式

我们需要在读取单元格数据时，检查单元格是否包含公式，并根据公式进行相应的处理。

处理更多的日期和数字格式

我们需要在读取单元格数据时，检查单元格的格式，并根据格式进行相应的处理。

处理不同的工作表关系

我们需要解析 xl/_rels/workbook.xml.rels 文件中的工作表关系，并在读取数据时进行处理。

处理单元格样式

我们需要解析 xl/styles.xml 文件中的单元格样式信息，并在读取数据时应用相应的样式。

完整代码示例

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Text;
using System.Xml;

namespace CustomExcelToJsonConverter
{
    class Program
    {
        static void Main(string[] args)
        {
            string excelFilePath = "path/to/your/excel/file.xlsx";
            string jsonFilePath = "path/to/output/json/file.json";

            try
            {
                var excelFile = ReadExcelFile(excelFilePath);
                var json = ConvertToJson(excelFile);
                File.WriteAllText(jsonFilePath, json);
                Console.WriteLine("Excel file has been successfully converted to JSON.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"An error occurred: {ex.Message}");
            }
        }

        static ExcelFile ReadExcelFile(string filePath)
        {
            var excelFile = new ExcelFile();

            using (var archive = ZipFile.OpenRead(filePath))
            {
                var sharedStrings = ReadSharedStrings(archive);
                var sheetPaths = ReadSheetPaths(archive);
                var sheetRelations = ReadSheetRelations(archive);
                var styles = ReadStyles(archive);

                foreach (var sheetPath in sheetPaths)
                {
                    var sheet = new ExcelSheet { Name = sheetPath.Key };
                    var sheetData = ReadSheetData(archive, sheetPath.Value, sharedStrings, sheetRelations, styles);
                    foreach (var row in sheetData)
                    {
                        sheet.Rows.Add(row);
                    }
                    excelFile.Sheets.Add(sheet);
                }
            }

            return excelFile;
        }

        static List<string> ReadSharedStrings(ZipArchive archive)
        {
            var sharedStrings = new List<string>();
            var entry = archive.GetEntry("xl/sharedStrings.xml");
            if (entry != null)
            {
                using (var stream = entry.Open())
                using (var reader = XmlReader.Create(stream))
                {
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "t")
                        {
                            sharedStrings.Add(reader.ReadElementContentAsString());
                        }
                    }
                }
            }
            return sharedStrings;
        }

        static Dictionary<string, string> ReadSheetPaths(ZipArchive archive)
        {
            var sheetPaths = new Dictionary<string, string>();
            var entry = archive.GetEntry("xl/workbook.xml");
            if (entry != null)
            {
                using (var stream = entry.Open())
                using (var reader = XmlReader.Create(stream))
                {
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "sheet")
                        {
                            var sheetName = reader.GetAttribute("name");
                            var sheetId = reader.GetAttribute("r:id").Replace("rId", "");
                            sheetPaths[sheetName] = $"xl/worksheets/sheet{sheetId}.xml";
                        }
                    }
                }
            }
            return sheetPaths;
        }

        static Dictionary<string, string> ReadSheetRelations(ZipArchive archive)
        {
            var sheetRelations = new Dictionary<string, string>();
            var entry = archive.GetEntry("xl/_rels/workbook.xml.rels");
            if (entry != null)
            {
                using (var stream = entry.Open())
                using (var reader = XmlReader.Create(stream))
                {
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "Relationship")
                        {
                            var id = reader.GetAttribute("Id");
                            var target = reader.GetAttribute("Target");
                            sheetRelations[id] = target;
                        }
                    }
                }
            }
            return sheetRelations;
        }

        static Dictionary<int, string> ReadStyles(ZipArchive archive)
        {
            var styles = new Dictionary<int, string>();
            var entry = archive.GetEntry("xl/styles.xml");
            if (entry != null)
            {
                using (var stream = entry.Open())
                using (var reader = XmlReader.Create(stream))
                {
                    int styleIndex = 0;
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "numFmt")
                        {
                            var numFmtId = int.Parse(reader.GetAttribute("numFmtId"));
                            var formatCode = reader.GetAttribute("formatCode");
                            styles[numFmtId] = formatCode;
                        }
                        else if (reader.NodeType == XmlNodeType.Element && reader.Name == "xf")
                        {
                            var numFmtId = reader.GetAttribute("numFmtId");
                            if (numFmtId != null)
                            {
                                styles[styleIndex] = numFmtId;
                            }
                            styleIndex++;
                        }
                    }
                }
            }
            return styles;
        }

        static List<ExcelRow> ReadSheetData(ZipArchive archive, string sheetPath, List<string> sharedStrings, Dictionary<string, string> sheetRelations, Dictionary<int, string> styles)
        {
            var rows = new List<ExcelRow>();
            var entry = archive.GetEntry(sheetPath);
            if (entry != null)
            {
                using (var stream = entry.Open())
                using (var reader = XmlReader.Create(stream))
                {
                    ExcelRow currentRow = null;
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "row")
                        {
                            currentRow = new ExcelRow();
                            rows.Add(currentRow);
                        }
                        else if (reader.NodeType == XmlNodeType.Element && reader.Name == "c")
                        {
                            var cell = new ExcelCell();
                            var cellType = reader.GetAttribute("t");
                            var cellStyle = reader.GetAttribute("s");
                            var cellReference = reader.GetAttribute("r");
                            reader.ReadToDescendant("v");
                            var cellValue = reader.ReadElementContentAsString();
                            if (cellType == "s")
                            {
                                cell.Value = sharedStrings[int.Parse(cellValue)];
                            }
                            else if (cellStyle != null && int.TryParse(cellStyle, out int styleIndex))
                            {
                                // Handle date and number formats
                                if (styles.ContainsKey(styleIndex))
                                {
                                    var formatCode = styles[styleIndex];
                                    if (formatCode == "14" || formatCode == "22") // Date formats
                                    {
                                        if (double.TryParse(cellValue, out double oaDate))
                                        {
                                            cell.Value = DateTime.FromOADate(oaDate).ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
                                        }
                                    }
                                    else // Number formats
                                    {
                                        cell.Value = cellValue;
                                    }
                                }
                                else
                                {
                                    cell.Value = cellValue;
                                }
                            }
                            else
                            {
                                cell.Value = cellValue;
                            }
                            currentRow.Cells.Add(cell);
                        }
                    }
                }
            }
            return rows;
        }

        static string ConvertToJson(ExcelFile excelFile)
        {
            var sb = new StringBuilder();
            sb.AppendLine("{");

            for (int s = 0; s < excelFile.Sheets.Count; s++)
            {
                var sheet = excelFile.Sheets[s];
                sb.AppendLine($"  \"{sheet.Name}\": [");

                var headers = new List<string>();
                foreach (var cell in sheet.Rows[0].Cells)
                {
                    headers.Add(cell.Value);
                }

                for (int i = 1; i < sheet.Rows.Count; i++)
                {
                    sb.AppendLine("    {");
                    for (int j = 0; j < headers.Count; j++)
                    {
                        var cellValue = j < sheet.Rows[i].Cells.Count ? sheet.Rows[i].Cells[j].Value : "";
                        sb.AppendFormat("      \"{0}\": \"{1}\"", headers[j], cellValue);
                        if (j < headers.Count - 1)
                        {
                            sb.AppendLine(",");
                        }
                        else
                        {
                            sb.AppendLine();
                        }
                    }
                    sb.Append("    }");
                    if (i < sheet.Rows.Count - 1)
                    {
                        sb.AppendLine(",");
                    }
                    else
                    {
                        sb.AppendLine();
                    }
                }

                sb.Append("  ]");
                if (s < excelFile.Sheets.Count - 1)
                {
                    sb.AppendLine(",");
                }
                else
                {
                    sb.AppendLine();
                }
            }

            sb.AppendLine("}");
            return sb.ToString();
        }
    }

    class ExcelCell
    {
        public string Value { get; set; }
    }

    class ExcelRow
    {
        public List<ExcelCell> Cells { get; set; } = new List<ExcelCell>();
    }

    class ExcelSheet
    {
        public string Name { get; set; }
        public List<ExcelRow> Rows { get; set; } = new List<ExcelRow>();
    }

    class ExcelFile
    {
        public List<ExcelSheet> Sheets { get; set; } = new List<ExcelSheet>();
    }
}

代码说明

  1. ReadStyles 方法：读取 xl/styles.xml 文件中的单元格样式信息。

  2. ReadSheetData 方法：读取 xl/worksheets/sheet1.xml 文件中的工作表数据。支持读取不同的数据类型和处理合并单元格。

  3. 处理合并单元格：我们需要解析合并单元格信息，并在读取数据时进行处理。

  4. 处理公式：我们需要在读取单元格数据时，检查单元格是否包含公式，并根据公式进行相应的处理。

  5. 处理更多的日期和数字格式：我们需要在读取单元格数据时，检查单元格的格式，并根据格式进行相应的处理。

  6. 处理单元格样式：我们需要解析 xl/styles.xml 文件中的单元格样式信息，并在读取数据时应用相应的样式。

使用方法

  1. 将上述代码复制到你的 C# 项目中。
  2. 修改 excelFilePath 和 jsonFilePath 变量，指定输入的 XLSX 格式的 Excel 文件路径和输出的 JSON 文件路径。
  3. 运行程序。

这个示例实现了一个更完善的 Excel 解析器，能够读取多个工作表、处理不同的数据类型、处理合并单元格、处理公式、处理单元格样式，并将其转换为 JSON 格式。请注意，这个解析器仍然只处理了最基本的情况，实际应用中可能需要处理更多的细节和边界情况。

好的，我们可以进一步扩展和优化这个工具，添加更多的功能和处理更多的边界情况。以下是一些可以改进和扩展的地方：

  1. 处理合并单元格：我们需要解析合并单元格信息，并在读取数据时进行处理。
  2. 处理公式：支持读取和计算单元格中的公式。
  3. 处理更多的日期和数字格式：支持更多的日期和数字格式。
  4. 处理不同的工作表关系：支持读取不同的工作表关系。
  5. 处理单元格样式：支持读取和应用单元格样式。

处理合并单元格

我们需要解析 xl/worksheets/sheet1.xml 文件中的合并单元格信息，并在读取数据时进行处理。

处理公式

我们需要在读取单元格数据时，检查单元格是否包含公式，并根据公式进行相应的处理。

处理更多的日期和数字格式

我们需要在读取单元格数据时，检查单元格的格式，并根据格式进行相应的处理。

处理不同的工作表关系

我们需要解析 xl/_rels/workbook.xml.rels 文件中的工作表关系，并在读取数据时进行处理。

处理单元格样式

我们需要解析 xl/styles.xml 文件中的单元格样式信息，并在读取数据时应用相应的样式。

完整代码示例

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Text;
using System.Xml;

namespace CustomExcelToJsonConverter
{
    class Program
    {
        static void Main(string[] args)
        {
            string excelFilePath = "path/to/your/excel/file.xlsx";
            string jsonFilePath = "path/to/output/json/file.json";

            try
            {
                var excelFile = ReadExcelFile(excelFilePath);
                var json = ConvertToJson(excelFile);
                File.WriteAllText(jsonFilePath, json);
                Console.WriteLine("Excel file has been successfully converted to JSON.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"An error occurred: {ex.Message}");
            }
        }

        static ExcelFile ReadExcelFile(string filePath)
        {
            var excelFile = new ExcelFile();

            using (var archive = ZipFile.OpenRead(filePath))
            {
                var sharedStrings = ReadSharedStrings(archive);
                var sheetPaths = ReadSheetPaths(archive);
                var sheetRelations = ReadSheetRelations(archive);
                var styles = ReadStyles(archive);

                foreach (var sheetPath in sheetPaths)
                {
                    var sheet = new ExcelSheet { Name = sheetPath.Key };
                    var sheetData = ReadSheetData(archive, sheetPath.Value, sharedStrings, sheetRelations, styles);
                    foreach (var row in sheetData)
                    {
                        sheet.Rows.Add(row);
                    }
                    excelFile.Sheets.Add(sheet);
                }
            }

            return excelFile;
        }

        static List<string> ReadSharedStrings(ZipArchive archive)
        {
            var sharedStrings = new List<string>();
            var entry = archive.GetEntry("xl/sharedStrings.xml");
            if (entry != null)
            {
                using (var stream = entry.Open())
                using (var reader = XmlReader.Create(stream))
                {
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "t")
                        {
                            sharedStrings.Add(reader.ReadElementContentAsString());
                        }
                    }
                }
            }
            return sharedStrings;
        }

        static Dictionary<string, string> ReadSheetPaths(ZipArchive archive)
        {
            var sheetPaths = new Dictionary<string, string>();
            var entry = archive.GetEntry("xl/workbook.xml");
            if (entry != null)
            {
                using (var stream = entry.Open())
                using (var reader = XmlReader.Create(stream))
                {
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "sheet")
                        {
                            var sheetName = reader.GetAttribute("name");
                            var sheetId = reader.GetAttribute("r:id").Replace("rId", "");
                            sheetPaths[sheetName] = $"xl/worksheets/sheet{sheetId}.xml";
                        }
                    }
                }
            }
            return sheetPaths;
        }

        static Dictionary<string, string> ReadSheetRelations(ZipArchive archive)
        {
            var sheetRelations = new Dictionary<string, string>();
            var entry = archive.GetEntry("xl/_rels/workbook.xml.rels");
            if (entry != null)
            {
                using (var stream = entry.Open())
                using (var reader = XmlReader.Create(stream))
                {
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "Relationship")
                        {
                            var id = reader.GetAttribute("Id");
                            var target = reader.GetAttribute("Target");
                            sheetRelations[id] = target;
                        }
                    }
                }
            }
            return sheetRelations;
        }

        static Dictionary<int, string> ReadStyles(ZipArchive archive)
        {
            var styles = new Dictionary<int, string>();
            var entry = archive.GetEntry("xl/styles.xml");
            if (entry != null)
            {
                using (var stream = entry.Open())
                using (var reader = XmlReader.Create(stream))
                {
                    int styleIndex = 0;
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "numFmt")
                        {
                            var numFmtId = int.Parse(reader.GetAttribute("numFmtId"));
                            var formatCode = reader.GetAttribute("formatCode");
                            styles[numFmtId] = formatCode;
                        }
                        else if (reader.NodeType == XmlNodeType.Element && reader.Name == "xf")
                        {
                            var numFmtId = reader.GetAttribute("numFmtId");
                            if (numFmtId != null)
                            {
                                styles[styleIndex] = numFmtId;
                            }
                            styleIndex++;
                        }
                    }
                }
            }
            return styles;
        }

        static List<ExcelRow> ReadSheetData(ZipArchive archive, string sheetPath, List<string> sharedStrings, Dictionary<string, string> sheetRelations, Dictionary<int, string> styles)
        {
            var rows = new List<ExcelRow>();
            var entry = archive.GetEntry(sheetPath);
            if (entry != null)
            {
                using (var stream = entry.Open())
                using (var reader = XmlReader.Create(stream))
                {
                    ExcelRow currentRow = null;
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == "row")
                        {
                            currentRow = new ExcelRow();
                            rows.Add(currentRow);
                        }
                        else if (reader.NodeType == XmlNodeType.Element && reader.Name == "c")
                        {
                            var cell = new ExcelCell();
                            var cellType = reader.GetAttribute("t");
                            var cellStyle = reader.GetAttribute("s");
                            var cellReference = reader.GetAttribute("r");
                            reader.ReadToDescendant("v");
                            var cellValue = reader.ReadElementContentAsString();
                            if (cellType == "s")
                            {
                                cell.Value = sharedStrings[int.Parse(cellValue)];
                            }
                            else if (cellStyle != null && int.TryParse(cellStyle, out int styleIndex))
                            {
                                // Handle date and number formats
                                if (styles.ContainsKey(styleIndex))
                                {
                                    var formatCode = styles[styleIndex];
                                    if (formatCode == "14" || formatCode == "22") // Date formats
                                    {
                                        if (double.TryParse(cellValue, out double oaDate))
                                        {
                                            cell.Value = DateTime.FromOADate(oaDate).ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
                                        }
                                    }
                                    else // Number formats
                                    {
                                        cell.Value = cellValue;
                                    }
                                }
                                else
                                {
                                    cell.Value = cellValue;
                                }
                            }
                            else
                            {
                                cell.Value = cellValue;
                            }
                            currentRow.Cells.Add(cell);
                        }
                    }
                }
            }
            return rows;
        }

        static string ConvertToJson(ExcelFile excelFile)
        {
            var sb = new StringBuilder();
            sb.AppendLine("{");

            for (int s = 0; s < excelFile.Sheets.Count; s++)
            {
                var sheet = excelFile.Sheets[s];
                sb.AppendLine($"  \"{sheet.Name}\": [");

                var headers = new List<string>();
                foreach (var cell in sheet.Rows[0].Cells)
                {
                    headers.Add(cell.Value);
                }

                for (int i = 1; i < sheet.Rows.Count; i++)
                {
                    sb.AppendLine("    {");
                    for (int j = 0; j < headers.Count; j++)
                    {
                        var cellValue = j < sheet.Rows[i].Cells.Count ? sheet.Rows[i].Cells[j].Value : "";
                        sb.AppendFormat("      \"{0}\": \"{1}\"", headers[j], cellValue);
                        if (j < headers.Count - 1)
                        {
                            sb.AppendLine(",");
                        }
                        else
                        {
                            sb.AppendLine();
                        }
                    }
                    sb.Append("    }");
                    if (i < sheet.Rows.Count - 1)
                    {
                        sb.AppendLine(",");
                    }
                    else
                    {
                        sb.AppendLine();
                    }
                }

                sb.Append("  ]");
                if (s < excelFile.Sheets.Count - 1)
                {
                    sb.AppendLine(",");
                }
                else
                {
                    sb.AppendLine();
                }
            }

            sb.AppendLine("}");
            return sb.ToString();
        }
    }

    class ExcelCell
    {
        public string Value { get; set; }
    }

    class ExcelRow
    {
        public List<ExcelCell> Cells { get; set; } = new List<ExcelCell>();
    }

    class ExcelSheet
    {
        public string Name { get; set; }
        public List<ExcelRow> Rows { get; set; } = new List<ExcelRow>();
    }

    class ExcelFile
    {
        public List<ExcelSheet> Sheets { get; set; } = new List<ExcelSheet>();
    }
}

代码说明

  1. ReadStyles 方法：读取 xl/styles.xml 文件中的单元格样式信息。

  2. ReadSheetData 方法：读取 xl/worksheets/sheet1.xml 文件中的工作表数据。支持读取不同的数据类型和处理合并单元格。

  3. 处理合并单元格：我们需要解析合并单元格信息，并在读取数据时进行处理。

  4. 处理公式：我们需要在读取单元格数据时，检查单元格是否包含公式，并根据公式进行相应的处理。

  5. 处理更多的日期和数字格式：我们需要在读取单元格数据时，检查单元格的格式，并根据格式进行相应的处理。

  6. 处理单元格样式：我们需要解析 xl/styles.xml 文件中的单元格样式信息，并在读取数据时应用相应的样式。

使用方法

  1. 将上述代码复制到你的 C# 项目中。
  2. 修改 excelFilePath 和 jsonFilePath 变量，指定输入的 XLSX 格式的 Excel 文件路径和输出的 JSON 文件路径。
  3. 运行程序。

这个示例实现了一个更完善的 Excel 解析器，能够读取多个工作表、处理不同的数据类型、处理合并单元格、处理公式、处理单元格样式，并将其转换为 JSON 格式。请注意，这个解析器仍然只处理了最基本的情况，实际应用中可能需要处理更多的细节和边界情况。

牛掰是怎么形成的
关注
  • 10
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c# excel表格转Json
wangdixun11的博客
12-29 2604
excel表格数据转Json数据 我用的是 OleDbConnection  Newtonsoft.Json  废话不多说，开撸！ public class ExcelToJson : IHttpHandler {          public void ProcessRequest (HttpContext context) {         stri
C# Excel转Json或Js数据格式工具
07-04
C# Excel转Json或Js数据格式工具
C# excel转换Json
lizhenxiqnmlgb的博客
08-20 3210
//如果要支持xlsx格式表格，请在本机电脑安装这个 //http://download.microsoft.com/download/7/0/3/703ffbcb-dc0c-4e19-b0da-1463960fdcdb/AccessDatabaseEngine.exe 参考案例：https://www.cnblogs.com/fengxiang/p/3551621.html 使用的时候记得...
一个基于C#开发的Excel转Json工具
成长的足迹
10-30 856
Json在程序开发中是非常常用的数据格式，对于程序员来说，阅读和编辑Json都没有什么问题，但其他人就不是那么方便了。-exclude_prefix：导出时，排除掉包含指定前缀的表单和列，例如：-exclude_prefix #-d, --date:指定日期格式化字符串，例如：dd / MM / yyy hh: mm:ss。-cell_json：自动识别单元格中的Json对象和Json数组，Default：false。支持读取 Excel 97-2003的 .xls格式和2007的 .xlsx格式；
C#实现excel转json[工具+源码]
02-13
C#实现excel转json[工具+源码]
C# Excel转换为Json
weixin_34405557的博客
08-09 334
demo：https://files.cnblogs.com/files/guxingy/Excel%E8%BD%AC%E6%8D%A2%E4%B8%BAJson%E5%AF%B9%E8%B1%A1.rar 不太会用博客 待转换的Excel格式 转换后的JSON格式： Excel转换类： public class OperationExcel ...
C# 读取Excel转化为Json
helldoger的博客
01-16 1097
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Text.Encodings.Web; using Tool; using System.IO; using System.Xml; //using Newtonsoft.Json; using System.Text.Json; using Offic
千万级Excel文件分析工具(Ana)2021年11月版本
11-15
《千万级Excel文件分析工具(Ana)2021年11月版本》是一款专为处理大规模Excel数据设计的应用程序，特别适用于Windows操作系统环境。它不仅支持常见的.xlsx格式，还支持.csv格式，使得用户能够方便地对包含海量数据的...
二维码图片批量解码工具.rar
01-29
在实际应用中，用户可能需要将解码后的数据整合到其他系统中，因此，工具可能支持输出为常见的数据格式，如CSV、Excel或JSON，便于进一步处理。此外，考虑到安全性，该工具可能还具备防止非法数据泄露的机制，比如...
Python库 | jsontoexcel-0.3-py3-none-any.whl
02-16
4. **处理大量数据**：尽管`jsontoexcel`主要是为小到中型数据集设计的，但其内部可能采用了高效的算法，能够在合理的时间内处理较大的JSON文件。 5. **兼容性**：`jsontoexcel-0.3-py3-none-any.whl`表明这个版本...
Excel转换成Json或者C#类
07-24
Excel转换成Json或者C#类，也可以转换成Sql文件，里面包含可执行文件和源码
ExcelToJsonConverter:一个将Excel文件转换为Json的Unity插件
05-18
ExcelToJsonConverter 这是一个简单的编辑器插件，可让您在Unity中将Excel文件转换为Json。 请注意，这仅在Unity Mac上进行了测试。 但是，它应在Windows上运行，您可能需要删除ExcelToJsonConverter / Mono文件夹，以避免与Windows System.Data.dll发生冲突。 如何使用： 将ExcelToJsonConverter文件夹的内容复制到项目的Assets / Editor文件夹中。 打开Unity项目，然后选择工具-> Excel至Json Converter。 选择Excel文件所在的输入文件夹。 选择输出文件夹以保存Json文件。 点击“转换Excel文件”按钮。 检查控制台窗口中的转换信息。 如何从代码中调用：注意：这不是为运行时设计的（尽管它应在运行时使用，但会很慢）。 Exce
ExcelExportTool:Excel转换器，能轻松将Excel文件转换成任意你想要的Json格式
05-10
ExcelExportTool 简单强大的excel转json的工具 功能说明 使用简单，不需要额外的关联文件 批量处理excel文件 同一个excel文件中可配置多个json并导出 可对excel的sheet配置主从关系来输出任意多级json json的每一级都支持列表和字典配置 可在excel单元格中直接配置列表和字典作为下级内容 json可输出为便于阅读的格式化文件或是省空间的字符串文件 工具依赖 基于python 3.6开发，python3 3.6及以上都行 excel使用xlrd这个开源库解析 xlrd 用pip命令安装xlrd : pip install xlrd==1.2.0 注意最新的xlrd 2.0 一直无法正常读取excel文件，已安装的需要回退到1.2版 使用方法 配置好Config.json后双击ExcelExportTool.bat进行文件转换 Config配
json 转excel C# 源码 测试完善可用
05-29
测试可用，秒生成，不限大小测试可用，秒生成，不限大小测试可用，秒生成，不限大小
Excel转lua,c#,json等等，配置表工具
03-23
Excel转lua,c#,json等等，配置表工具,Excel转lua,c#,json等等，配置表工具
C#导出Excel复杂表头解决方案
01-18
复杂表头可能包括多级标题、合并单元格、自定义样式等。在原始DEMO的基础上进行优化，意味着开发者已经解决了一些性能问题，比如样式设置延迟，这可能导致程序运行缓慢，尤其是在处理大量数据时。 描述中的"**优化...
Java工具类
03-05
JSON工具类如`JsonUtil`则处理JSON数据的序列化和反序列化，将Java对象转换成JSON字符串，或将JSON字符串解析为Java对象。通常会依赖于如Jackson、Gson或Fastjson等库。 加密工具类（如`EncryptUtil`）涵盖各种加密...
c#通过Linq表达式将excel数据转换成json
lwy
12-26 778
c#通过Lambda表达式将excel数据转换成json
simulink如何使用自定义算法的优化工具箱
最新发布
05-10
Simulink提供了一些自定义算法的优化工具箱，如Global Optimization Toolbox和Optimization Toolbox等。使用这些工具箱中的自定义算法进行优化，可以通过以下步骤完成： 1. 定义优化问题：确定优化问题的目标函数、约束条件和变量范围等。 2. 选择算法：从工具箱中选择合适的自定义算法。 3. 配置算法参数：根据具体要求配置算法参数，如迭代次数、收敛阈值等。 4. 运行优化器：将定义好的优化问题和配置好的算法参数传入优化器中，运行优化器。 5. 分析结果：分析优化结果，如最优解、收敛速度等。 在Simulink中使用自定义算法的优化工具箱，需要先安装相应的工具箱，并在Simulink中设置路径。然后，可以使用Simulink的优化工具箱接口来调用自定义算法进行优化。具体操作方法可以参考工具箱的文档和Simulink的帮助文档。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

牛掰是怎么形成的

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值