NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
NuGet, #260 most downloaded on NuGet
See release notes https://github.com/ClosedXML/ClosedXML/releases/tag/0.105.1 ClosedXML is a .NET library for reading, manipulating and writing Excel 2007+ (.xlsx, .xlsm) files. It aims to provide an intuitive and user-friendly interface to dealing with the underlying OpenXML API.
Latest stable
0.105.1
Last release 4 months ago
25 Jul 2026
Release timing varies
gaps range from 2 weeks to 1.2 years
Some releases are documented
notes for 28 of 56 stable releases
11 versions withdrawn
withdrawn after publishing
127 years old
89 releases · first in 1900
Drag across the ruler to compare, or tap a release to open it.
fix: bound SixLabors.Fonts to version range [1.0.0,3.0.0) by @igitur in #2870
Full Changelog: 0.105.0...0.105.1
Automatic fixer of function names
Correct name for newer functions (post 2013) is not what is seen in the GUI (e.g. correct name for CONCAT is _xlfn.CONCAT). That is rather obscure fact not known to most developers. The formula setters (e.g. IXLCell.FormulaA1) now automatically fix function names, so it is stored correctly in the file.
using var wb = new XLWorkbook();
var ws = wb.AddWorksheet();
// Originally required "_xlfn.CONCAT(\"hello\", \" world!\")";
ws.Cell("A1").FormulaA1 = "CONCAT(\"hello\", \" world!\")"; In many cases, the sorted area has a column with references. The formula often references another row. Pre-0.105, the references in the formulas weren't updated correctly.
using var wb = new XLWorkbook();
var ws = wb.AddWorksheet();
ws.Cell("A1").Value = 4;
ws.Cell("B1").FormulaA1 = "A1+1";
ws.Cell("A2").Value = 2;
ws.Cell("B2").FormulaA1 = "A2+1";
ws.Cell("A3").Value = 1;
ws.Cell("B3").FormulaA1 = "A3+1";
ws.Range("A1:B3").Sort(1, XLSortOrder.Ascending);Basically all implemented functions should be more faithful to how Excel behaves and evaluation of functions should be faster. implemented functions should be "complete" in sense that they correctly work for various arguments (e.g. various forms of ROMAN or pattern search in SUMIFS).
The functions (before refactoring) had serious problems with ranges, errors or type coercion or structured references. The original parser back then didn't even parse literal arrays ({1,2,3;4,5,6}). Parser and other things were updated, but because there was ~180 functions, original implementation was kept and functions were functions were reused through an adapter. Except the adapter never worked right and there were some other serious problems.
Note truncated.
Your coding agent can read these notes before it upgrades. Set up the MCP server →
Automatic fixer of function names
Correct name for newer functions (post 2013) is not what is seen in the GUI (e.g. correct name for CONCAT is _xlfn.CONCAT). That is rather obscure fact not known to most developers. The formula setters (e.g. IXLCell.FormulaA1) now automatically fix function names, so it is stored correctly in the file.
using var wb = new XLWorkbook();
var ws = wb.AddWorksheet();
// Originally required "_xlfn.CONCAT(\"hello\", \" world!\")";
ws.Cell("A1").FormulaA1 = "CONCAT(\"hello\", \" world!\")"; In many cases, the sorted area has a column with references. The formula often references another row. Pre-0.105, the references in the formulas weren't updated correctly.
using var wb = new XLWorkbook();
var ws = wb.AddWorksheet();
ws.Cell("A1").Value = 4;
ws.Cell("B1").FormulaA1 = "A1+1";
ws.Cell("A2").Value = 2;
ws.Cell("B2").FormulaA1 = "A2+1";
ws.Cell("A3").Value = 1;
ws.Cell("B3").FormulaA1 = "A3+1";
ws.Range("A1:B3").Sort(1, XLSortOrder.Ascending);Basically all implemented functions should be more faithful to how Excel behaves and evaluation of functions should be faster. implemented functions should be "complete" in sense that they correctly work for various arguments (e.g. various forms of ROMAN or pattern search in SUMIFS).
The functions (before refactoring) had serious problems with ranges, errors or type coercion or structured references. The original parser back then didn't even parse literal arrays ({1,2,3;4,5,6}). Parser and other things were updated, but because there was ~180 functions, original implementation was kept and functions were functions were reused through an adapter. Except the adapter never worked right and there were some other serious problems.
Note truncated.
Update DocumentFormat.OpenXml due to vulnerability in System.IO.Packaging 8.0.0 by @jahav in #2503
Full Changelog: 0.104.1...0.104.2
Summary of breaking changes is available at docs.closedxml.io :
Release notes from 0.102.1 to the 0.104.1.
Summary of breaking changes is available at docs.closedxml.io:
OpenXML SDK has released version 3. The 0.104.0 uses it as a dependency.
The XLParser has been replaced with ClosedParser. The key benefits are
There is also a visualizer to display AST in a browser at https://parser.closedxml.io
In previous version, formulas used to be calculated recursively. Each formula checked it's supporting cells for other formulas and if there were some, they were recursively evaluated. There was some logic to decrease number of evaluations. That works for a very simple cases, but isn't very good for various non-happy paths (i.e. cells weren't calculated when they should be).
This version has replaced it with a standard
For more info, see docs, the Microsoft has a page about principles Excel Recalculation
and there is one with API at docs.closedxml.io.
New parser also allows a basic evaluation of structured references. Format of structured reference must use official grammar, not Excel friendly names (e.g. Pastry[@Name] is user-friendly name for Pastry[[#This Row],[Name]]). It's now possible to
using var wb = new XLWorkbook();
var ws = wb.AddWorksheet();
ws.Cell("A1").InsertTable(new Pastry[]
{
new("Cake", 14),
new("Waffle", 3),
}, "Pastry");
ws.Cell("D1").FormulaA1 = "SUM(Pastry[Price])";
ws.Cell("D3").FormulaA1 = "\"Pastry \" & Pastry[[#This Row],[Name]]";
wb.RecalculateAllFormulas();
Console.WriteLine($"Expected: {17}, Actual: {ws.Cell("D1").Value}");
Console.WriteLine($"Expected: \"Pastry Waffle\", Actual: {ws.Cell("D3").Value}");Expected: 17, Actual: 17
Expected: "Pastry Waffle", Actual: Pastry Waffle
When a sheet is renamed, a formula referencing the sheet is also updated. This is a part of long term effort to fix effects of structural changes of a workbook. It will be a long road (e.g. sheet still delete doesn't swicth to #REF!),** but is one of basic features that should be working acorss the board.
using var wb = new XLWorkbook();
var sheet = wb.AddWorksheet();
var anotherSheet = wb.AddWorksheet("Another");
sheet.Cell("A1").FormulaA1 = "Another!B4";
anotherSheet.Name = "Changed";
Console.WriteLine(sheet.Cell("A1").FormulaA1);Changed!B4
Internal structure has been cleaned up and optimized.
The dirty tracking has been moved out of cells to formulas and thus memory taken up by a single cell value is now only 16 bytes instead of 24 (?) bytes in 0.102. Of course there are some other structures around that take up memory as well, but the single cell value is now 16 bytes (I hoped for 8, but not feasible with double, DateTime and TimeSpan as possible cell values - all take up 8 bytes... not enough bits).
The same string in different instances is now not duplicated, but only one instance is used. As seen on following test, it can lead to significant decrease in memory consumption. 250k rows with 10 text rows (same string, different instance): 117 MiB om 0.103 vs 325 MiB in 0.102.1.
InsertData performanceInsert 250k rows of 10 columns of text and 5 columns of numbers (gist).
| Description | Rows | Columns | Time/Memory to insert data | Save workbook | Total time/memory |
|---|---|---|---|---|---|
| 0.103.0-beta | 250 000 | 15 | 1.619 sec / 117 MiB | 6.343 sec | 477 MiB |
| 0.102.1 | 250 000 | 15 | 7.160 sec / 325 MiB | 6.676 sec | 692 MiB |
Basically workbooks with a large amount of cells should see ~15%-20% speedup (as long as there are mainly values, not styles or OLAP metadata....).
Reading the 250k from previous chapter:
| Description | Rows | Columns | Time to load data | Used memory |
|---|---|---|---|---|
| 0.103.0-beta | 250 000 | 15 | 15.648 sec | 236 MiB |
| 0.102.1 | 250 000 | 15 | 20.460 sec | 329 MiB |
Of course, this includes all stuff from 0.103.0-beta. Version 0.103 never got a non-beta release.
The internal structure of pivot tables, along with most other features, has been completely overhauled. This update should significantly reduce crashes when loading and saving workbooks containing pivot tables.
The main issue with the previous internal structure was that it didn't align with the structure used by OOXML. This was problematic because we need to support all valid files. As a result, we have to handle a wide range of inputs and correctly convert them to our internal structure, which is rather hard. A more clear 1:1 mapping with OOXML is much simpler and more reliable.
The Autofilter feature has been revamped, which includes some API changes. Its behavior is now more closely aligned with how Excel operates. The XML documentation provides detailed explanations, and there is a dedicated documentation page. Several bugs have also been fixed.
For more details, refer to the Autofilter section of the migration guide.
Although ClosedXML still doesn't have source package (Fody static weaving causes pdb mismatch and nuget will refuse symbol package), there is a source link info in the package.
SourceLink basically takes a repository and a commit from the package and retrieves source from directly from forge (in this case GitHub).
When workbook is a valid one, ClosedXML shouldn't throw on load. That is a rather high priority (more than saving or manipulation). Unfortunately, that is hard to find such areas that cause most problems.
One of activities that was going in a background is trying to use excel files around the internet (found by CommonCrawl) to evaluate how bad it is. There aren't results yet, but it is something that is going on.
Note truncated.
Bump version to 0.104.0 for release
Bump version to 0.104.0 for release
A release candidate 1 for 0.104.0.
A release candidate 1 for 0.104.0.
Of course, this includes all stuff from 0.103.0-beta. Version 0.103 never got a non-beta release.
OpenXML SDK has released version 3.0.1. The 0.104-rc1 uses it as a dependency.
The internal structure of pivot tables, along with most other features, has been completely overhauled. This update should significantly reduce crashes when loading and saving workbooks containing pivot tables.
The main issue with the previous internal structure was that it didn't align with the structure used by OOXML. This was problematic because we need to support all valid files. As a result, we have to handle a wide range of inputs and correctly convert them to our internal structure, which is rather hard. A more clear 1:1 mapping with OOXML is much simpler and more reliable.
The Autofilter feature has been revamped, which includes some API changes. Its behavior is now more closely aligned with how Excel operates. The XML documentation provides detailed explanations, and there is a dedicated documentation page. Several bugs have also been fixed.
For more details, refer to the Autofilter section of the migration guide.
When workbook is a valid one, ClosedXML shouldn't throw on load. That is a rather high priority (more than saving or manipulation). Unfortunately, that is hard to find such areas that cause most problems.
One of activities that was going in a background is trying to use excel files around the internet (found by CommonCrawl) to evaluate how bad it is. There aren't results yet, but it is something that is going on.
Full Changelog: https://github.com/ClosedXML/ClosedXML/compare/0.104.0-preview2...0.104.0-rc1
A release candidate 1 for 0.104.0.
Of course, this includes all stuff from 0.103.0-beta. Version 0.103 never got a non-beta release.
OpenXML SDK has released version 3.0.1. The 0.104-rc1 uses it as a dependency.
The internal structure of pivot tables, along with most other features, has been completely overhauled. This update should significantly reduce crashes when loading and saving workbooks containing pivot tables.
The main issue with the previous internal structure was that it didn't align with the structure used by OOXML. This was problematic because we need to support all valid files. As a result, we have to handle a wide range of inputs and correctly convert them to our internal structure, which is rather hard. A more clear 1:1 mapping with OOXML is much simpler and more reliable.
The Autofilter feature has been revamped, which includes some API changes. Its behavior is now more closely aligned with how Excel operates. The XML documentation provides detailed explanations, and there is a dedicated documentation page. Several bugs have also been fixed.
For more details, refer to the Autofilter section of the migration guide.
When workbook is a valid one, ClosedXML shouldn't throw on load. That is a rather high priority (more than saving or manipulation). Unfortunately, that is hard to find such areas that cause most problems.
One of activities that was going in a background is trying to use excel files around the internet (found by CommonCrawl) to evaluate how bad it is. There aren't results yet, but it is something that is going on.
Full Changelog: 0.104.0-preview2...0.104.0-rc1
Second test release for checking SourceLink support on nuget (first failed due to fody/PDB checksum) #2070
Second test release for checking SourceLink support on nuget (first failed due to fody/PDB checksum) #2070
Test release for checking SourceLink support #2070
Test release for checking SourceLink support #2070
There won't be a non-beta release for 0.103. The production release will be 0.104, not 0.103. This milestone was about fixing technical debt, but ulti
There won't be a non-beta release for 0.103. The production release will be 0.104, not 0.103. This milestone was about fixing technical debt, but ultimately it needs some more time to mature before it is sent to the users.
There are some nice performance updates, so in spirit of release early, release often, there will be a beta package on nuget.
Rich text is now immutable behind the scenes (and will likely be turned into immutable in the future). It should be transparent to the user, though IXLPhonetic no longer has a setter for its IXLPhonetic.Text, IXLPhonetic.Start and IXLPhonetic.End properties.
New calculation engine just works in a different way and will behave differently.
The XLParser has been replaced with ClosedParser. The key benefits are
There is also a visualizer to display AST in a browser at https://parser.closedxml.io
In previous version, formulas used to be calculated recursively. Each formula checked it's supporting cells for other formulas and if there were some, they were recursively evaluated. There was some logic to decrease number of evaluations. That works for a very simple cases, but isn't very good for various non-happy paths (i.e. cells weren't calculated when they should be).
This version has replaced it with a standard
For more info, see docs, the Microsoft has a page about principles Excel Recalculation and there is one with API at docs.closedxml.io.
Internal structure has been cleaned up and optimized.
The dirty tracking has been moved out of cells to formulas and thus memory taken up by a single cell value is now only 16 bytes instead of 24 (?) bytes in 0.102. Of course there are some other structures around that take up memory as well, but the single cell value is now 16 bytes (I hoped for 8, but not feasible with double, DateTime and TimeSpan as possible cell values - all take up 8 bytes... not enough bits).
The same string in different instances is now not duplicated, but only one instance is used. As seen on following test, it can lead to significant decrease in memory consumption. 250k rows with 10 text rows (same string, different instance): 117 MiB om 0.103 vs 325 MiB in 0.102.1.
InsertData performanceInsert 250k rows of 10 columns of text and 5 columns of numbers (gist).
| Description | Rows | Columns | Time/Memory to insert data | Save workbook | Total time/memory |
|---|---|---|---|---|---|
| 0.103.0-beta | 250 000 | 15 | 1.619 sec / 117 MiB | 6.343 sec | 477 MiB |
| 0.102.1 | 250 000 | 15 | 7.160 sec / 325 MiB | 6.676 sec | 692 MiB |
Basically workbooks with a large amount of cells should see ~15%-20% speedup (as long as there are mainly values, not styles or OLAP metadata....).
Reading the 250k from previous chapter:
| Description | Rows | Columns | Time to load data | Used memory |
|---|---|---|---|---|
| 0.103.0-beta | 250 000 | 15 | 15.648 sec | 236 MiB |
| 0.102.1 | 250 000 | 15 | 20.460 sec | 329 MiB |
Full Changelog: https://github.com/ClosedXML/ClosedXML/compare/0.102.0...0.103.0-beta
Eliminate a couple of performance killers by @Pankraty in #2363
Full Changelog: 0.102.2...0.102.3
Add a warning about allowed ranges of DocumentFormat.OpenXML see issue #2220 and PR #2246 .
Add a warning about allowed ranges of DocumentFormat.OpenXML see issue #2220 and PR #2246.
Full Changelog: 0.102.1...0.102.2
SixLabors.Fonts has released version 1.0.0 and some NET Framework projects suddently have errors due to NuGet behavior.
SixLabors.Fonts has released version 1.0.0 and some NET Framework projects suddently have errors due to NuGet behavior.
If a project is consuming ClosedXML through package.config instead of PackageReference style projects, the NuGet will resolve version 1.0.0 instead of declared beta19 dependency. SixLabors.Fonts has API changes and thus it will start to throw MissingMethodExceptions.
The issue should only affect net framework projects, not dotnet core that use PackageReference style by default.
Full Changelog: https://github.com/ClosedXML/ClosedXML/compare/0.102.0...0.102.1
Suppress false positives from vulnerability checkers by @jahav in https://github.com/ClosedXML/ClosedXML/pull/2100
Please read migration guide from 0.101 to 0.102. The key ones changes are:
IXLCell is now a proxy to a sparse array and a new proxy is created each time it is requested by user code. Object.ReferenceEquals(ws.Cell("A1"), ws.Cell("A1")) now evaluates to false (used to be true)IXLWorksheet AddWorksheet(DataTable dataTable) and IXLWorksheet AddWorksheet(DataTable dataTable, string sheetName) now use different name for the created table.The cells in a workbook used to be stored in a Dictionary<int, Dictionary<XLCell>>. That has several significant drawbacks and the storage has been replaced with a sparse arrays of individual slices (basically a sparse array containing a specific part of a cell).
Key benefits (in long term):
Other than memory, it's a potential for the future. Replacing a storage engine is not simple and pretty much everything uses XLCell adapter.
An example of different for 500k rows of value only cells (gist). About 200MB vs 900MB.
Default graphic engine of ClosedXML now contains an embedded font. That should be a quality of life improvement for users on Linux and other non-Windows environment who encountered
Unable to find font font name or fallback font fallback font name. Install missing fonts or specify a different fallback font through ‘LoadOptions.DefaultGraphicEngine = new DefaultGraphicEngine(“Fallback font name”)’..
The embedded font is an absolute bare bones Carlito font (though with a different name to avoid collision with the real one).
See doc for workflow of font selection: https://closedxml.readthedocs.io/en/latest/features/graphic-engine.html#fallback-and-embedded-font
A basic support for array formulas has been added. You can create array formula through IXLRangeBase object.
csharp ws.Range("B2:D3").FormulaArrayA1 = "B1:D1*POWER(1+A2:A3, 2)";
For more info, see doc: https://closedxml.readthedocs.io/en/latest/features/formulas.html#array-formulas
The ancient PR from 2019 has been finally fixed and merged. It doesn't really add very useful features (multiple pivot tables don't have to have individual data store files in a xlsx file), but it is a big step to represent pivot cache data in a workbook. That is pretty much required to do anything useful with pivot tables.
The biggest visible improvement is that there is at least some very basic documentation about pivot tables https://closedxml.readthedocs.io/en/latest/features/pivot-tables.html
Some other OOXML producers (e.g. NPOI) don't add Normal style into a stylesheet and in 0.101 a feature had a missing null check leading to NullReferenceException.
Not really something that is useful at this moment, but there has been significant work done on a replacement of a XLParser (https://github.com/ClosedXML/ClosedXML.Parser).
I hope to be done with the Phase 1 of my maintainership - architecture and dependencies. Most of the "OMG, this must be done before anything else" has been done. I hope to finish the rest (split writers of individual files from 5000+LOC file, use better parser and use calculation chain for formula evaluation) in the next one.
Full Changelog: https://github.com/ClosedXML/ClosedXML/compare/0.101.0...0.102.0
Suppress false positives from vulnerability checkers by @jahav in https://github.com/ClosedXML/ClosedXML/pull/2100
The cells in a workbook used to be stored in a Dictionary<int, Dictionary<XLCell>>. That has several significant drawbacks and the storage has been replaced with a sparse arrays of individual slices (basically a sparse array containing a specific part of a cell).
Key benefits (in long term):
Other than memory, it's a potential for the future. Replacing a storage engine is not simple and pretty much everything uses XLCell adapter.
An example of different for 500k rows of value only cells (gist). About 200MB vs 900MB.
Default graphic engine of ClosedXML now contains an embedded font. That should be a quality of life improvement for users on Linux and other non-Windows environment who encountered
Unable to find font font name or fallback font fallback font name. Install missing fonts or specify a different fallback font through ‘LoadOptions.DefaultGraphicEngine = new DefaultGraphicEngine(“Fallback font name”)’..
The embedded font is an absolute bare bones Carlito font (though with a different name to avoid collision with the real one).
See doc for workflow of font selection: https://closedxml.readthedocs.io/en/latest/features/graphic-engine.html#fallback-and-embedded-font
A basic support for array formulas has been added. You can create array formula through IXLRangeBase object.
csharp ws.Range("B2:D3").FormulaArrayA1 = "B1:D1*POWER(1+A2:A3, 2)";
For more info, see doc: https://closedxml.readthedocs.io/en/latest/features/formulas.html#array-formulas
The ancient PR from 2019 has been finally fixed and merged. It doesn't really add very useful features (multiple pivot tables don't have to have individual data store files in a xlsx file), but it is a big step to represent pivot cache data in a workbook. That is pretty much required to do anything useful with pivot tables.
The biggest visible improvement is that there is at least some very basic documentation about pivot tables https://closedxml.readthedocs.io/en/latest/features/pivot-tables.html
Not really something that is useful at this moment, but there has been significant work done on a replacement of a XLParser (https://github.com/ClosedXML/ClosedXML.Parser).
I hope to be done with the Phase 1 of my maintainership - architecture and dependencies. Most of the "OMG, this must be done before anything else" has been done. I hope to finish the rest (split writers of individual files from 5000+LOC file, use better parser and use calculation chain for formula evaluation) in the next one.
Full Changelog: https://github.com/ClosedXML/ClosedXML/compare/0.101.0...0.102-rc
Other than some enums being changed from int to byte, and a new method on IXLGraphicEngine interface there should be no breaking changes in the releas…
Mostly speed improvements, but some cool and nifty improvements, see changelog below.
Other than some enums being changed from int to byte, and a new method on IXLGraphicEngine interface there should be no breaking changes in the release (see https://closedxml.readthedocs.io/en/latest/migrations/migrate-to-0.101.html).
Saving of cells in a worksheet has been significantly improved. As an example, a file of 100k rows and 44 columns (see gist) took 38 seconds to save in 0.100.3, but only 17 seconds in 0.101-rc .
Adjust to content has been refactored and it now calculates size of text by counting glyphs. Originally, we asked SixLabors.Fonts library to calculate it, but it is really slow (it has to deal with all possible typographic options, like having rtl and ltr text on same line).
It is faster to just use glyph size, plus I am pretty sure Excel also calculates width/height of a cell that way (likely legacy from earlier 90s version).
Time to run AdjustToContent using a sample of 1000 rows.
| Run# | 0.96.0 | 0.100.3 | 0.101-rc |
|---|---|---|---|
| 1 | 168 ms | 1203 ms | 1674 ms |
| 2 | 4 ms | 568 ms | 31 ms |
| 3 | 4 ms | 551 ms | 25 ms |
| 4 | 4 ms | 540 ms | 26 ms |
| 5 | 3 ms | 544 ms | 25 ms |
| 6 | 3 ms | 550 ms | 26 ms |
| 7 | 4 ms | 556 ms | 46 ms |
| 8 | 3 ms | 556 ms | 28 ms |
| 9 | 4 ms | 541 ms | 23 ms |
| 10 | 3 ms | 535 ms | 23 ms |
Full Changelog: https://github.com/ClosedXML/ClosedXML/compare/0.100.3...0.101.0
Other than some enums being changed from int to byte, and a new method on IXLGraphicEngine interface there should be no breaking changes in the releas…
Mostly speed improvements, but some cool and nifty improvements, see changelog below. Prod release will be 1 week after RC.
Other than some enums being changed from int to byte, and a new method on IXLGraphicEngine interface there should be no breaking changes in the release (see https://closedxml.readthedocs.io/en/latest/migrations/migrate-to-0.101.html).
Saving of cells in a worksheet has been significantly improved. As an example, a file of 100k rows and 44 columns (see gist) took 38 seconds to save in 0.100.3, but only 17 seconds in 0.101-rc .
Adjust to content has been refactored and it now calculates size of text by counting glyphs. Originally, we asked SixLabors.Fonts library to calculate it, but it is really slow (it has to deal with all possible typographic options, like having rtl and ltr text on same line).
It is faster to just use glyph size, plus I am pretty sure Excel also calculates width/height of a cell that way (likely legacy from earlier 90s version).
Time to run AdjustToContent using a sample of 1000 rows.
| Run# | 0.96.0 | 0.100.3 | 0.101-rc |
|---|---|---|---|
| 1 | 168 ms | 1203 ms | 1674 ms |
| 2 | 4 ms | 568 ms | 31 ms |
| 3 | 4 ms | 551 ms | 25 ms |
| 4 | 4 ms | 540 ms | 26 ms |
| 5 | 3 ms | 544 ms | 25 ms |
| 6 | 3 ms | 550 ms | 26 ms |
| 7 | 4 ms | 556 ms | 46 ms |
| 8 | 3 ms | 556 ms | 28 ms |
| 9 | 4 ms | 541 ms | 23 ms |
| 10 | 3 ms | 535 ms | 23 ms |
Full Changelog: https://github.com/ClosedXML/ClosedXML/compare/0.100.3...0.101.0
Fix a regression where some types of numbers were inserted as text by InsertData/InsertTable API.
Fix a regression where some types of numbers were inserted as text by InsertData/InsertTable API.
// Only int and double were inserted as numbers, now all types are
cell.InsertData(new object[] { (sbyte)1, (byte)2, (short)3, (ushort)4, (uint)6, (long)7, (ulong)8, 15f, 17m });
Full Changelog: https://github.com/ClosedXML/ClosedXML/compare/0.100.2...0.100.3
Second fix for https://github.com/ClosedXML/ClosedXML/releases/tag/0.100.0.
Second fix for https://github.com/ClosedXML/ClosedXML/releases/tag/0.100.0.
Added conversion for nullable numbers/DateTime/TimeSpan to XLCellValue. Null values will be converted to Blank.Value in the XLCellValue. There is no value in having user code littered by cell.Value = nullableNumber ?? Blank.Value.
Null strings assigned to XLCellValue will also be converted to Blank.Value (unlike exception from 0.100).
Full Changelog: https://github.com/ClosedXML/ClosedXML/compare/0.100.1...0.100.2
This is a quick improvement for https://github.com/ClosedXML/ClosedXML/releases/tag/0.100.0. It adds an implicit conversion for decimal numbers to XLC
This is a quick improvement for https://github.com/ClosedXML/ClosedXML/releases/tag/0.100.0.
It adds an implicit conversion for decimal numbers to XLCellValue, so users who generate workbooks with decimal number don't have to add explicit casting from decimal to double everywhere.
Full Changelog: https://github.com/ClosedXML/ClosedXML/compare/0.100.0...0.100.1
This is more like list of you should upgrade despite breaking changes :)
These are release notes for a version 0.100. We skipped a few version since the last release (0.97), because 0.100 should denote a major change at the very heart of ClosedXML. Not as clean break as I hoped, but close enough.
The list of all things that were changed from 0.97 to 0.100 is at the migration guide at the https://closedxml.readthedocs.io/en/latest/migrations/migrate-to-0.100.html
This is more like list of you should upgrade despite breaking changes :)
Memory consumption during saving of large data workbooks was significantly improved. Originally, ClosedXML workbook representation was converted to DocumentFomrat.OpenXML DOM representation and the DOM was then saved. Instead of creating whole DOM, sheet data (=cell values) are now directly streamed to the output file and aren't included in the DOM.
To demonstrate difference, see the before and after memory consumption of a report that generated 30 000 rows, 45 columns. Memory consumption has decreased from 2.08 GiB 🡆 0.8 GiB.
Save cells and strings through DOM: 2.08 GiB
Save cell and strings through streaming: 0.8 GiB
The purple area are bytes of uncompressed package zip stream.
IXLCell.Value and IXLCellValue.CachedValue have now type XLCellValue. At the core, xlsx consists of addressable cells with a functions that transform a set of values in source cells to different values in target cells. Is is really important to represent potential values of cells by a sane type. All other things, pivot tables, auto filter, graphs rely on this premise.
Cell value has been represented as string text and a value. The string depended on the value, e.g. 0/1 for boolean. That has been the case since the beginning of the ClosedXML project (see the original XLCell). The value was also returned as an Object.
This approach has several drawbacks
Object is not suitable representation of cell value. User had no idea what kind of values could be returned as a cell value. Everything could also break down, if a new type would be returned (e.g. XLError).IXLColumn.Value of a cell is not represented by a XLCellValue structure. It is basically a union of one of possible types that can be value of a cell:
Since datetime and duration are basically masqaraded number, you can use XLCellValue.GetUnifiedNumber() to get a backing number, no matter if the type is number, datetime and duration.
The structure contains implicit operators, as well as other methods to make transaction as seamless as possible
// Will use an implicit cast operator to convert string to XLCellValue and pass it to the Value setter
ws.Cell("A1").Value = "Text";
There is also a new singleton Blank.Value that represent a blank value of a cell. Null is not blank. Empty string is not a blank value of a cell. Null instead of blank was considered and everything is just so much easier to work with, if blank is represented as a custom singleton type and not as a null.
XLCellValue will be able to represent all values of a cell and won't be boxed/unboxed all the time.
ClosedXML used to guess a data type from a value. It caused all sort of unexpected behaviors (e.g. text value Z12.31 has been converted to date time 12/30/2022 19:00). Date caused most problems, but other sometimes too (e.g. text "Infinity" was detected as a number).
This behavior was likely intended to emulate how user interacts with an Excel. Excel guesses type, but only if the cell Number Format is set to "General" (e.g. if NumberFormat is set to Text, there is no conversion even in Excel). Application is not human and doesn't have to interact with xlsx in the same way.
This behavior was removed. Type that is set is the type that will be returned. Note that although XLCellValue can represent date and time as a different types, in reality that is only presentation logic for user. They are both just serial date time numbers.
Cell value now can accurately represent error or a blank value.
ClosedXML used to throw on error value and cell couldn't contain an error. That was a significant problem, especially for formula calculation where formula referenced a cell that should contain an error value.
ClosedXML used to represent blank cell as an empty string, but no longer. It uses Blank.Value singleton, wrapped in XLCellValue. Also brings significant improvement in accuracy for CalcEngine evaluation.
Excel has a pretty complicated undocumented coercion process from text to number. It can convert fraction text (="1 1/2"*2 is 3), dates (e.g. ="1900-01-05"*2 is 10, though date format is culture specific), percent (e.g. ="100%"*2), braces imply negative value (="(100%)"*2 = -2) and many more. That causes a significant problems for formula evaluation, especially if the source cell contains a date as a text, not as a date.
ClosedXml used to only convert test that looked like double, it now coerces nearly everything Excel does. Coercion from dates should mostly work, but Excel has it's own database of acceptable formats and it's own format, while we rely on .NET Core infrastructure.
Thanks to incorporation of XLError to core of CalcEngine, the exceptions are no longer necessary and have been removed. Error is a normal value type that is used during formula evaluation (e.g. ISNA accepts it and VLOOKUP returns it).
Technically speaking CalcEngine can still throw MissingContextException, but only if evaluation is not called from a cell, but from method like XLWorkbook.Evaluate. Functions like ROW just can't work without the context of the cell.
If you ever tried to use CalcEngine, you have encountered a dreaded The function *SomeFunctionwas not recognised. exception.
ClosedXML will no longer throw an exception on unimplemented function, but will return #NAME? error instead. It has several reasons
=SOME.UNKNOWN.FUN(4), why should it throw on =LARGE(A1:A5,1)?Basically, the exception doesn't bring any benefit and only imposes costs. User can report missing function on #NAME? error just like on exception.
CalcEngine now can evaluate array literal expressions, so formulas like VLOOKUP(4, {1,2; 3,2; 5,3; 7,4}, 2) now actually work.
Array processing is limited to argument parsing across formulas and CalcEngine still needs some love to process it work correctly. Array formulas are still not implemented.
Information and lookup functions were reimplemented to take advantage of other improvements. They should now be compliant with Excel (with exception of wildcard search for VLOOKUP).
Documentation is being moved from wiki to the ReadTheDocs. It has been there for since 2019, but we didn't actually had any documentation. Documentation is super important and ClosedXML lacks in that area. It is of course WIP, but it should improve over the time (see https://closedxml.readthedocs.io/en/latest/features/protect.html, https://closedxml.readthedocs.io/en/latest/features/cell-format.html#number-format or infamous https://closedxml.readthedocs.io/en/latest/tips/missing-font.html).
The move to ReadTheDocs has significant advantages:
We are not breaking the compatibility just because. Break imposes heavy penalty on users of the library. That makes it less likely to use it and that is definitely not the goal. Even the ClosedXML.Report must be fixed after every release.
That is not desirable situation. Version 1.0 and semantic versioning is certainly the goal. But it must be with an clear API that can endure some development between minor version. That is just not the case at the moment.
API will be reviewed along with the documentation and will be adjusted as necessary. ClosedXML will practice release early, release often. If breaking changes are not acceptable, stay on version that works and wait for 1.0 (though that will likely take at least a year, likely more... we are on a second decade).
Technically we do semver since forever, since Major version zero (0.y.z) is for initial development. Anything MAY change at any time. The public API SHOULD NOT be considered stable. ). Initial development for a decade /sigh.
Similar to current release, the general plan is to work on neglected foundational things and bug fixes.
It is likely there will be 0.100.x to fix whatever bugs XLCellValue caused that weren't convered by tests.
Pivot tables won't get any love in 0.101, but hopefully in the next one. It is one of distinguishing features of ClosedXML and it has a lot of reported issues.
Full Changelog: https://github.com/ClosedXML/ClosedXML/compare/0.97.0...0.100.0
We have removed a System.Drawing.Common dependency, it was deprecated and throws runtime exception when called on non-windows environments. All comple…
Project has been on hiatus for a while, but things are now moving forward. See full list of changes at https://github.com/ClosedXML/ClosedXML/milestone/17?closed=1
System.Common.Drawing were removed (use another overload):IXLPictures.AddPicture(Bitmap bitmap)IXLPictures.AddPicture(Bitmap bitmap, String name)IXLWorksheet.AddPicture(Bitmap bitmap)IXLWorksheet.AddPicture(Bitmap bitmap, string name)XLDataType.DateTime or XLDataType.TimeSpan. The DataType has to be set explicitely.We have removed a System.Drawing.Common dependency, it was deprecated and throws runtime exception when called on non-windows environments. All complexity has been hidden behind an interface IXLGraphicEngine and a default implementation DefaultGraphicEngine in the `ClosedXML.Graphics namespace. The default engine uses SixLabors.Fonts library for font measurements. You can read more on the Graphic Engine wiki page.
On non-windows environment, it will be necessary to specify a default font. Use this code
// All workbooks created later will use the engine with a fallback font DejaVu Sans
LoadOptions.DefaultGraphicsEngine = new DefaultGraphicEngine("DejaVu Sans"); // or Tahoma or any other font that is installed
ClosedXML has used a handcrafted parser for a while. The parse could parse a simple formulas, but a lot of features were out of its grasp (e.g. arrays, references to other worksheets, operations on references and so much more). We have replaced the original the original parser with the XLParser to facilitate a more powerful formulas.
You can try the parsing yourself on an online demo page: https://xlparser.perfectxl.nl/demo/
Through slower than the original parser, we are working with upstream to improve performance (https://github.com/spreadsheetlab/XLParser/issues/163, https://github.com/spreadsheetlab/XLParser/issues/161). Not-so-close future of CalcEngine is also multi threaded.
CalcEngine has been half-rewritten. It can now correctly represent all Excel types (e.g. Error is now a value, not an an exception) and perform operations on them (e.g. reference unions, comparisons work as they should).
As an example, SUM of two areas that overlap should count overlapping cells twice, thus the result should be 12, not 9.
using var wb = new XLWorkbook();
var ws = wb.AddWorksheet();
ws.Range(1, 1, 3, 3).SetValue(1);
var sum = ws.Evaluate("SUM((A1:B3,B1:C3))");
Console.WriteLine($"Result of a SUM function: {sum}");
Result of a SUM function: 12
A major change has been implicit intersections in the semantic of 2019 excel (Excel 2021 and 365 already support dynamic array formulas):
using var wb = new XLWorkbook();
var ws = wb.AddWorksheet();
ws.Cell("A1").SetValue(0);
ws.Cell("A2").SetValue(Math.PI / 4);
ws.Cell("A3").SetValue(Math.PI / 2);
var c1 = ws.Cell("C1");
c1.FormulaA1 = "SIN(A1:A3)";
var c2 = ws.Cell("C2");
c2.FormulaA1 = "SIN(A1:A3)";
var c3 = ws.Cell("C3");
c3.FormulaA1 = "SIN(A1:A3)";
Console.WriteLine($"C1: {c1.Value} C2: {c2.Value} C3: {c3.Value}");
C1: 0 C2: 0.7071067811865472 C3: 1
XLWorksheet.Evaluate functions now have an optional parameters to specify a context where is formula evaluated. If formula requires a context and it is missing, it will throw a MissingContextException.
using var wb = new XLWorkbook();
var ws = wb.AddWorksheet();
var row = ws.Evaluate("ROW()", "A3"); // Needs A3 for the context, otherwise MissingContextException
Console.WriteLine($"Result of a ROW function: {row}");
We have added a support for ROW and COLUMN functions. They even return arrays (e.g. formula ROW(A2:D4) return {2;3;4}) , though it is difficult to see due to half revamped of CalcEngine.
using var wb = new XLWorkbook();
var ws = wb.AddWorksheet();
var sum = ws.Evaluate("SUM(COLUMN(B1:D2))");
Console.WriteLine($"Result: {sum}");
Result: 9
We hope to make a release every few months. For the next release, the general plan is to work on neglected things before new features.
ClosedXML NuGet package is now signed. ClosedXML.Signed is deprecated. #1552
See full list of changes at: https://github.com/ClosedXML/ClosedXML/pulls?q=is%3Apr+milestone%3Av0.96+is%3Aclosed
IXLCell.Hyperlink removed; use GetHyperlink() to get an existing hyperlink or to create a new one if it does not exist; instead of property setter, use SetHyperlink(); to replace the existing hyperlink with a fresh one, use CreateHyperlink();IXLCell.DataValidation removed; use GetDataValidation();IXLCell.NewDataValidation removed; use CreateDataValidation();IXLCell.Comment removed; use GetComment() to access the existing comment or to create a new one if it does not exist; use CreateComment() to replace the existing comment with the fresh one;IXLCell.RichText removed; use GetRichText() to access the existing rich text or to create a new one if it does not exist; use CreateRichText() to replace the existing rich text with the fresh one.Nothing published for this version
Nothing published for this version
Nothing published for this version
## Bugs #1399 .CellsUsed() should return only cells with content.
#1399 .CellsUsed() should return only cells with content.
Range strings, e.g. A1:B2 are now always treated as absolute, i.e. relative to A1 instead of relative to the top left cell of a given range.
A1:B2 are now always treated as absolute, i.e. relative to A1 instead of relative to the top left cell of a given range.IXLSheetProtection has been totally refactored and now uses a flag based enum to control the elements that are allowed or locked.IXLSheetProtection.IsProtected setterXLClearOptions and XLCellUsedOptions 's flags are now alignedIXLDataValidation.Ranges made readonlyAddRange, AddRanges, ClearRanges, RemoveRange)#1063 Copy comment style correctly when shifting ranges #1108 Correctly save empty cell with quote prefix (do not treat as empty) #1125 Change cached value type when data type changes #1132 <c> elements with missing r attribute: XLAddress constructor had parameters swapped #1133 Enumerate ranges in a deterministic order #1134 Correctly propagate worksheet style to cells from a worksheet #1135 Correctly load column-wide styles #1137 Fix changing inner borders of the range #1150 Correctly clear inline string when required #1153 Correctly throw DivisionByZeroException when denominator is zero. #1155 Ignore _X (capital X) as XML escaping char #1161 Avoid creation of new item in Internals.RowsCollection when adding comment #1168 Fix initialization of default styles for XLCells, XLRows, XLColumns and XLRanges #1172 Clear all RelId's if workbook is loaded from template. #1178 Fixes in GetHashCode functions (#1073) #1196 Fix error by two pivot with one source #1195 #1223 Fix pivot subtotals loading #1234 Merged ranges cell values should not be set, except for top left cell of merged range #1245 Fix the issue with conditional formats created in non-US culture (#1187) #1247 Fix issues related to cells inserting (#1236) #1266 Fix CONCATENATE for cell references #1282 Treat missing numberFormatId as General numberformat #1289 Remove unused code and fix ATAN2 tests #1292 Redefine rules for sheet name escaping (#1287) #1307 Fix null exception when saving a file #1316 Fix exception when loading rows with no row index populated (#1314) #1323 #651: fix loading with deleted worksheets. #1351 Fix null DateTime in XLCell.InsertDataInternal with IEnumerable #1356 Fix a regular expression used for extracting A1 references #1359 Fixed the Expression double conversion operator to handle string values #1362 Set longText attribute for string items in pivot table #1369 Fix issues with loading comments (#1244) #1384 When saving, mark the first selected tab as active if no active tabs exist (#1383) #1386 Set the first sheet active and visible on loading if no active tab is specified in file (#1383)
#1015 Implement TEXTJOIN function (#1010) #1038 IXLSheetProtection refactoring #1054 Implement workbook FileSharing and a few of the properties #1058 Don't recalculate formula cached values after load #1077 Refactor digit and letter parsing to allow Unicode characters #1109 Don't automatically adjust columns width to contents when inserting datatable. Some users want to opt out because of PlatformNotSupportedException #1122 Add helper methods to add worksheet with default sheet name #1129 Alternative implementation of pivot table formats #1130 Enhance TRUNC function for additional parameter #1136 Implement NUMBERVALUE function #1151 Performance improvement to delete entire columns #1158 Check that print titles are valid row ranges or column ranges #1166 Ignore default Excel function namespace and implement CONCAT function #1169 Avoid creating new XLCell instances during range shifting #1170 Remove IXLSheetProtection.IsProtected public setter #1174 Correctly dispose temporary memorystream #1175 Sparklines implementation #1183 Improve Merge operation performance #1194 Disallow table name that is also a valid address (#1192) #1205 Improve performance of worksheet copying (#1188) #1208 optional range consolidation via save options #1219 Implement MATCH and INDEX functions #1224 Improve performance of loading workbooks having many merged ranges (#1220) #1227 Refactor comments #1232 Set versioning number to allow enhanced pivot table features #1237 Improve HLOOKUP and VLOOKUP performance #1240 Prevent copying of deleted worksheets. #1253 Replace licenseUrl (deprecated) with license tag #1278 Clear CellsCollection on WorksheetInternals disposal (#1276) #1284 Improvements for workbook saving (#1280) #1293 Remove the unnecessary check for VML elements not existing (#1285) #1326 PopulateAutoFilter range check (#1325) #1353 Implement % operator and correctly parse expressions with multiple unary operators (--, ++) #1357 Replace String.Compare with TryGetValue #1364 Fix issues occurred when running tests on .Net Core 3.0 #1368 Clear inlined rich text data on saving (#1361) #1376 CEILING and FLOOR fixes #1379 Explicitly set document type on saving (#1375) #1381 Exclude dependent SUBTOTAL formulas in SUBTOTAL evaluation #1388 Remove the dependency on FastMember. Improve performance of InsertData (#797) #1391 Replace ContainsKey with TryGetValue
Nothing published for this version
Range strings, e.g. A1:B2 are now always treated as absolute, i.e. relative to A1 instead of relative to the top left cell of a given range.
A1:B2 are now always treated as absolute, i.e. relative to A1 instead of relative to the top left cell of a given range.IXLSheetProtection has been totally refactored and now uses a flag based enum to control the elements that are allowed or locked.IXLSheetProtection.IsProtected setterXLClearOptions and XLCellUsedOptions 's flags are now alignedIXLSheetProtection refactoringPlatformNotSupportedExceptionTRUNC function for additional parameterNUMBERVALUE functionIXLSheetProtection.IsProtected public setter<c> elements with missing r attribute: XLAddress constructor had parameters swappedDivisionByZeroException when denominator is zero._X (capital X) as XML escaping charInternals.RowsCollection when adding commentXLCells, XLRows, XLColumns and XLRangesThanks to @Pankraty for many PRs, as usual.
Binaries are available at:
ClosedXML: https://ci.appveyor.com/project/ClosedXML/closedxml/builds/23591647/job/dyitdjnq6ta3nnpb/artifacts
ClosedXML.Signed: https://ci.appveyor.com/project/ClosedXML/closedxml/builds/23591647/job/hk6hbr6kt807lvxf/artifacts
Also see the release notes for v0.94.0
Also see the release notes for v0.94.0
Nothing published for this version
This unsigned ClosedXML package now depends on FastMember instead of FastMember.Signed. The signed ClosedXML.Signed still depends on FastMember.Signed
ClosedXML package now depends on FastMember instead of FastMember.Signed. The signed ClosedXML.Signed still depends on FastMember.Signed.IDisposable interface removed from IXLWorksheet. See #1049IXLPictures interface has changed to accept parameters of type IXLCell instead of IXLAddress. See #930IXLBaseAutoFilter removed and replaced with the existing IXLAutoFilter. See #909IXLRange.ToString() and IXLRangeAddress.ToString() now return context aware range strings. See #1021VisibleRows for autofilters.DataRange when savingGuid values to be inserted when dumping dataIXLTables.TryGetTable()XLCell.TryGetValue and implement additional testsTryGetValue_decimal_Good2test environment-independentXLPivotField.ShowBlankItems by default to false and fix treatment of defaults from loading fileXLConditionalFormat equality comparer fails for ColorScaleRelId default to nullCellsUsed refactoring and fixThe ClosedXML NuGet package now depends on FastMember instead of FastMember.Signed. The ClosedXML.Signed NuGet package still depends on FastMember.Sig
FastMember instead of FastMember.Signed. The ClosedXML.Signed NuGet package still depends on FastMember.Signed.IDisposable interface removed from IXLWorksheet. See #1049IXLPictures interface has changed to accept parameters of type IXLCell instead of IXLAddress. See #930IXLBaseAutoFilter removed and replaced with the existing IXLAutoFilter. See #909IXLRange.ToString() and IXLRangeAddress.ToString() now return context aware range strings. See #1021VisibleRows for autofilters.DataRange when savingGuid values to be inserted when dumping dataIXLTables.TryGetTable()XLCell.TryGetValue and implement additional testsTryGetValue_decimal_Good2test environment-independentXLPivotField.ShowBlankItems by default to false and fix treatment of defaults from loading fileXLConditionalFormat equality comparer fails for ColorScaleRelId default to nullCellsUsed refactoring and fixIDisposable interface removed from IXLWorksheet. See #1049
IDisposable interface removed from IXLWorksheet. See #1049IXLPictures interface has changed to accept parameters of type IXLCell instead of IXLAddress. See #930IXLBaseAutoFilter removed and replaced with the existing IXLAutoFilter. See #909IXLRange.ToString() and IXLRangeAddress.ToString() now return context aware range strings. See #1021VisibleRows for autofilters.DataRange when savingGuid values to be inserted when dumping dataIXLTables.TryGetTable()XLCell.TryGetValue and implement additional testsTryGetValue_decimal_Good2test environment-independentXLPivotField.ShowBlankItems by default to false and fix treatment of defaults from loading fileXLConditionalFormat equality comparer fails for ColorScaleRelId default to nullCellsUsed refactoring and fix- #925 : Fix determining the column letter by index - #950 : Fix loading transparent fill - #952 : Fix saving alignment
Big internal refactoring to reduce memory consumption.
A big thank you to @Pankraty for the work he's done on implementing the style and range repositories.
ClosedXML if you don't require a signed version. Use ClosedXML.Signed if you require a signed version (strong name).IXLWorkbook.RecalculateAllFormulas if you get unexpected results.IXLCell.ValueCached is now obsolete. Use IXLCell.CachedValue rather.TableStyleMedium2 (as Excel does)XLAddress and XLRangeAddress is now immutable. Use ws.Cell(.., ..).Address and ws.Range(..).RangeAddress to get instances.IDisposable interface removed from many classes, e.g from IXLRange..ForEach method..SetValue() to a date that's lower than the base date will throw an ArgumentException.IXLConditionalFormat instances. Use the new IXLConditionalFormat.Ranges) (plural) method to retrieve all ranges. IXLConditionalFormat.Range (singular) will return only the first range.Big internal refactoring to reduce memory consumption.
A big thank you to @Pankraty for the work he's done on implementing the style and range repositories.
ClosedXML if you don't require a signed version. Use ClosedXML.Signed if you require a signed version (strong name).IXLWorkbook.RecalculateAllFormulas if you get unexpected results.IXLCell.ValueCached is now obsolete. Use IXLCell.CachedValue rather.TableStyleMedium2 (as Excel does)XLAddress and XLRangeAddress is now immutable. Use ws.Cell(.., ..).Address and ws.Range(..).RangeAddress to get instances.IDisposable interface removed from many classes, e.g from IXLRange..ForEach method..SetValue() to a date that's lower than the base date will throw an ArgumentException.IXLConditionalFormat instances. Use the new IXLConditionalFormat.Ranges) (plural) method to retrieve all ranges. IXLConditionalFormat.Range (singular) will return only the first range.Big internal refactoring to reduce memory consumption.
A big thank you to @Pankraty for the work he's done on implementing the style and range repositories.
ClosedXML if you don't require a signed version. Use ClosedXML.Signed if you require a signed version (strong name).IXLWorkbook.RecalculateAllFormulas if you get unexpected results.IXLCell.ValueCached is now obsolete. Use IXLCell.CachedValue rather.TableStyleMedium2 (as Excel does)XLAddress and XLRangeAddress is now immutable. Use ws.Cell(.., ..).Address and ws.Range(..).RangeAddress to get instances.IDisposable interface removed from many classes, e.g from IXLRange..ForEach method..SetValue() to a date that's lower than the base date will throw an ArgumentException.IXLConditionalFormat instances. Use the new IXLConditionalFormat.Ranges) (plural) method to retrieve all ranges. IXLConditionalFormat.Range (singular) will return only the first range.Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Big thanks to @Pankraty for a lot of hard work. Many optimisations went into this build. ClosedXML should be much faster than previously.
Big thanks to @Pankraty for a lot of hard work. Many optimisations went into this build. ClosedXML should be much faster than previously.
Big thanks to @Pankraty for a lot of hard work. Many optimisations went into this build. ClosedXML should be much faster than previously.
Big thanks to @Pankraty for a lot of hard work. Many optimisations went into this build. ClosedXML should be much faster than previously.
Identical to https://github.com/ClosedXML/ClosedXML/releases/tag/0.91.0, but with updated reference to FastMember.Signed v1.3.0.
Identical to https://github.com/ClosedXML/ClosedXML/releases/tag/0.91.0, but with updated reference to FastMember.Signed v1.3.0.
Breaking change: XLCellValues enum has been renamed to XLDataType.
Breaking change: XLCellValues enum has been renamed to XLDataType.
e63fa4e
Breaking change: XLCellValues enum has been renamed to XLDataType .
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
## Change Log ### 0.89.0 (2017/09/09 16:04 +00:00) - #477 Merge pull request #477 from igitur/issue476-unhide-sheet (@igitur) - #467 Merge pull reques
### 0.89.0-beta1 (2017/08/23 17:49 +00:00) - #443 Merge pull request #443 from igitur/optimize-calcchain-generation (@igitur) - #455 Merge pull reques
https://github.com/ClosedXML/ClosedXML/pulls?utf8=%E2%9C%93&q=is%3Apr%20milestone%3Av0.88
https://github.com/ClosedXML/ClosedXML/pulls?utf8=%E2%9C%93&q=is%3Apr%20milestone%3Av0.88
Nothing published for this version
Nothing published for this version
One column per quarter.