From 3388c0531250891cc49eae3719075ec98657749b Mon Sep 17 00:00:00 2001 From: Gabriel Matte Date: Wed, 18 Nov 2026 11:28:05 -0300 Subject: [PATCH 01/39] fix(xlsb): finish the row when WriteRow rejects a cell XlsbSheetWriter.WriteRow had no try/finally around the cell loop, so a rejected value (NaN, oversized text) left the row active and every later StartRow, WriteRow or End threw, losing the whole package. The row is now finished in a finally, keeping the cells written before the rejection, which matches what disposing an XlsbRowWriter after a rejected Write does. XLSX and XLS have no bulk WriteRow, so only XLSB was affected. --- .../Writer/Xlsb/XlsbSheetWriter.cs | 12 ++++++++--- .../Writer/Xlsb/XlsbWriterTests.cs | 21 +++++++++++++++++++ 2 files changed, 30 insertions(+), 3 deletions(-) diff --git a/src/ExcelReader.Core/Writer/Xlsb/XlsbSheetWriter.cs b/src/ExcelReader.Core/Writer/Xlsb/XlsbSheetWriter.cs index d296933b..49ecddf6 100644 --- a/src/ExcelReader.Core/Writer/Xlsb/XlsbSheetWriter.cs +++ b/src/ExcelReader.Core/Writer/Xlsb/XlsbSheetWriter.cs @@ -304,11 +304,17 @@ private XlsbRowWriter StartRowCore(int styleId, int heightTwips) public void WriteRow(ReadOnlySpan values) { BeginRow(styleId: 0, heightTwips: 0); - for (int i = 0; i < values.Length; i++) + try + { + for (int i = 0; i < values.Length; i++) + { + WriteCell(i, values[i]); + } + } + finally { - WriteCell(i, values[i]); + FinishRow(); } - FinishRow(); } internal void NotifyRowEnded() diff --git a/tests/ExcelReader.Tests/Writer/Xlsb/XlsbWriterTests.cs b/tests/ExcelReader.Tests/Writer/Xlsb/XlsbWriterTests.cs index ac3e7b98..0e815049 100644 --- a/tests/ExcelReader.Tests/Writer/Xlsb/XlsbWriterTests.cs +++ b/tests/ExcelReader.Tests/Writer/Xlsb/XlsbWriterTests.cs @@ -308,6 +308,27 @@ public async Task BulkXlsbCellRowPreservesEmptyCells() Assert.Equal("ccc", rows[0].C); } + [Fact] + public async Task BulkXlsbCellRowRejectedCellKeepsSheetUsable() + { + await using var ms = await WriteAsync(async wb => + { + XlsbSheetWriter sheet = wb.AddSheet("Sheet1"); + sheet.WriteRow([XlsbCell.Create("A"), XlsbCell.Empty, XlsbCell.Create("C")]); + Assert.Throws(() => sheet.WriteRow([XlsbCell.Create("aaa"), XlsbCell.Create(double.NaN)])); + sheet.WriteRow([XlsbCell.Create("bbb"), XlsbCell.Empty, XlsbCell.Create("ccc")]); + await sheet.EndAsync(TestContext.Current.CancellationToken); + }); + + await using var reader = Excel.FromXlsb(ms); + var rows = ExcelParser.FromAttributes().Parse(reader.FirstSheet).ToList(); + Assert.Equal(2, rows.Count); + Assert.Equal("aaa", rows[0].A); + Assert.Null(rows[0].C); + Assert.Equal("bbb", rows[1].A); + Assert.Equal("ccc", rows[1].C); + } + [Fact] public async Task BulkXlsbCellDate1904RoundTrips() { From cb7ea1ca7c45d4f76d83f2405f81864d84e23044 Mon Sep 17 00:00:00 2001 From: Gabriel Matte Date: Wed, 18 Nov 2026 11:29:40 -0300 Subject: [PATCH 02/39] fix(netframework): typed reads skip indexer properties TypeMap bound every public instance property, so a POCO with an indexer made Read throw NotSupportedException for 'Item' even though no column could ever match it. The writer already filtered indexers. --- .../Parser/Internal/TypeMap.cs | 2 +- .../Reader/TypedReadTests.cs | 19 +++++++++++++++++++ 2 files changed, 20 insertions(+), 1 deletion(-) diff --git a/src/ExcelReader.NetFramework/Parser/Internal/TypeMap.cs b/src/ExcelReader.NetFramework/Parser/Internal/TypeMap.cs index c3698039..b1a94cf5 100644 --- a/src/ExcelReader.NetFramework/Parser/Internal/TypeMap.cs +++ b/src/ExcelReader.NetFramework/Parser/Internal/TypeMap.cs @@ -18,7 +18,7 @@ private TypeMap() List> properties = new List>(); foreach (PropertyInfo property in typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance)) { - if (Attribute.IsDefined(property, typeof(ExcelIgnoreAttribute))) + if (property.GetIndexParameters().Length > 0 || Attribute.IsDefined(property, typeof(ExcelIgnoreAttribute))) { continue; } diff --git a/tests/ExcelReader.NetFramework.Tests/Reader/TypedReadTests.cs b/tests/ExcelReader.NetFramework.Tests/Reader/TypedReadTests.cs index 5e61c191..ab281edc 100644 --- a/tests/ExcelReader.NetFramework.Tests/Reader/TypedReadTests.cs +++ b/tests/ExcelReader.NetFramework.Tests/Reader/TypedReadTests.cs @@ -90,6 +90,14 @@ public void NullableGetsNullForEmptyCells() Assert.Equal(OneThenNull, rows.Select(r => r.Qty).ToArray()); } + [Fact] + public void IndexerIsNotMapped() + { + using ExcelWorkbook workbook = OpenCsv(QtyCsv); + WithIndexer[] rows = workbook.Sheet(0).Read(); + Assert.Equal(OneThenNull, rows.Select(r => r.Qty).ToArray()); + } + [Fact] public void NonNullableGetsDefaultForEmptyCells() { @@ -392,5 +400,16 @@ public sealed class ProductOnly { public string? Product { get; set; } } + + public sealed class WithIndexer + { + public int? Qty { get; set; } + + public object? this[string key] + { + get => null; + set { } + } + } } } From e9c899c9a87bdd28a6f0e29f8c601da208c80946 Mon Sep 17 00:00:00 2001 From: Gabriel Matte Date: Wed, 18 Nov 2026 11:30:02 -0300 Subject: [PATCH 03/39] fix(reader): parse workbook-stored numbers invariantly whatever the culture XLSX numbers with more than 15 significant digits keep only their text, and Cell.TryParse parsed that text with the caller's culture: under pt-BR 35.840000000000003 became 35840000000000004, under fr-FR it failed. Number and Date cells now always parse invariantly (also in the ISpanParsable path); string and CSV cells still honor the culture. --- .../Parser/ExcelParserOptions.cs | 5 +++-- .../Parser/Internal/ColumnParserFactory.cs | 1 + src/ExcelReader.Core/Reader/Cell.cs | 14 ++++++++++++-- .../Parser/ParserFeatureTests.cs | 15 +++++++++++++++ .../Reader/CellNullProviderTests.cs | 19 +++++++++++++++++++ 5 files changed, 50 insertions(+), 4 deletions(-) diff --git a/src/ExcelReader.Core/Parser/ExcelParserOptions.cs b/src/ExcelReader.Core/Parser/ExcelParserOptions.cs index 6b96934e..5228beb0 100644 --- a/src/ExcelReader.Core/Parser/ExcelParserOptions.cs +++ b/src/ExcelReader.Core/Parser/ExcelParserOptions.cs @@ -18,8 +18,9 @@ public sealed class ExcelParserOptions public HeaderNormalization HeaderNormalization { get; init; } = HeaderNormalization.Trim; /// - /// Gets the culture used when parsing text-backed numeric and cells (e.g. pt-BR - /// "1.234,56"). Binary numeric cells from XLS/XLSB carry a raw double and ignore this setting. + /// Gets the culture used when parsing text cells (CSV fields, XLSX/XLSB/XLS strings) as numbers or + /// (e.g. pt-BR "1.234,56"). Numeric and date cells stored by the workbook are + /// always read invariantly and ignore this setting. /// Defaults to . /// public CultureInfo Culture { get; init; } = CultureInfo.InvariantCulture; diff --git a/src/ExcelReader.Core/Parser/Internal/ColumnParserFactory.cs b/src/ExcelReader.Core/Parser/Internal/ColumnParserFactory.cs index 5f0c926b..fb27f36d 100644 --- a/src/ExcelReader.Core/Parser/Internal/ColumnParserFactory.cs +++ b/src/ExcelReader.Core/Parser/Internal/ColumnParserFactory.cs @@ -309,6 +309,7 @@ internal static bool ReadTextTimeOnly(in Cell cell, in ExcelRowContext context, internal static bool TryParseSpanParsable(in Cell cell, IFormatProvider provider, [MaybeNullWhen(false)] out TValue value) where TValue : ISpanParsable { + provider = cell.TextProvider(provider); // XLSB and XLS keep a number in binary, with no text in Value to parse. if (cell.Value.IsEmpty && cell.Type is CellType.Number or CellType.Date) { diff --git a/src/ExcelReader.Core/Reader/Cell.cs b/src/ExcelReader.Core/Reader/Cell.cs index 4cc8a2e5..eab402ac 100644 --- a/src/ExcelReader.Core/Reader/Cell.cs +++ b/src/ExcelReader.Core/Reader/Cell.cs @@ -95,13 +95,14 @@ public bool TryGetDouble(out double value) /// /// /// The format provider used for text parsing and for deciding whether '.' is the decimal separator; - /// null means , the culture XLSX and XLSB store numbers in. + /// null means . Ignored for and + /// cells, whose text is a workbook-stored number and always invariant. /// /// The parsed value, when this method returns true. [SkipLocalsInit] public bool TryParse(IFormatProvider? provider, [MaybeNullWhen(false)] out T result) where T : IUtf8SpanParsable { - provider ??= CultureInfo.InvariantCulture; + provider = TextProvider(provider); if (!_hasNumber) { if (typeof(T) == typeof(double) && UsesDotDecimalSeparator(provider) && FastDouble.TryParse(Value, out double fast)) @@ -170,6 +171,15 @@ public bool TryParse(IFormatProvider? provider, [MaybeNullWhen(false)] out T : T.TryParse(Value, provider, out result); } + internal IFormatProvider TextProvider(IFormatProvider? provider) + { + if (Type is CellType.Number or CellType.Date) + { + return CultureInfo.InvariantCulture; + } + return provider ?? CultureInfo.InvariantCulture; + } + private static bool TryParseDecimalText(ReadOnlySpan utf8, IFormatProvider provider, out decimal value) { return (UsesDotDecimalSeparator(provider) && FastDecimal.TryParse(utf8, out value)) diff --git a/tests/ExcelReader.Tests/Parser/ParserFeatureTests.cs b/tests/ExcelReader.Tests/Parser/ParserFeatureTests.cs index 00d4e276..7324379f 100644 --- a/tests/ExcelReader.Tests/Parser/ParserFeatureTests.cs +++ b/tests/ExcelReader.Tests/Parser/ParserFeatureTests.cs @@ -80,6 +80,21 @@ public async Task PtBrCultureParsesCommaDecimalAndThousandsSeparator() Assert.Equal(1234.56m, row.Amount); } + [Theory] + [InlineData("pt-BR")] + [InlineData("fr-FR")] + public void CultureDoesNotApplyToWorkbookStoredNumbers(string culture) + { + using var ms = WorkbookBuilder.Build( + """Amount35.840000000000003"""); + using var reader = Excel.FromXlsx(ms); + var config = new ExcelParserOptions { Culture = CultureInfo.GetCultureInfo(culture) }; + + MoneyRow row = ExcelParser.FromAttributes(config).Parse(reader.FirstSheet).Single(); + + Assert.Equal(35.840000000000003m, row.Amount); + } + [Fact] public async Task InvariantCultureRejectsCommaDecimal() { diff --git a/tests/ExcelReader.Tests/Reader/CellNullProviderTests.cs b/tests/ExcelReader.Tests/Reader/CellNullProviderTests.cs index 16b881cb..2deb6d5b 100644 --- a/tests/ExcelReader.Tests/Reader/CellNullProviderTests.cs +++ b/tests/ExcelReader.Tests/Reader/CellNullProviderTests.cs @@ -43,6 +43,25 @@ public void NullProviderParsesDecimalsInvariantlyWhateverTheCurrentCulture() Assert.Equal(35.840000000000003m, ParseUnderBrazilianCulture(cell)); } + [Theory] + [InlineData("pt-BR", CellType.Number)] + [InlineData("fr-FR", CellType.Number)] + [InlineData("de-DE", CellType.Date)] + public void WorkbookNumberTextParsesInvariantlyWhateverTheProvider(string culture, CellType type) + { + var provider = CultureInfo.GetCultureInfo(culture); + var cell = new Cell(type, "35.840000000000003"u8); + + Assert.True(cell.TryParse(provider, out double d)); + Assert.Equal(35.840000000000003, d); + Assert.True(cell.TryParse(provider, out decimal m)); + Assert.Equal(35.840000000000003m, m); + Assert.True(cell.TryParse(provider, out float f)); + Assert.Equal(35.84f, f); + Assert.True(cell.TryParse(provider, out Half h)); + Assert.Equal((Half)35.84, h); + } + [Fact] public void StoredNumberFallbackParsesItsInvariantTextWhateverTheProvider() { From 350b53c543a16b271db5fb74df75d99593dd8c9d Mon Sep 17 00:00:00 2001 From: Gabriel Matte Date: Wed, 18 Nov 2026 11:30:22 -0300 Subject: [PATCH 04/39] fix(parser): bind a CsvSheet held as IExcelSheet with the CSV map Parse(IExcelSheet) always used the Excel type map, so a CSV sheet reached through IExcelWorkbook read text dates as default, accepted integer TimeOnly cells as midnight, and turned blank lines into all-default models (or a required-value failure). It now picks the CSV map for a CsvSheet and the generic projector skips CSV blank records like the CSV-specialized one. --- .../Parser/ExcelEnumerable.cs | 5 ++- src/ExcelReader.Core/Parser/ExcelParser.cs | 6 ++- .../Parser/Internal/RowProjector.cs | 20 +++++++++- .../Parser/CsvParserTests.cs | 40 +++++++++++++++++++ 4 files changed, 66 insertions(+), 5 deletions(-) diff --git a/src/ExcelReader.Core/Parser/ExcelEnumerable.cs b/src/ExcelReader.Core/Parser/ExcelEnumerable.cs index 6937b258..e5295ef7 100644 --- a/src/ExcelReader.Core/Parser/ExcelEnumerable.cs +++ b/src/ExcelReader.Core/Parser/ExcelEnumerable.cs @@ -3,6 +3,7 @@ using System.Diagnostics.CodeAnalysis; using ExcelReader.Core.Parser.Internal; using ExcelReader.Core.Reader; +using ExcelReader.Core.Reader.Csv; using ExcelReader.Core.Reader.Xlsx; namespace ExcelReader.Core.Parser @@ -90,7 +91,7 @@ internal Enumerator( bool throwOnParseFailure = false) : base(rows) { - _projector = new RowProjector(typeInfo, comparer, normalization, headerRow, isDate1904, provider, throwOnParseFailure); + _projector = new RowProjector(typeInfo, comparer, normalization, headerRow, isDate1904, provider, throwOnParseFailure, rows is CsvReader.Enumerator); } private protected override ProjectionStep Classify() @@ -122,7 +123,7 @@ internal AsyncEnumerator( CancellationToken ct) : base(sheet, ct) { - _projector = new RowProjector(typeInfo, comparer, normalization, headerRow, sheet.IsDate1904, provider, throwOnParseFailure); + _projector = new RowProjector(typeInfo, comparer, normalization, headerRow, sheet.IsDate1904, provider, throwOnParseFailure, sheet is CsvSheet); } private protected override ProjectionStep Classify() diff --git a/src/ExcelReader.Core/Parser/ExcelParser.cs b/src/ExcelReader.Core/Parser/ExcelParser.cs index 1abed23c..e713131f 100644 --- a/src/ExcelReader.Core/Parser/ExcelParser.cs +++ b/src/ExcelReader.Core/Parser/ExcelParser.cs @@ -74,6 +74,10 @@ public ExcelEnumerable Parse(IExcelSheet sh { ArgumentNullException.ThrowIfNull(sheet); ExcelTableSheet.ThrowIfHeaderless(sheet); + if (sheet is CsvSheet) + { + return new ExcelEnumerable(sheet, _config, _csvInfo()); + } return new ExcelEnumerable(sheet, _config, _info()); } @@ -83,7 +87,7 @@ public ExcelEnumerable Parse(IExcelSheet sh /// /// Uses a specialized enumerable (dense field binding, single-pass projection), since CSV rows have /// no gaps or styles. Prefer this overload over for CSV: a sheet - /// held as goes through the generic path. + /// held as binds the same way but through the slower generic path. /// public CsvEnumerable Parse(CsvSheet sheet) { diff --git a/src/ExcelReader.Core/Parser/Internal/RowProjector.cs b/src/ExcelReader.Core/Parser/Internal/RowProjector.cs index 19ab1294..d04371ad 100644 --- a/src/ExcelReader.Core/Parser/Internal/RowProjector.cs +++ b/src/ExcelReader.Core/Parser/Internal/RowProjector.cs @@ -13,12 +13,13 @@ internal struct RowProjector private readonly int _headerRow; private readonly ExcelRowContext _context; private readonly bool _throwOnParseFailure; + private readonly bool _skipBlankRows; private ColumnBinding[]? _bindings; private bool[] _seen; private int _requireValueCount; private int _rowNumber; - internal RowProjector(TypeMapInfo typeInfo, StringComparer comparer, HeaderNormalization normalization, int headerRow, bool isDate1904, IFormatProvider provider, bool throwOnParseFailure = false) + internal RowProjector(TypeMapInfo typeInfo, StringComparer comparer, HeaderNormalization normalization, int headerRow, bool isDate1904, IFormatProvider provider, bool throwOnParseFailure = false, bool skipBlankRows = false) { _typeInfo = typeInfo; _comparer = comparer; @@ -26,6 +27,7 @@ internal RowProjector(TypeMapInfo typeInfo, StringComparer comparer, HeaderNo _headerRow = headerRow; _context = new ExcelRowContext { IsDate1904 = isDate1904, FormatProvider = provider }; _throwOnParseFailure = throwOnParseFailure; + _skipBlankRows = skipBlankRows; _seen = []; } @@ -38,9 +40,13 @@ internal ProjectionStep Classify(in Row row) BuildIndexColumnMap(); } _rowNumber++; - return ProjectionStep.Yield; + return YieldUnlessBlank(in row); } ProjectionStep step = ProjectionRules.ClassifyRow(ref _rowNumber, _headerRow, _bindings is not null); + if (step == ProjectionStep.Yield) + { + return YieldUnlessBlank(in row); + } if (step != ProjectionStep.BuildMap) { return step; @@ -49,6 +55,16 @@ internal ProjectionStep Classify(in Row row) return ProjectionStep.Skip; } + // A CSV blank line is a record of one empty field; the CSV-specialized projector skips it the same way. + private readonly ProjectionStep YieldUnlessBlank(in Row row) + { + if (_skipBlankRows && row.Descriptors is [{ Type: CellType.Empty }]) + { + return ProjectionStep.Skip; + } + return ProjectionStep.Yield; + } + [MethodImpl(MethodImplOptions.NoInlining)] internal readonly T Project(Row row) { diff --git a/tests/ExcelReader.Tests/Parser/CsvParserTests.cs b/tests/ExcelReader.Tests/Parser/CsvParserTests.cs index f6c28366..0cb8f68e 100644 --- a/tests/ExcelReader.Tests/Parser/CsvParserTests.cs +++ b/tests/ExcelReader.Tests/Parser/CsvParserTests.cs @@ -428,5 +428,45 @@ public void EnumeratorResetThrows() Assert.Throws(e.Reset); } + + [Fact] + public async Task ACsvSheetHeldAsIExcelSheetParsesLikeTheCsvOverload() + { + using var ms = Csv("At,Day\n01/15/2024 10:30:00,01/15/2024\n\n"); + using var reader = Excel.FromCsv(ms); + IExcelSheet sheet = reader.FirstSheet; + + StampRow row = Assert.Single(ExcelParser.FromAttributes().Parse(sheet).ToList()); + StampRow asyncRow = Assert.Single(await ExcelParser.FromAttributes().Parse(sheet).ToListAsync(TestContext.Current.CancellationToken)); + + Assert.Equal(new DateTime(2024, 1, 15, 10, 30, 0), row.At); + Assert.Equal(new DateOnly(2024, 1, 15), row.Day); + Assert.Equal(row.At, asyncRow.At); + } + + [Fact] + public void ACsvSheetHeldAsIExcelSheetSkipsBlankLinesWithoutARequiredFailure() + { + using var ms = Csv("Id,Note\n7,valid\n\n8,more\n\n"); + using var reader = Excel.FromCsv(ms); + IExcelSheet sheet = reader.FirstSheet; + + List rows = ExcelParser.FromAttributes().Parse(sheet).ToList(); + + Assert.Equal([7, 8], rows.Select(r => r.Id)); + } + + [Fact] + public void ACsvSheetHeldAsIExcelSheetRejectsAnIntegerTimeOnly() + { + using var ms = Csv("Start\n1230\n"); + using var reader = Excel.FromCsv(ms); + IExcelSheet sheet = reader.FirstSheet; + var config = new ExcelParserOptions { ThrowOnParseFailure = true }; + + ExcelParseException ex = Assert.Throws( + () => ExcelParser.FromAttributes(config).Parse(sheet).ToList()); + Assert.Equal("Start", ex.ColumnName); + } } } From 45ef3ea903c593958dfafc0980cae6d3b96d3a63 Mon Sep 17 00:00:00 2001 From: Gabriel Matte Date: Wed, 18 Nov 2026 11:31:59 -0300 Subject: [PATCH 05/39] fix(netframework): a new property hides the base property it shadows GetProperties returns both members when a derived class redeclares a property with a different type, so typed reads filled both and typed writes emitted two columns with the same header. Reader and writer now share one property walk that keeps only the most-derived member per name, as Core's generator does. --- .../Parser/Internal/MappedProperties.cs | 16 +++++++++++++++ .../Parser/Internal/TypeMap.cs | 7 +------ .../Writer/Internal/WriteMap.cs | 5 +++-- .../Reader/TypedReadTests.cs | 19 ++++++++++++++++++ .../Writer/WriteSheetTests.cs | 20 +++++++++++++++++++ 5 files changed, 59 insertions(+), 8 deletions(-) create mode 100644 src/ExcelReader.NetFramework/Parser/Internal/MappedProperties.cs diff --git a/src/ExcelReader.NetFramework/Parser/Internal/MappedProperties.cs b/src/ExcelReader.NetFramework/Parser/Internal/MappedProperties.cs new file mode 100644 index 00000000..29bf0fcb --- /dev/null +++ b/src/ExcelReader.NetFramework/Parser/Internal/MappedProperties.cs @@ -0,0 +1,16 @@ +using System.Reflection; + +namespace ExcelReader.NetFramework.Parser.Internal +{ + internal static class MappedProperties + { + internal static IEnumerable Of(Type type) + { + return type.GetProperties(BindingFlags.Public | BindingFlags.Instance) + .Where(p => p.GetIndexParameters().Length == 0) + .GroupBy(p => p.Name, StringComparer.Ordinal) + .Select(g => g.Aggregate((a, b) => b.DeclaringType!.IsSubclassOf(a.DeclaringType!) ? b : a)) + .Where(p => !Attribute.IsDefined(p, typeof(ExcelIgnoreAttribute))); + } + } +} diff --git a/src/ExcelReader.NetFramework/Parser/Internal/TypeMap.cs b/src/ExcelReader.NetFramework/Parser/Internal/TypeMap.cs index b1a94cf5..0ec477f8 100644 --- a/src/ExcelReader.NetFramework/Parser/Internal/TypeMap.cs +++ b/src/ExcelReader.NetFramework/Parser/Internal/TypeMap.cs @@ -16,13 +16,8 @@ private TypeMap() } List> properties = new List>(); - foreach (PropertyInfo property in typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance)) + foreach (PropertyInfo property in MappedProperties.Of(typeof(T))) { - if (property.GetIndexParameters().Length > 0 || Attribute.IsDefined(property, typeof(ExcelIgnoreAttribute))) - { - continue; - } - if (property.GetSetMethod() is null) { RejectMappedGetOnly(property); diff --git a/src/ExcelReader.NetFramework/Writer/Internal/WriteMap.cs b/src/ExcelReader.NetFramework/Writer/Internal/WriteMap.cs index f9588ba3..17de8389 100644 --- a/src/ExcelReader.NetFramework/Writer/Internal/WriteMap.cs +++ b/src/ExcelReader.NetFramework/Writer/Internal/WriteMap.cs @@ -1,6 +1,7 @@ using System.Reflection; using ExcelReader.NetFramework.Interop; using ExcelReader.NetFramework.Parser; +using ExcelReader.NetFramework.Parser.Internal; namespace ExcelReader.NetFramework.Writer.Internal { @@ -10,8 +11,8 @@ internal sealed class WriteMap private WriteMap() { - IEnumerable properties = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance) - .Where(p => p.GetGetMethod() is not null && p.GetIndexParameters().Length == 0 && !Attribute.IsDefined(p, typeof(ExcelIgnoreAttribute))) + IEnumerable properties = MappedProperties.Of(typeof(T)) + .Where(p => p.GetGetMethod() is not null) .OrderBy(p => Depth(p.DeclaringType!)) .ThenBy(p => p.MetadataToken); Columns = properties.Select(Create).ToArray(); diff --git a/tests/ExcelReader.NetFramework.Tests/Reader/TypedReadTests.cs b/tests/ExcelReader.NetFramework.Tests/Reader/TypedReadTests.cs index ab281edc..3277dece 100644 --- a/tests/ExcelReader.NetFramework.Tests/Reader/TypedReadTests.cs +++ b/tests/ExcelReader.NetFramework.Tests/Reader/TypedReadTests.cs @@ -98,6 +98,15 @@ public void IndexerIsNotMapped() Assert.Equal(OneThenNull, rows.Select(r => r.Qty).ToArray()); } + [Fact] + public void NewPropertyHidesTheBaseOne() + { + using ExcelWorkbook workbook = OpenCsv(QtyCsv); + HidingQty[] rows = workbook.Sheet(0).Read(); + Assert.Equal(OneThenZero, rows.Select(r => r.Qty).ToArray()); + Assert.All(rows, r => Assert.Null(((HiddenQty)r).Qty)); + } + [Fact] public void NonNullableGetsDefaultForEmptyCells() { @@ -411,5 +420,15 @@ public object? this[string key] set { } } } + + public class HiddenQty + { + public string? Qty { get; set; } + } + + public sealed class HidingQty : HiddenQty + { + public new int Qty { get; set; } + } } } diff --git a/tests/ExcelReader.NetFramework.Tests/Writer/WriteSheetTests.cs b/tests/ExcelReader.NetFramework.Tests/Writer/WriteSheetTests.cs index f9c3d0da..1667f01a 100644 --- a/tests/ExcelReader.NetFramework.Tests/Writer/WriteSheetTests.cs +++ b/tests/ExcelReader.NetFramework.Tests/Writer/WriteSheetTests.cs @@ -56,6 +56,16 @@ public sealed class TimeRow public TimeSpan At { get; set; } } + public class HiddenCode + { + public string? Code { get; set; } + } + + public sealed class HidingCode : HiddenCode + { + public new int Code { get; set; } + } + public sealed class WriteSheetTests { private static readonly string[] Header = { "Nome", "Id", "Qty", "Small", "Tiny", "Price", "Ratio", "Amount", "Active", "When", "At", "MaybeQty", "MaybeWhen" }; @@ -142,6 +152,16 @@ public void HeaderUsesFirstColumnName() Assert.Equal(Header, header.Cells.Select(c => c.Text).ToArray()); } + [Fact] + public void NewPropertyHidesTheBaseOne() + { + using ExcelWorkbookWriter writer = ExcelWorkbookWriter.CreateInMemory(ExcelFormat.Csv); + writer.WriteSheet("H", new[] { new HidingCode { Code = 7 } }); + using ExcelWorkbook workbook = Open(writer.CloseToArray(), ExcelFormat.Csv); + + Assert.Equal("Code|7", string.Join("|", workbook.Sheet(0).ReadRows().SelectMany(r => r.Cells).Select(c => c.Text))); + } + [Fact] public void EmptyListWritesHeaderOnly() { From e42b44e6ed2ad4b19d5b608a896f316d91f4e118 Mon Sep 17 00:00:00 2001 From: Gabriel Matte Date: Wed, 18 Nov 2026 11:35:08 -0300 Subject: [PATCH 06/39] fix(netframework): Aggregate rethrows the failure the native run ended on Fail kept whichever callback exception happened first in wall-clock time, but the native pipeline reports the earliest failing chunk in sheet order and may discard and re-read later chunks. With failures in several chunks the rethrown exception varied run to run. Each failure now returns its own positive code, which native passes back verbatim, so the exception is looked up by the status the run returned. --- .../Interop/AggregationRun.cs | 27 ++++++++++------ .../Reader/ForEachAndAggregateTests.cs | 31 +++++++++++++++++++ 2 files changed, 49 insertions(+), 9 deletions(-) diff --git a/src/ExcelReader.NetFramework/Interop/AggregationRun.cs b/src/ExcelReader.NetFramework/Interop/AggregationRun.cs index 7c424769..fa75abd2 100644 --- a/src/ExcelReader.NetFramework/Interop/AggregationRun.cs +++ b/src/ExcelReader.NetFramework/Interop/AggregationRun.cs @@ -18,7 +18,7 @@ internal abstract unsafe class AggregationRun private static readonly IntPtr CombinePointer = Marshal.GetFunctionPointerForDelegate(CombineCallback); private static readonly IntPtr FreeStatePointer = Marshal.GetFunctionPointerForDelegate(FreeStateCallback); - private ExceptionDispatchInfo? _error; + private readonly List _errors = new List(); [UnmanagedFunctionPointer(CallingConvention.Cdecl)] private delegate int SeedFn(IntPtr* outState, IntPtr userData); @@ -54,11 +54,7 @@ internal static TAccumulator Run(ExcelWorkbook workbook, int sheet IntPtr state = IntPtr.Zero; int status = NativeMethods.xl_aggregate(handle.DangerousGetHandle(), sheet, &aggregation, headerRow, degreeOfParallelism, &state); object? result = Take(state); - if (status == CallbackFailed) - { - run._error?.Throw(); - } - + run.FailureFor(status)?.Throw(); NativeError.ThrowIfFailed(status); if (result is null) { @@ -168,11 +164,24 @@ private static void OnFreeState(IntPtr state, IntPtr userData) } } - // The native side may re-read a failed chunk and still succeed, so the exception surfaces only if the run fails. + // Each failure gets its own code; native returns the code of the failure the run ended on. private int Fail(Exception exception) { - Interlocked.CompareExchange(ref _error, ExceptionDispatchInfo.Capture(exception), null); - return CallbackFailed; + lock (_errors) + { + _errors.Add(ExceptionDispatchInfo.Capture(exception)); + return CallbackFailed - (_errors.Count - 1); + } + } + + private ExceptionDispatchInfo? FailureFor(int status) + { + if (status <= 0 || CallbackFailed - status >= _errors.Count) + { + return null; + } + + return _errors[CallbackFailed - status]; } } diff --git a/tests/ExcelReader.NetFramework.Tests/Reader/ForEachAndAggregateTests.cs b/tests/ExcelReader.NetFramework.Tests/Reader/ForEachAndAggregateTests.cs index a5a952ed..2f60cece 100644 --- a/tests/ExcelReader.NetFramework.Tests/Reader/ForEachAndAggregateTests.cs +++ b/tests/ExcelReader.NetFramework.Tests/Reader/ForEachAndAggregateTests.cs @@ -127,6 +127,14 @@ public void AggregateRethrowsTheCallbackException() Assert.Equal("boom", error.Message); } + [Fact] + public void AggregateRethrowsTheFailureASequentialReadHits() + { + using ExcelWorkbook workbook = ExcelWorkbook.Open(LargeCsv(), new ExcelOpenOptions { Format = ExcelFormat.Csv }); + InvalidTimeZoneException error = Assert.Throws(() => workbook.Sheet(0).Aggregate(() => new ThrowingFrom(), degreeOfParallelism: 4)); + Assert.Equal(ThrowingFrom.FirstFailingId.ToString(CultureInfo.InvariantCulture), error.Message); + } + [Fact] public void AggregateRejectsANullSeedResult() { @@ -196,6 +204,29 @@ public void Combine(Ordered other) } } + private sealed class ThrowingFrom : IExcelAccumulator + { + internal const int FirstFailingId = 100; + + public void Accumulate(ExcelRowView row) + { + int id = (int)row[0].Number!.Value; + if (id == FirstFailingId - 1) + { + Thread.Sleep(300); + } + + if (id >= FirstFailingId) + { + throw new InvalidTimeZoneException(id.ToString(CultureInfo.InvariantCulture)); + } + } + + public void Combine(ThrowingFrom other) + { + } + } + private sealed class Throwing : IExcelAccumulator { public void Accumulate(ExcelRowView row) From d5cb58432fcc018ee15bfd23151d86b475b15666 Mon Sep 17 00:00:00 2001 From: Gabriel Matte Date: Wed, 18 Nov 2026 11:35:33 -0300 Subject: [PATCH 07/39] fix(reader): honor the cancellation token on memory-backed XLSX and XLSB sheets OpenSheetAsync took a shortcut to the sync OpenSheet when the zip was memory-backed (ReadOnlyMemory overloads, or a writable MemoryStream exposing its buffer), which built the enumerator with a default token, so a cancelled token never stopped the read. --- .../Reader/Xlsb/XlsbWorkbook.cs | 9 +++-- .../Reader/Xlsx/XlsxWorkbook.cs | 9 +++-- .../Reader/MidStreamCancellationTests.cs | 36 +++++++++++++++++++ 3 files changed, 50 insertions(+), 4 deletions(-) diff --git a/src/ExcelReader.Core/Reader/Xlsb/XlsbWorkbook.cs b/src/ExcelReader.Core/Reader/Xlsb/XlsbWorkbook.cs index 9473fbb1..662357a1 100644 --- a/src/ExcelReader.Core/Reader/Xlsb/XlsbWorkbook.cs +++ b/src/ExcelReader.Core/Reader/Xlsb/XlsbWorkbook.cs @@ -266,12 +266,17 @@ public bool TryGetTable(ReadOnlySpan name, [MaybeNullWhen(false)] out Exce } internal Enumerator OpenSheet(int index) + { + return OpenSheet(index, CancellationToken.None); + } + + private Enumerator OpenSheet(int index, CancellationToken ct) { Lifetime.Acquire(this); try { ZipEntryRef entry = WorkbookLookups.GetWorksheetEntry(_zip!, _sheets![index].Path); - return new Enumerator(this, _zip!.OpenEntryStream(entry, _decompressedBytes.ForRead(), _options), entry.UncompressedSize); + return new Enumerator(this, _zip!.OpenEntryStream(entry, _decompressedBytes.ForRead(), _options), entry.UncompressedSize, ct); } catch { @@ -315,7 +320,7 @@ internal Enumerator OpenSheetAsync(int index, CancellationToken ct) { if (_zip!.HasMemory) { - return OpenSheet(index); + return OpenSheet(index, ct); } Lifetime.Acquire(this); try diff --git a/src/ExcelReader.Core/Reader/Xlsx/XlsxWorkbook.cs b/src/ExcelReader.Core/Reader/Xlsx/XlsxWorkbook.cs index 0469029f..70db325a 100644 --- a/src/ExcelReader.Core/Reader/Xlsx/XlsxWorkbook.cs +++ b/src/ExcelReader.Core/Reader/Xlsx/XlsxWorkbook.cs @@ -203,13 +203,18 @@ public bool TryGetTable(ReadOnlySpan name, [MaybeNullWhen(false)] out Exce } internal Enumerator OpenSheet(int index) + { + return OpenSheet(index, CancellationToken.None); + } + + private Enumerator OpenSheet(int index, CancellationToken ct) { Lifetime.Acquire(this); try { EnsureSharedLoaded(); ZipEntryRef entry = WorkbookLookups.GetWorksheetEntry(_zip, _sheets[index].Path); - return new Enumerator(this, _zip.OpenEntryStream(entry, _decompressedBytes.ForRead(), _options), entry.UncompressedSize); + return new Enumerator(this, _zip.OpenEntryStream(entry, _decompressedBytes.ForRead(), _options), entry.UncompressedSize, ct); } catch { @@ -254,7 +259,7 @@ internal Enumerator OpenSheetAsync(int index, CancellationToken ct) { if (_zip.HasMemory) { - return OpenSheet(index); + return OpenSheet(index, ct); } Lifetime.Acquire(this); try diff --git a/tests/ExcelReader.Tests/Reader/MidStreamCancellationTests.cs b/tests/ExcelReader.Tests/Reader/MidStreamCancellationTests.cs index 81f6e4d2..3ad2ca1d 100644 --- a/tests/ExcelReader.Tests/Reader/MidStreamCancellationTests.cs +++ b/tests/ExcelReader.Tests/Reader/MidStreamCancellationTests.cs @@ -131,6 +131,42 @@ public async Task XlsbCancellationAfterCancelThrowsOnNextMoveNext() await Assert.ThrowsAnyAsync(async () => await e.MoveNextAsync()); } + [Fact] + public async Task XlsxMemoryBackedEnumeratorHonorsCancellation() + { + using MemoryStream built = WorkbookBuilder.Build("1"); + using CancellationTokenSource cts = new(); + cts.Cancel(); + + await using XlsxWorkbook fromMemory = Excel.FromXlsx(built.ToArray()); + await using XlsxWorkbook fromWritableStream = await Excel.FromXlsxAsync(new MemoryStream(built.ToArray()), ct: TestContext.Current.CancellationToken); + + await AssertCancelsAsync(fromMemory.FirstSheet.GetAsyncEnumerator(cts.Token)); + await AssertCancelsAsync(fromWritableStream.FirstSheet.GetAsyncEnumerator(cts.Token)); + } + + [Fact] + public async Task XlsbMemoryBackedEnumeratorHonorsCancellation() + { + byte[] bytes = await BuildSmallXlsbAsync(TestContext.Current.CancellationToken); + using CancellationTokenSource cts = new(); + cts.Cancel(); + + await using XlsbWorkbook fromMemory = Excel.FromXlsb(bytes); + await using XlsbWorkbook fromWritableStream = await Excel.FromXlsbAsync(new MemoryStream(bytes), ct: TestContext.Current.CancellationToken); + + await AssertCancelsAsync(fromMemory.FirstSheet.GetAsyncEnumerator(cts.Token)); + await AssertCancelsAsync(fromWritableStream.FirstSheet.GetAsyncEnumerator(cts.Token)); + } + + private static async Task AssertCancelsAsync(IExcelRowEnumerator e) + { + await using (e) + { + await Assert.ThrowsAnyAsync(async () => await e.MoveNextAsync()); + } + } + private static byte[] BuildLargeXlsx() { StringBuilder sb = new(512 * 1024); From 765f2c57be4c648055f5735c8b4324168711ad5a Mon Sep 17 00:00:00 2001 From: Gabriel Matte Date: Wed, 18 Nov 2026 11:35:43 -0300 Subject: [PATCH 08/39] fix(writer): leave cell reference and pending style intact on a rejected write XlsxRowWriter consumed the pending explicit cell reference (set by Skip) and the pending Style() as call arguments, before CellFormatter validated the value. A rejected NaN, infinite or pre-epoch date therefore dropped both, so the next cell lost its r= attribute and landed in the wrong column. Row state is now committed only after the cell is written. XLSB and XLS had the same pending-style loss: EffectiveStyle ran before the non-finite and epoch checks. Those checks now run first. --- .../Writer/Xls/XlsSheetWriter.cs | 4 +- .../Writer/Xlsb/XlsbSheetWriter.cs | 7 +- .../Writer/Xlsx/XlsxRowWriter.cs | 51 +++++++------- .../Writer/Styles/CellStyleWriteTests.cs | 66 +++++++++++++++++++ 4 files changed, 99 insertions(+), 29 deletions(-) diff --git a/src/ExcelReader.Core/Writer/Xls/XlsSheetWriter.cs b/src/ExcelReader.Core/Writer/Xls/XlsSheetWriter.cs index 5aa0583f..412705b3 100644 --- a/src/ExcelReader.Core/Writer/Xls/XlsSheetWriter.cs +++ b/src/ExcelReader.Core/Writer/Xls/XlsSheetWriter.cs @@ -282,6 +282,7 @@ internal void NotifyRowEnded() internal void EmitNumber(int row, int col, double value) { ValidateColumn(col); + CellValueGuards.ThrowIfNonFinite(value, nameof(value)); int abstractStyle = EffectiveStyle(col); WriteNumberCell(row, col, abstractStyle == 0 ? XlsGlobals.GeneralXf : XlsGlobals.CustomXf(abstractStyle), value); Track(row, col); @@ -290,8 +291,8 @@ internal void EmitNumber(int row, int col, double value) internal void EmitDate(int row, int col, DateTime value) { ValidateColumn(col); - int abstractStyle = EffectiveStyle(col); double serial = ExcelEpoch.OADateToSerial(value.ToOADate(), _date1904); + int abstractStyle = EffectiveStyle(col); WriteNumberCell(row, col, abstractStyle == 0 ? XlsGlobals.DateXf : XlsGlobals.CustomXf(_owner.DateStyle(abstractStyle)), serial); Track(row, col); } @@ -334,7 +335,6 @@ internal void EmitBlank(int row, int col) private void WriteNumberCell(int row, int col, int xf, double value) { - CellValueGuards.ThrowIfNonFinite(value, nameof(value)); if (!XlsRk.TryEncode(value, out int rk)) { FlushRkRun(); diff --git a/src/ExcelReader.Core/Writer/Xlsb/XlsbSheetWriter.cs b/src/ExcelReader.Core/Writer/Xlsb/XlsbSheetWriter.cs index 49ecddf6..bc0cf655 100644 --- a/src/ExcelReader.Core/Writer/Xlsb/XlsbSheetWriter.cs +++ b/src/ExcelReader.Core/Writer/Xlsb/XlsbSheetWriter.cs @@ -851,21 +851,22 @@ internal void WriteBoolCell(int columnIndex, bool value) MaybeFlush(); } - internal void WriteDateSerialCell(int columnIndex, double serial) + internal void WriteDateSerialCell(int columnIndex, double oadate) { + double serial = ExcelEpoch.OADateToSerial(oadate, _date1904); int styleId = EffectiveStyle(columnIndex); - WriteDoubleCellCore(columnIndex, ExcelEpoch.OADateToSerial(serial, _date1904), styleId == 0 ? 1 : _owner.DateStyle(styleId)); + WriteDoubleCellCore(columnIndex, serial, styleId == 0 ? 1 : _owner.DateStyle(styleId)); } internal void WriteDoubleCell(int columnIndex, double value) { + CellValueGuards.ThrowIfNonFinite(value, nameof(value)); WriteDoubleCellCore(columnIndex, value, EffectiveStyle(columnIndex)); } private void WriteDoubleCellCore(int columnIndex, double value, int style) { ValidateColumn(columnIndex); - CellValueGuards.ThrowIfNonFinite(value, nameof(value)); TrackColumn(columnIndex); if (XlsRk.TryEncode(value, out int rk)) { diff --git a/src/ExcelReader.Core/Writer/Xlsx/XlsxRowWriter.cs b/src/ExcelReader.Core/Writer/Xlsx/XlsxRowWriter.cs index 3b1d9803..4673a371 100644 --- a/src/ExcelReader.Core/Writer/Xlsx/XlsxRowWriter.cs +++ b/src/ExcelReader.Core/Writer/Xlsx/XlsxRowWriter.cs @@ -38,9 +38,7 @@ private int EffectiveStyle() { if (_pendingStyle >= 0) { - int pending = _pendingStyle; - _pendingStyle = -1; - return pending; + return _pendingStyle; } return _rowStyleId != 0 ? _rowStyleId : _owner.GetColumnStyle(_columnIndex); } @@ -90,8 +88,8 @@ public void WriteUtf8(ReadOnlySpan utf8) ThrowIfDisposed(); if (!_owner.UseSharedStrings && CellFormatter.IsPlainUtf8Text(utf8)) { - CellFormatter.WritePlainUtf8String(_row, utf8, _columnIndex, _rowNumber, ConsumeCellReference(), EffectiveStyle()); - _columnIndex++; + CellFormatter.WritePlainUtf8String(_row, utf8, _columnIndex, _rowNumber, IncludeCellReference(), EffectiveStyle()); + CompleteCell(); return; } Utf8Chars.Decode(utf8, this, static (chars, self) => self.WriteText(chars, owned: null)); @@ -103,12 +101,12 @@ private void WriteText(ReadOnlySpan value, string? owned) if (_owner.UseSharedStrings) { int index = owned is null ? _owner.GetSharedStringIndex(value) : _owner.GetSharedStringIndex(owned); - CellFormatter.WriteSharedString(_row, index, _columnIndex, _rowNumber, ConsumeCellReference(), EffectiveStyle()); - _columnIndex++; + CellFormatter.WriteSharedString(_row, index, _columnIndex, _rowNumber, IncludeCellReference(), EffectiveStyle()); + CompleteCell(); return; } - CellFormatter.WriteString(_row, value, _columnIndex, _rowNumber, ConsumeCellReference(), EffectiveStyle()); - _columnIndex++; + CellFormatter.WriteString(_row, value, _columnIndex, _rowNumber, IncludeCellReference(), EffectiveStyle()); + CompleteCell(); } /// @@ -116,8 +114,8 @@ private void WriteText(ReadOnlySpan value, string? owned) public void Write(bool value) { ThrowIfDisposed(); - CellFormatter.WriteBool(_row, value, _columnIndex, _rowNumber, ConsumeCellReference(), EffectiveStyle()); - _columnIndex++; + CellFormatter.WriteBool(_row, value, _columnIndex, _rowNumber, IncludeCellReference(), EffectiveStyle()); + CompleteCell(); } /// @@ -139,8 +137,8 @@ public void Write(DateTime value) { ThrowIfDisposed(); int styleId = EffectiveStyle(); - CellFormatter.WriteDateTime(_row, value, _owner.Date1904, _columnIndex, _rowNumber, ConsumeCellReference(), styleId == 0 ? 1 : _owner.DateStyle(styleId)); - _columnIndex++; + CellFormatter.WriteDateTime(_row, value, _owner.Date1904, _columnIndex, _rowNumber, IncludeCellReference(), styleId == 0 ? 1 : _owner.DateStyle(styleId)); + CompleteCell(); } /// @@ -165,8 +163,8 @@ public void Write(DateOnly value) { ThrowIfDisposed(); int styleId = EffectiveStyle(); - CellFormatter.WriteDateTime(_row, value.ToDateTime(TimeOnly.MinValue), _owner.Date1904, _columnIndex, _rowNumber, ConsumeCellReference(), styleId == 0 ? 1 : _owner.DateStyle(styleId)); - _columnIndex++; + CellFormatter.WriteDateTime(_row, value.ToDateTime(TimeOnly.MinValue), _owner.Date1904, _columnIndex, _rowNumber, IncludeCellReference(), styleId == 0 ? 1 : _owner.DateStyle(styleId)); + CompleteCell(); } /// @@ -191,8 +189,8 @@ public void Write(DateOnly? value) public void Write(TimeOnly value) { ThrowIfDisposed(); - CellFormatter.WriteNumber(_row, value.Ticks / (double)TimeSpan.TicksPerDay, _columnIndex, _rowNumber, ConsumeCellReference(), EffectiveStyle()); - _columnIndex++; + CellFormatter.WriteNumber(_row, value.Ticks / (double)TimeSpan.TicksPerDay, _columnIndex, _rowNumber, IncludeCellReference(), EffectiveStyle()); + CompleteCell(); } /// @@ -214,8 +212,8 @@ public void Write(T value) where T : IUtf8SpanFormattable { ThrowIfDisposed(); - CellFormatter.WriteNumber(_row, value, _columnIndex, _rowNumber, ConsumeCellReference(), EffectiveStyle()); - _columnIndex++; + CellFormatter.WriteNumber(_row, value, _columnIndex, _rowNumber, IncludeCellReference(), EffectiveStyle()); + CompleteCell(); } /// @@ -255,18 +253,23 @@ public void Skip(int count = 1) _columnIndex += count; } - private bool ConsumeCellReference() + private bool IncludeCellReference() { ExcelLimits.ThrowIfColumnOutOfRange(_columnIndex); - bool result = _useCellReferences; + return _useCellReferences; + } + + private void CompleteCell() + { + _pendingStyle = -1; _useCellReferences = false; - return result; + _columnIndex++; } private void WriteEmptyCell() { - CellFormatter.WriteEmpty(_row, _columnIndex, _rowNumber, includeReference: ConsumeCellReference(), styleId: EffectiveStyle()); - _columnIndex++; + CellFormatter.WriteEmpty(_row, _columnIndex, _rowNumber, includeReference: IncludeCellReference(), styleId: EffectiveStyle()); + CompleteCell(); } /// diff --git a/tests/ExcelReader.Tests/Writer/Styles/CellStyleWriteTests.cs b/tests/ExcelReader.Tests/Writer/Styles/CellStyleWriteTests.cs index a9fddb0d..6c071913 100644 --- a/tests/ExcelReader.Tests/Writer/Styles/CellStyleWriteTests.cs +++ b/tests/ExcelReader.Tests/Writer/Styles/CellStyleWriteTests.cs @@ -175,6 +175,61 @@ public void DateUnderPendingStyleWithoutFormatReadsAsDate(string format) Assert.True(Probe(format, file, 0, 0).Bold); } + public static TheoryData RejectedWrites + { + get + { + TheoryData data = []; + foreach (string format in (string[])["xlsx", "xlsb", "xls"]) + { + foreach (string kind in (string[])["double", "float", "half", "DateTime", "DateOnly"]) + { + data.Add(format, kind); + } + } + return data; + } + } + + [Theory] + [MemberData(nameof(RejectedWrites))] + public void RejectedWriteKeepsColumnAndPendingStyle(string format, string kind) + { + byte[] file = Build(format, book => + { + int bold = book.AddStyle(Bold); + using IRowWriter row = book.StartRow(); + row.Skip(2); + row.Style(bold); + Assert.ThrowsAny(() => WriteRejected(row, kind)); + row.Write("x"); + }); + Assert.Equal("x", StringAt(format, file, 0, 2)); + Assert.True(Probe(format, file, 0, 2).Bold); + } + + private static void WriteRejected(IRowWriter row, string kind) + { + switch (kind) + { + case "double": + row.Write(double.NaN); + break; + case "float": + row.Write(float.PositiveInfinity); + break; + case "half": + row.Write(Half.NaN); + break; + case "DateTime": + row.Write(new DateTime(1899, 1, 1)); + break; + default: + row.Write(new DateOnly(1899, 1, 1)); + break; + } + } + [Theory] [MemberData(nameof(Formats))] public void UnknownStyleIdThrows(string format) @@ -298,6 +353,17 @@ private static Cell CellAt(string format, byte[] file, int row, int column) return rows.Current[column]; } + private static string StringAt(string format, byte[] file, int row, int column) + { + using IExcelWorkbook reader = OpenReader(format, file); + using var rows = reader.FirstSheet.GetEnumerator(); + for (int i = 0; i <= row; i++) + { + Assert.True(rows.MoveNext()); + } + return rows.Current[column].GetString(); + } + private static IExcelWorkbook OpenReader(string format, byte[] file) { var ms = new MemoryStream(file); From 8ab8dee9bc3bc7716e8adefa19cd4a88d0605fde Mon Sep 17 00:00:00 2001 From: Gabriel Matte Date: Wed, 18 Nov 2026 11:35:49 -0300 Subject: [PATCH 09/39] fix(csv): cancel a partitioned parallel parse with the ParseAsync token ParallelCsvEnumerable only saw the token handed to GetAsyncEnumerator, so the ct given to SheetParallel.ParseAsync was dropped on the partitioned path and a cancelled parse read every row. It now links both tokens, as the XLSX pipeline does. --- .../Parser/ParallelCsv/ParallelCsvEnumerable.cs | 7 +++++-- .../Parser/ParallelCsv/ParallelCsvFactory.cs | 2 +- .../Parser/ParallelCsv/ParseCsvParallelTests.cs | 12 ++++++++++++ 3 files changed, 18 insertions(+), 3 deletions(-) diff --git a/src/ExcelReader.Core/Parser/ParallelCsv/ParallelCsvEnumerable.cs b/src/ExcelReader.Core/Parser/ParallelCsv/ParallelCsvEnumerable.cs index bd4eebe3..0c7e3964 100644 --- a/src/ExcelReader.Core/Parser/ParallelCsv/ParallelCsvEnumerable.cs +++ b/src/ExcelReader.Core/Parser/ParallelCsv/ParallelCsvEnumerable.cs @@ -19,6 +19,7 @@ internal sealed class ParallelCsvEnumerable : IAsyncEnumerable private readonly ReaderLifetime? _lease; private readonly object? _owner; + private readonly CancellationToken _ct; internal ParallelCsvEnumerable( CsvChunkSource source, @@ -30,7 +31,8 @@ internal ParallelCsvEnumerable( ExcelParserOptions config, int degreeOfParallelism, ReaderLifetime? lease = null, - object? owner = null) + object? owner = null, + CancellationToken ct = default) { _source = source; _plan = plan; @@ -42,6 +44,7 @@ internal ParallelCsvEnumerable( _dop = degreeOfParallelism; _lease = lease; _owner = owner; + _ct = ct; } [SuppressMessage("Reliability", "CA2025:Do not pass 'IDisposable' instances into unawaited tasks", @@ -49,7 +52,7 @@ internal ParallelCsvEnumerable( public async IAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { _lease?.Acquire(_owner!); - using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); + using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _ct); CancellationToken ct = cts.Token; int inFlight = _dop; diff --git a/src/ExcelReader.Core/Parser/ParallelCsv/ParallelCsvFactory.cs b/src/ExcelReader.Core/Parser/ParallelCsv/ParallelCsvFactory.cs index 80b1e0cb..7d7863fb 100644 --- a/src/ExcelReader.Core/Parser/ParallelCsv/ParallelCsvFactory.cs +++ b/src/ExcelReader.Core/Parser/ParallelCsv/ParallelCsvFactory.cs @@ -71,7 +71,7 @@ private static IAsyncEnumerable Build( return Sequential(source.OpenReader(options), parser, ct); } - return new ParallelCsvEnumerable(source, plan, dataStart, map, info, options, config, dop, lease, owner); + return new ParallelCsvEnumerable(source, plan, dataStart, map, info, options, config, dop, lease, owner, ct); } private static CsvEnumerable Sequential( diff --git a/tests/ExcelReader.Tests/Parser/ParallelCsv/ParseCsvParallelTests.cs b/tests/ExcelReader.Tests/Parser/ParallelCsv/ParseCsvParallelTests.cs index 0fc07212..2072a5c2 100644 --- a/tests/ExcelReader.Tests/Parser/ParallelCsv/ParseCsvParallelTests.cs +++ b/tests/ExcelReader.Tests/Parser/ParallelCsv/ParseCsvParallelTests.cs @@ -400,5 +400,17 @@ public async Task ANonSeekableStreamFallsBackWithoutThrowing() Assert.Equal(20_000, actual.Count); Assert.Equal(19_999, actual[^1].Age); } + + [Fact] + public async Task APartitionedParseHonorsTheTokenPassedToParseAsync() + { + using CsvReader source = Excel.FromCsv(BuildCsv(20_000)); + using var cts = new CancellationTokenSource(); + await cts.CancelAsync(); + + IAsyncEnumerable rows = SheetParallel.ParseAsync(source.FirstSheet, ExcelParser.FromAttributes(), options: new SheetParallelOptions { DegreeOfParallelism = 4 }, ct: cts.Token); + + await Assert.ThrowsAnyAsync(() => DrainAsync(rows)); + } } } From 6f6c99d3ce9b1125e67a49e41027f568e5c84b4f Mon Sep 17 00:00:00 2001 From: Gabriel Matte Date: Wed, 18 Nov 2026 11:36:28 -0300 Subject: [PATCH 10/39] fix(netframework): number-only cell text round-trips to the same double GetText formatted with "R", which on .NET Framework x64 can drop the last bit (0.84551240822557006 came back one ulp off from XLSB and XLS). The "R" text is kept when it parses back to the value, otherwise G17 is used. --- .../Reader/ExcelCellView.cs | 5 +++- .../Reader/ForEachAndAggregateTests.cs | 25 +++++++++++++++++++ 2 files changed, 29 insertions(+), 1 deletion(-) diff --git a/src/ExcelReader.NetFramework/Reader/ExcelCellView.cs b/src/ExcelReader.NetFramework/Reader/ExcelCellView.cs index 915a056f..32124aec 100644 --- a/src/ExcelReader.NetFramework/Reader/ExcelCellView.cs +++ b/src/ExcelReader.NetFramework/Reader/ExcelCellView.cs @@ -80,7 +80,10 @@ public double? Number return null; } - return _cell->Number.ToString("R", CultureInfo.InvariantCulture); + double number = _cell->Number; + string shortest = number.ToString("R", CultureInfo.InvariantCulture); + // .NET Framework's "R" can lose the last bit on x64. + return double.Parse(shortest, NumberStyles.Float, CultureInfo.InvariantCulture) == number ? shortest : number.ToString("G17", CultureInfo.InvariantCulture); } } } diff --git a/tests/ExcelReader.NetFramework.Tests/Reader/ForEachAndAggregateTests.cs b/tests/ExcelReader.NetFramework.Tests/Reader/ForEachAndAggregateTests.cs index 2f60cece..018fb568 100644 --- a/tests/ExcelReader.NetFramework.Tests/Reader/ForEachAndAggregateTests.cs +++ b/tests/ExcelReader.NetFramework.Tests/Reader/ForEachAndAggregateTests.cs @@ -1,6 +1,7 @@ using System.Globalization; using System.Text; using ExcelReader.NetFramework.Reader; +using ExcelReader.NetFramework.Writer; namespace ExcelReader.NetFramework.Tests.Reader { @@ -77,6 +78,30 @@ public void CellViewExposesNumberAndText() Assert.Equal(CsvTexts, texts, StringComparer.Ordinal); } + [Theory] + [InlineData(ExcelFormat.Xlsx)] + [InlineData(ExcelFormat.Xlsb)] + [InlineData(ExcelFormat.Xls)] + public void NumberTextRoundTrips(ExcelFormat format) + { + double[] values = { 0.84551240822557006, 0.1 + 0.2, 1.0 / 3, 5e-324, double.MaxValue }; + using ExcelWorkbookWriter writer = ExcelWorkbookWriter.CreateInMemory(format); + writer.StartSheet("N"); + foreach (double value in values) + { + writer.StartRow(); + writer.Write(value); + writer.EndRow(); + } + + writer.EndSheet(); + using ExcelWorkbook workbook = ExcelWorkbook.Open(writer.CloseToArray(), new ExcelOpenOptions { Format = format }); + List texts = new List(); + workbook.Sheet(0).ForEach(row => texts.Add(row[0].GetText())); + + Assert.Equal(values.Select(v => BitConverter.DoubleToInt64Bits(v)), texts.Select(t => BitConverter.DoubleToInt64Bits(double.Parse(t!, CultureInfo.InvariantCulture)))); + } + [Fact] public void RowViewIndexerRejectsOutOfRange() { From 83fd91415d40f3ff2456890f56b0b2b308c60888 Mon Sep 17 00:00:00 2001 From: Gabriel Matte Date: Wed, 18 Nov 2026 11:39:10 -0300 Subject: [PATCH 11/39] fix(csv): let the parallel parse's sequential fallback be enumerated again When the data after the header fit in one chunk, the factory opened a private CsvReader and handed it to the CsvEnumerable, whose first enumeration disposed it; a second await foreach threw ObjectDisposedException. The fallback now reads the caller's reader sheet, which opens a fresh cursor per enumeration, so there is no owned reader left to dispose. --- src/ExcelReader.Core/Parser/CsvEnumerable.cs | 17 ++++------------- .../Parser/ParallelCsv/ParallelCsvFactory.cs | 9 +++++---- .../Parser/ParallelCsv/ParseCsvParallelTests.cs | 11 +++++++++++ 3 files changed, 20 insertions(+), 17 deletions(-) diff --git a/src/ExcelReader.Core/Parser/CsvEnumerable.cs b/src/ExcelReader.Core/Parser/CsvEnumerable.cs index 71e0a86f..5d554a33 100644 --- a/src/ExcelReader.Core/Parser/CsvEnumerable.cs +++ b/src/ExcelReader.Core/Parser/CsvEnumerable.cs @@ -25,15 +25,13 @@ public sealed class CsvEnumerable : IEnumerable, IAsyncEnumerable private readonly ExcelParserOptions _config; private readonly CancellationToken _ct; private readonly TypeMapInfo _info; - private readonly CsvReader? _ownedReader; - internal CsvEnumerable(CsvSheet sheet, ExcelParserOptions config, TypeMapInfo info, CsvReader? ownedReader, CancellationToken ct) + internal CsvEnumerable(CsvSheet sheet, ExcelParserOptions config, TypeMapInfo info, CancellationToken ct) { _sheet = sheet; _config = config; _info = info; _ct = ct; - _ownedReader = ownedReader; } internal CsvEnumerable(CsvSheet sheet, ExcelParserOptions config, TypeMapInfo explicitInfo) @@ -69,7 +67,7 @@ IAsyncEnumerator IAsyncEnumerable.GetAsyncEnumerator(CancellationToken can public AsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { CancellationToken effective = cancellationToken.CanBeCanceled ? cancellationToken : _ct; - return new AsyncEnumerator(_sheet, _info, _config.ColumnNameComparer, _config.HeaderNormalization, _config.HeaderRow, _config.Culture, _config.ThrowOnParseFailure, _ownedReader, effective); + return new AsyncEnumerator(_sheet, _info, _config.ColumnNameComparer, _config.HeaderNormalization, _config.HeaderRow, _config.Culture, _config.ThrowOnParseFailure, effective); } /// Enumerates CSV rows synchronously, projecting each into a instance by fixed field index. @@ -107,7 +105,6 @@ private protected override T Project() public sealed class AsyncEnumerator : AsyncRowEnumerator { private CsvRowProjector _projector; - private readonly CsvReader? _ownedReader; internal AsyncEnumerator( CsvSheet sheet, @@ -117,22 +114,16 @@ internal AsyncEnumerator( int headerRow, IFormatProvider provider, bool throwOnParseFailure, - CsvReader? ownedReader, CancellationToken ct) : base(sheet, ct) { _projector = new CsvRowProjector(typeInfo, comparer, normalization, headerRow, provider, throwOnParseFailure); - _ownedReader = ownedReader; } /// - public override async ValueTask DisposeAsync() + public override ValueTask DisposeAsync() { - await base.DisposeAsync().ConfigureAwait(false); - if (_ownedReader is not null) - { - await _ownedReader.DisposeAsync().ConfigureAwait(false); - } + return base.DisposeAsync(); } private protected override ProjectionStep Classify() diff --git a/src/ExcelReader.Core/Parser/ParallelCsv/ParallelCsvFactory.cs b/src/ExcelReader.Core/Parser/ParallelCsv/ParallelCsvFactory.cs index 7d7863fb..f17e0e29 100644 --- a/src/ExcelReader.Core/Parser/ParallelCsv/ParallelCsvFactory.cs +++ b/src/ExcelReader.Core/Parser/ParallelCsv/ParallelCsvFactory.cs @@ -22,7 +22,7 @@ internal static IAsyncEnumerable Create(CsvReader reader, int degreeOfPara int dop = Normalize(degreeOfParallelism); if (!reader.TryGetChunkSource(out CsvChunkSource source) || !CanPartition(dop, source.Length, reader.Options)) { - return new CsvEnumerable(reader.FirstSheet, parser.Config, parser.CsvInfo, ownedReader: null, ct); + return new CsvEnumerable(reader.FirstSheet, parser.Config, parser.CsvInfo, ct); } return Build(source, reader.Options, parser, dop, chunkSizeOverride: 0, ct, reader.Lifetime, reader); } @@ -49,7 +49,7 @@ private static IAsyncEnumerable Build( int chunkSizeOverride, CancellationToken ct, ReaderLifetime? lease = null, - object? owner = null) + CsvReader? owner = null) { ExcelParserOptions config = parser.Config; TypeMapInfo info = parser.CsvInfo; @@ -68,7 +68,8 @@ private static IAsyncEnumerable Build( CsvChunkPlan plan = CsvChunkPlan.Create(dataStart, source.Length - dataStart, dop, chunkSizeOverride); if (plan.Count <= 1) { - return Sequential(source.OpenReader(options), parser, ct); + // Without an owner the source is in memory, so the reader opened here holds nothing to release. + return Sequential(owner ?? source.OpenReader(options), parser, ct); } return new ParallelCsvEnumerable(source, plan, dataStart, map, info, options, config, dop, lease, owner, ct); @@ -77,7 +78,7 @@ private static IAsyncEnumerable Build( private static CsvEnumerable Sequential( CsvReader reader, ExcelParser parser, CancellationToken ct) { - return new CsvEnumerable(reader.Sheets[0], parser.Config, parser.CsvInfo, ownedReader: reader, ct); + return new CsvEnumerable(reader.FirstSheet, parser.Config, parser.CsvInfo, ct); } private static async IAsyncEnumerable Empty() diff --git a/tests/ExcelReader.Tests/Parser/ParallelCsv/ParseCsvParallelTests.cs b/tests/ExcelReader.Tests/Parser/ParallelCsv/ParseCsvParallelTests.cs index 2072a5c2..f0767329 100644 --- a/tests/ExcelReader.Tests/Parser/ParallelCsv/ParseCsvParallelTests.cs +++ b/tests/ExcelReader.Tests/Parser/ParallelCsv/ParseCsvParallelTests.cs @@ -412,5 +412,16 @@ public async Task APartitionedParseHonorsTheTokenPassedToParseAsync() await Assert.ThrowsAnyAsync(() => DrainAsync(rows)); } + + [Fact] + public async Task TheSequentialFallbackAfterAHugeHeaderCanBeEnumeratedTwice() + { + byte[] csv = Encoding.UTF8.GetBytes("Name,Age," + new string('x', 300_000) + "\nada,1\ngrace,2\n"); + using CsvReader source = Excel.FromCsv(csv); + IAsyncEnumerable rows = SheetParallel.ParseAsync(source.FirstSheet, ExcelParser.FromAttributes(), options: new SheetParallelOptions { DegreeOfParallelism = 4 }, ct: TestContext.Current.CancellationToken); + + Assert.Equal(2, (await DrainAsync(rows)).Count); + Assert.Equal(2, (await DrainAsync(rows)).Count); + } } } From 3a5a9add46235247be81a6d1f642b96823487173 Mon Sep 17 00:00:00 2001 From: Gabriel Matte Date: Wed, 18 Nov 2026 11:43:52 -0300 Subject: [PATCH 12/39] fix(xls): reject a Workbook stream past 2 GiB instead of wrapping offsets BuildGlobals summed sheet lengths in int, so a workbook stream over 2 GiB wrapped the BOUNDSHEET lbPlyPos, INDEX and DBCELL offsets negative and the container came out corrupt. BIFF8 stores those as 32-bit offsets and a CFB v3 stream must stay under 2 GiB, so the sum is now checked and throws ExcelLimitExceededException (WorkbookStreamBytes). The OLE writer's sector rounding of the stream size is also done in long, since a size within 511 bytes of int.MaxValue overflowed it. --- .../Writer/Xls/OleCompoundWriter.cs | 8 ++++---- .../Writer/Xls/XlsWorkbookWriter.cs | 14 +++++++++++++- .../ExcelReader.Tests/Writer/Xls/XlsWriterTests.cs | 10 ++++++++++ 3 files changed, 27 insertions(+), 5 deletions(-) diff --git a/src/ExcelReader.Core/Writer/Xls/OleCompoundWriter.cs b/src/ExcelReader.Core/Writer/Xls/OleCompoundWriter.cs index 74ae486b..8dd25e1b 100644 --- a/src/ExcelReader.Core/Writer/Xls/OleCompoundWriter.cs +++ b/src/ExcelReader.Core/Writer/Xls/OleCompoundWriter.cs @@ -390,8 +390,8 @@ private static byte[] BuildDifat(int fatCount, int difatCount, int firstDifatSec internal static ValueTask WriteAsync(Stream destination, int workbookSize, Func writeBody, CancellationToken ct) { - int storedSize = Math.Max(CeilingDiv(workbookSize, SectorSize) * SectorSize, MiniCutoff); - int padding = storedSize - workbookSize; + long storedSize = Math.Max((long)CeilingDivLong(workbookSize, SectorSize) * SectorSize, MiniCutoff); + int padding = (int)(storedSize - workbookSize); CfbStreamSpec spec = new( "Workbook", storedSize, @@ -406,8 +406,8 @@ internal static ValueTask WriteAsync(Stream destination, int workbookSize, Func< internal static void Write(Stream destination, int workbookSize, Action writeBody) { - int storedSize = Math.Max(CeilingDiv(workbookSize, SectorSize) * SectorSize, MiniCutoff); - int padding = storedSize - workbookSize; + long storedSize = Math.Max((long)CeilingDivLong(workbookSize, SectorSize) * SectorSize, MiniCutoff); + int padding = (int)(storedSize - workbookSize); CfbStreamSpec spec = new( "Workbook", storedSize, diff --git a/src/ExcelReader.Core/Writer/Xls/XlsWorkbookWriter.cs b/src/ExcelReader.Core/Writer/Xls/XlsWorkbookWriter.cs index afbb1f98..af6c9fbe 100644 --- a/src/ExcelReader.Core/Writer/Xls/XlsWorkbookWriter.cs +++ b/src/ExcelReader.Core/Writer/Xls/XlsWorkbookWriter.cs @@ -1,5 +1,6 @@ using System.Diagnostics.CodeAnalysis; using System.Runtime.InteropServices; +using ExcelReader.Core.Reader; using ExcelReader.Core.Writer.Internal; using ExcelReader.Core.Writer.Xlsx; @@ -141,7 +142,7 @@ private BiffBuffer BuildGlobals(List layouts, out int workbookSi { globals.PatchI32(offsetPositions[i], offset); layouts[i].Place(offset); - offset += layouts[i].Length; + offset = AdvanceSheetOffset(offset, layouts[i].Length); } workbookSize = offset; return globals; @@ -153,6 +154,17 @@ private BiffBuffer BuildGlobals(List layouts, out int workbookSi } } + // BIFF8 stores sheet and DBCELL positions as 32-bit offsets, and a CFB v3 stream stays under 2 GiB. + internal static int AdvanceSheetOffset(int offset, int sheetLength) + { + long next = (long)offset + sheetLength; + if (next > int.MaxValue) + { + throw new ExcelLimitExceededException("WorkbookStreamBytes", int.MaxValue, next); + } + return (int)next; + } + private void ReleaseStream() { if (_leaveOpen) diff --git a/tests/ExcelReader.Tests/Writer/Xls/XlsWriterTests.cs b/tests/ExcelReader.Tests/Writer/Xls/XlsWriterTests.cs index 79c4bed4..81d996db 100644 --- a/tests/ExcelReader.Tests/Writer/Xls/XlsWriterTests.cs +++ b/tests/ExcelReader.Tests/Writer/Xls/XlsWriterTests.cs @@ -21,6 +21,16 @@ private static async Task WriteAsync( return ms.ToArray(); } + [Fact] + public void WorkbookStreamPastTwoGiBThrowsLimitExceeded() + { + Assert.Equal(int.MaxValue, XlsWorkbookWriter.AdvanceSheetOffset(int.MaxValue - 10, 10)); + var ex = Assert.Throws(() => XlsWorkbookWriter.AdvanceSheetOffset(int.MaxValue - 10, 11)); + Assert.Equal("WorkbookStreamBytes", ex.LimitName); + Assert.Equal(int.MaxValue, ex.Limit); + Assert.Equal(int.MaxValue + 1L, ex.Actual); + } + [Fact] public async Task RoundTripsAllCellTypes() { From 2e6d57e5965d9adb7cd1bb7922e93adba081e379 Mon Sep 17 00:00:00 2001 From: Gabriel Matte Date: Wed, 18 Nov 2026 11:45:28 -0300 Subject: [PATCH 13/39] fix(csv): keep the constructor token when a CsvEnumerable is enumerated with another GetAsyncEnumerator replaced the token captured at creation (the SheetParallel.ParseAsync ct) with any cancelable one passed to it, so .WithCancellation(other) dropped the original. Both are now linked when both can cancel, and the async enumerator disposes the linked source. --- src/ExcelReader.Core/Parser/CsvEnumerable.cs | 28 ++++++++++++++++--- .../ParallelCsv/ParseCsvParallelTests.cs | 13 +++++++++ 2 files changed, 37 insertions(+), 4 deletions(-) diff --git a/src/ExcelReader.Core/Parser/CsvEnumerable.cs b/src/ExcelReader.Core/Parser/CsvEnumerable.cs index 5d554a33..a7f49d4f 100644 --- a/src/ExcelReader.Core/Parser/CsvEnumerable.cs +++ b/src/ExcelReader.Core/Parser/CsvEnumerable.cs @@ -66,8 +66,18 @@ IAsyncEnumerator IAsyncEnumerable.GetAsyncEnumerator(CancellationToken can /// public AsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { - CancellationToken effective = cancellationToken.CanBeCanceled ? cancellationToken : _ct; - return new AsyncEnumerator(_sheet, _info, _config.ColumnNameComparer, _config.HeaderNormalization, _config.HeaderRow, _config.Culture, _config.ThrowOnParseFailure, effective); + if (!cancellationToken.CanBeCanceled || !_ct.CanBeCanceled) + { + CancellationToken effective = cancellationToken.CanBeCanceled ? cancellationToken : _ct; + return CreateAsyncEnumerator(linked: null, effective); + } + var linked = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _ct); + return CreateAsyncEnumerator(linked, linked.Token); + } + + private AsyncEnumerator CreateAsyncEnumerator(CancellationTokenSource? linked, CancellationToken ct) + { + return new AsyncEnumerator(_sheet, _info, _config.ColumnNameComparer, _config.HeaderNormalization, _config.HeaderRow, _config.Culture, _config.ThrowOnParseFailure, linked, ct); } /// Enumerates CSV rows synchronously, projecting each into a instance by fixed field index. @@ -105,6 +115,7 @@ private protected override T Project() public sealed class AsyncEnumerator : AsyncRowEnumerator { private CsvRowProjector _projector; + private readonly CancellationTokenSource? _linked; internal AsyncEnumerator( CsvSheet sheet, @@ -114,16 +125,25 @@ internal AsyncEnumerator( int headerRow, IFormatProvider provider, bool throwOnParseFailure, + CancellationTokenSource? linked, CancellationToken ct) : base(sheet, ct) { _projector = new CsvRowProjector(typeInfo, comparer, normalization, headerRow, provider, throwOnParseFailure); + _linked = linked; } /// - public override ValueTask DisposeAsync() + public override async ValueTask DisposeAsync() { - return base.DisposeAsync(); + try + { + await base.DisposeAsync().ConfigureAwait(false); + } + finally + { + _linked?.Dispose(); + } } private protected override ProjectionStep Classify() diff --git a/tests/ExcelReader.Tests/Parser/ParallelCsv/ParseCsvParallelTests.cs b/tests/ExcelReader.Tests/Parser/ParallelCsv/ParseCsvParallelTests.cs index f0767329..e55e4921 100644 --- a/tests/ExcelReader.Tests/Parser/ParallelCsv/ParseCsvParallelTests.cs +++ b/tests/ExcelReader.Tests/Parser/ParallelCsv/ParseCsvParallelTests.cs @@ -413,6 +413,19 @@ public async Task APartitionedParseHonorsTheTokenPassedToParseAsync() await Assert.ThrowsAnyAsync(() => DrainAsync(rows)); } + [Fact] + public async Task ASequentialParseKeepsTheParseAsyncTokenWhenEnumeratedWithAnother() + { + using CsvReader source = Excel.FromCsv(BuildCsv(3)); + using var cts = new CancellationTokenSource(); + using var other = new CancellationTokenSource(); + await cts.CancelAsync(); + + IAsyncEnumerable rows = SheetParallel.ParseAsync(source.FirstSheet, ExcelParser.FromAttributes(), options: new SheetParallelOptions { DegreeOfParallelism = 1 }, ct: cts.Token); + + await Assert.ThrowsAnyAsync(async () => await rows.ToListAsync(other.Token)); + } + [Fact] public async Task TheSequentialFallbackAfterAHugeHeaderCanBeEnumeratedTwice() { From 7819968e2baab4af51f1f7cf00a2a771d0f7f33e Mon Sep 17 00:00:00 2001 From: Gabriel Matte Date: Wed, 18 Nov 2026 11:47:45 -0300 Subject: [PATCH 14/39] fix(reader): detect encrypted or oversized ZIPs as Unknown DetectFileFormat only caught InvalidDataException, so a password-protected ZIP (NotSupportedException) or one with more entries than MaxZipEntries (ExcelLimitExceededException) escaped instead of returning the documented Unknown. Opening such a file still throws NotSupportedException, which the error guide documents for features the reader does not support. --- src/ExcelReader.Core/Reader/Excel.cs | 17 ++++--- .../Reader/DetectFileFormatContractTests.cs | 49 +++++++++++++++++++ 2 files changed, 60 insertions(+), 6 deletions(-) diff --git a/src/ExcelReader.Core/Reader/Excel.cs b/src/ExcelReader.Core/Reader/Excel.cs index 3bd4b1ce..2fcb05bd 100644 --- a/src/ExcelReader.Core/Reader/Excel.cs +++ b/src/ExcelReader.Core/Reader/Excel.cs @@ -636,7 +636,7 @@ private static void RequireOpenableFormat(ExcelFileFormat format) /// Detects a workbook's file format (XLSX/XLSB/XLS/unknown) from a seekable stream's signature, without consuming it. /// A seekable stream containing the workbook data. The stream's position is restored after detection. Reading starts at the stream's current , which is treated as the start of the workbook; bytes before it are ignored. - /// The detected , or if the signature matches no supported format or the ZIP is corrupt or holds no XLSX/XLSB workbook part. + /// The detected , or if the signature matches no supported format or the ZIP is corrupt, cannot be read (encrypted entries, an unsupported compression method, more entries than the default limit) or holds no XLSX/XLSB workbook part. /// is . /// does not support seeking. public static ExcelFileFormat DetectFileFormat(Stream stream) @@ -651,7 +651,7 @@ public static ExcelFileFormat DetectFileFormat(Stream stream) zip?.Dispose(); return format; } - catch (InvalidDataException) + catch (Exception ex) when (IsNotAReadableWorkbook(ex)) { return ExcelFileFormat.Unknown; } @@ -668,7 +668,7 @@ public static ExcelFileFormat DetectFileFormat(Stream stream) /// Detects a workbook's file format (XLSX/XLSB/XLS/unknown) from an in-memory buffer's signature, without consuming it. /// /// A buffer containing the workbook data. - /// The detected , or if the signature matches no supported format or the ZIP is corrupt or holds no XLSX/XLSB workbook part. + /// The detected , or if the signature matches no supported format or the ZIP is corrupt, cannot be read (encrypted entries, an unsupported compression method, more entries than the default limit) or holds no XLSX/XLSB workbook part. public static ExcelFileFormat DetectFileFormat(ReadOnlyMemory data) { try @@ -677,7 +677,7 @@ public static ExcelFileFormat DetectFileFormat(ReadOnlyMemory data) memZip?.Dispose(); return format; } - catch (InvalidDataException) + catch (Exception ex) when (IsNotAReadableWorkbook(ex)) { return ExcelFileFormat.Unknown; } @@ -686,7 +686,7 @@ public static ExcelFileFormat DetectFileFormat(ReadOnlyMemory data) /// Asynchronously detects a workbook's file format (XLSX/XLSB/XLS/unknown) from a seekable stream's signature, without consuming it. /// A seekable stream containing the workbook data. The stream's position is restored after detection. Reading starts at the stream's current , which is treated as the start of the workbook; bytes before it are ignored. /// A token to cancel the detection operation. - /// The detected , or if the signature matches no supported format or the ZIP is corrupt or holds no XLSX/XLSB workbook part. + /// The detected , or if the signature matches no supported format or the ZIP is corrupt, cannot be read (encrypted entries, an unsupported compression method, more entries than the default limit) or holds no XLSX/XLSB workbook part. /// is . /// does not support seeking. public static async ValueTask DetectFileFormatAsync(Stream stream, CancellationToken ct = default) @@ -701,7 +701,7 @@ public static async ValueTask DetectFileFormatAsync(Stream stre zip?.Dispose(); return format; } - catch (InvalidDataException) + catch (Exception ex) when (IsNotAReadableWorkbook(ex)) { return ExcelFileFormat.Unknown; } @@ -715,6 +715,11 @@ public static async ValueTask DetectFileFormatAsync(Stream stre } } + private static bool IsNotAReadableWorkbook(Exception ex) + { + return ex is InvalidDataException or NotSupportedException or ExcelLimitExceededException; + } + private static IExcelWorkbook OpenSeekable(Stream stream, bool leaveOpen, ExcelReaderOptions? options) { stream = RebaseToPosition(stream, ref leaveOpen); diff --git a/tests/ExcelReader.Tests/Reader/DetectFileFormatContractTests.cs b/tests/ExcelReader.Tests/Reader/DetectFileFormatContractTests.cs index e72aaf7f..7d77d7cd 100644 --- a/tests/ExcelReader.Tests/Reader/DetectFileFormatContractTests.cs +++ b/tests/ExcelReader.Tests/Reader/DetectFileFormatContractTests.cs @@ -18,6 +18,31 @@ private static byte[] WordLikeZip() return buffer.ToArray(); } + private static byte[] EncryptedZip() + { + byte[] bytes = WordLikeZip(); + const int LocalFlagsOffset = 6; + const int CentralFlagsOffset = 8; + int central = bytes.AsSpan().IndexOf("PK\u0001\u0002"u8); + Assert.True(central > 0); + bytes[LocalFlagsOffset] |= 1; + bytes[central + CentralFlagsOffset] |= 1; + return bytes; + } + + private static byte[] ZipWithMoreEntriesThanTheDefaultLimit() + { + using MemoryStream buffer = new(); + using (ZipArchive zip = new(buffer, ZipArchiveMode.Create, leaveOpen: true)) + { + for (int i = 0; i <= ExcelReaderOptions.Default.MaxZipEntries; i++) + { + zip.CreateEntry(i.ToString(System.Globalization.CultureInfo.InvariantCulture), CompressionLevel.NoCompression); + } + } + return buffer.ToArray(); + } + public static TheoryData NotAWorkbook => [ ZipSignatureOnly, @@ -39,6 +64,30 @@ public async Task ReturnsUnknownForAZipThatIsNotAWorkbook(byte[] bytes) Assert.Equal(ExcelFileFormat.Unknown, Excel.DetectFileFormat(bytes)); } + [Fact] + public Task ReturnsUnknownForAnEncryptedZip() + { + return AssertUnknownAsync(EncryptedZip()); + } + + [Fact] + public Task ReturnsUnknownForAZipPastTheEntryLimit() + { + return AssertUnknownAsync(ZipWithMoreEntriesThanTheDefaultLimit()); + } + + private static async Task AssertUnknownAsync(byte[] bytes) + { + using MemoryStream stream = new(bytes); + await using MemoryStream asyncStream = new(bytes); + + Assert.Equal(ExcelFileFormat.Unknown, Excel.DetectFileFormat(stream)); + Assert.Equal(0, stream.Position); + Assert.Equal(ExcelFileFormat.Unknown, await Excel.DetectFileFormatAsync(asyncStream, TestContext.Current.CancellationToken)); + Assert.Equal(0, asyncStream.Position); + Assert.Equal(ExcelFileFormat.Unknown, Excel.DetectFileFormat(bytes)); + } + [Fact] public void OpeningAZipThatIsNotAWorkbookIsRejected() { From a16db95c3a5d36dfe050266b2ce68c53cbd92d7f Mon Sep 17 00:00:00 2001 From: Gabriel Matte Date: Wed, 18 Nov 2026 11:47:56 -0300 Subject: [PATCH 15/39] fix(xls): truncate continuation sheet names on a code-point boundary CreateContinuation cut the base name by UTF-16 code unit to fit the 31-char limit with its " (n)" suffix, so a name with an astral character at the cut point produced a continuation sheet ending in a lone high surrogate, which the AddSheet name validation would have rejected. The cut now drops the whole pair. --- src/ExcelReader.Core/Writer/Xls/XlsSheetWriter.cs | 14 +++++++++++--- .../ExcelReader.Tests/Writer/Xls/XlsWriterTests.cs | 10 ++++++++++ 2 files changed, 21 insertions(+), 3 deletions(-) diff --git a/src/ExcelReader.Core/Writer/Xls/XlsSheetWriter.cs b/src/ExcelReader.Core/Writer/Xls/XlsSheetWriter.cs index 412705b3..a14f3176 100644 --- a/src/ExcelReader.Core/Writer/Xls/XlsSheetWriter.cs +++ b/src/ExcelReader.Core/Writer/Xls/XlsSheetWriter.cs @@ -390,15 +390,23 @@ private static void ValidateColumn(int col) } } + private string TruncatedBaseName(int maxLength) + { + if (_baseName.Length <= maxLength) + { + return _baseName; + } + int length = char.IsHighSurrogate(_baseName[maxLength - 1]) ? maxLength - 1 : maxLength; + return _baseName[..length]; + } + private XlsSheetWriter CreateContinuation() { string contName; for (int n = _owner.SheetCount + 1; ; n++) { string suffix = $" ({n})"; - contName = _baseName.Length + suffix.Length <= MaxSheetNameLength - ? _baseName + suffix - : _baseName[..(MaxSheetNameLength - suffix.Length)] + suffix; + contName = TruncatedBaseName(MaxSheetNameLength - suffix.Length) + suffix; if (_owner.TryClaimSheetName(contName)) { break; diff --git a/tests/ExcelReader.Tests/Writer/Xls/XlsWriterTests.cs b/tests/ExcelReader.Tests/Writer/Xls/XlsWriterTests.cs index 81d996db..0b5c23a7 100644 --- a/tests/ExcelReader.Tests/Writer/Xls/XlsWriterTests.cs +++ b/tests/ExcelReader.Tests/Writer/Xls/XlsWriterTests.cs @@ -89,6 +89,16 @@ public async Task ContinuationSheetSkipsANameAlreadyTaken() Assert.Equal(["Data (2)", "Data", "Data (3)"], [.. reader.Sheets.Select(static s => s.Name)]); } + [Fact] + public async Task ContinuationSheetNameDoesNotSplitASurrogatePair() + { + string baseName = new string('a', 26) + "😀" + "bc"; + byte[] bytes = await WriteAsync(wb => WriteRows(wb.AddSheet(baseName), 65_537), ct: TestContext.Current.CancellationToken); + + using var reader = Excel.FromXls(new MemoryStream(bytes)); + Assert.Equal([baseName, new string('a', 26) + " (2)"], [.. reader.Sheets.Select(static s => s.Name)]); + } + [Fact] public async Task SheetCannotTakeTheNameOfAContinuationSheet() { From e8da3dc9bd62ab3617d12ac513df4e90c9b1c776 Mon Sep 17 00:00:00 2001 From: Gabriel Matte Date: Wed, 18 Nov 2026 11:48:43 -0300 Subject: [PATCH 16/39] fix(csv): yield nothing from a parallel parse whose source ends before the header row CsvHeaderBinder threw InvalidOperationException when the source had fewer rows than HeaderRow, while the sequential parser yields an empty sequence. The binder now reports no data start, so the factory returns the empty result. --- .../Parser/ParallelCsv/CsvHeaderBinder.cs | 4 ++-- .../Parser/ParallelCsv/ParseCsvParallelTests.cs | 14 ++++++++++++++ 2 files changed, 16 insertions(+), 2 deletions(-) diff --git a/src/ExcelReader.Core/Parser/ParallelCsv/CsvHeaderBinder.cs b/src/ExcelReader.Core/Parser/ParallelCsv/CsvHeaderBinder.cs index d6a205d7..c591c87d 100644 --- a/src/ExcelReader.Core/Parser/ParallelCsv/CsvHeaderBinder.cs +++ b/src/ExcelReader.Core/Parser/ParallelCsv/CsvHeaderBinder.cs @@ -30,8 +30,8 @@ internal static CsvBoundColumnMap Bind( firstDataRecordOffset = rows.MoveNext() ? rows.CurrentRecordStart : long.MaxValue; return map; } - throw new InvalidOperationException( - $"The CSV source has no row at header index {config.HeaderRow}."); + firstDataRecordOffset = long.MaxValue; + return new CsvBoundColumnMap([], [], [], []); } } } diff --git a/tests/ExcelReader.Tests/Parser/ParallelCsv/ParseCsvParallelTests.cs b/tests/ExcelReader.Tests/Parser/ParallelCsv/ParseCsvParallelTests.cs index e55e4921..865f2330 100644 --- a/tests/ExcelReader.Tests/Parser/ParallelCsv/ParseCsvParallelTests.cs +++ b/tests/ExcelReader.Tests/Parser/ParallelCsv/ParseCsvParallelTests.cs @@ -436,5 +436,19 @@ public async Task TheSequentialFallbackAfterAHugeHeaderCanBeEnumeratedTwice() Assert.Equal(2, (await DrainAsync(rows)).Count); Assert.Equal(2, (await DrainAsync(rows)).Count); } + + [Fact] + public async Task ASourceShorterThanTheHeaderRowYieldsNothingLikeTheSequentialParser() + { + byte[] csv = Encoding.UTF8.GetBytes("Name,Age\n" + new string('x', 300_000) + "\n"); + var parser = ExcelParser.FromAttributes(new ExcelParserOptions { HeaderRow = 5 }); + using CsvReader sequential = Excel.FromCsv(csv); + Assert.Empty(parser.Parse(sequential.FirstSheet).ToList()); + + using CsvReader source = Excel.FromCsv(csv); + List actual = await DrainAsync(SheetParallel.ParseAsync(source.FirstSheet, parser, options: new SheetParallelOptions { DegreeOfParallelism = 4 }, ct: TestContext.Current.CancellationToken)); + + Assert.Empty(actual); + } } } From 2af4fabf8ee2b3d62fbfb0cfac05e0b8d2467e83 Mon Sep 17 00:00:00 2001 From: Gabriel Matte Date: Wed, 18 Nov 2026 11:49:12 -0300 Subject: [PATCH 17/39] fix(xlsx): skip comments, PIs and DOCTYPE when detecting the element prefix A tag inside a leading comment or processing instruction was taken for the root element, so a prefixed sheet, workbook, styles or shared-strings part read as unprefixed and yielded nothing. --- src/ExcelReader.Core/Reader/Xlsx/XlsxXml.cs | 38 ++++++++++- .../Xlsx/NamespacePrefixAndIsoDateTests.cs | 68 +++++++++++++++++++ 2 files changed, 105 insertions(+), 1 deletion(-) diff --git a/src/ExcelReader.Core/Reader/Xlsx/XlsxXml.cs b/src/ExcelReader.Core/Reader/Xlsx/XlsxXml.cs index 66ee7d99..9453a305 100644 --- a/src/ExcelReader.Core/Reader/Xlsx/XlsxXml.cs +++ b/src/ExcelReader.Core/Reader/Xlsx/XlsxXml.cs @@ -425,10 +425,19 @@ internal static ReadOnlySpan DetectElementPrefix(ReadOnlySpan src) { return default; } - if (src[i] is (byte)'?' or (byte)'!' or (byte)'/') + if (src[i] == (byte)'/') { continue; } + if (src[i] is (byte)'?' or (byte)'!') + { + i = MarkupEnd(src, i); + if (i < 0) + { + return default; + } + continue; + } int nameStart = i; for (int j = i; j < src.Length; j++) { @@ -446,6 +455,33 @@ internal static ReadOnlySpan DetectElementPrefix(ReadOnlySpan src) } } + private static int MarkupEnd(ReadOnlySpan src, int i) + { + ReadOnlySpan rest = src[i..]; + if (src[i] == (byte)'?') + { + int pi = rest.IndexOf("?>"u8); + return pi < 0 ? -1 : i + pi + 2; + } + if (rest.StartsWith("!--"u8)) + { + int comment = rest[3..].IndexOf("-->"u8); + return comment < 0 ? -1 : i + comment + 6; + } + int depth = 0; + for (int j = 0; j < rest.Length; j++) + { + byte c = rest[j]; + depth += c == (byte)'[' ? 1 : 0; + depth -= c == (byte)']' ? 1 : 0; + if (c == (byte)'>' && depth <= 0) + { + return i + j + 1; + } + } + return -1; + } + internal static byte[] Token(ReadOnlySpan lead, ReadOnlySpan prefix, ReadOnlySpan rest) { byte[] token = new byte[lead.Length + prefix.Length + rest.Length]; diff --git a/tests/ExcelReader.Tests/Reader/Xlsx/NamespacePrefixAndIsoDateTests.cs b/tests/ExcelReader.Tests/Reader/Xlsx/NamespacePrefixAndIsoDateTests.cs index 24765dad..98e1e764 100644 --- a/tests/ExcelReader.Tests/Reader/Xlsx/NamespacePrefixAndIsoDateTests.cs +++ b/tests/ExcelReader.Tests/Reader/Xlsx/NamespacePrefixAndIsoDateTests.cs @@ -1,3 +1,5 @@ +using System.IO.Compression; +using System.Text; using ExcelReader.Core.Reader; using ExcelReader.Core.Reader.Xlsx; @@ -5,6 +7,7 @@ namespace ExcelReader.Tests.Reader.Xlsx { public class NamespacePrefixAndIsoDateTests { + private const string Main = "http://schemas.openxmlformats.org/spreadsheetml/2006/main"; [Fact] public void PrefixedNumberAndInlineStringCellsAreRead() @@ -245,5 +248,70 @@ public void IsoDateCellCombinedWithPrefix() Assert.True(e.Current[0].TryGetDateTime(reader.IsDate1904, out DateTime dt)); Assert.Equal(new DateTime(2026, 3, 4), dt); } + + [Fact] + public void PrefixedSheetIsReadWhenAnXmlCommentContainsATag() + { + using MemoryStream ms = Package( + sheet: $"""5""", + sharedStrings: null); + using XlsxWorkbook reader = Excel.FromXlsx(ms); + using XlsxWorkbook.Enumerator e = reader.FirstSheet.GetEnumerator(); + + Assert.True(e.MoveNext()); + Assert.Equal("5", e.Current[0].GetString()); + } + + [Fact] + public void PrefixedSharedStringsAreReadWhenAnXmlCommentContainsATag() + { + using MemoryStream ms = Package( + sheet: $"""0""", + sharedStrings: $"""alpha"""); + using XlsxWorkbook reader = Excel.FromXlsx(ms); + using XlsxWorkbook.Enumerator e = reader.FirstSheet.GetEnumerator(); + + Assert.True(e.MoveNext()); + Assert.Equal("alpha", e.Current[0].GetString()); + } + + [Theory] + [InlineData("", "x:")] + [InlineData("?>", "x:")] + [InlineData("\">]>", "x:")] + [InlineData("", "")] + [InlineData("