From fe0ba00289170c75929725adcbf7991feba9431e Mon Sep 17 00:00:00 2001 From: Michele Bastione Date: Thu, 10 Sep 2026 17:51:19 +0200 Subject: [PATCH 1/4] Renamed MiniExcelLib.MiniExcel class to MiniExcelV2 This change was adopted to avoid confusion with the `MiniExcelLibs.MiniExcel` facade class containing the V1 methods' signatures. Users will be able to unambiguosly distinguish between the legacy facade methods and the new idiomatic ones. --- .../BenchmarkSections/CreateExcelBenchmark.cs | 4 +- .../BenchmarkSections/QueryExcelBenchmark.cs | 4 +- .../TemplateExcelBenchmark.cs | 6 +- .../BenchmarkSections/XlsxAsyncBenchmark.cs | 4 +- src/MiniExcel.Core/MiniExcel.cs | 11 --- src/MiniExcel.Core/MiniExcelV2.cs | 19 ++++ src/MiniExcel/MiniExcel.cs | 12 +-- src/MiniExcel/MiniExcelConverter.cs | 8 +- .../DataReader/CsvDataReaderAsyncTests.cs | 2 +- .../DataReader/CsvDataReaderTests.cs | 2 +- .../Issues/GiteeIssuesTests.cs | 2 +- .../Issues/GithubIssuesAsyncTests.cs | 8 +- .../Issues/GithubIssuesTests.cs | 8 +- .../Main/MiniExcelCsvAsyncTests.cs | 4 +- .../Main/MiniExcelCsvTests.cs | 6 +- .../AlterSheets/MiniExcelAlterSheetsTests.cs | 2 +- .../MiniExcelAlterSheetsTestsAsync.cs | 2 +- .../Comments/CommentsRetrievalAsyncTests.cs | 2 +- .../Comments/CommentsRetrievalTests.cs | 2 +- .../MiniExcelAutoAdjustWidthTests.cs | 2 +- .../MiniExcelOpenXmlConfigurationTests.cs | 4 +- .../DataReader/OpenXmlDataReaderAsyncTests.cs | 2 +- .../DataReader/OpenXmlDataReaderTests.cs | 2 +- .../MiniExcelMappingTemplateTests.cs | 18 ++-- .../FluentMapping/MiniExcelMappingTests.cs | 62 ++++++------ .../Issues/MiniExcelGiteeIssuesAsyncTests.cs | 4 +- .../Issues/MiniExcelGiteeIssuesTests.cs | 6 +- .../Issues/MiniExcelGithubIssuesAsyncTests.cs | 6 +- .../Issues/MiniExcelGithubIssuesTests.cs | 6 +- .../MiniExcelOpenXmlExporterAsyncTests.cs | 4 +- .../Main/MiniExcelOpenXmlExporterTests.cs | 4 +- .../MiniExcelOpenXmlImporterAsyncTests.cs | 4 +- .../Main/MiniExcelOpenXmlImporterTests.cs | 4 +- ...MiniExcelOpenXmlMultipleSheetAsyncTests.cs | 2 +- .../MiniExcelOpenXmlMultipleSheetTests.cs | 4 +- .../MiniExcelOpenXmlSheetInformations.cs | 2 +- .../MiniExcelOpenXmlSheetInformationsAsync.cs | 97 +++++++++---------- .../Tables/MiniExcelOpenXmlTableAsyncTests.cs | 2 +- .../Tables/MiniExcelOpenXmlTableTests.cs | 2 +- .../Templates/CalcChainAsyncTests.cs | 2 +- .../Templates/CalcChainTests.cs | 2 +- .../Templates/MiniExcelTemplateAsyncTests.cs | 6 +- .../Templates/MiniExcelTemplateTests.cs | 4 +- 43 files changed, 181 insertions(+), 178 deletions(-) delete mode 100644 src/MiniExcel.Core/MiniExcel.cs create mode 100644 src/MiniExcel.Core/MiniExcelV2.cs diff --git a/benchmarks/MiniExcel.Benchmarks/BenchmarkSections/CreateExcelBenchmark.cs b/benchmarks/MiniExcel.Benchmarks/BenchmarkSections/CreateExcelBenchmark.cs index 9c424472..4bc5fe09 100644 --- a/benchmarks/MiniExcel.Benchmarks/BenchmarkSections/CreateExcelBenchmark.cs +++ b/benchmarks/MiniExcel.Benchmarks/BenchmarkSections/CreateExcelBenchmark.cs @@ -24,7 +24,7 @@ public void SetUp() ExcelPackage.LicenseContext = LicenseContext.NonCommercial; Encoding.RegisterProvider(CodePagesEncodingProvider.Instance); - _exporter = MiniExcel.Exporters.GetOpenXmlExporter(); + _exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); var simpleRegistry = new MappingRegistry(); simpleRegistry.Configure(config => @@ -40,7 +40,7 @@ public void SetUp() config.Property(x => x.Column9).ToCell("I1"); config.Property(x => x.Column10).ToCell("J1"); }); - _simpleMappingExporter = MiniExcel.Exporters.GetMappingExporter(simpleRegistry); + _simpleMappingExporter = MiniExcelV2.Exporters.GetMappingExporter(simpleRegistry); } [Benchmark(Description = "MiniExcel Create Xlsx")] diff --git a/benchmarks/MiniExcel.Benchmarks/BenchmarkSections/QueryExcelBenchmark.cs b/benchmarks/MiniExcel.Benchmarks/BenchmarkSections/QueryExcelBenchmark.cs index d82879ce..00ada916 100644 --- a/benchmarks/MiniExcel.Benchmarks/BenchmarkSections/QueryExcelBenchmark.cs +++ b/benchmarks/MiniExcel.Benchmarks/BenchmarkSections/QueryExcelBenchmark.cs @@ -23,7 +23,7 @@ public void SetUp() ExcelPackage.LicenseContext = LicenseContext.NonCommercial; Encoding.RegisterProvider(CodePagesEncodingProvider.Instance); - _importer = MiniExcel.Importers.GetOpenXmlImporter(); + _importer = MiniExcelV2.Importers.GetOpenXmlImporter(); // Setup mapping for query (matches CreateExcelBenchmark mapping) var registry = new MappingRegistry(); @@ -40,7 +40,7 @@ public void SetUp() config.Property(x => x.Column9).ToCell("I1"); config.Property(x => x.Column10).ToCell("J1"); }); - _mappingImporter = MiniExcel.Importers.GetMappingImporter(registry); + _mappingImporter = MiniExcelV2.Importers.GetMappingImporter(registry); } [Benchmark(Description = "MiniExcel QueryFirst")] diff --git a/benchmarks/MiniExcel.Benchmarks/BenchmarkSections/TemplateExcelBenchmark.cs b/benchmarks/MiniExcel.Benchmarks/BenchmarkSections/TemplateExcelBenchmark.cs index 71cdd025..dc084f2f 100644 --- a/benchmarks/MiniExcel.Benchmarks/BenchmarkSections/TemplateExcelBenchmark.cs +++ b/benchmarks/MiniExcel.Benchmarks/BenchmarkSections/TemplateExcelBenchmark.cs @@ -22,8 +22,8 @@ public class Employee [GlobalSetup] public void Setup() { - _templater = MiniExcel.Templaters.GetOpenXmlTemplater(); - _exporter = MiniExcel.Exporters.GetOpenXmlExporter(); + _templater = MiniExcelV2.Templaters.GetOpenXmlTemplater(); + _exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); var registry = new MappingRegistry(); registry.Configure(config => @@ -31,7 +31,7 @@ public void Setup() config.Property(x => x.Name).ToCell("A2"); config.Property(x => x.Department).ToCell("B2"); }); - _mappingTemplater = MiniExcel.Templaters.GetMappingTemplater(registry); + _mappingTemplater = MiniExcelV2.Templaters.GetMappingTemplater(registry); } [Benchmark(Description = "MiniExcel Fill Template")] diff --git a/benchmarks/MiniExcel.Benchmarks/BenchmarkSections/XlsxAsyncBenchmark.cs b/benchmarks/MiniExcel.Benchmarks/BenchmarkSections/XlsxAsyncBenchmark.cs index 5117c047..17732840 100644 --- a/benchmarks/MiniExcel.Benchmarks/BenchmarkSections/XlsxAsyncBenchmark.cs +++ b/benchmarks/MiniExcel.Benchmarks/BenchmarkSections/XlsxAsyncBenchmark.cs @@ -12,8 +12,8 @@ public class XlsxAsyncBenchmark : BenchmarkBase [GlobalSetup] public void Setup() { - _exporter = MiniExcel.Exporters.GetOpenXmlExporter(); - _templater = MiniExcel.Templaters.GetOpenXmlTemplater(); + _exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); + _templater = MiniExcelV2.Templaters.GetOpenXmlTemplater(); } [Benchmark(Description = "MiniExcel Create Xlsx Async")] diff --git a/src/MiniExcel.Core/MiniExcel.cs b/src/MiniExcel.Core/MiniExcel.cs deleted file mode 100644 index fcfa381e..00000000 --- a/src/MiniExcel.Core/MiniExcel.cs +++ /dev/null @@ -1,11 +0,0 @@ -using MiniExcelLib.Core; - -// ReSharper disable once CheckNamespace -namespace MiniExcelLib; - -public static class MiniExcel -{ - public static readonly MiniExcelExporterProvider Exporters = new(); - public static readonly MiniExcelImporterProvider Importers = new(); - public static readonly MiniExcelTemplaterProvider Templaters = new(); -} diff --git a/src/MiniExcel.Core/MiniExcelV2.cs b/src/MiniExcel.Core/MiniExcelV2.cs new file mode 100644 index 00000000..b5b9b7c5 --- /dev/null +++ b/src/MiniExcel.Core/MiniExcelV2.cs @@ -0,0 +1,19 @@ +using MiniExcelLib.Core; + +// ReSharper disable once CheckNamespace +namespace MiniExcelLib; + +public static class MiniExcelV2 +{ + public static readonly MiniExcelExporterProvider Exporters = new(); + public static readonly MiniExcelImporterProvider Importers = new(); + public static readonly MiniExcelTemplaterProvider Templaters = new(); +} + +[Obsolete("This class will be removed in the full release, use MiniExcelV2 instead.", true)] +public static class MiniExcel +{ + public static readonly MiniExcelExporterProvider Exporters = new(); + public static readonly MiniExcelImporterProvider Importers = new(); + public static readonly MiniExcelTemplaterProvider Templaters = new(); +} diff --git a/src/MiniExcel/MiniExcel.cs b/src/MiniExcel/MiniExcel.cs index d68437ae..04956b22 100644 --- a/src/MiniExcel/MiniExcel.cs +++ b/src/MiniExcel/MiniExcel.cs @@ -5,8 +5,6 @@ using MiniExcelLib.OpenXml.Models; using MiniExcelLib.OpenXml.Picture; using Zomp.SyncMethodGenerator; - -using NewMiniExcel = MiniExcelLib.MiniExcel; using NewOpenXmlConfiguration = MiniExcelLib.OpenXml.OpenXmlConfiguration; using MiniExcelDataReader = MiniExcelLib.Core.MiniExcelDataReaderBase; @@ -15,12 +13,12 @@ namespace MiniExcelLibs; public static partial class MiniExcel { - private static readonly OpenXmlExporter ExcelExporter = NewMiniExcel.Exporters.GetOpenXmlExporter(); - private static readonly OpenXmlImporter ExcelImporter = NewMiniExcel.Importers.GetOpenXmlImporter(); - private static readonly OpenXmlTemplater ExcelTemplater = NewMiniExcel.Templaters.GetOpenXmlTemplater(); + private static readonly OpenXmlExporter ExcelExporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); + private static readonly OpenXmlImporter ExcelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); + private static readonly OpenXmlTemplater ExcelTemplater = MiniExcelV2.Templaters.GetOpenXmlTemplater(); - private static readonly CsvExporter CsvExporter = NewMiniExcel.Exporters.GetCsvExporter(); - private static readonly CsvImporter CsvImporter = NewMiniExcel.Importers.GetCsvImporter(); + private static readonly CsvExporter CsvExporter = MiniExcelV2.Exporters.GetCsvExporter(); + private static readonly CsvImporter CsvImporter = MiniExcelV2.Importers.GetCsvImporter(); [CreateSyncVersion] diff --git a/src/MiniExcel/MiniExcelConverter.cs b/src/MiniExcel/MiniExcelConverter.cs index ddf9cdfa..72cc3821 100644 --- a/src/MiniExcel/MiniExcelConverter.cs +++ b/src/MiniExcel/MiniExcelConverter.cs @@ -53,11 +53,11 @@ public static async Task ConvertCsvToXlsxAsync(string csvPath, string xlsxPath, [CreateSyncVersion] public static async Task ConvertCsvToXlsxAsync(Stream csvStream, Stream xlsxStream, bool csvHasHeader = false, CancellationToken cancellationToken = default) { - var value = MiniExcel.Importers.GetCsvImporter() + var value = MiniExcelV2.Importers.GetCsvImporter() .QueryAsync(csvStream, hasHeaderRow: csvHasHeader, leaveOpen: true, cancellationToken: cancellationToken) .ConfigureAwait(false); - await MiniExcel.Exporters.GetOpenXmlExporter() + await MiniExcelV2.Exporters.GetOpenXmlExporter() .ExportAsync(xlsxStream, value, printHeader: csvHasHeader, cancellationToken: cancellationToken) .ConfigureAwait(false); } @@ -105,11 +105,11 @@ public static async Task ConvertXlsxToCsvAsync(string xlsxPath, string csvPath, [CreateSyncVersion] public static async Task ConvertXlsxToCsvAsync(Stream xlsxStream, Stream csvStream, bool xlsxHasHeader = true, CancellationToken cancellationToken = default) { - var value = MiniExcel.Importers.GetOpenXmlImporter() + var value = MiniExcelV2.Importers.GetOpenXmlImporter() .QueryAsync(xlsxStream, hasHeaderRow: xlsxHasHeader, leaveOpen: true, cancellationToken: cancellationToken) .ConfigureAwait(false); - await MiniExcel.Exporters.GetCsvExporter() + await MiniExcelV2.Exporters.GetCsvExporter() .ExportAsync(csvStream, value, printHeader: xlsxHasHeader, cancellationToken: cancellationToken) .ConfigureAwait(false); } diff --git a/tests/MiniExcel.Csv.Tests/DataReader/CsvDataReaderAsyncTests.cs b/tests/MiniExcel.Csv.Tests/DataReader/CsvDataReaderAsyncTests.cs index 8b439fc0..6e68e945 100644 --- a/tests/MiniExcel.Csv.Tests/DataReader/CsvDataReaderAsyncTests.cs +++ b/tests/MiniExcel.Csv.Tests/DataReader/CsvDataReaderAsyncTests.cs @@ -2,7 +2,7 @@ namespace MiniExcelLib.Csv.Tests.DataReader; public class CsvDataReaderAsyncTests { - private readonly CsvImporter _csvImporter = MiniExcel.Importers.GetCsvImporter(); + private readonly CsvImporter _csvImporter = MiniExcelV2.Importers.GetCsvImporter(); [Fact] public async Task GetDataReader_WithSimpleData_ReturnsValidDataReader() diff --git a/tests/MiniExcel.Csv.Tests/DataReader/CsvDataReaderTests.cs b/tests/MiniExcel.Csv.Tests/DataReader/CsvDataReaderTests.cs index 607c6ea1..ce9efe7a 100644 --- a/tests/MiniExcel.Csv.Tests/DataReader/CsvDataReaderTests.cs +++ b/tests/MiniExcel.Csv.Tests/DataReader/CsvDataReaderTests.cs @@ -2,7 +2,7 @@ namespace MiniExcelLib.Csv.Tests.DataReader; public class CsvDataReaderTests { - private readonly CsvImporter _csvImporter = MiniExcel.Importers.GetCsvImporter(); + private readonly CsvImporter _csvImporter = MiniExcelV2.Importers.GetCsvImporter(); [Fact] public void GetDataReader_WithSimpleData_ReturnsValidDataReader() diff --git a/tests/MiniExcel.Csv.Tests/Issues/GiteeIssuesTests.cs b/tests/MiniExcel.Csv.Tests/Issues/GiteeIssuesTests.cs index ce071a15..a8fda4d5 100644 --- a/tests/MiniExcel.Csv.Tests/Issues/GiteeIssuesTests.cs +++ b/tests/MiniExcel.Csv.Tests/Issues/GiteeIssuesTests.cs @@ -2,7 +2,7 @@ namespace MiniExcelLib.Csv.Tests.Issues; public class GiteeIssuesTests { - private readonly CsvExporter _csvExporter = MiniExcel.Exporters.GetCsvExporter(); + private readonly CsvExporter _csvExporter = MiniExcelV2.Exporters.GetCsvExporter(); // https://gitee.com/dotnetchina/MiniExcel/issues/I4X92G [Fact] diff --git a/tests/MiniExcel.Csv.Tests/Issues/GithubIssuesAsyncTests.cs b/tests/MiniExcel.Csv.Tests/Issues/GithubIssuesAsyncTests.cs index b76faa75..27e9d03a 100644 --- a/tests/MiniExcel.Csv.Tests/Issues/GithubIssuesAsyncTests.cs +++ b/tests/MiniExcel.Csv.Tests/Issues/GithubIssuesAsyncTests.cs @@ -2,8 +2,8 @@ public class GithubIssuesAsyncTests { - private readonly CsvExporter _csvExporter = MiniExcel.Exporters.GetCsvExporter(); - private readonly CsvImporter _csvImporter = MiniExcel.Importers.GetCsvImporter(); + private readonly CsvExporter _csvExporter = MiniExcelV2.Exporters.GetCsvExporter(); + private readonly CsvImporter _csvImporter = MiniExcelV2.Importers.GetCsvImporter(); // Support Enum Mapping [Fact] @@ -31,11 +31,11 @@ public async Task Issue89() Assert.Equal(Issue89Dto.WorkState.Leave, rows1[2].State); using var outputPath = AutoDeletingPath.Create(); - var rowsWritten = await MiniExcel.Exporters.GetOpenXmlExporter().ExportAsync(outputPath.ToString(), rows1); + var rowsWritten = await MiniExcelV2.Exporters.GetOpenXmlExporter().ExportAsync(outputPath.ToString(), rows1); Assert.Single(rowsWritten); Assert.Equal(3, rowsWritten[0]); - var rows2 = await MiniExcel.Importers.GetOpenXmlImporter().QueryAsync(outputPath.ToString()).ToListAsync(); + var rows2 = await MiniExcelV2.Importers.GetOpenXmlImporter().QueryAsync(outputPath.ToString()).ToListAsync(); Assert.Equal(Issue89Dto.WorkState.OnDuty, rows2[0].State); Assert.Equal(Issue89Dto.WorkState.Fired, rows2[1].State); Assert.Equal(Issue89Dto.WorkState.Leave, rows2[2].State); diff --git a/tests/MiniExcel.Csv.Tests/Issues/GithubIssuesTests.cs b/tests/MiniExcel.Csv.Tests/Issues/GithubIssuesTests.cs index fa3f0744..95a5d248 100644 --- a/tests/MiniExcel.Csv.Tests/Issues/GithubIssuesTests.cs +++ b/tests/MiniExcel.Csv.Tests/Issues/GithubIssuesTests.cs @@ -2,11 +2,11 @@ public class GithubIssuesTests { - private readonly CsvExporter _csvExporter = MiniExcel.Exporters.GetCsvExporter(); - private readonly CsvImporter _csvImporter = MiniExcel.Importers.GetCsvImporter(); + private readonly CsvExporter _csvExporter = MiniExcelV2.Exporters.GetCsvExporter(); + private readonly CsvImporter _csvImporter = MiniExcelV2.Importers.GetCsvImporter(); - private readonly OpenXmlExporter _openXmlExporter = MiniExcel.Exporters.GetOpenXmlExporter(); - private readonly OpenXmlImporter _openXmlImporter = MiniExcel.Importers.GetOpenXmlImporter(); + private readonly OpenXmlExporter _openXmlExporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); + private readonly OpenXmlImporter _openXmlImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); // Support for Enum Mapping diff --git a/tests/MiniExcel.Csv.Tests/Main/MiniExcelCsvAsyncTests.cs b/tests/MiniExcel.Csv.Tests/Main/MiniExcelCsvAsyncTests.cs index 4fd7201e..5eec34e1 100644 --- a/tests/MiniExcel.Csv.Tests/Main/MiniExcelCsvAsyncTests.cs +++ b/tests/MiniExcel.Csv.Tests/Main/MiniExcelCsvAsyncTests.cs @@ -2,8 +2,8 @@ public class MiniExcelCsvAsyncTests { - private readonly CsvExporter _csvExporter = MiniExcel.Exporters.GetCsvExporter(); - private readonly CsvImporter _csvImporter = MiniExcel.Importers.GetCsvImporter(); + private readonly CsvExporter _csvExporter = MiniExcelV2.Exporters.GetCsvExporter(); + private readonly CsvImporter _csvImporter = MiniExcelV2.Importers.GetCsvImporter(); [Fact] public async Task Gb2312_Encoding_Read_Test() diff --git a/tests/MiniExcel.Csv.Tests/Main/MiniExcelCsvTests.cs b/tests/MiniExcel.Csv.Tests/Main/MiniExcelCsvTests.cs index 443eb2ab..dbd55e70 100644 --- a/tests/MiniExcel.Csv.Tests/Main/MiniExcelCsvTests.cs +++ b/tests/MiniExcel.Csv.Tests/Main/MiniExcelCsvTests.cs @@ -2,8 +2,8 @@ public class MiniExcelCsvTests { - private readonly CsvExporter _csvExporter = MiniExcel.Exporters.GetCsvExporter(); - private readonly CsvImporter _csvImporter = MiniExcel.Importers.GetCsvImporter(); + private readonly CsvExporter _csvExporter = MiniExcelV2.Exporters.GetCsvExporter(); + private readonly CsvImporter _csvImporter = MiniExcelV2.Importers.GetCsvImporter(); [Fact] public void gb2312_Encoding_Read_Test() @@ -486,7 +486,7 @@ private static string MiniExcelGenerateCsv(string value) using (var stream = File.Create(path)) { IEnumerable records = [new { v1 = value, v2 = value }]; - var rowsWritten = MiniExcel.Exporters.GetCsvExporter().Export(stream, records); + var rowsWritten = MiniExcelV2.Exporters.GetCsvExporter().Export(stream, records); Assert.Equal(1, rowsWritten); } diff --git a/tests/MiniExcel.OpenXml.Tests/AlterSheets/MiniExcelAlterSheetsTests.cs b/tests/MiniExcel.OpenXml.Tests/AlterSheets/MiniExcelAlterSheetsTests.cs index cb69b531..73d443c0 100644 --- a/tests/MiniExcel.OpenXml.Tests/AlterSheets/MiniExcelAlterSheetsTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/AlterSheets/MiniExcelAlterSheetsTests.cs @@ -6,7 +6,7 @@ namespace MiniExcelLib.OpenXml.Tests.AlterSheets; public class MiniExcelAlterSheetTests { - private readonly OpenXmlExporter _excelExporter = MiniExcel.Exporters.GetOpenXmlExporter(); + private readonly OpenXmlExporter _excelExporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); [Fact] public void AlterSheet_WhenNewNameProvided_RenamesWorksheet() diff --git a/tests/MiniExcel.OpenXml.Tests/AlterSheets/MiniExcelAlterSheetsTestsAsync.cs b/tests/MiniExcel.OpenXml.Tests/AlterSheets/MiniExcelAlterSheetsTestsAsync.cs index 30d1061c..72f3cd94 100644 --- a/tests/MiniExcel.OpenXml.Tests/AlterSheets/MiniExcelAlterSheetsTestsAsync.cs +++ b/tests/MiniExcel.OpenXml.Tests/AlterSheets/MiniExcelAlterSheetsTestsAsync.cs @@ -6,7 +6,7 @@ namespace MiniExcelLib.OpenXml.Tests.AlterSheets; public class MiniExcelAlterSheetsTestAsync { - private readonly OpenXmlExporter _excelExporter = MiniExcel.Exporters.GetOpenXmlExporter(); + private readonly OpenXmlExporter _excelExporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); [Fact] public async Task AlterSheetAsync_WhenNewNameProvided_RenamesWorksheet() diff --git a/tests/MiniExcel.OpenXml.Tests/Comments/CommentsRetrievalAsyncTests.cs b/tests/MiniExcel.OpenXml.Tests/Comments/CommentsRetrievalAsyncTests.cs index 6c857353..917e4c42 100644 --- a/tests/MiniExcel.OpenXml.Tests/Comments/CommentsRetrievalAsyncTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/Comments/CommentsRetrievalAsyncTests.cs @@ -4,7 +4,7 @@ namespace MiniExcelLib.OpenXml.Tests.Comments; public class CommentsRetrievalAsyncTests { - private readonly OpenXmlImporter _excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); + private readonly OpenXmlImporter _excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); [Fact] public async Task SheetWithCommentsAndNotesTestAsync() diff --git a/tests/MiniExcel.OpenXml.Tests/Comments/CommentsRetrievalTests.cs b/tests/MiniExcel.OpenXml.Tests/Comments/CommentsRetrievalTests.cs index f4162278..7795a9c4 100644 --- a/tests/MiniExcel.OpenXml.Tests/Comments/CommentsRetrievalTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/Comments/CommentsRetrievalTests.cs @@ -4,7 +4,7 @@ namespace MiniExcelLib.OpenXml.Tests.Comments; public class CommentsRetrievalTests { - private readonly OpenXmlImporter _excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); + private readonly OpenXmlImporter _excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); [Fact] public void SheetWithNotesAndCommentsWithRepliesTest() diff --git a/tests/MiniExcel.OpenXml.Tests/Configuration/MiniExcelAutoAdjustWidthTests.cs b/tests/MiniExcel.OpenXml.Tests/Configuration/MiniExcelAutoAdjustWidthTests.cs index 12449313..c3906704 100644 --- a/tests/MiniExcel.OpenXml.Tests/Configuration/MiniExcelAutoAdjustWidthTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/Configuration/MiniExcelAutoAdjustWidthTests.cs @@ -7,7 +7,7 @@ namespace MiniExcelLib.OpenXml.Tests.Configuration; public class MiniExcelAutoAdjustWidthTests { - private readonly OpenXmlExporter _excelExporter = MiniExcel.Exporters.GetOpenXmlExporter(); + private readonly OpenXmlExporter _excelExporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); [Fact] public async Task AutoAdjustWidthThrowsExceptionWithoutFastMode_Async() diff --git a/tests/MiniExcel.OpenXml.Tests/Configuration/MiniExcelOpenXmlConfigurationTests.cs b/tests/MiniExcel.OpenXml.Tests/Configuration/MiniExcelOpenXmlConfigurationTests.cs index 26948890..51f55c40 100644 --- a/tests/MiniExcel.OpenXml.Tests/Configuration/MiniExcelOpenXmlConfigurationTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/Configuration/MiniExcelOpenXmlConfigurationTests.cs @@ -4,8 +4,8 @@ namespace MiniExcelLib.OpenXml.Tests.Configuration; public class MiniExcelOpenXmlConfigurationTest { - private readonly OpenXmlImporter _excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); - private readonly OpenXmlExporter _excelExporter = MiniExcel.Exporters.GetOpenXmlExporter(); + private readonly OpenXmlImporter _excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); + private readonly OpenXmlExporter _excelExporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); [Fact] public async Task DisableWriteFilePathTest() diff --git a/tests/MiniExcel.OpenXml.Tests/DataReader/OpenXmlDataReaderAsyncTests.cs b/tests/MiniExcel.OpenXml.Tests/DataReader/OpenXmlDataReaderAsyncTests.cs index f74b6c04..e7b64e8d 100644 --- a/tests/MiniExcel.OpenXml.Tests/DataReader/OpenXmlDataReaderAsyncTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/DataReader/OpenXmlDataReaderAsyncTests.cs @@ -4,7 +4,7 @@ namespace MiniExcelLib.OpenXml.Tests.DataReader; public class OpenXmlDataReaderAsyncTests { - private readonly OpenXmlImporter _excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); + private readonly OpenXmlImporter _excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); static OpenXmlDataReaderAsyncTests() { diff --git a/tests/MiniExcel.OpenXml.Tests/DataReader/OpenXmlDataReaderTests.cs b/tests/MiniExcel.OpenXml.Tests/DataReader/OpenXmlDataReaderTests.cs index 88b07c91..7612fb36 100644 --- a/tests/MiniExcel.OpenXml.Tests/DataReader/OpenXmlDataReaderTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/DataReader/OpenXmlDataReaderTests.cs @@ -4,7 +4,7 @@ namespace MiniExcelLib.OpenXml.Tests.DataReader; public class OpenXmlDataReaderTests { - private readonly OpenXmlImporter _excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); + private readonly OpenXmlImporter _excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); static OpenXmlDataReaderTests() { diff --git a/tests/MiniExcel.OpenXml.Tests/FluentMapping/MiniExcelMappingTemplateTests.cs b/tests/MiniExcel.OpenXml.Tests/FluentMapping/MiniExcelMappingTemplateTests.cs index 10c334a6..8f49a2c4 100644 --- a/tests/MiniExcel.OpenXml.Tests/FluentMapping/MiniExcelMappingTemplateTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/FluentMapping/MiniExcelMappingTemplateTests.cs @@ -6,8 +6,8 @@ namespace MiniExcelLib.OpenXml.Tests.FluentMapping; public class MiniExcelMappingTemplateTests { - private readonly OpenXmlImporter _importer = MiniExcel.Importers.GetOpenXmlImporter(); - private readonly OpenXmlExporter _exporter = MiniExcel.Exporters.GetOpenXmlExporter(); + private readonly OpenXmlImporter _importer = MiniExcelV2.Importers.GetOpenXmlImporter(); + private readonly OpenXmlExporter _exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); private static DateTime ParseDateValue(object? value) { @@ -70,7 +70,7 @@ public async Task BasicTemplateTest() }; using var outputPath = AutoDeletingPath.Create(); - var templater = MiniExcel.Templaters.GetMappingTemplater(registry); + var templater = MiniExcelV2.Templaters.GetMappingTemplater(registry); await templater.FillTemplateAsync(outputPath.ToString(), templatePath.ToString(), [data]); var rows = _importer.Query(outputPath.ToString(), hasHeaderRow: false).ToList(); @@ -129,7 +129,7 @@ public async Task StreamOverloadTest() using (var outputStream = File.Create(outputPath.ToString())) using (var templateStream = File.OpenRead(templatePath.ToString())) { - var templater = MiniExcel.Templaters.GetMappingTemplater(registry); + var templater = MiniExcelV2.Templaters.GetMappingTemplater(registry); await templater.FillTemplateAsync(outputStream, templateStream, [data]); } @@ -170,7 +170,7 @@ public async Task ByteArrayOverloadTest() using var outputPath = AutoDeletingPath.Create(); using (var outputStream = File.Create(outputPath.ToString())) { - var templater = MiniExcel.Templaters.GetMappingTemplater(registry); + var templater = MiniExcelV2.Templaters.GetMappingTemplater(registry); await templater.FillTemplateAsync(outputStream, templateBytes, [data]); } @@ -235,7 +235,7 @@ public async Task CollectionTemplateTest() }; using var outputPath = AutoDeletingPath.Create(); - var templater = MiniExcel.Templaters.GetMappingTemplater(registry); + var templater = MiniExcelV2.Templaters.GetMappingTemplater(registry); await templater.FillTemplateAsync(outputPath.ToString(), templatePath.ToString(), [dept]); var rows = _importer.Query(outputPath.ToString(), hasHeaderRow: false).ToList(); @@ -283,7 +283,7 @@ public async Task EmptyDataTest() }); using var outputPath = AutoDeletingPath.Create(); - var templater = MiniExcel.Templaters.GetMappingTemplater(registry); + var templater = MiniExcelV2.Templaters.GetMappingTemplater(registry); await templater.FillTemplateAsync(outputPath.ToString(), templatePath.ToString(), Array.Empty()); var rows = _importer.Query(outputPath.ToString(), hasHeaderRow: false).ToList(); @@ -327,7 +327,7 @@ public async Task NullValuesTest() // Apply template using var outputPath = AutoDeletingPath.Create(); - var templater = MiniExcel.Templaters.GetMappingTemplater(registry); + var templater = MiniExcelV2.Templaters.GetMappingTemplater(registry); await templater.FillTemplateAsync(outputPath.ToString(), templatePath.ToString(), [data]); // Verify null handling @@ -372,7 +372,7 @@ public async Task MultipleItemsTest() // Apply template using var outputPath = AutoDeletingPath.Create(); - var templater = MiniExcel.Templaters.GetMappingTemplater(registry); + var templater = MiniExcelV2.Templaters.GetMappingTemplater(registry); await templater.FillTemplateAsync(outputPath.ToString(), templatePath.ToString(), data); // Verify - should only update first item since mapping is for specific cells diff --git a/tests/MiniExcel.OpenXml.Tests/FluentMapping/MiniExcelMappingTests.cs b/tests/MiniExcel.OpenXml.Tests/FluentMapping/MiniExcelMappingTests.cs index 038820cc..513d556a 100644 --- a/tests/MiniExcel.OpenXml.Tests/FluentMapping/MiniExcelMappingTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/FluentMapping/MiniExcelMappingTests.cs @@ -131,12 +131,12 @@ public async Task MappingReader_ReadBasicData_Success() var testData = new[] { new TestModel { Name = "Test", Value = 42 } }; using var stream = new MemoryStream(); - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); await exporter.ExportAsync(stream, testData); stream.Position = 0; // Act - var importer = MiniExcel.Importers.GetMappingImporter(registry); + var importer = MiniExcelV2.Importers.GetMappingImporter(registry); var resultList = new List(); await foreach (var item in importer.QueryAsync(stream)) { @@ -167,7 +167,7 @@ public async Task SaveAs_WithBasicMapping_ShouldGenerateCorrectFile() cfg.ToWorksheet("People"); }); - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); // Act & Assert using var stream = new MemoryStream(); @@ -193,7 +193,7 @@ public void SaveAs_WithBasicMapping_SyncVersion_ShouldGenerateCorrectFile() cfg.ToWorksheet("Employees"); }); - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); // Act & Assert using var stream = new MemoryStream(); @@ -221,8 +221,8 @@ public async Task Query_WithBasicMapping_ShouldReadDataCorrectly() cfg.Property(p => p.Salary).ToCell("E1"); }); - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); - var importer = MiniExcel.Importers.GetMappingImporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); + var importer = MiniExcelV2.Importers.GetMappingImporter(registry); // Act using var stream = new MemoryStream(); @@ -308,8 +308,8 @@ public async Task Collection_Vertical_Should_Write_And_Read_Correctly() } }; - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); - var importer = MiniExcel.Importers.GetMappingImporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); + var importer = MiniExcelV2.Importers.GetMappingImporter(registry); using var stream = new MemoryStream(); await exporter.ExportAsync(stream, testData); @@ -354,8 +354,8 @@ public async Task Collection_ComplexObjectsWithMapping_ShouldMapCorrectly() }); }); - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); - var importer = MiniExcel.Importers.GetMappingImporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); + var importer = MiniExcelV2.Importers.GetMappingImporter(registry); var compiled = registry.GetMapping(); var boundaries = compiled.OptimizedBoundaries!; @@ -418,8 +418,8 @@ public async Task Collection_WithItemMappingOnly_ShouldWriteAndReadCorrectly() }); }); - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); - var importer = MiniExcel.Importers.GetMappingImporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); + var importer = MiniExcelV2.Importers.GetMappingImporter(registry); using var stream = new MemoryStream(); await exporter.ExportAsync(stream, departments); @@ -591,8 +591,8 @@ public async Task Collection_NestedCollections_ShouldMapCorrectly() }); }); - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); - var importer = MiniExcel.Importers.GetMappingImporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); + var importer = MiniExcelV2.Importers.GetMappingImporter(registry); // Act using var stream = new MemoryStream(); @@ -671,8 +671,8 @@ public async Task Collection_MixedSimpleAndComplex_ShouldMapCorrectly() }); }); - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); - var importer = MiniExcel.Importers.GetMappingImporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); + var importer = MiniExcelV2.Importers.GetMappingImporter(registry); // Act using var stream = new MemoryStream(); @@ -719,7 +719,7 @@ public async Task Formula_Properties_Should_Be_Handled_Correctly() new Product { Id = 1, Price = 10.50m, Stock = 100 } }; - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); using var stream = new MemoryStream(); await exporter.ExportAsync(stream, testData); @@ -748,7 +748,7 @@ public async Task Format_Properties_Should_Apply_Formatting() } }; - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); using var stream = new MemoryStream(); await exporter.ExportAsync(stream, testData); @@ -778,7 +778,7 @@ public async Task Mapping_WithComplexCellAddresses_ShouldMapCorrectly() cfg.ToWorksheet("Products"); }); - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); using var stream = new MemoryStream(); await exporter.ExportAsync(stream, products); @@ -787,7 +787,7 @@ public async Task Mapping_WithComplexCellAddresses_ShouldMapCorrectly() // Read back and verify stream.Position = 0; - var importer = MiniExcel.Importers.GetOpenXmlImporter(); + var importer = MiniExcelV2.Importers.GetOpenXmlImporter(); var data = importer.QueryAsync(stream); var firstRow = await data.FirstOrDefaultAsync(); Assert.NotNull(firstRow); @@ -816,7 +816,7 @@ public async Task Mapping_WithNumericFormats_ShouldApplyCorrectly() cfg.ToWorksheet("Formatted"); }); - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); using var stream = new MemoryStream(); await exporter.ExportAsync(stream, products); @@ -845,7 +845,7 @@ public async Task Mapping_WithDateFormats_ShouldApplyCorrectly() cfg.ToWorksheet("DateFormats"); }); - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); using var stream = new MemoryStream(); await exporter.ExportAsync(stream, products); @@ -869,7 +869,7 @@ public async Task Mapping_WithBooleanValues_ShouldMapCorrectly() cfg.ToWorksheet("Booleans"); }); - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); using var stream = new MemoryStream(); await exporter.ExportAsync(stream, products); @@ -895,7 +895,7 @@ public async Task Mapping_WithMultipleRowsToSameCells_ShouldOverwrite() cfg.ToWorksheet("Overwrite"); }); - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); using var stream = new MemoryStream(); await exporter.ExportAsync(stream, products); @@ -930,7 +930,7 @@ public async Task Mapping_WithComplexTypes_ShouldHandleCorrectly() cfg.ToWorksheet("ComplexTypes"); }); - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); using var stream = new MemoryStream(); await exporter.ExportAsync(stream, items); @@ -963,7 +963,7 @@ public async Task Mapping_WithMultipleConfigurations_ShouldUseLast() cfg.ToWorksheet("Second"); }); - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); using var stream = new MemoryStream(); await exporter.ExportAsync(stream, products); @@ -1002,7 +1002,7 @@ public async Task Mapping_WithEnumerableTypes_ShouldHandleCorrectly() cfg.ToWorksheet("Enumerable"); }); - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); // Test with array var array = new[] { new Product { Name = "Array", Price = 10 } }; @@ -1084,7 +1084,7 @@ public async Task Mapping_WithSaveToFile_ShouldCreateFile() cfg.ToWorksheet("FileOutput"); }); - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); var filePath = Path.GetTempFileName() + ".xlsx"; try @@ -1140,7 +1140,7 @@ public async Task Empty_Collection_Should_Handle_Gracefully() new ComplexEntity { Id = 1, Tags = [] } // Empty collection }; - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); using var stream = new MemoryStream(); await exporter.ExportAsync(stream, testData); @@ -1168,7 +1168,7 @@ public async Task Null_Values_Should_Handle_Gracefully() } }; - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); using var stream = new MemoryStream(); await exporter.ExportAsync(stream, testData); @@ -1221,7 +1221,7 @@ public async Task Large_Dataset_Should_Stream_Efficiently() Price = i * 10.5m }); - var exporter = MiniExcel.Exporters.GetMappingExporter(registry); + var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); using var stream = new MemoryStream(); await exporter.ExportAsync(stream, testData); diff --git a/tests/MiniExcel.OpenXml.Tests/Issues/MiniExcelGiteeIssuesAsyncTests.cs b/tests/MiniExcel.OpenXml.Tests/Issues/MiniExcelGiteeIssuesAsyncTests.cs index 40aeb229..59502c0c 100644 --- a/tests/MiniExcel.OpenXml.Tests/Issues/MiniExcelGiteeIssuesAsyncTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/Issues/MiniExcelGiteeIssuesAsyncTests.cs @@ -4,8 +4,8 @@ namespace MiniExcelLib.OpenXml.Tests.Issues; public class MiniExcelGiteeIssuesAsyncTests { - private readonly OpenXmlImporter _excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); - private readonly OpenXmlExporter _excelExporter = MiniExcel.Exporters.GetOpenXmlExporter(); + private readonly OpenXmlImporter _excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); + private readonly OpenXmlExporter _excelExporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); // https://gitee.com/dotnetchina/MiniExcel/issues/I3OSKV // When exporting, the pure numeric string will be forcibly converted to a numeric type, resulting in the loss of the end data diff --git a/tests/MiniExcel.OpenXml.Tests/Issues/MiniExcelGiteeIssuesTests.cs b/tests/MiniExcel.OpenXml.Tests/Issues/MiniExcelGiteeIssuesTests.cs index fdbd8dcb..8935814e 100644 --- a/tests/MiniExcel.OpenXml.Tests/Issues/MiniExcelGiteeIssuesTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/Issues/MiniExcelGiteeIssuesTests.cs @@ -5,9 +5,9 @@ namespace MiniExcelLib.OpenXml.Tests.Issues; public class MiniExcelGiteeIssuesTests { - private readonly OpenXmlImporter _excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); - private readonly OpenXmlExporter _excelExporter = MiniExcel.Exporters.GetOpenXmlExporter(); - private readonly OpenXmlTemplater _excelTemplater = MiniExcel.Templaters.GetOpenXmlTemplater(); + private readonly OpenXmlImporter _excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); + private readonly OpenXmlExporter _excelExporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); + private readonly OpenXmlTemplater _excelTemplater = MiniExcelV2.Templaters.GetOpenXmlTemplater(); [Fact] public void TestIssueI4ZYUU() diff --git a/tests/MiniExcel.OpenXml.Tests/Issues/MiniExcelGithubIssuesAsyncTests.cs b/tests/MiniExcel.OpenXml.Tests/Issues/MiniExcelGithubIssuesAsyncTests.cs index abf556f6..75d26f9e 100644 --- a/tests/MiniExcel.OpenXml.Tests/Issues/MiniExcelGithubIssuesAsyncTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/Issues/MiniExcelGithubIssuesAsyncTests.cs @@ -8,9 +8,9 @@ public class MiniExcelGithubIssuesAsyncTests(ITestOutputHelper output) { private readonly ITestOutputHelper _output = output; - private readonly OpenXmlImporter _excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); - private readonly OpenXmlExporter _excelExporter = MiniExcel.Exporters.GetOpenXmlExporter(); - private readonly OpenXmlTemplater _excelTemplater = MiniExcel.Templaters.GetOpenXmlTemplater(); + private readonly OpenXmlImporter _excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); + private readonly OpenXmlExporter _excelExporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); + private readonly OpenXmlTemplater _excelTemplater = MiniExcelV2.Templaters.GetOpenXmlTemplater(); static MiniExcelGithubIssuesAsyncTests() { diff --git a/tests/MiniExcel.OpenXml.Tests/Issues/MiniExcelGithubIssuesTests.cs b/tests/MiniExcel.OpenXml.Tests/Issues/MiniExcelGithubIssuesTests.cs index b6cb098d..bc95e98a 100644 --- a/tests/MiniExcel.OpenXml.Tests/Issues/MiniExcelGithubIssuesTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/Issues/MiniExcelGithubIssuesTests.cs @@ -13,9 +13,9 @@ public class MiniExcelGithubIssuesTests(ITestOutputHelper output) { private readonly ITestOutputHelper _output = output; - private readonly OpenXmlImporter _excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); - private readonly OpenXmlExporter _excelExporter = MiniExcel.Exporters.GetOpenXmlExporter(); - private readonly OpenXmlTemplater _excelTemplater = MiniExcel.Templaters.GetOpenXmlTemplater(); + private readonly OpenXmlImporter _excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); + private readonly OpenXmlExporter _excelExporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); + private readonly OpenXmlTemplater _excelTemplater = MiniExcelV2.Templaters.GetOpenXmlTemplater(); static MiniExcelGithubIssuesTests() { diff --git a/tests/MiniExcel.OpenXml.Tests/Main/MiniExcelOpenXmlExporterAsyncTests.cs b/tests/MiniExcel.OpenXml.Tests/Main/MiniExcelOpenXmlExporterAsyncTests.cs index cc7186e2..8e588363 100644 --- a/tests/MiniExcel.OpenXml.Tests/Main/MiniExcelOpenXmlExporterAsyncTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/Main/MiniExcelOpenXmlExporterAsyncTests.cs @@ -7,8 +7,8 @@ namespace MiniExcelLib.OpenXml.Tests.Main; public class MiniExcelOpenXmlExporterAsyncTests { - private readonly OpenXmlImporter _excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); - private readonly OpenXmlExporter _excelExporter = MiniExcel.Exporters.GetOpenXmlExporter(); + private readonly OpenXmlImporter _excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); + private readonly OpenXmlExporter _excelExporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); static MiniExcelOpenXmlExporterAsyncTests() { diff --git a/tests/MiniExcel.OpenXml.Tests/Main/MiniExcelOpenXmlExporterTests.cs b/tests/MiniExcel.OpenXml.Tests/Main/MiniExcelOpenXmlExporterTests.cs index b3839e8c..cbe80593 100644 --- a/tests/MiniExcel.OpenXml.Tests/Main/MiniExcelOpenXmlExporterTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/Main/MiniExcelOpenXmlExporterTests.cs @@ -9,8 +9,8 @@ public class MiniExcelOpenXmlExporterTests(ITestOutputHelper output) { private readonly ITestOutputHelper _output = output; - private readonly OpenXmlImporter _excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); - private readonly OpenXmlExporter _excelExporter = MiniExcel.Exporters.GetOpenXmlExporter(); + private readonly OpenXmlImporter _excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); + private readonly OpenXmlExporter _excelExporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); static MiniExcelOpenXmlExporterTests() { diff --git a/tests/MiniExcel.OpenXml.Tests/Main/MiniExcelOpenXmlImporterAsyncTests.cs b/tests/MiniExcel.OpenXml.Tests/Main/MiniExcelOpenXmlImporterAsyncTests.cs index 5b6f5f5a..f60c6d2b 100644 --- a/tests/MiniExcel.OpenXml.Tests/Main/MiniExcelOpenXmlImporterAsyncTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/Main/MiniExcelOpenXmlImporterAsyncTests.cs @@ -7,8 +7,8 @@ namespace MiniExcelLib.OpenXml.Tests.Main; public class MiniExcelOpenXmlImporterAsyncTests { - private readonly OpenXmlImporter _excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); - private readonly OpenXmlExporter _excelExporter = MiniExcel.Exporters.GetOpenXmlExporter(); + private readonly OpenXmlImporter _excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); + private readonly OpenXmlExporter _excelExporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); static MiniExcelOpenXmlImporterAsyncTests() { diff --git a/tests/MiniExcel.OpenXml.Tests/Main/MiniExcelOpenXmlImporterTests.cs b/tests/MiniExcel.OpenXml.Tests/Main/MiniExcelOpenXmlImporterTests.cs index c0771f76..302a2363 100644 --- a/tests/MiniExcel.OpenXml.Tests/Main/MiniExcelOpenXmlImporterTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/Main/MiniExcelOpenXmlImporterTests.cs @@ -9,8 +9,8 @@ public class MiniExcelOpenXmlImporterTests(ITestOutputHelper output) { private readonly ITestOutputHelper _output = output; - private readonly OpenXmlImporter _excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); - private readonly OpenXmlExporter _excelExporter = MiniExcel.Exporters.GetOpenXmlExporter(); + private readonly OpenXmlImporter _excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); + private readonly OpenXmlExporter _excelExporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); static MiniExcelOpenXmlImporterTests() { diff --git a/tests/MiniExcel.OpenXml.Tests/MultipleSheets/MiniExcelOpenXmlMultipleSheetAsyncTests.cs b/tests/MiniExcel.OpenXml.Tests/MultipleSheets/MiniExcelOpenXmlMultipleSheetAsyncTests.cs index 654cf78a..a15d3f59 100644 --- a/tests/MiniExcel.OpenXml.Tests/MultipleSheets/MiniExcelOpenXmlMultipleSheetAsyncTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/MultipleSheets/MiniExcelOpenXmlMultipleSheetAsyncTests.cs @@ -4,7 +4,7 @@ namespace MiniExcelLib.OpenXml.Tests.MultipleSheets; public class MiniExcelOpenXmlMultipleSheetAsyncTests { - private readonly OpenXmlImporter _excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); + private readonly OpenXmlImporter _excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); [Fact] public async Task SpecifySheetNameQueryTest() diff --git a/tests/MiniExcel.OpenXml.Tests/MultipleSheets/MiniExcelOpenXmlMultipleSheetTests.cs b/tests/MiniExcel.OpenXml.Tests/MultipleSheets/MiniExcelOpenXmlMultipleSheetTests.cs index 6cd94f6c..dd8b66f9 100644 --- a/tests/MiniExcel.OpenXml.Tests/MultipleSheets/MiniExcelOpenXmlMultipleSheetTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/MultipleSheets/MiniExcelOpenXmlMultipleSheetTests.cs @@ -5,7 +5,7 @@ namespace MiniExcelLib.OpenXml.Tests.MultipleSheets; public class MiniExcelOpenXmlMultipleSheetTests { - private readonly OpenXmlImporter _excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); + private readonly OpenXmlImporter _excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); [Fact] public void SpecifySheetNameQueryTest() @@ -227,7 +227,7 @@ public void WriteHiddenSheetTest() using var file = AutoDeletingPath.Create(); var path = file.ToString(); - var rowsWritten = MiniExcel.Exporters.GetOpenXmlExporter().Export(path, sheets, configuration: configuration); + var rowsWritten = MiniExcelV2.Exporters.GetOpenXmlExporter().Export(path, sheets, configuration: configuration); Assert.Equal(2, rowsWritten.Length); Assert.Equal(2, rowsWritten[0]); diff --git a/tests/MiniExcel.OpenXml.Tests/SheetInformations/MiniExcelOpenXmlSheetInformations.cs b/tests/MiniExcel.OpenXml.Tests/SheetInformations/MiniExcelOpenXmlSheetInformations.cs index a34111a8..2dcd6a01 100644 --- a/tests/MiniExcel.OpenXml.Tests/SheetInformations/MiniExcelOpenXmlSheetInformations.cs +++ b/tests/MiniExcel.OpenXml.Tests/SheetInformations/MiniExcelOpenXmlSheetInformations.cs @@ -7,7 +7,7 @@ namespace MiniExcelLib.OpenXml.Tests.SheetInformations; public class MiniExcelOpenXmlSheetInformations { - private readonly OpenXmlImporter _excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); + private readonly OpenXmlImporter _excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); [Fact] public void GetSheetDimensionsTest() diff --git a/tests/MiniExcel.OpenXml.Tests/SheetInformations/MiniExcelOpenXmlSheetInformationsAsync.cs b/tests/MiniExcel.OpenXml.Tests/SheetInformations/MiniExcelOpenXmlSheetInformationsAsync.cs index 3b3bfc40..98b0dc38 100644 --- a/tests/MiniExcel.OpenXml.Tests/SheetInformations/MiniExcelOpenXmlSheetInformationsAsync.cs +++ b/tests/MiniExcel.OpenXml.Tests/SheetInformations/MiniExcelOpenXmlSheetInformationsAsync.cs @@ -1,15 +1,12 @@ -using DocumentFormat.OpenXml.Office2010.Excel; -using DocumentFormat.OpenXml.Spreadsheet; -using DocumentFormat.OpenXml.Wordprocessing; -using MiniExcelLib.OpenXml.Models; -using MiniExcelLib.Tests.Common.Utils; - -namespace MiniExcelLib.OpenXml.Tests.SheetInformations; - -public class MiniExcelOpenXmlSheetInformationsAsync -{ - private readonly OpenXmlImporter _excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); - +using MiniExcelLib.OpenXml.Models; +using MiniExcelLib.Tests.Common.Utils; + +namespace MiniExcelLib.OpenXml.Tests.SheetInformations; + +public class MiniExcelOpenXmlSheetInformationsAsync +{ + private readonly OpenXmlImporter _excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); + [Fact] public async Task GetSheetDimensionsAsyncTest() { @@ -29,19 +26,19 @@ public async Task GetSheetDimensionsAsyncTest() [Fact] public async Task GetSheetDimensionsAsyncWithLeaveOpenTest() { - var path = PathHelper.GetFile("xlsx/TestMultiSheet.xlsx"); - + var path = PathHelper.GetFile("xlsx/TestMultiSheet.xlsx"); + await using var stream = File.OpenRead(path); var dimensions = await _excelImporter.GetSheetDimensionsAsync(stream, leaveOpen: true); Assert.NotNull(dimensions); - Assert.Equal(3, dimensions.Count); - + Assert.Equal(3, dimensions.Count); + Assert.Equal(12, dimensions[0].Rows.Count); Assert.Equal(4, dimensions[0].Columns.Count); Assert.Equal(5, dimensions[2].Rows.Count); Assert.Equal(2, dimensions[2].Columns.Count); - + Assert.True(stream.CanRead); } @@ -55,63 +52,63 @@ public async Task GetSheetInformationsAsyncTest() Assert.NotEmpty(sheetInfos); Assert.Equal(3, sheetInfos.Count); - for (int i = 0; i < 3; i++) - { + for (int i = 0; i < 3; i++) + { Assert.Equal($"Sheet{i + 1}", sheetInfos[i].Name); Assert.Equal((uint)i, sheetInfos[i].Index); Assert.Equal(SheetState.Visible, sheetInfos[i].State); - } + } } [Fact] public async Task GetSheetInformationsAsyncWithLeaveOpenTest() { - var path = PathHelper.GetFile("xlsx/TestMultiSheet.xlsx"); - + var path = PathHelper.GetFile("xlsx/TestMultiSheet.xlsx"); + await using var stream = File.OpenRead(path); - var sheetInfos = await _excelImporter.GetSheetInformationsAsync(stream, leaveOpen: true); - + var sheetInfos = await _excelImporter.GetSheetInformationsAsync(stream, leaveOpen: true); + Assert.NotNull(sheetInfos); Assert.NotEmpty(sheetInfos); Assert.Equal(3, sheetInfos.Count); - for (int i = 0; i < 3; i++) - { + for (int i = 0; i < 3; i++) + { Assert.Equal($"Sheet{i + 1}", sheetInfos[i].Name); Assert.Equal((uint)i, sheetInfos[i].Index); Assert.Equal(SheetState.Visible, sheetInfos[i].State); - } - + } + Assert.True(stream.CanRead); - } - + } + [Fact] public async Task GetColumnNamesAsyncTest() { - var path = PathHelper.GetFile("xlsx/TestTypeMapping.xlsx"); - + var path = PathHelper.GetFile("xlsx/TestTypeMapping.xlsx"); + await using var stream = File.OpenRead(path); - var columnNames = await _excelImporter.GetColumnNamesAsync(stream, hasHeaderRow: true); - + var columnNames = await _excelImporter.GetColumnNamesAsync(stream, hasHeaderRow: true); + Assert.Equal(["ID", "Name", "BoD", "Age", "VIP", "Mail", "Points", "IgnoredProperty"], columnNames); - } - + } + [Fact] public async Task GetColumnNamesAsyncWithoutHeaderTest() { - var path = PathHelper.GetFile("xlsx/TestTypeMapping.xlsx"); - + var path = PathHelper.GetFile("xlsx/TestTypeMapping.xlsx"); + await using var stream = File.OpenRead(path); - var columnNames = await _excelImporter.GetColumnNamesAsync(path); - + var columnNames = await _excelImporter.GetColumnNamesAsync(path); + Assert.Equal(["A", "B", "C", "D", "E", "F", "G", "H"], columnNames); - } - - [Fact] - public async Task GetColumnsFromEmptyFileAsyncTest() - { - var path = PathHelper.GetFile("xlsx/TestEmpty.xlsx"); - var columns = await _excelImporter.GetColumnNamesAsync(path); - Assert.Empty(columns); - } -} + } + + [Fact] + public async Task GetColumnsFromEmptyFileAsyncTest() + { + var path = PathHelper.GetFile("xlsx/TestEmpty.xlsx"); + var columns = await _excelImporter.GetColumnNamesAsync(path); + Assert.Empty(columns); + } +} diff --git a/tests/MiniExcel.OpenXml.Tests/Tables/MiniExcelOpenXmlTableAsyncTests.cs b/tests/MiniExcel.OpenXml.Tests/Tables/MiniExcelOpenXmlTableAsyncTests.cs index f5e0c074..036c4d2d 100644 --- a/tests/MiniExcel.OpenXml.Tests/Tables/MiniExcelOpenXmlTableAsyncTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/Tables/MiniExcelOpenXmlTableAsyncTests.cs @@ -4,7 +4,7 @@ namespace MiniExcelLib.OpenXml.Tests.Tables; public class MiniExcelOpenXmlTableAsyncTests { - private readonly OpenXmlImporter _excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); + private readonly OpenXmlImporter _excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); /// /// Tests querying a named table from a file path with dynamic results. diff --git a/tests/MiniExcel.OpenXml.Tests/Tables/MiniExcelOpenXmlTableTests.cs b/tests/MiniExcel.OpenXml.Tests/Tables/MiniExcelOpenXmlTableTests.cs index 058b1e4d..6ad8e217 100644 --- a/tests/MiniExcel.OpenXml.Tests/Tables/MiniExcelOpenXmlTableTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/Tables/MiniExcelOpenXmlTableTests.cs @@ -4,7 +4,7 @@ namespace MiniExcelLib.OpenXml.Tests.Tables; public class MiniExcelOpenXmlTableTests { - private readonly OpenXmlImporter _excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); + private readonly OpenXmlImporter _excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); /// diff --git a/tests/MiniExcel.OpenXml.Tests/Templates/CalcChainAsyncTests.cs b/tests/MiniExcel.OpenXml.Tests/Templates/CalcChainAsyncTests.cs index 823845e1..10715873 100644 --- a/tests/MiniExcel.OpenXml.Tests/Templates/CalcChainAsyncTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/Templates/CalcChainAsyncTests.cs @@ -7,7 +7,7 @@ namespace MiniExcelLib.OpenXml.Tests.Templates; public class CalcChainAsyncTests { - private readonly OpenXmlTemplater _templater = MiniExcel.Templaters.GetOpenXmlTemplater(); + private readonly OpenXmlTemplater _templater = MiniExcelV2.Templaters.GetOpenXmlTemplater(); [Fact] public async Task TemplateWithStaticFormula_DoesNotWriteStaleOrEmptyCalcChain() diff --git a/tests/MiniExcel.OpenXml.Tests/Templates/CalcChainTests.cs b/tests/MiniExcel.OpenXml.Tests/Templates/CalcChainTests.cs index 5264392a..6e635d9c 100644 --- a/tests/MiniExcel.OpenXml.Tests/Templates/CalcChainTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/Templates/CalcChainTests.cs @@ -14,7 +14,7 @@ namespace MiniExcelLib.OpenXml.Tests.Templates; /// public class CalcChainTests { - private readonly OpenXmlTemplater _templater = MiniExcel.Templaters.GetOpenXmlTemplater(); + private readonly OpenXmlTemplater _templater = MiniExcelV2.Templaters.GetOpenXmlTemplater(); [Fact] public void TemplateWithStaticFormula_DoesNotWriteStaleOrEmptyCalcChain() diff --git a/tests/MiniExcel.OpenXml.Tests/Templates/MiniExcelTemplateAsyncTests.cs b/tests/MiniExcel.OpenXml.Tests/Templates/MiniExcelTemplateAsyncTests.cs index e6d3efd3..f42f1044 100644 --- a/tests/MiniExcel.OpenXml.Tests/Templates/MiniExcelTemplateAsyncTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/Templates/MiniExcelTemplateAsyncTests.cs @@ -6,8 +6,8 @@ namespace MiniExcelLib.OpenXml.Tests.Templates; public class MiniExcelTemplateAsyncTests { - private readonly OpenXmlImporter _excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); - private readonly OpenXmlTemplater _excelTemplater = MiniExcel.Templaters.GetOpenXmlTemplater(); + private readonly OpenXmlImporter _excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); + private readonly OpenXmlTemplater _excelTemplater = MiniExcelV2.Templaters.GetOpenXmlTemplater(); static MiniExcelTemplateAsyncTests() { @@ -962,7 +962,7 @@ public async Task AddPictureTest() ]; using var path = AutoDeletingPath.Create(); - await MiniExcel.Exporters.GetOpenXmlExporter().ExportAsync(path.ToString(), Array.Empty>()); + await MiniExcelV2.Exporters.GetOpenXmlExporter().ExportAsync(path.ToString(), Array.Empty>()); await _excelTemplater.AddPictureAsync(path.ToString(), images: pictures); } diff --git a/tests/MiniExcel.OpenXml.Tests/Templates/MiniExcelTemplateTests.cs b/tests/MiniExcel.OpenXml.Tests/Templates/MiniExcelTemplateTests.cs index e9399827..cbc60ea1 100644 --- a/tests/MiniExcel.OpenXml.Tests/Templates/MiniExcelTemplateTests.cs +++ b/tests/MiniExcel.OpenXml.Tests/Templates/MiniExcelTemplateTests.cs @@ -8,8 +8,8 @@ namespace MiniExcelLib.OpenXml.Tests.Templates; public class MiniExcelTemplateTests { - private readonly OpenXmlImporter _excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); - private readonly OpenXmlTemplater _excelTemplater = MiniExcel.Templaters.GetOpenXmlTemplater(); + private readonly OpenXmlImporter _excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); + private readonly OpenXmlTemplater _excelTemplater = MiniExcelV2.Templaters.GetOpenXmlTemplater(); [Fact] public void TestImageType() From df69ad49584ef4c5c283a716760179c96d455e2e Mon Sep 17 00:00:00 2001 From: Michele Bastione Date: Thu, 10 Sep 2026 19:21:48 +0200 Subject: [PATCH 2/4] Added summary to the MiniExcel facade class The remarks explain the purpose of the class and advise the consumers of the library to favor the usage of the new `MiniExcelV2` class instead for a better user experience. --- src/MiniExcel/MiniExcel.cs | 33 ++++++++++++++++++++------------- 1 file changed, 20 insertions(+), 13 deletions(-) diff --git a/src/MiniExcel/MiniExcel.cs b/src/MiniExcel/MiniExcel.cs index 04956b22..2952b2bd 100644 --- a/src/MiniExcel/MiniExcel.cs +++ b/src/MiniExcel/MiniExcel.cs @@ -5,12 +5,19 @@ using MiniExcelLib.OpenXml.Models; using MiniExcelLib.OpenXml.Picture; using Zomp.SyncMethodGenerator; + using NewOpenXmlConfiguration = MiniExcelLib.OpenXml.OpenXmlConfiguration; +using NewCsvConfiguration = MiniExcelLib.Csv.CsvConfiguration; using MiniExcelDataReader = MiniExcelLib.Core.MiniExcelDataReaderBase; // ReSharper disable once CheckNamespace namespace MiniExcelLibs; +/// +/// This class is a facade containing the methods' signatures from the V1 API, preserved for backwards compatibility. +/// We encourage the users to take advantage of the idiomatic class instead +/// for a compartimentalized, richer and more flexible API. +/// public static partial class MiniExcel { private static readonly OpenXmlExporter ExcelExporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); @@ -60,7 +67,7 @@ public static async Task InsertAsync(string path, object value, string shee return type switch { ExcelType.XLSX => await ExcelExporter.InsertSheetAsync(path, value, sheetName, printHeader, overwriteSheet, configuration as NewOpenXmlConfiguration, progress, cancellationToken).ConfigureAwait(false), - ExcelType.CSV => await CsvExporter.AppendAsync(path, value, printHeader, configuration as Csv.CsvConfiguration, progress, cancellationToken).ConfigureAwait(false), + ExcelType.CSV => await CsvExporter.AppendAsync(path, value, printHeader, configuration as NewCsvConfiguration, progress, cancellationToken).ConfigureAwait(false), _ => throw new InvalidDataException($"Type {type} is not a valid Excel type") }; } @@ -74,7 +81,7 @@ public static async Task InsertAsync(this Stream stream, object value, stri return type switch { ExcelType.XLSX => await ExcelExporter.InsertSheetAsync(stream, value, sheetName, printHeader, overwriteSheet, configuration as NewOpenXmlConfiguration, progress, cancellationToken).ConfigureAwait(false), - ExcelType.CSV => await CsvExporter.AppendAsync(stream, value, configuration as Csv.CsvConfiguration, progress, cancellationToken).ConfigureAwait(false), + ExcelType.CSV => await CsvExporter.AppendAsync(stream, value, configuration as NewCsvConfiguration, progress, cancellationToken).ConfigureAwait(false), _ => throw new InvalidDataException($"Type {type} is not a valid Excel type") }; } @@ -88,7 +95,7 @@ public static async Task SaveAsAsync(string path, object value, bool prin return type switch { ExcelType.XLSX => await ExcelExporter.ExportAsync(path, value, printHeader, sheetName, overwriteFile, configuration as NewOpenXmlConfiguration, progress, cancellationToken).ConfigureAwait(false), - ExcelType.CSV => [await CsvExporter.ExportAsync(path, value, printHeader, overwriteFile, configuration as Csv.CsvConfiguration, progress, cancellationToken).ConfigureAwait(false)], + ExcelType.CSV => [await CsvExporter.ExportAsync(path, value, printHeader, overwriteFile, configuration as NewCsvConfiguration, progress, cancellationToken).ConfigureAwait(false)], _ => throw new InvalidDataException($"Type {type} is not a valid Excel type") }; } @@ -102,7 +109,7 @@ public static async Task SaveAsAsync(this Stream stream, object value, bo return type switch { ExcelType.XLSX => await ExcelExporter.ExportAsync(stream, value, printHeader, sheetName, configuration as NewOpenXmlConfiguration, progress, cancellationToken).ConfigureAwait(false), - ExcelType.CSV => [await CsvExporter.ExportAsync(stream, value, printHeader, configuration as Csv.CsvConfiguration, progress, cancellationToken).ConfigureAwait(false)], + ExcelType.CSV => [await CsvExporter.ExportAsync(stream, value, printHeader, configuration as NewCsvConfiguration, progress, cancellationToken).ConfigureAwait(false)], _ => throw new InvalidDataException($"Type {type} is not a valid Excel type") }; } @@ -117,7 +124,7 @@ public static async Task SaveAsAsync(this Stream stream, object value, bo return type switch { ExcelType.XLSX => ExcelImporter.QueryAsync(path, sheetName, startCell, !hasHeader, configuration as NewOpenXmlConfiguration, cancellationToken), - ExcelType.CSV => CsvImporter.QueryAsync(path, !hasHeader, configuration as Csv.CsvConfiguration, cancellationToken), + ExcelType.CSV => CsvImporter.QueryAsync(path, !hasHeader, configuration as NewCsvConfiguration, cancellationToken), _ => throw new InvalidDataException($"Type {type} is not a valid Excel type") }; } @@ -132,7 +139,7 @@ public static async Task SaveAsAsync(this Stream stream, object value, bo return type switch { ExcelType.XLSX => ExcelImporter.QueryAsync(stream, sheetName, startCell, !hasHeader, configuration as NewOpenXmlConfiguration, leaveOpen: true, cancellationToken), - ExcelType.CSV => CsvImporter.QueryAsync(stream, !hasHeader, configuration as Csv.CsvConfiguration, leaveOpen: true, cancellationToken), + ExcelType.CSV => CsvImporter.QueryAsync(stream, !hasHeader, configuration as NewCsvConfiguration, leaveOpen: true, cancellationToken), _ => throw new InvalidDataException($"Type {type} is not a valid Excel type") }; } @@ -144,7 +151,7 @@ public static IAsyncEnumerable QueryAsync(string path, bool useHeaderRo return type switch { ExcelType.XLSX => ExcelImporter.QueryAsync(path, useHeaderRow, sheetName, startCell, configuration as NewOpenXmlConfiguration, cancellationToken), - ExcelType.CSV => CsvImporter.QueryAsync(path, useHeaderRow, configuration as Csv.CsvConfiguration, cancellationToken), + ExcelType.CSV => CsvImporter.QueryAsync(path, useHeaderRow, configuration as NewCsvConfiguration, cancellationToken), _ => throw new InvalidDataException($"Type {type} is not a valid Excel type") }; } @@ -156,7 +163,7 @@ public static IAsyncEnumerable QueryAsync(this Stream stream, bool useH return type switch { ExcelType.XLSX => ExcelImporter.QueryAsync(stream, useHeaderRow, sheetName, startCell, configuration as NewOpenXmlConfiguration, leaveOpen: true, cancellationToken), - ExcelType.CSV => CsvImporter.QueryAsync(stream, useHeaderRow, configuration as Csv.CsvConfiguration,leaveOpen: true, cancellationToken), + ExcelType.CSV => CsvImporter.QueryAsync(stream, useHeaderRow, configuration as NewCsvConfiguration,leaveOpen: true, cancellationToken), _ => throw new InvalidDataException($"Type {type} is not a valid Excel type") }; } @@ -189,7 +196,7 @@ public static IAsyncEnumerable QueryRangeAsync(this Stream stream, bool return type switch { ExcelType.XLSX => ExcelImporter.QueryRangeAsync(stream, useHeaderRow, sheetName, startCell, endCell, configuration as NewOpenXmlConfiguration, leaveOpen: true, cancellationToken), - ExcelType.CSV => CsvImporter.QueryAsync(stream, useHeaderRow, configuration as Csv.CsvConfiguration, leaveOpen: true, cancellationToken), + ExcelType.CSV => CsvImporter.QueryAsync(stream, useHeaderRow, configuration as NewCsvConfiguration, leaveOpen: true, cancellationToken), _ => throw new InvalidDataException($"Type {type} is not a valid Excel type") }; } @@ -283,7 +290,7 @@ public static async Task QueryAsDataTableAsync(string path, bool useH return type switch { ExcelType.XLSX => await ExcelImporter.QueryAsDataTableAsync(path, useHeaderRow, sheetName, startCell, configuration as NewOpenXmlConfiguration, cancellationToken).ConfigureAwait(false), - ExcelType.CSV => await CsvImporter.QueryAsDataTableAsync(path, useHeaderRow, configuration as Csv.CsvConfiguration, cancellationToken).ConfigureAwait(false), + ExcelType.CSV => await CsvImporter.QueryAsDataTableAsync(path, useHeaderRow, configuration as NewCsvConfiguration, cancellationToken).ConfigureAwait(false), _ => throw new InvalidDataException($"Type {type} is not a valid Excel type") }; } @@ -296,7 +303,7 @@ public static async Task QueryAsDataTableAsync(this Stream stream, bo return type switch { ExcelType.XLSX => await ExcelImporter.QueryAsDataTableAsync(stream, useHeaderRow, sheetName, startCell, configuration as NewOpenXmlConfiguration, leaveOpen: true, cancellationToken).ConfigureAwait(false), - ExcelType.CSV => await CsvImporter.QueryAsDataTableAsync(stream, useHeaderRow, configuration as Csv.CsvConfiguration, leaveOpen: true, cancellationToken).ConfigureAwait(false), + ExcelType.CSV => await CsvImporter.QueryAsDataTableAsync(stream, useHeaderRow, configuration as NewCsvConfiguration, leaveOpen: true, cancellationToken).ConfigureAwait(false), _ => throw new InvalidDataException($"Excel type {type} is not a valid Excel type") }; } @@ -324,7 +331,7 @@ public static async Task> GetColumnsAsync(string path, bool return type switch { ExcelType.XLSX => await ExcelImporter.GetColumnNamesAsync(path, useHeaderRow, sheetName, startCell, cancellationToken).ConfigureAwait(false), - ExcelType.CSV => await CsvImporter.GetColumnNamesAsync(path, useHeaderRow, configuration as Csv.CsvConfiguration, cancellationToken).ConfigureAwait(false), + ExcelType.CSV => await CsvImporter.GetColumnNamesAsync(path, useHeaderRow, configuration as NewCsvConfiguration, cancellationToken).ConfigureAwait(false), _ => throw new InvalidDataException($"Excel type {type} is not a valid Excel type") }; } @@ -336,7 +343,7 @@ public static async Task> GetColumnsAsync(this Stream stream return type switch { ExcelType.XLSX => await ExcelImporter.GetColumnNamesAsync(stream, useHeaderRow, sheetName, startCell, leaveOpen: true, cancellationToken).ConfigureAwait(false), - ExcelType.CSV => await CsvImporter.GetColumnNamesAsync(stream, useHeaderRow, configuration as Csv.CsvConfiguration, leaveOpen: true, cancellationToken).ConfigureAwait(false), + ExcelType.CSV => await CsvImporter.GetColumnNamesAsync(stream, useHeaderRow, configuration as NewCsvConfiguration, leaveOpen: true, cancellationToken).ConfigureAwait(false), _ => throw new InvalidDataException($"Excel type {type} is not a valid Excel type") }; } From 2fd9f0a2c99646c027294530d22db30003dbc99f Mon Sep 17 00:00:00 2001 From: Michele Bastione Date: Thu, 10 Sep 2026 22:26:54 +0200 Subject: [PATCH 3/4] Updated docs to reflect last changes and fixed a few minor mistakes --- README_V2.md | 144 ++++++++++++++++++------------------- V2-Upgrade-Notes.md | 15 ++-- src/MiniExcel/MiniExcel.cs | 2 +- 3 files changed, 80 insertions(+), 81 deletions(-) diff --git a/README_V2.md b/README_V2.md index adc4b206..64155f20 100644 --- a/README_V2.md +++ b/README_V2.md @@ -99,11 +99,11 @@ dotnet add package MiniExcel.Csv Firstly, you have to get an importer. The available ones are the `OpenXmlImporter` and the `CsvImporter`: ```csharp -var importer = MiniExcel.Importers.GetOpenXmlImporter(); +var importer = MiniExcelV2.Importers.GetOpenXmlImporter(); // or -var importer = MiniExcel.Importers.GetCsvImporter(); +var importer = MiniExcelV2.Importers.GetCsvImporter(); ``` You can then use it to query Excel or csv documents as dynamic objects, or map them directly to a suitable strong type: @@ -140,11 +140,11 @@ await foreach (var row in query) Similarly to what was described before, the first thing you need to do is getting an exporter: ```csharp -var exporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); // or -var exporter = MiniExcel.Exporters.GetCsvExporter(); +var exporter = MiniExcelV2.Exporters.GetCsvExporter(); ``` You can then use it to create an Excel or csv document from a `IEnumerable` whose generic type can be some strong type, anonymous type or even a `IDictionary`: @@ -224,7 +224,7 @@ public class UserAccount public decimal Points { get; set; } } -var importer = MiniExcel.Importers.GetOpenXmlImporter(); +var importer = MiniExcelV2.Importers.GetOpenXmlImporter(); var rows = importer.Query(path); // or @@ -253,7 +253,7 @@ public class UserAccount public decimal Points { get; set; } } -var importer = MiniExcel.Importers.GetOpenXmlImporter(); +var importer = MiniExcelV2.Importers.GetOpenXmlImporter(); var rows = importer.Query(path); ``` @@ -266,7 +266,7 @@ By default no header will be used and the dynamic keys will be `.A`, `.B`, `.C`, | Github | 2 | ```csharp -var importer = MiniExcel.Importers.GetOpenXmlImporter(); +var importer = MiniExcelV2.Importers.GetOpenXmlImporter(); var rows = importer.Query(path).ToList(); // rows[0].A = "MiniExcel" @@ -284,8 +284,8 @@ You can also specify that a header must be used, in which case the dynamic keys ```csharp -var importer = MiniExcel.Importers.GetOpenXmlImporter(); -var rows = importer.Query(path, useHeaderRow: true).ToList(); +var importer = MiniExcelV2.Importers.GetOpenXmlImporter(); +var rows = importer.Query(path, hasHeaderRow: true).ToList(); // rows[0].Name = "MiniExcel" // rows[0].Value = 1 @@ -298,28 +298,28 @@ var rows = importer.Query(path, useHeaderRow: true).ToList(); e.g: Query the tenth row by skipping the first 9 and taking the first ```csharp -var importer = MiniExcel.Importers.GetOpenXmlImporter(); +var importer = MiniExcelV2.Importers.GetOpenXmlImporter(); var tenthRow = importer.Query(path).Skip(9).First(); ``` #### 4. Specify the Excel sheet to query from ```csharp -var excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); +var excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); excelImporter.Query(path, sheetName: "SheetName"); ``` #### 5. Get the sheets' names from an Excel workbook ```csharp -var excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); +var excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); var sheetNames = excelImporter.GetSheetNames(path); ``` #### 6. Get the columns' names from an Excel worksheet ```csharp -var excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); +var excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); var columns = excelImporter.GetColumnNames(path); // columns = [ColumnName1, ColumnName2, ...] when there is a header row @@ -331,7 +331,7 @@ var columns = excelImporter.GetColumnNames(path); You can extract threaded comments and their replies from a worksheet using the `RetrieveComments` method: ```csharp -var excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); +var excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); var comments = excelImporter.RetrieveComments(path, sheetName: "Sheet1").Comments; foreach (var comment in comments) @@ -362,7 +362,7 @@ Under the hood the dynamic objects returned in a query are implemented using `Ex making it possible to cast them to `IDictionary`: ```csharp -var excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); +var excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); var rows = excelImporter.Query(path).Cast>(); @@ -379,14 +379,14 @@ foreach(IDictionary row in excelImporter.Query(path)) This is not recommended, as `DataTable` will forcibly load all data into memory, effectively losing the advantages MiniExcel offers. ```csharp -var excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); +var excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); var table = excelImporter.QueryAsDataTable(path); ``` #### 10. Specify what cell to start reading data from ```csharp -var excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); +var excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); excelImporter.Query(path, startCell: "B3") ``` ![image](https://user-images.githubusercontent.com/12729184/117260316-8593c400-ae81-11eb-9877-c087b7ac2b01.png) @@ -401,7 +401,7 @@ var config = new OpenXmlConfiguration FillMergedCells = true }; -var importer = MiniExcel.Importers.GetOpenXmlImporter(); +var importer = MiniExcelV2.Importers.GetOpenXmlImporter(); var rows = importer.Query(path, configuration: config); ``` @@ -428,7 +428,7 @@ var config = new OpenXmlConfiguration EnableSharedStringCache = false }; -var importer = MiniExcel.Importers.GetOpenXmlImporter(); +var importer = MiniExcelV2.Importers.GetOpenXmlImporter(); importer.Query(path, configuration: config) ``` @@ -441,7 +441,7 @@ var config = new OpenXmlConfiguration SharedStringCacheSize = 10 * 1024 * 1024 }; -var importer = MiniExcel.Importers.GetOpenXmlImporter(); +var importer = MiniExcelV2.Importers.GetOpenXmlImporter(); importer.Query(path, configuration: config) ``` @@ -455,7 +455,7 @@ There are various ways to export data to an Excel document using MiniExcel. When using an anonymous type: ```csharp -var exporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); var values = new[] { new { Column1 = "MiniExcel", Column2 = 1 }, @@ -473,7 +473,7 @@ class ExportTest public int Column2 { get; set; } } -var exporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); ExportTest[] values = [ new() { Column1 = "MiniExcel", Column2 = 1 }, @@ -485,7 +485,7 @@ exporter.Export(path, values); #### 2. From a IEnumerable> ```csharp -var exporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); List> values = [ new() { { "Column1", "MiniExcel" }, { "Column2", 1 } }, @@ -512,7 +512,7 @@ using var connection = YourDbConnection(); connection.Open(); var reader = connection.ExecuteReader("SELECT 'MiniExcel' AS Column1, 1 as Column2 UNION ALL SELECT 'Github', 2"); -var exporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); exporter.Export("Demo.xlsx", reader); ``` @@ -531,7 +531,7 @@ table.Columns.Add("Column2", typeof(decimal)); table.Rows.Add("MiniExcel", 1); table.Rows.Add("Github", 2); -var exporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); exporter.Export("test.xlsx", table); ``` @@ -550,7 +550,7 @@ var cmd = new CommandDefinition( // Note: QueryAsync will throw a closed connection exception var rows = connection.Query(cmd); -var exporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); exporter.Export("dapper_test.xlsx", rows); ``` > **WARNING**: If you simply use `var rows = connection.Query(sql)` all data will be loaded into memory instead! @@ -580,7 +580,7 @@ var sheets = new Dictionary ["department"] = department }; -var exporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); exporter.Export(path, sheets); ``` @@ -590,7 +590,7 @@ var sheets = new DataSet(); sheets.Tables.Add(UsersDataTable); sheets.Tables.Add(DepartmentDataTable); -var exporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); exporter.Export(path, sheets); ``` @@ -604,7 +604,7 @@ MiniExcel supports the functionality of inserting a new sheet into an existing E var config = new OpenXmlConfiguration { FastMode = true }; var value = new { ID = 3, Name = "Mike", InDate = new DateTime(2021, 04, 23) }; -var exporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); exporter.InsertSheet(path, value, sheetName: "Sheet2", configuration: config); ``` > **Note**: In order to insert worksheets FastMode must be enabled! @@ -615,7 +615,7 @@ exporter.InsertSheet(path, value, sheetName: "Sheet2", configuration: config); You can export data directly to a `MemoryStream`, `FileStream`, and generally any stream that supports seeking: ```csharp -var exporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); using var stream = new MemoryStream(); exporter.Export(stream, values); @@ -630,7 +630,7 @@ Default style Without style configuration ```csharp -var exporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); var config = new OpenXmlConfiguration { @@ -649,7 +649,7 @@ By default, autofilter is enabled on the headers of exported Excel documents. You can disable this by setting the `AutoFilter` property of the configuration to `false`: ```csharp -var exporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); var config = new OpenXmlConfiguration { AutoFilter = false }; exporter.Export(path, value, configuration: config); ``` @@ -657,7 +657,7 @@ exporter.Export(path, value, configuration: config); #### 11. Creating images ```csharp -var exporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); var value = new[] { new { Name = "github", Image = File.ReadAllBytes("images/github_logo.png") }, @@ -692,7 +692,7 @@ Dictionary[] value = } ]; -var exporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); exporter.Export("test.xlsx", value); ``` @@ -706,7 +706,7 @@ var config = new OpenXmlConfiguration EnableWriteNullValueCell = false // Default value is true }; -var exporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); exporter.Export("test.xlsx", value, configuration: config); ``` @@ -720,7 +720,7 @@ var config = new OpenXmlConfiguration WriteEmptyStringAsNull = true // Default value is false }; -var exporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); exporter.Export("test.xlsx", value, configuration: config); ``` @@ -731,7 +731,7 @@ Both properties work with `null` and `DBNull` values. MiniExcel allows you to freeze both rows and columns in place: ```csharp -var exporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); var config = new OpenXmlConfiguration { FreezeRowCount = 1, // default is 1 @@ -794,7 +794,7 @@ Template: Code: ```csharp //1. By POCO -var templater = MiniExcel.Templaters.GetOpenXmlTemplater(); +var templater = MiniExcelV2.Templaters.GetOpenXmlTemplater(); var value = new { employees = new[] @@ -810,7 +810,7 @@ var value = new templater.ApplyTemplate(path, templatePath, value); //2. By Dictionary -var templater = MiniExcel.Templaters.GetOpenXmlTemplater(); +var templater = MiniExcelV2.Templaters.GetOpenXmlTemplater(); var value = new Dictionary() { ["employees"] = new[] @@ -842,7 +842,7 @@ Code: ```csharp // 1. By POCO -var templater = MiniExcel.Templaters.GetOpenXmlTemplater(); +var templater = MiniExcelV2.Templaters.GetOpenXmlTemplater(); var value = new { title = "FooCompany", @@ -862,7 +862,7 @@ var value = new templater.ApplyTemplate(path, templatePath, value); // 2. By Dictionary -var templater = MiniExcel.Templaters.GetOpenXmlTemplater(); +var templater = MiniExcelV2.Templaters.GetOpenXmlTemplater(); var value = new Dictionary() { ["title"] = "FooCompany", @@ -933,7 +933,7 @@ var value = new } }; -var templater = MiniExcel.Templaters.GetOpenXmlTemplater(); +var templater = MiniExcelV2.Templaters.GetOpenXmlTemplater(); templater.ApplyTemplate(path, templatePath, value); ``` @@ -965,7 +965,7 @@ var value = new TotalStar = projects.Sum(s => s.Star) }; -var templater = MiniExcel.Templaters.GetOpenXmlTemplater(); +var templater = MiniExcelV2.Templaters.GetOpenXmlTemplater(); templater.ApplyTemplate(path, templatePath, value); ``` @@ -990,7 +990,7 @@ var value = new Dictionary() } }; -var templater = MiniExcel.Templaters.GetOpenXmlTemplater(); +var templater = MiniExcelV2.Templaters.GetOpenXmlTemplater(); templater.ApplyTemplate(path, templatePath, value); ``` - Without `@group` tag @@ -1058,7 +1058,7 @@ This functionality merges cells vertically between the tags `@merge` and `@endme You can use `@mergelimit` to limit boundaries of merging cells vertically. ```csharp -var templater = MiniExcel.Templaters.GetOpenXmlTemplater(); +var templater = MiniExcelV2.Templaters.GetOpenXmlTemplater(); templater.MergeSameCells(mergedFilePath, templatePath); ``` @@ -1092,7 +1092,7 @@ var value = new Dictionary() ["managers"] = managers, }; -var templater = MiniExcel.Templaters.GetOpenXmlTemplater(); +var templater = MiniExcelV2.Templaters.GetOpenXmlTemplater(); templater.ApplyTemplate(path, templatePath, value); ``` @@ -1125,7 +1125,7 @@ var config = new OpenXmlConfiguration IgnoreTemplateParameterMissing = false, }; -var templater = MiniExcel.Templaters.GetOpenXmlTemplater(); +var templater = MiniExcelV2.Templaters.GetOpenXmlTemplater(); templater.ApplyTemplate(path, templatePath, value, config); ``` @@ -1205,7 +1205,7 @@ public class ExcelAttributeDemo public string Test7 { get; set; } } -var importer = MiniExcel.Importers.GetOpenXmlImporter(); +var importer = MiniExcelV2.Importers.GetOpenXmlImporter(); var rows = importer.Query(path).ToList(); // rows[0].Test1 = "Column1" @@ -1235,7 +1235,7 @@ Dto[] value = new() { Name = "Henry", InDate = new DateTime(2020, 04, 05) } ]; -var exporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); exporter.Export(path, value); ``` @@ -1350,7 +1350,7 @@ var config = new OpenXmlConfiguration var value = new[] { new { id = 1, name = "Jack", createdate = new DateTime(2022, 04, 12), point = 123.456 } }; -var exporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); exporter.Export(path, value, configuration: config); ``` @@ -1398,7 +1398,7 @@ var sheets = new Dictionary ["departmentSheet"] = department }; -var exporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); exporter.Export(path, sheets, configuration: configuration); ``` @@ -1428,7 +1428,7 @@ registry.Configure(cfg => cfg.ToWorksheet("Employees"); }); -var exporter = MiniExcel.Exporters.GetMappingExporter(registry); +var exporter = MiniExcelV2.Exporters.GetMappingExporter(registry); await exporter.ExportAsync(stream, people); ``` @@ -1445,7 +1445,7 @@ registry.Configure(cfg => }); // Read data using the mapping -var importer = MiniExcel.Importers.GetMappingImporter(registry); +var importer = MiniExcelV2.Importers.GetMappingImporter(registry); var people = importer.Query(stream).ToList(); ``` @@ -1513,7 +1513,7 @@ var data = new TestEntity Points = 123 }; -var termplater = MiniExcel.Templaters.GetMappingTemplater(registry); +var termplater = MiniExcelV2.Templaters.GetMappingTemplater(registry); await termplater.ApplyTemplateAsync(outputPath, templatePath, new[] { data }); ``` @@ -1551,7 +1551,7 @@ var config = new CsvConfiguration Seperator=';' }; -var exporter = MiniExcel.Exporters.GetCsvExporter(); +var exporter = MiniExcelV2.Exporters.GetCsvExporter(); exporter.Export(path, values, configuration: config); ``` @@ -1566,7 +1566,7 @@ var config = new CsvConfiguration .ToArray() }; -var importer = MiniExcel.Importers.GetCsvImporter(); +var importer = MiniExcelV2.Importers.GetCsvImporter(); var rows = importer.Query(path, configuration: config).ToList(); ``` @@ -1580,7 +1580,7 @@ var config = new CsvConfiguration NewLine='\n' }; -var exporter = MiniExcel.Exporters.GetCsvExporter(); +var exporter = MiniExcelV2.Exporters.GetCsvExporter(); exporter.Export(path, values,configuration: config); ``` @@ -1595,8 +1595,8 @@ var config = new CsvConfiguration StreamReaderFunc = stream => new StreamReader(stream,Encoding.GetEncoding("gb2312")) }; -var importer = MiniExcel.Importers.GetCsvImporter(); -var rows = importer.Query(path, useHeaderRow: true, configuration: config); +var importer = MiniExcelV2.Importers.GetCsvImporter(); +var rows = importer.Query(path, hasHeaderRow: true, configuration: config); // Write var config = new CsvConfiguration @@ -1604,7 +1604,7 @@ var config = new CsvConfiguration StreamWriterFunc = stream => new StreamWriter(stream, Encoding.GetEncoding("gb2312")) }; -var exporter = MiniExcel.Exporters.GetCsvExporter(); +var exporter = MiniExcelV2.Exporters.GetCsvExporter(); exporter.Export(path, value, configuration: config); ``` @@ -1626,12 +1626,12 @@ var config = new CsvConfiguration There is support for reading one cell at a time using a custom `IDataReader`: ```csharp -var importer = MiniExcel.Importers.GetOpenXmlImporter(); +var importer = MiniExcelV2.Importers.GetOpenXmlImporter(); using OpenXmlDataReader reader = importer.GetDataReader(path, hasHeaderRow: true); // or -var importer = MiniExcel.Importers.GetCsvImporter(); +var importer = MiniExcelV2.Importers.GetCsvImporter(); using CsvDataReader reader = importer.GetDataReader(path, hasHeaderRow: true); @@ -1652,7 +1652,7 @@ Calling the `NextResult` method on the `CsvDataReader` will always raise a `NotS It is possible to append an arbitrary number of rows to a csv document: ```csharp -var exporter = MiniExcel.Exporters.GetCsvExporter(); +var exporter = MiniExcelV2.Exporters.GetCsvExporter(); // Insert 1 rows after last var value = new { ID = 3, Name = "Mike", InDate = new DateTime(2021, 04, 23) }; @@ -1739,7 +1739,7 @@ You can set the configuration property `FastMode` to achieve faster saving speed ```csharp var config = new OpenXmlConfiguration { FastMode = true }; -var exporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); exporter.Export(path, reader, configuration: config); ``` @@ -1767,7 +1767,7 @@ MiniExcelPicture[] images = }, ]; -var templater = MiniExcel.Exporters.GetOpenXmlExporter(); +var templater = MiniExcelV2.Templaters.GetOpenXmlTemplater(); templater.AddPicture(path, images); ``` ![Image](https://github.com/user-attachments/assets/19c4d241-9753-4ede-96c8-f810c1a22247) @@ -1777,7 +1777,7 @@ templater.AddPicture(path, images); You can easily retrieve the dimensions of all worksheets of an Excel file: ```csharp -var importer = MiniExcel.Importers.GetOpenXmlImporter(); +var importer = MiniExcelV2.Importers.GetOpenXmlImporter(); var dim = importer.GetSheetDimensions(path); ``` @@ -1787,7 +1787,7 @@ It is possible to query arbitrary tables from any worksheet. You can either keep it dynamic or map it to a strong-typed object like reqular queries: ```csharp -var importer = MiniExcel.Importers.GetOpenXmlImporter(); +var importer = MiniExcelV2.Importers.GetOpenXmlImporter(); var rows = importer.QueryTable(yourPath, "Sheet1", "YourTable").ToList(); // or @@ -1842,7 +1842,7 @@ If you need template styling, one workaround is to use scalar placeholders (e.g. A. You can retrieve the sheet names with the `GetSheetNames` method and then Query them using the `sheetName` parameter: ```csharp -var importer = MiniExcel.Importers.GetOpenXmlImporter(); +var importer = MiniExcelV2.Importers.GetOpenXmlImporter(); var sheetNames = importer.GetSheetNames(path); var rows = new Dictionary>(); @@ -1857,7 +1857,7 @@ foreach (var sheet in sheetNames) A. You can use the `GetSheetInformations` method: ```csharp -var importer = MiniExcel.Importers.GetOpenXmlImporter(); +var importer = MiniExcelV2.Importers.GetOpenXmlImporter(); var sheets = importer.GetSheetInformations(path); foreach (var sheetInfo in sheets) @@ -1874,7 +1874,7 @@ foreach (var sheetInfo in sheets) A. Yes, you can use the method `GetSheetDimensions`: ```csharp -var excelImporter = MiniExcel.Importers.GetOpenXmlImporter(); +var excelImporter = MiniExcelV2.Importers.GetOpenXmlImporter(); var dimensions = excelImporter.GetSheetDimensions(path); Console.WriteLine($"Total rows: {dimensions[0].Rows.Count}"); @@ -1929,14 +1929,14 @@ A. Yes, simply set the `IgnoreEmptyRows` property of the `OpenXmlConfiguration`. A. You have to use the `overwriteFile` parameter for overwriting an existing file on disk: ```csharp -var excelExporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var excelExporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); excelExporter.Export(path, value, overwriteFile: true); ``` You can also implement your own stream for finer grained control: ```csharp -var excelExporter = MiniExcel.Exporters.GetOpenXmlExporter(); +var excelExporter = MiniExcelV2.Exporters.GetOpenXmlExporter(); using var stream = File.Create("Demo.xlsx"); excelExporter.Export(stream,value); diff --git a/V2-Upgrade-Notes.md b/V2-Upgrade-Notes.md index 62a80ea6..cfd8ce8a 100644 --- a/V2-Upgrade-Notes.md +++ b/V2-Upgrade-Notes.md @@ -1,19 +1,18 @@ ## MiniExcel 2.0 Upgrade Notes - Support for .NET Framework 4.5 was dropped, the minimum supported Framework version is now 4.6.2. -- The root namespace was changed from `MiniExcelLibs` to `MiniExcelLib`. -- Instead of having all methods being part of the `MiniExcel` static class, the functionalities are now split into 3 providers: -`MiniExcel.Importers`, `MiniExcel.Exporters` and `MiniExcel.Templaters` will give you access to, respectively, the `MiniExcelImporterProvider`, `MiniExcelExporterProvider` and `MiniExcelTemplaterProvider`. +- The root namespace was changed from `MiniExcelLibs` to `MiniExcelLib`, and the static class working as the library's entry point was renamed from `MiniExcel` to `MiniExcelV2` +- Instead of having all methods being part of a single static class, the functionalities are now split into 3 providers: +`MiniExcelV2.Importers`, `MiniExcelV2.Exporters` and `MiniExcelV2.Templaters` will give you access to, respectively, the `MiniExcelImporterProvider`, `MiniExcelExporterProvider` and `MiniExcelTemplaterProvider`. - This way Excel and Csv query methods are split between the `OpenXmlImporter` and the `CsvImporter`, accessible from the `MiniExcelImporterProvider`. - The same structure was adopted for export methods through `OpenXmlExporter` and `CsvExporter`, while template methods are instead currently only found in `OpenXmlTemplater`. - OpenXml and Csv methods are only available if the respective `MiniExcel.OpenXml` and `MiniExcel.Csv` packages are downloaded, or if the complete `MiniExcel` package is installed. - You can only access the conversion methods `ConvertCsvToXlsx` and `ConvertXlsxToCsv` from the `MiniExcelConverter` utility class, which is part of the full MiniExcel package. -- If the full MiniExcel package is downloaded, the previous namespace will coexist along the new one, containing the original static methods' signatures, which have become a facade for the aferomentioned providers. +- If the full MiniExcel package is downloaded, the previous namespace will coexist along the new one, containing a facade `MiniExcel` static class with all the original methods' signatures for backwards compatibility. - `IConfiguration` is now `IMiniExcelConfiguration`, but most methods now require the proper implementation (`OpenXmlConfiguration` or `CsvConfiguration`) to be provided rather than the interface -- MiniExcel now fully supports asynchronous streaming the queries, +- MiniExcel now fully supports asynchronously streaming the queries, so the return type for `OpenXmlImporter.QueryAsync` is `IAsyncEnumerable` instead of `Task>` - When applying a template, unlike version 1.x, the flag for overwriting an already existing file must be provided explicitly. -- `leaveOpen` parameter has been added to most methods that take a stream as input in both `OpenXmlImporter` and `CsvImporter` to configure whether the stream must be disposed after the operation performed is completed. -- `useHeaderRow` parameter in multiple `OpenXmlImporter` methods has been renamed to `hasHeaderRow` for making its usage clearer. +- A `leaveOpen` parameter has been added to most methods that take a stream as input in both `OpenXmlImporter` and `CsvImporter` to configure whether the stream must be disposed after the operation performed is completed. +- The `useHeaderRow` parameter in multiple `OpenXmlImporter` and `CsvImporter` methods has been renamed to `hasHeaderRow` for making its usage clearer. - `CsvExporter.Export` API methods, not being required to return the same type of `OpenXmlExporter.Export`, now return `int` instead of `int[]`. -- Most `OpenXmlImporter` and `CsvImporter` methods that take a stream as input now take an additional `leaveOpen` boolean parameter, to set to `true` explicitly if you want the stream to be left open at the of the operation. \ No newline at end of file diff --git a/src/MiniExcel/MiniExcel.cs b/src/MiniExcel/MiniExcel.cs index 2952b2bd..5ffac023 100644 --- a/src/MiniExcel/MiniExcel.cs +++ b/src/MiniExcel/MiniExcel.cs @@ -16,7 +16,7 @@ namespace MiniExcelLibs; /// /// This class is a facade containing the methods' signatures from the V1 API, preserved for backwards compatibility. /// We encourage the users to take advantage of the idiomatic class instead -/// for a compartimentalized, richer and more flexible API. +/// for a compartmentalized, richer and more flexible API. /// public static partial class MiniExcel { From c388485c7bcba0df402b4e3e909a80fb5d22dcc2 Mon Sep 17 00:00:00 2001 From: Michele Bastione Date: Thu, 10 Sep 2026 23:32:36 +0200 Subject: [PATCH 4/4] Clarified the difference between the `MiniExcel` and `MiniExcelV2` classes in the upgrade notes --- V2-Upgrade-Notes.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/V2-Upgrade-Notes.md b/V2-Upgrade-Notes.md index cfd8ce8a..3834ca86 100644 --- a/V2-Upgrade-Notes.md +++ b/V2-Upgrade-Notes.md @@ -1,7 +1,7 @@ ## MiniExcel 2.0 Upgrade Notes - Support for .NET Framework 4.5 was dropped, the minimum supported Framework version is now 4.6.2. -- The root namespace was changed from `MiniExcelLibs` to `MiniExcelLib`, and the static class working as the library's entry point was renamed from `MiniExcel` to `MiniExcelV2` +- The root namespace was changed from `MiniExcelLibs` to `MiniExcelLib`; there is also a new entry point to the library, the static class `MiniExcelV2`. The original class has been turned into a facade for backwards compatibility reasons (more on that later). - Instead of having all methods being part of a single static class, the functionalities are now split into 3 providers: `MiniExcelV2.Importers`, `MiniExcelV2.Exporters` and `MiniExcelV2.Templaters` will give you access to, respectively, the `MiniExcelImporterProvider`, `MiniExcelExporterProvider` and `MiniExcelTemplaterProvider`. - This way Excel and Csv query methods are split between the `OpenXmlImporter` and the `CsvImporter`, accessible from the `MiniExcelImporterProvider`.