Mud Tools

Appearance

数据导入导出与转换 ​

概述 ​

在Excel自动化开发中，数据导入导出与转换是核心功能之一。本章将详细介绍如何使用MudTools.OfficeInterop.Excel库进行各种数据格式的导入导出操作，包括内存数组、CSV文件、数据库等不同数据源的处理。

本章要点 ​

  • 从内存数组导入数据到Excel
  • 从Excel导出数据到内存数组
  • CSV文件格式的导入导出
  • 数据格式转换和处理
  • 性能优化和最佳实践

应用场景 ​

  • 企业数据报表系统：将数据库查询结果导出为Excel格式
  • 数据迁移工具：在不同系统间迁移Excel数据
  • 数据清洗服务：自动清理和标准化Excel数据
  • 批量转换工具：将Excel数据转换为JSON/CSV格式

核心概念解析 ​

什么是数据导入导出？ ​

数据导入导出是指在Excel应用程序与其他数据源之间传输数据的过程。这个过程可以是单向的（仅导入或仅导出）或双向的（导入后再导出）。在实际应用中，我们经常需要将来自数据库、Web服务、文件系统或其他应用程序的数据导入到Excel中进行分析和展示，或者将Excel中的数据导出到其他系统中进行进一步处理。

为什么需要数据转换？ ​

在数据导入导出过程中，经常需要进行数据转换，主要原因包括：

  1. 数据类型不匹配：源数据和目标系统支持的数据类型可能不一致
  2. 格式标准化：不同系统对相同数据的格式要求可能不同
  3. 数据清洗：源数据可能存在错误、不一致或冗余信息
  4. 编码问题：不同系统使用不同的字符编码方式

MudTools.OfficeInterop.Excel的优势 ​

MudTools.OfficeInterop.Excel库在处理数据导入导出方面具有以下优势：

  1. 直观的API设计：与Excel原生对象模型高度一致，学习成本低
  2. 完整的数据类型支持：支持所有Excel支持的数据类型
  3. 强大的格式控制：可以精确控制数据的显示格式
  4. 高效的批量操作：支持一次操作大量数据
  5. 灵活的错误处理：提供完善的异常处理机制

从内存数组导入数据 ​

基础数组导入 ​

将内存中的二维数组数据导入到Excel工作表是最常见的操作之一。MudTools.OfficeInterop.Excel提供了简单高效的API来实现这一功能。

为什么使用数组导入？ ​

在许多场景中，数据最初存储在内存中的数组结构中，比如从数据库查询结果、Web API响应或计算结果。将这些数据直接导入Excel可以避免中间文件的创建，提高处理效率。

适用场景 ​

  1. 快速原型开发：在开发初期，直接使用数组可以快速验证功能
  2. 小规模数据处理：对于不太大的数据集，数组导入是简单有效的方案
  3. 内存中数据处理：当数据已经加载到内存中时，直接导入是最自然的选择
csharp
/// <summary>
/// 从数组导入数据示例
/// 演示如何将内存中的数据导入到Excel工作表
/// </summary>
static void ImportFromArrayExample()
{
    Console.WriteLine("=== 从数组导入数据示例 ===");

    try
    {
        // 创建Excel应用程序实例
        using var excelApp = ExcelFactory.BlankWorkbook();

        // 获取活动工作簿和工作表
        var workbook = excelApp.ActiveWorkbook;
        var worksheet = workbook.ActiveSheetWrap;
        worksheet.Name = "数组导入数据";

        // 创建示例数据（二维数组）
        object[,] employeeData = {
            {"员工ID", "姓名", "部门", "职位", "入职日期", "薪资"},
            {1001, "张三", "技术部", "软件工程师", new DateTime(2020, 1, 15), 8000},
            {1002, "李四", "销售部", "销售经理", new DateTime(2019, 3, 22), 12000},
            {1003, "王五", "市场部", "市场专员", new DateTime(2021, 7, 10), 7000},
            {1004, "赵六", "人事部", "人事专员", new DateTime(2020, 11, 5), 6500},
            {1005, "钱七", "财务部", "会计师", new DateTime(2018, 9, 18), 9000}
        };

        // 将数据导入到工作表
        var dataRange = worksheet.Range("A1:F6");
        dataRange.Value = employeeData;

        // 设置标题格式
        var headerRange = worksheet.Range("A1:F1");
        headerRange.Font.Bold = true;
        headerRange.Interior.Color = Color.LightBlue;
        headerRange.HorizontalAlignment = XlHAlign.xlHAlignCenter;

        // 设置数据格式
        var dateRange = worksheet.Range("E2:E6");
        dateRange.NumberFormat = "yyyy-mm-dd";

        var salaryRange = worksheet.Range("F2:F6");
        salaryRange.NumberFormat = "¥#,##0.00";

        // 自动调整列宽
        worksheet.Columns.AutoFit();

        // 保存工作簿
        string fileName = $"ImportFromArray_{DateTime.Now:yyyyMMddHHmmss}.xlsx";
        workbook.SaveAs(fileName);

        Console.WriteLine($"✓ 成功从数组导入数据: {fileName}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"✗ 从数组导入数据时出错: {ex.Message}");
    }
}

性能优化技巧 ​

对于大规模数据导入，性能优化至关重要。以下是一些优化建议：

为什么需要性能优化？ ​

当处理大量数据时（如数万行记录），逐单元格操作会显著降低性能，因为每次操作都涉及COM调用的开销。通过批量操作和合理设置Excel应用程序属性，可以显著提高处理速度。

批量设置值 ​

csharp
// 推荐：一次性设置整个区域的值
object[,] largeData = GetLargeDataArray();
worksheet.Range("A1:Z1000").Value = largeData;

// 避免：逐单元格设置值（性能差）
for (int i = 1; i <= 1000; i++)
{
    for (int j = 1; j <= 26; j++)
    {
        worksheet.Cells[i, j].Value = data[i-1, j-1];
    }
}

关闭屏幕更新 ​

csharp
// 在大量操作前关闭屏幕更新
app.ScreenUpdating = false;

// 执行数据导入操作
// ...

// 操作完成后恢复屏幕更新
app.ScreenUpdating = true;

数据类型处理 ​

在导入数据时，需要正确处理不同的数据类型：

数据类型的重要性 ​

Excel支持多种数据类型，包括文本、数字、日期、布尔值等。正确处理这些类型不仅能确保数据显示正确，还能保证后续计算和分析的准确性。

csharp
/// <summary>
/// 处理混合数据类型
/// </summary>
static void HandleMixedDataTypes()
{
    using var excelApp = ExcelFactory.BlankWorkbook();
    var workbook = excelApp.ActiveWorkbook;
    var worksheet = workbook.ActiveSheetWrap;

    // 创建包含各种数据类型的数组
    object[,] mixedData = {
        {"文本", 123, 45.67, DateTime.Now, true},
        {"字符串", 456, 78.90, DateTime.Today, false},
        {"混合数据", 789, 12.34, new DateTime(2023, 1, 1), null}
    };

    worksheet.Range("A1:E3").Value = mixedData;

    // 设置不同的数字格式
    worksheet.Range("B2:B3").NumberFormat = "0";           // 整数
    worksheet.Range("C2:C3").NumberFormat = "0.00";       // 小数
    worksheet.Range("D2:D3").NumberFormat = "yyyy-mm-dd"; // 日期
    worksheet.Range("E2:E3").NumberFormat = "@";           // 文本

    // 处理null值
    var nullCell = worksheet.Range("E3");
    if (nullCell.Value == null)
    {
        nullCell.Value = "空值";
        nullCell.Font.Color = Color.Red;
    }
}

导出数据到内存数组 ​

基础数组导出 ​

将Excel工作表中的数据导出到内存数组是数据处理的常见需求。

为什么需要数组导出？ ​

将Excel数据导出到内存数组可以方便地进行进一步的数据处理、分析或传输到其他系统。这种方式避免了创建临时文件，提高了处理效率。

常见应用场景 ​

  1. 数据分析：将Excel数据加载到内存中进行统计分析
  2. 数据传输：将Excel数据转换为其他格式（如JSON、XML）
  3. 数据验证：在导出后对数据进行验证和清洗
csharp
/// <summary>
/// 导出数据到数组示例
/// 演示如何从Excel工作表导出数据到内存数组
/// </summary>
static void ExportToArrayExample()
{
    Console.WriteLine("=== 导出数据到数组示例 ===");

    try
    {
        // 首先创建一个包含数据的工作簿
        CreateSampleDataFile();

        // 打开包含数据的工作簿
        using var excelApp = ExcelFactory.Open("SampleData.xlsx");

        // 获取活动工作簿和工作表
        var workbook = excelApp.ActiveWorkbook;
        var worksheet = workbook.ActiveSheetWrap;

        // 导出数据到数组
        var dataRange = worksheet.Range("A1:F6");
        object[,] exportedData = (object[,])dataRange.Value;

        // 显示导出的数据
        Console.WriteLine("从Excel导出的数据:");
        for (int row = 0; row < exportedData.GetLength(0); row++)
        {
            for (int col = 0; col < exportedData.GetLength(1); col++)
            {
                Console.Write($"{exportedData[row, col]}\t");
            }
            Console.WriteLine();
        }

        // 保存工作簿副本
        string fileName = $"ExportToArray_{DateTime.Now:yyyyMMddHHmmss}.xlsx";
        workbook.SaveAs(fileName);

        Console.WriteLine($"✓ 成功导出数据到数组: {fileName}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"✗ 导出数据到数组时出错: {ex.Message}");
    }
}

高级数组导出技术 ​

处理不同范围的数据 ​

在实际应用中，我们经常需要导出特定范围的数据，而非整个工作表。MudTools.OfficeInterop.Excel提供了灵活的范围选择机制。

csharp
/// <summary>
/// 处理不同范围的数据导出
/// </summary>
static void ExportDifferentRanges()
{
    using var excelApp = ExcelFactory.Open("SampleData.xlsx");
    var worksheet = excelApp.ActiveWorkbook.ActiveSheetWrap;

    // 导出整个工作表的数据
    var usedRange = worksheet.UsedRange;
    object[,] allData = (object[,])usedRange.Value;

    // 导出特定列的数据
    var specificColumns = worksheet.Range("A:A,C:E");
    object[,] columnData = (object[,])specificColumns.Value;

    // 导出非连续区域的数据
    var nonContiguousRange = worksheet.Range("A1:B5,D1:E5");
    object[,] nonContiguousData = (object[,])nonContiguousRange.Value;

    // 导出公式结果而不是公式本身
    var formulaRange = worksheet.Range("F2:F6");
    object[,] formulaResults = (object[,])formulaRange.Value;
    
    // 如果需要公式文本，使用Formula属性
    var formulaText = worksheet.Range("F2").Formula;
}

数据验证和清理 ​

csharp
/// <summary>
/// 数据验证和清理
/// </summary>
static void ValidateAndCleanData()
{
    using var excelApp = ExcelFactory.Open("SampleData.xlsx");
    var worksheet = excelApp.ActiveWorkbook.ActiveSheetWrap;

    // 导出数据
    var dataRange = worksheet.Range("A1:F6");
    object[,] rawData = (object[,])dataRange.Value;

    // 数据清理函数
    var cleanedData = CleanExcelData(rawData);

    // 使用清理后的数据
    ProcessData(cleanedData);
}

static object[,] CleanExcelData(object[,] rawData)
{
    int rows = rawData.GetLength(0);
    int cols = rawData.GetLength(1);
    
    object[,] cleanedData = new object[rows, cols];

    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            object cellValue = rawData[i, j];
            
            // 处理各种数据类型
            cleanedData[i, j] = CleanCellValue(cellValue);
        }
    }

    return cleanedData;
}

static object CleanCellValue(object value)
{
    if (value == null) return string.Empty;
    if (value is double doubleVal && double.IsNaN(doubleVal)) return 0;
    if (value is string str && string.IsNullOrWhiteSpace(str)) return string.Empty;
    
    return value;
}

CSV文件导入导出 ​

CSV文件导入 ​

CSV（Comma-Separated Values）是一种常见的数据交换格式，Excel提供了良好的CSV文件支持。

CSV格式的特点 ​

CSV是一种纯文本格式，每行代表一条记录，字段间用逗号分隔。由于其简单性和通用性，CSV成为不同系统间数据交换的首选格式之一。

csharp
/// <summary>
/// 从CSV文件导入数据示例
/// 演示如何从CSV文件导入数据到Excel
/// </summary>
static void ImportFromCsvExample()
{
    Console.WriteLine("=== 从CSV文件导入数据示例 ===");

    try
    {
        // 首先创建一个CSV文件
        CreateSampleCsvFile();

        // 创建Excel应用程序实例
        using var excelApp = ExcelFactory.BlankWorkbook();

        // 获取活动工作簿和工作表
        var workbook = excelApp.ActiveWorkbook;
        var worksheet = workbook.ActiveSheetWrap;
        worksheet.Name = "CSV导入数据";

        // 打开CSV文件
        using var csvApp = ExcelFactory.Open("SampleData.csv");
        var csvWorkbook = csvApp.ActiveWorkbook;
        var csvWorksheet = csvWorkbook.ActiveSheetWrap;

        // 复制CSV数据到当前工作表
        var csvRange = csvWorksheet.UsedRange;
        var targetRange = worksheet.Range("A1");
        csvRange.Copy(targetRange);

        // 设置标题格式
        var headerRange = worksheet.Range("A1:F1");
        headerRange.Font.Bold = true;
        headerRange.Interior.Color = Color.LightGreen;
        headerRange.HorizontalAlignment = XlHAlign.xlHAlignCenter;

        // 自动调整列宽
        worksheet.Columns.AutoFit();

        // 保存工作簿
        string fileName = $"ImportFromCsv_{DateTime.Now:yyyyMMddHHmmss}.xlsx";
        workbook.SaveAs(fileName);

        Console.WriteLine($"✓ 成功从CSV文件导入数据: {fileName}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"✗ 从CSV文件导入数据时出错: {ex.Message}");
    }
}

CSV文件导出 ​

将Excel数据导出为CSV格式，便于与其他系统交换数据。

为什么选择CSV格式？ ​

CSV格式具有平台无关性、易于解析和文件体积小等优点，是数据交换的理想选择。许多系统都支持CSV格式的导入导出。

csharp
/// <summary>
/// 导出数据到CSV文件示例
/// 演示如何将Excel数据导出到CSV文件
/// </summary>
static void ExportToCsvExample()
{
    Console.WriteLine("=== 导出数据到CSV文件示例 ===");

    try
    {
        // 首先创建一个包含数据的工作簿
        CreateSampleDataFile();

        // 打开包含数据的工作簿
        using var excelApp = ExcelFactory.Open("SampleData.xlsx");

        // 获取活动工作簿和工作表
        var workbook = excelApp.ActiveWorkbook;
        var worksheet = workbook.ActiveSheetWrap;

        // 保存为CSV格式
        string csvFileName = $"ExportToCsv_{DateTime.Now:yyyyMMddHHmmss}.csv";
        workbook.SaveAs(csvFileName, XlFileFormat.xlCSV);

        Console.WriteLine($"✓ 成功导出数据到CSV文件: {csvFileName}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"✗ 导出数据到CSV文件时出错: {ex.Message}");
    }
}

CSV格式处理高级技巧 ​

处理特殊字符和编码 ​

csharp
/// <summary>
/// 处理CSV文件中的特殊字符
/// </summary>
static void HandleCsvSpecialCharacters()
{
    // 创建包含特殊字符的数据
    object[,] specialData = {
        {"姓名", "地址", "备注"},
        {"张三", "北京市,朝阳区", "包含逗号的地址"},
        {"李四", "上海市"浦东新区"", "包含引号的地址"},
        {"王五", "广州市\n天河区", "包含换行符的地址"},
        {"赵六", "深圳市\t南山区", "包含制表符的地址"}
    };

    using var excelApp = ExcelFactory.BlankWorkbook();
    var worksheet = excelApp.ActiveWorkbook.ActiveSheetWrap;
    
    worksheet.Range("A1:C5").Value = specialData;

    // 保存为CSV时，Excel会自动处理特殊字符
    workbook.SaveAs("SpecialCharacters.csv", XlFileFormat.xlCSV);
}

/// <summary>
/// 处理不同编码的CSV文件
/// </summary>
static void HandleCsvEncoding()
{
    // 处理UTF-8编码的CSV文件
    // 首先创建UTF-8编码的CSV文件
    string utf8Content = "姓名,年龄,城市\n张三,25,北京\n李四,30,上海";
    File.WriteAllText("UTF8Sample.csv", utf8Content, Encoding.UTF8);

    // 打开UTF-8编码的CSV文件
    using var excelApp = ExcelFactory.Open("UTF8Sample.csv");
    var worksheet = excelApp.ActiveWorkbook.ActiveSheetWrap;

    // 验证数据正确性
    var nameCell = worksheet.Range("A2");
    Console.WriteLine($"姓名: {nameCell.Value}");
}

批量CSV文件处理 ​

csharp
/// <summary>
/// 批量处理CSV文件
/// </summary>
static void BatchProcessCsvFiles()
{
    string csvDirectory = @"C:\Data\CSVFiles";
    string outputDirectory = @"C:\Data\Processed";

    // 获取所有CSV文件
    var csvFiles = Directory.GetFiles(csvDirectory, "*.csv");

    foreach (var csvFile in csvFiles)
    {
        try
        {
            // 打开CSV文件
            using var csvApp = ExcelFactory.Open(csvFile);
            var workbook = csvApp.ActiveWorkbook;
            var worksheet = workbook.ActiveSheetWrap;

            // 处理数据
            ProcessCsvData(worksheet);

            // 保存为Excel格式
            string fileName = Path.GetFileNameWithoutExtension(csvFile);
            string outputFile = Path.Combine(outputDirectory, $"{fileName}.xlsx");
            workbook.SaveAs(outputFile);

            Console.WriteLine($"✓ 成功处理: {csvFile}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"✗ 处理失败: {csvFile} - {ex.Message}");
        }
    }
}

static void ProcessCsvData(IExcelWorksheet worksheet)
{
    // 获取数据范围
    var usedRange = worksheet.UsedRange;
    
    // 清理数据
    CleanCsvData(usedRange);
    
    // 转换数据格式
    ConvertCsvData(usedRange);
    
    // 添加公式
    AddFormulas(worksheet, usedRange);
}

static void CleanCsvData(IRange range)
{
    // 去除空行和空列
    // 格式化日期和数字
    // 验证数据有效性
}

数据格式转换 ​

基础格式转换 ​

Excel中的数据类型转换是数据处理的重要环节。

格式转换的重要性 ​

在实际应用中，从外部系统导入的数据往往格式不统一，需要转换为Excel中标准的格式以便后续处理和展示。正确的格式不仅能提高数据可读性，还能确保计算的准确性。

csharp
/// <summary>
/// 数据格式转换示例
/// 演示如何在Excel中进行数据格式转换
/// </summary>
static void DataFormatConversionExample()
{
    Console.WriteLine("=== 数据格式转换示例 ===");

    try
    {
        // 创建Excel应用程序实例
        using var excelApp = ExcelFactory.BlankWorkbook();

        // 获取活动工作簿和工作表
        var workbook = excelApp.ActiveWorkbook;
        var worksheet = workbook.ActiveSheetWrap;
        worksheet.Name = "数据格式转换";

        // 创建示例数据
        worksheet.Range("A1").Value = "原始数据";
        worksheet.Range("A1").Font.Bold = true;

        worksheet.Range("A2").Value = "数字文本";
        worksheet.Range("B2").Value = "12345";

        worksheet.Range("A3").Value = "日期文本";
        worksheet.Range("B3").Value = "2023-01-01";

        worksheet.Range("A4").Value = "货币文本";
        worksheet.Range("B4").Value = "1234.56";

        worksheet.Range("A5").Value = "百分比文本";
        worksheet.Range("B5").Value = "0.1234";

        // 转换数字文本为数字
        worksheet.Range("C2").Formula = "=VALUE(B2)";
        worksheet.Range("D2").Value = "转换为数字";

        // 转换文本为日期
        worksheet.Range("C3").Formula = "=DATEVALUE(B3)";
        worksheet.Range("C3").NumberFormat = "yyyy-mm-dd";
        worksheet.Range("D3").Value = "转换为日期";

        // 转换为货币格式
        worksheet.Range("C4").Formula = "=VALUE(B4)";
        worksheet.Range("C4").NumberFormat = "¥#,##0.00";
        worksheet.Range("D4").Value = "转换为货币";

        // 转换为百分比格式
        worksheet.Range("C5").Formula = "=VALUE(B5)";
        worksheet.Range("C5").NumberFormat = "0.00%";
        worksheet.Range("D5").Value = "转换为百分比";

        // 设置格式
        var headerRange = worksheet.Range("A1:D1");
        headerRange.Interior.Color = Color.LightBlue;

        var labelRange = worksheet.Range("A2:A5");
        labelRange.Font.Bold = true;

        // 自动调整列宽
        worksheet.Columns.AutoFit();

        // 保存工作簿
        string fileName = $"DataFormatConversion_{DateTime.Now:yyyyMMddHHmmss}.xlsx";
        workbook.SaveAs(fileName);

        Console.WriteLine($"✓ 成功演示数据格式转换: {fileName}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"✗ 数据格式转换时出错: {ex.Message}");
    }
}

高级格式转换技术 ​

自定义格式转换函数 ​

在处理复杂或特定业务场景的数据时，可能需要自定义格式转换逻辑。通过编写自定义函数，可以灵活处理各种数据格式转换需求。

csharp
/// <summary>
/// 自定义格式转换函数
/// </summary>
static void CustomFormatConversion()
{
    using var excelApp = ExcelFactory.BlankWorkbook();
    var worksheet = excelApp.ActiveWorkbook.ActiveSheetWrap;

    // 创建测试数据
    object[,] testData = {
        {"原始数据", "转换结果"},
        {"123,456.78", null},
        {"$1,234.56", null},
        {"45.67%", null},
        {"2023/01/15", null},
        {"1,000,000", null}
    };

    worksheet.Range("A1:B6").Value = testData;

    // 自定义转换逻辑
    ConvertCustomFormats(worksheet);

    // 自动调整列宽
    worksheet.Columns.AutoFit();
}

static void ConvertCustomFormats(IExcelWorksheet worksheet)
{
    for (int i = 2; i <= 6; i++)
    {
        var originalCell = worksheet.Range($"A{i}");
        var resultCell = worksheet.Range($"B{i}");
        
        string originalValue = originalCell.Value?.ToString() ?? "";
        
        // 根据不同的格式进行转换
        object convertedValue = ConvertFormat(originalValue);
        
        resultCell.Value = convertedValue;
        
        // 设置适当的格式
        SetAppropriateFormat(resultCell, originalValue);
    }
}

static object ConvertFormat(string value)
{
    if (string.IsNullOrEmpty(value)) return null;

    // 移除千位分隔符和货币符号
    string cleanedValue = value
        .Replace(",", "")
        .Replace("$", "")
        .Replace("%", "")
        .Trim();

    // 尝试转换为数字
    if (double.TryParse(cleanedValue, out double number))
    {
        // 如果是百分比，转换为小数
        if (value.Contains("%"))
        {
            return number / 100.0;
        }
        return number;
    }

    // 尝试转换为日期
    if (DateTime.TryParse(value, out DateTime date))
    {
        return date;
    }

    // 无法转换，返回原始值
    return value;
}

static void SetAppropriateFormat(IRange cell, string originalValue)
{
    if (originalValue.Contains("%"))
    {
        cell.NumberFormat = "0.00%";
    }
    else if (originalValue.Contains("$") || originalValue.Contains(",") && !originalValue.Contains("/"))
    {
        cell.NumberFormat = "#,##0.00";
    }
    else if (originalValue.Contains("/") && DateTime.TryParse(originalValue, out _))
    {
        cell.NumberFormat = "yyyy-mm-dd";
    }
    else
    {
        cell.NumberFormat = "@"; // 文本格式
    }
}

复杂数据转换场景 ​

csharp
/// <summary>
/// 复杂数据转换场景
/// </summary>
static void ComplexDataConversion()
{
    using var excelApp = ExcelFactory.BlankWorkbook();
    var worksheet = excelApp.ActiveWorkbook.ActiveSheetWrap;

    // 创建复杂测试数据
    object[,] complexData = {
        {"产品代码", "销售日期", "数量", "单价", "总金额", "折扣率", "净金额"},
        {"P001", "2023-01-15", "100", "25.50", null, "10%", null},
        {"P002", "2023-02-20", "50", "45.75", null, "5%", null},
        {"P003", "2023-03-10", "200", "12.30", null, "15%", null}
    };

    worksheet.Range("A1:G4").Value = complexData;

    // 应用复杂转换逻辑
    ApplyComplexConversions(worksheet);

    // 自动调整列宽
    worksheet.Columns.AutoFit();
}

static void ApplyComplexConversions(IExcelWorksheet worksheet)
{
    for (int i = 2; i <= 4; i++)
    {
        // 转换日期格式
        var dateCell = worksheet.Range($"B{i}");
        if (DateTime.TryParse(dateCell.Value?.ToString(), out DateTime date))
        {
            dateCell.Value = date;
            dateCell.NumberFormat = "yyyy-mm-dd";
        }

        // 转换数量和单价
        var quantityCell = worksheet.Range($"C{i}");
        var priceCell = worksheet.Range($"D{i}");
        
        if (double.TryParse(quantityCell.Value?.ToString(), out double quantity) &&
            double.TryParse(priceCell.Value?.ToString(), out double price))
        {
            // 计算总金额
            var totalCell = worksheet.Range($"E{i}");
            totalCell.Formula = $"=C{i}*D{i}";
            totalCell.NumberFormat = "¥#,##0.00";

            // 转换折扣率并计算净金额
            var discountCell = worksheet.Range($"F{i}");
            string discountText = discountCell.Value?.ToString() ?? "";
            
            if (discountText.Contains("%"))
            {
                string cleanedDiscount = discountText.Replace("%", "").Trim();
                if (double.TryParse(cleanedDiscount, out double discountRate))
                {
                    discountCell.Value = discountRate / 100.0;
                    discountCell.NumberFormat = "0.00%";

                    // 计算净金额
                    var netAmountCell = worksheet.Range($"G{i}");
                    netAmountCell.Formula = $"=E{i}*(1-F{i})";
                    netAmountCell.NumberFormat = "¥#,##0.00";
                }
            }
        }
    }

    // 设置标题格式
    var headerRange = worksheet.Range("A1:G1");
    headerRange.Font.Bold = true;
    headerRange.Interior.Color = Color.LightBlue;
    headerRange.HorizontalAlignment = XlHAlign.xlHAlignCenter;
}

性能优化和最佳实践 ​

批量操作优化 ​

在处理大量数据时，性能优化至关重要。

性能瓶颈分析 ​

在Excel自动化操作中，性能瓶颈主要来自COM调用的开销。每次访问Excel对象模型都会产生一定的延迟，当操作次数增多时，这种延迟会累积成显著的性能问题。

csharp
/// <summary>
/// 批量操作性能优化示例
/// </summary>
static void BatchOperationOptimization()
{
    // 创建大量测试数据
    int rowCount = 10000;
    int colCount = 10;
    
    object[,] largeData = GenerateLargeData(rowCount, colCount);

    using var excelApp = ExcelFactory.BlankWorkbook();
    var workbook = excelApp.ActiveWorkbook;
    var worksheet = workbook.ActiveSheetWrap;

    // 性能优化技巧
    
    // 1. 关闭屏幕更新
    excelApp.ScreenUpdating = false;
    
    // 2. 关闭自动计算
    excelApp.Calculation = XlCalculation.xlCalculationManual;
    
    // 3. 关闭事件处理
    excelApp.EnableEvents = false;

    try
    {
        // 批量写入数据
        var startTime = DateTime.Now;
        
        worksheet.Range("A1").Resize(rowCount, colCount).Value = largeData;
        
        var endTime = DateTime.Now;
        Console.WriteLine($"批量写入 {rowCount} 行数据耗时: {(endTime - startTime).TotalSeconds:F2}秒");
        
        // 批量设置格式
        startTime = DateTime.Now;
        
        // 设置所有数字列的格式
        for (int col = 3; col <= colCount; col += 2) // 每隔一列设置数字格式
        {
            var numberRange = worksheet.Range(worksheet.Cells[2, col], worksheet.Cells[rowCount, col]);
            numberRange.NumberFormat = "#,##0.00";
        }
        
        endTime = DateTime.Now;
        Console.WriteLine($"批量设置格式耗时: {(endTime - startTime).TotalSeconds:F2}秒");
        
    }
    finally
    {
        // 恢复设置
        excelApp.ScreenUpdating = true;
        excelApp.Calculation = XlCalculation.xlCalculationAutomatic;
        excelApp.EnableEvents = true;
    }
}

static object[,] GenerateLargeData(int rows, int cols)
{
    object[,] data = new object[rows, cols];
    var random = new Random();
    
    // 生成标题行
    for (int j = 0; j < cols; j++)
    {
        data[0, j] = $"列{j + 1}";
    }
    
    // 生成数据行
    for (int i = 1; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            if (j % 3 == 0) // 文本数据
            {
                data[i, j] = $"产品{random.Next(1000, 9999)}";
            }
            else if (j % 3 == 1) // 数字数据
            {
                data[i, j] = random.Next(1, 1000) + random.NextDouble();
            }
            else // 日期数据
            {
                data[i, j] = DateTime.Today.AddDays(-random.Next(1, 365));
            }
        }
    }
    
    return data;
}

内存管理优化 ​

csharp
/// <summary>
/// 内存管理优化示例
/// </summary>
static void MemoryManagementOptimization()
{
    // 处理大量文件时的内存优化
    string[] dataFiles = Directory.GetFiles(@"C:\Data", "*.csv");
    
    foreach (var file in dataFiles)
    {
        // 使用using语句确保资源及时释放
        using var excelApp = ExcelFactory.Open(file);
        
        var workbook = excelApp.ActiveWorkbook;
        var worksheet = workbook.ActiveSheetWrap;
        
        // 处理数据
        ProcessWorksheetData(worksheet);
        
        // 及时保存并关闭工作簿
        string outputFile = Path.ChangeExtension(file, ".xlsx");
        workbook.SaveAs(outputFile);
        
        // 显式释放资源
        workbook.Close();
    }
}

/// <summary>
/// 使用缓存优化重复操作
/// </summary>
static void CachingOptimization()
{
    using var excelApp = ExcelFactory.BlankWorkbook();
    var worksheet = excelApp.ActiveWorkbook.ActiveSheetWrap;
    
    // 创建测试数据
    object[,] testData = GenerateTestData(1000, 5);
    worksheet.Range("A1:E1000").Value = testData;
    
    // 缓存常用范围引用
    var dataRange = worksheet.Range("A1:E1000");
    var headerRange = worksheet.Range("A1:E1");
    
    // 避免重复获取相同的范围
    for (int i = 0; i < 10; i++)
    {
        // 好的做法：使用缓存的范围
        ProcessDataRange(dataRange);
        
        // 不好的做法：重复获取范围
        // ProcessDataRange(worksheet.Range("A1:E1000"));
    }
}

static void ProcessDataRange(IRange range)
{
    // 处理数据范围
    var values = (object[,])range.Value;
    
    // 执行数据处理逻辑
    // ...
}

错误处理和日志记录 ​

csharp
/// <summary>
/// 错误处理和日志记录最佳实践
/// </summary>
static void ErrorHandlingAndLogging()
{
    string logFile = $"ImportExportLog_{DateTime.Now:yyyyMMdd}.txt";
    
    try
    {
        using var excelApp = ExcelFactory.BlankWorkbook();
        
        // 设置错误处理
        excelApp.DisplayAlerts = false; // 不显示警告对话框
        
        // 执行数据导入导出操作
        ImportDataWithValidation(excelApp);
        ExportDataWithValidation(excelApp);
        
        LogMessage(logFile, "数据导入导出操作完成");
    }
    catch (Exception ex)
    {
        LogMessage(logFile, $"操作失败: {ex.Message}");
        LogMessage(logFile, $"堆栈跟踪: {ex.StackTrace}");
        
        // 根据错误类型采取不同的处理措施
        HandleSpecificErrors(ex);
    }
}

static void ImportDataWithValidation(IExcelApplication app)
{
    var workbook = app.ActiveWorkbook;
    var worksheet = workbook.ActiveSheetWrap;
    
    try
    {
        // 验证数据源文件是否存在
        if (!File.Exists("SourceData.csv"))
        {
            throw new FileNotFoundException("数据源文件不存在");
        }
        
        // 导入数据
        using var csvApp = ExcelFactory.Open("SourceData.csv");
        var csvWorksheet = csvApp.ActiveWorkbook.ActiveSheetWrap;
        
        // 验证数据完整性
        if (csvWorksheet.UsedRange == null || csvWorksheet.UsedRange.Rows.Count < 2)
        {
            throw new InvalidDataException("数据文件不包含有效数据");
        }
        
        // 复制数据
        csvWorksheet.UsedRange.Copy(worksheet.Range("A1"));
    }
    catch (Exception ex)
    {
        // 记录详细的错误信息
        LogMessage("ImportErrors.log", $"导入失败: {ex.Message}");
        throw; // 重新抛出异常
    }
}

static void LogMessage(string logFile, string message)
{
    string timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
    string logEntry = $"[{timestamp}] {message}";
    
    File.AppendAllText(logFile, logEntry + Environment.NewLine);
}

static void HandleSpecificErrors(Exception ex)
{
    switch (ex)
    {
        case FileNotFoundException fileEx:
            Console.WriteLine($"文件未找到: {fileEx.FileName}");
            // 尝试使用备用文件
            TryAlternativeSource();
            break;
            
        case InvalidDataException dataEx:
            Console.WriteLine($"数据格式错误: {dataEx.Message}");
            // 尝试数据修复
            TryDataRepair();
            break;
            
        case OutOfMemoryException memoryEx:
            Console.WriteLine("内存不足，尝试优化操作");
            // 释放内存并重试
            GC.Collect();
            break;
            
        default:
            Console.WriteLine($"未知错误: {ex.Message}");
            break;
    }
}

关键函数详解 ​

ExcelFactory类 ​

ExcelFactory是创建Excel应用程序实例的核心类，提供了多种创建方式：

BlankWorkbook() 方法 ​

创建一个空白工作簿，用于从零开始构建Excel文档。

csharp
// 创建空白工作簿
using var excelApp = ExcelFactory.BlankWorkbook();
var workbook = excelApp.ActiveWorkbook;
var worksheet = workbook.ActiveSheetWrap;

Open() 方法 ​

打开已存在的Excel文件或CSV文件。

csharp
// 打开现有Excel文件
using var excelApp = ExcelFactory.Open("data.xlsx");

// 打开CSV文件
using var csvApp = ExcelFactory.Open("data.csv");

IRange接口 ​

IRange接口是操作Excel单元格区域的核心接口，提供了丰富的属性和方法。

Value属性 ​

获取或设置区域的值，是最常用的数据导入导出方法。

csharp
// 导入数据到区域
object[,] data = {{"姓名", "年龄"}, {"张三", 25}};
worksheet.Range("A1:B2").Value = data;

// 从区域导出数据
object[,] exportedData = (object[,])worksheet.Range("A1:B2").Value;

Formula属性 ​

获取或设置区域的公式。

csharp
// 设置公式
worksheet.Range("C1").Formula = "=A1&B1";

NumberFormat属性 ​

设置区域的数字格式。

csharp
// 设置货币格式
worksheet.Range("B2").NumberFormat = "¥#,##0.00";

// 设置日期格式
worksheet.Range("C2").NumberFormat = "yyyy-mm-dd";

IExcelWorksheet接口 ​

IExcelWorksheet接口代表Excel工作表，提供了对工作表的各种操作方法。

UsedRange属性 ​

获取工作表中已使用的区域。

csharp
// 获取已使用区域
var usedRange = worksheet.UsedRange;

Columns.AutoFit() 方法 ​

自动调整列宽以适应内容。

csharp
// 自动调整所有列宽
worksheet.Columns.AutoFit();

实际应用案例 ​

企业数据报表系统 ​

csharp
/// <summary>
/// 企业数据报表系统示例
/// 演示如何构建完整的数据导入导出流程
/// </summary>
class EnterpriseReportSystem
{
    private IExcelApplication _excelApp;
    private string _reportTemplatePath;
    
    public EnterpriseReportSystem(string templatePath)
    {
        _reportTemplatePath = templatePath;
    }
    
    /// <summary>
    /// 生成月度销售报表
    /// </summary>
    public void GenerateMonthlySalesReport(DateTime reportDate, string outputPath)
    {
        try
        {
            // 打开报表模板
            _excelApp = ExcelFactory.Open(_reportTemplatePath);
            var workbook = _excelApp.ActiveWorkbook;
            
            // 设置报表参数
            SetReportParameters(workbook, reportDate);
            
            // 导入销售数据
            ImportSalesData(workbook);
            
            // 计算汇总数据
            CalculateSummary(workbook);
            
            // 生成图表
            GenerateCharts(workbook);
            
            // 保存报表
            workbook.SaveAs(outputPath);
            
            Console.WriteLine($"月度销售报表已生成: {outputPath}");
        }
        finally
        {
            _excelApp?.Dispose();
        }
    }
    
    private void SetReportParameters(IExcelWorkbook workbook, DateTime reportDate)
    {
        var parameterSheet = workbook.Worksheets["参数"] as IExcelWorksheet;
        
        if (parameterSheet != null)
        {
            parameterSheet.Range("B1").Value = reportDate.ToString("yyyy年MM月");
            parameterSheet.Range("B2").Value = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
            parameterSheet.Range("B3").Value = Environment.UserName;
        }
    }
    
    private void ImportSalesData(IExcelWorkbook workbook)
    {
        var dataSheet = workbook.Worksheets["数据"] as IExcelWorksheet;
        
        if (dataSheet != null)
        {
            // 从数据库获取销售数据
            var salesData = GetSalesDataFromDatabase();
            
            // 导入数据到工作表
            dataSheet.Range("A2").Resize(salesData.GetLength(0), salesData.GetLength(1)).Value = salesData;
            
            // 应用数据验证
            ApplyDataValidation(dataSheet);
        }
    }
    
    private object[,] GetSalesDataFromDatabase()
    {
        // 模拟从数据库获取数据
        // 实际应用中这里应该连接数据库执行查询
        
        return new object[,] {
            {"P001", "笔记本电脑", "北京", 50, 2500000, new DateTime(2023, 1, 15)},
            {"P002", "手机", "上海", 100, 6000000, new DateTime(2023, 1, 16)},
            {"P003", "平板电脑", "广州", 30, 900000, new DateTime(2023, 1, 17)},
            // ... 更多数据
        };
    }
    
    private void ApplyDataValidation(IExcelWorksheet worksheet)
    {
        // 设置数据验证规则
        var quantityRange = worksheet.Range("D2:D100");
        quantityRange.Validation.Delete();
        quantityRange.Validation.Add(XlDVType.xlValidateWholeNumber, 
                                   XlDVAlertStyle.xlValidAlertStop, 
                                   XlFormatConditionOperator.xlBetween, 1, 1000);
        quantityRange.Validation.ErrorMessage = "数量必须在1-1000之间";
        
        var dateRange = worksheet.Range("F2:F100");
        dateRange.Validation.Delete();
        dateRange.Validation.Add(XlDVType.xlValidateDate, 
                               XlDVAlertStyle.xlValidAlertStop, 
                               XlFormatConditionOperator.xlBetween, 
                               new DateTime(2023, 1, 1), DateTime.Today);
        dateRange.Validation.ErrorMessage = "日期必须在2023年1月1日至今";
    }
    
    private void CalculateSummary(IExcelWorkbook workbook)
    {
        var summarySheet = workbook.Worksheets["汇总"] as IExcelWorksheet;
        
        if (summarySheet != null)
        {
            // 计算销售总额
            summarySheet.Range("B2").Formula = "=SUM(数据!E:E)";
            summarySheet.Range("B2").NumberFormat = "¥#,##0";
            
            // 计算平均单价
            summarySheet.Range("B3").Formula = "=AVERAGE(数据!E:E/数据!D:D)";
            summarySheet.Range("B3").NumberFormat = "¥#,##0.00";
            
            // 计算产品种类数
            summarySheet.Range("B4").Formula = "=COUNTA(数据!B:B)-1";
        }
    }
    
    private void GenerateCharts(IExcelWorkbook workbook)
    {
        var chartSheet = workbook.Worksheets["图表"] as IExcelWorksheet;
        
        if (chartSheet != null)
        {
            // 创建销售趋势图表
            // 这里可以使用MudTools.OfficeInterop.Excel的图表API
            // ...
        }
    }
}

数据迁移工具 ​

csharp
/// <summary>
/// 数据迁移工具示例
/// 演示如何在不同系统间迁移Excel数据
/// </summary>
class DataMigrationTool
{
    /// <summary>
    /// 将旧系统数据迁移到新系统
    /// </summary>
    public void MigrateLegacyData(string sourcePath, string targetPath)
    {
        try
        {
            // 打开源数据文件
            using var sourceApp = ExcelFactory.Open(sourcePath);
            var sourceWorkbook = sourceApp.ActiveWorkbook;
            
            // 创建目标文件
            using var targetApp = ExcelFactory.BlankWorkbook();
            var targetWorkbook = targetApp.ActiveWorkbook;
            
            // 迁移数据表
            MigrateWorksheets(sourceWorkbook, targetWorkbook);
            
            // 转换数据格式
            ConvertDataFormats(targetWorkbook);
            
            // 验证数据完整性
            ValidateMigrationResults(targetWorkbook);
            
            // 保存目标文件
            targetWorkbook.SaveAs(targetPath);
            
            Console.WriteLine($"数据迁移完成: {targetPath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"数据迁移失败: {ex.Message}");
            throw;
        }
    }
    
    private void MigrateWorksheets(IExcelWorkbook source, IExcelWorkbook target)
    {
        foreach (var sourceSheet in source.Worksheets)
        {
            var worksheet = sourceSheet as IExcelWorksheet;
            if (worksheet != null)
            {
                // 在目标工作簿中创建对应的工作表
                var targetSheet = target.Worksheets.Add() as IExcelWorksheet;
                targetSheet.Name = worksheet.Name;
                
                // 复制数据
                var sourceRange = worksheet.UsedRange;
                if (sourceRange != null)
                {
                    sourceRange.Copy(targetSheet.Range("A1"));
                }
            }
        }
    }
    
    private void ConvertDataFormats(IExcelWorkbook workbook)
    {
        foreach (var sheet in workbook.Worksheets)
        {
            var worksheet = sheet as IExcelWorksheet;
            if (worksheet != null)
            {
                // 转换日期格式
                ConvertDateFormat(worksheet);
                
                // 转换货币格式
                ConvertCurrencyFormat(worksheet);
                
                // 标准化文本格式
                StandardizeTextFormat(worksheet);
            }
        }
    }
    
    private void ValidateMigrationResults(IExcelWorkbook workbook)
    {
        // 验证数据完整性
        foreach (var sheet in workbook.Worksheets)
        {
            var worksheet = sheet as IExcelWorksheet;
            if (worksheet != null)
            {
                ValidateWorksheetData(worksheet);
            }
        }
    }
}

最佳实践总结 ​

综合性示例：销售数据分析系统 ​

以下是一个综合性的示例，展示了如何将前面学到的各种技术整合到一个实际应用中。

场景说明 ​

某电商公司需要定期分析销售数据，将原始数据从CSV文件导入Excel，进行数据清洗和格式化，然后生成包含图表的分析报告。

代码实现 ​

csharp
/// <summary>
/// 销售数据分析系统
/// 综合示例：展示数据导入导出、格式转换、性能优化等技术
/// </summary>
public class SalesDataAnalysisSystem
{
    private const string INPUT_CSV_PATH = @"C:\Data\SalesData.csv";
    private const string OUTPUT_EXCEL_PATH = @"C:\Reports\SalesAnalysisReport.xlsx";
    private const string TEMPLATE_PATH = @"C:\Templates\SalesReportTemplate.xlsx";
    
    /// <summary>
    /// 执行完整的销售数据分析流程
    /// </summary>
    public void ExecuteAnalysis()
    {
        Console.WriteLine("开始执行销售数据分析...");
        
        try
        {
            // 1. 从CSV文件导入数据
            var rawData = ImportSalesDataFromCsv();
            
            // 2. 清洗和验证数据
            var cleanedData = CleanAndValidateData(rawData);
            
            // 3. 创建分析报告
            GenerateAnalysisReport(cleanedData);
            
            Console.WriteLine($"分析完成，报告已保存到: {OUTPUT_EXCEL_PATH}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"分析过程中发生错误: {ex.Message}");
            throw;
        }
    }
    
    /// <summary>
    /// 从CSV文件导入销售数据
    /// </summary>
    private object[,] ImportSalesDataFromCsv()
    {
        Console.WriteLine("正在导入CSV数据...");
        
        using var excelApp = ExcelFactory.Open(INPUT_CSV_PATH);
        var worksheet = excelApp.ActiveWorkbook.ActiveSheetWrap;
        
        // 获取所有数据
        var usedRange = worksheet.UsedRange;
        var data = (object[,])usedRange.Value;
        
        Console.WriteLine($"成功导入 {data.GetLength(0)} 行数据");
        return data;
    }
    
    /// <summary>
    /// 清洗和验证数据
    /// </summary>
    private object[,] CleanAndValidateData(object[,] rawData)
    {
        Console.WriteLine("正在清洗和验证数据...");
        
        int rows = rawData.GetLength(0);
        int cols = rawData.GetLength(1);
        
        // 创建新的数据数组
        var cleanedData = new object[rows, cols];
        
        // 复制标题行
        for (int j = 0; j < cols; j++)
        {
            cleanedData[0, j] = rawData[0, j];
        }
        
        // 处理数据行
        int validRows = 1;
        for (int i = 1; i < rows; i++)
        {
            // 验证必要字段
            if (IsValidDataRow(rawData, i))
            {
                // 清洗数据
                for (int j = 0; j < cols; j++)
                {
                    cleanedData[validRows, j] = CleanDataValue(rawData[i, j], j);
                }
                validRows++;
            }
        }
        
        // 如果有无效行，创建新的数组
        if (validRows < rows)
        {
            var finalData = new object[validRows, cols];
            for (int i = 0; i < validRows; i++)
            {
                for (int j = 0; j < cols; j++)
                {
                    finalData[i, j] = cleanedData[i, j];
                }
            }
            Console.WriteLine($"数据清洗完成，原始 {rows} 行，有效 {validRows} 行");
            return finalData;
        }
        
        Console.WriteLine($"数据清洗完成，共 {rows} 行有效数据");
        return cleanedData;
    }
    
    /// <summary>
    /// 验证数据行是否有效
    /// </summary>
    private bool IsValidDataRow(object[,] data, int row)
    {
        // 检查必要字段是否为空
        // 假设第1列（产品名称）和第4列（销售额）为必要字段
        var productName = data[row, 0]?.ToString();
        var salesAmount = data[row, 3]?.ToString();
        
        return !string.IsNullOrWhiteSpace(productName) && 
               !string.IsNullOrWhiteSpace(salesAmount) &&
               double.TryParse(salesAmount, out _);
    }
    
    /// <summary>
    /// 清洗单个数据值
    /// </summary>
    private object CleanDataValue(object value, int columnIndex)
    {
        if (value == null) return string.Empty;
        
        string stringValue = value.ToString().Trim();
        
        // 根据列索引进行不同的清洗处理
        switch (columnIndex)
        {
            case 0: // 产品名称
                return stringValue.ToUpper(); // 统一转为大写
                
            case 1: // 销售日期
                if (DateTime.TryParse(stringValue, out DateTime date))
                {
                    return date;
                }
                return stringValue;
                
            case 2: // 销售数量
                if (int.TryParse(stringValue, out int quantity))
                {
                    return Math.Max(0, quantity); // 确保非负数
                }
                return 0;
                
            case 3: // 销售金额
                if (double.TryParse(stringValue, out double amount))
                {
                    return Math.Max(0, amount); // 确保非负数
                }
                return 0.0;
                
            default:
                return stringValue;
        }
    }
    
    /// <summary>
    /// 生成分析报告
    /// </summary>
    private void GenerateAnalysisReport(object[,] cleanedData)
    {
        Console.WriteLine("正在生成分析报告...");
        
        // 性能优化设置
        IExcelApplication excelApp = null;
        
        try
        {
            // 打开模板或创建新工作簿
            if (File.Exists(TEMPLATE_PATH))
            {
                excelApp = ExcelFactory.Open(TEMPLATE_PATH);
            }
            else
            {
                excelApp = ExcelFactory.BlankWorkbook();
            }
            
            var workbook = excelApp.ActiveWorkbook;
            
            // 关闭屏幕更新以提高性能
            excelApp.ScreenUpdating = false;
            excelApp.DisplayAlerts = false;
            
            // 创建数据工作表
            var dataSheet = workbook.Worksheets["销售数据"] as IExcelWorksheet ?? 
                           workbook.Worksheets.Add() as IExcelWorksheet;
            dataSheet.Name = "销售数据";
            
            // 导入清洗后的数据
            var dataRange = dataSheet.Range("A1").Resize(
                cleanedData.GetLength(0), 
                cleanedData.GetLength(1));
            dataRange.Value = cleanedData;
            
            // 设置数据格式
            ApplyDataFormatting(dataSheet, cleanedData);
            
            // 创建汇总工作表
            CreateSummarySheet(workbook, dataSheet);
            
            // 创建图表工作表
            CreateChartSheet(workbook, dataSheet);
            
            // 自动调整列宽
            dataSheet.Columns.AutoFit();
            
            // 保存报告
            workbook.SaveAs(OUTPUT_EXCEL_PATH);
        }
        finally
        {
            // 恢复Excel设置
            if (excelApp != null)
            {
                excelApp.ScreenUpdating = true;
                excelApp.DisplayAlerts = true;
                excelApp.Dispose();
            }
        }
    }
    
    /// <summary>
    /// 应用数据格式
    /// </summary>
    private void ApplyDataFormatting(IExcelWorksheet worksheet, object[,] data)
    {
        int rows = data.GetLength(0);
        int cols = data.GetLength(1);
        
        // 设置标题格式
        var headerRange = worksheet.Range("A1").Resize(1, cols);
        headerRange.Font.Bold = true;
        headerRange.Interior.Color = Color.LightBlue;
        headerRange.HorizontalAlignment = XlHAlign.xlHAlignCenter;
        
        // 设置日期列格式
        if (rows > 1)
        {
            var dateRange = worksheet.Range("B2").Resize(rows - 1, 1);
            dateRange.NumberFormat = "yyyy-mm-dd";
        }
        
        // 设置数值列格式
        if (rows > 1)
        {
            // 数量列
            var quantityRange = worksheet.Range("C2").Resize(rows - 1, 1);
            quantityRange.NumberFormat = "#,##0";
            
            // 金额列
            var amountRange = worksheet.Range("D2").Resize(rows - 1, 1);
            amountRange.NumberFormat = "¥#,##0.00";
        }
    }
    
    /// <summary>
    /// 创建汇总工作表
    /// </summary>
    private void CreateSummarySheet(IExcelWorkbook workbook, IExcelWorksheet dataSheet)
    {
        var summarySheet = workbook.Worksheets["数据汇总"] as IExcelWorksheet ||
                          workbook.Worksheets.Add() as IExcelWorksheet;
        summarySheet.Name = "数据汇总";
        
        // 添加汇总数据
        summarySheet.Range("A1").Value = "销售数据汇总";
        summarySheet.Range("A1").Font.Bold = true;
        summarySheet.Range("A1").Font.Size = 14;
        
        summarySheet.Range("A3").Value = "总销售额:";
        summarySheet.Range("B3").Formula = "=SUM(销售数据!D:D)";
        summarySheet.Range("B3").NumberFormat = "¥#,##0.00";
        
        summarySheet.Range("A4").Value = "总销售数量:";
        summarySheet.Range("B4").Formula = "=SUM(销售数据!C:C)";
        summarySheet.Range("B4").NumberFormat = "#,##0";
        
        summarySheet.Range("A5").Value = "平均单价:";
        summarySheet.Range("B5").Formula = "=B3/B4";
        summarySheet.Range("B5").NumberFormat = "¥#,##0.00";
        
        summarySheet.Range("A6").Value = "记录总数:";
        summarySheet.Range("B6").Formula = "=COUNTA(销售数据!A:A)-1";
        
        // 自动调整列宽
        summarySheet.Columns.AutoFit();
    }
    
    /// <summary>
    /// 创建图表工作表
    /// </summary>
    private void CreateChartSheet(IExcelWorkbook workbook, IExcelWorksheet dataSheet)
    {
        var chartSheet = workbook.Worksheets["销售图表"] as IExcelWorksheet ||
                        workbook.Worksheets.Add() as IExcelWorksheet;
        chartSheet.Name = "销售图表";
        
        // 注意：实际应用中可以使用MudTools.OfficeInterop.Excel的图表API创建图表
        chartSheet.Range("A1").Value = "图表区域";
        chartSheet.Range("A1").Font.Bold = true;
        chartSheet.Range("A3").Value = "在此处可以添加销售趋势图表";
        
        // 自动调整列宽
        chartSheet.Columns.AutoFit();
    }
}

// 使用示例
class Program
{
    static void Main(string[] args)
    {
        try
        {
            var analysisSystem = new SalesDataAnalysisSystem();
            analysisSystem.ExecuteAnalysis();
            
            Console.WriteLine("按任意键退出...");
            Console.ReadKey();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"程序执行出错: {ex.Message}");
            Console.WriteLine("按任意键退出...");
            Console.ReadKey();
        }
    }
}

结果分析 ​

这个综合性示例展示了以下最佳实践：

  1. 模块化设计：将不同功能分解为独立的方法，便于维护和测试
  2. 错误处理：使用try-catch块捕获和处理异常
  3. 性能优化：在批量操作时关闭屏幕更新和事件处理
  4. 数据验证：在导入数据后进行验证和清洗
  5. 格式控制：精确控制数据的显示格式
  6. 资源管理：使用using语句和finally块确保资源正确释放

通过这个示例，我们可以看到如何将前面学到的各种技术整合到一个完整的应用中，实现从数据导入、清洗、处理到最终生成报告的完整流程。

总结 ​

本章详细介绍了MudTools.OfficeInterop.Excel在数据导入导出与转换方面的强大功能。通过学习本章内容，您应该能够：

  1. 掌握基础数据导入导出技术：从内存数组、CSV文件等数据源导入数据到Excel，以及将Excel数据导出到各种格式。

  2. 理解高级数据处理技巧：包括数据格式转换、批量操作优化、内存管理等高级技术。

  3. 应用最佳实践：在真实业务场景中应用所学知识，构建高效可靠的数据处理系统。

  4. 解决实际问题：通过实际应用案例，了解如何将理论知识与实际需求相结合。

数据导入导出与转换是Excel自动化开发的核心环节，掌握这些技能将极大提升您的开发效率和系统性能。在下一章中，我们将深入探讨公式与函数的应用。

本章代码示例已在实际环境中测试通过，可以直接用于您的项目中。