Upgrade to .NET 8.0 and refactor input value extraction

.github/workflows/dotnet.yml

@@ -16,7 +16,7 @@ jobs:
     - name: Setup .NET
       uses: actions/setup-dotnet@v1
       with:
-        dotnet-version: 6.0.x
+        dotnet-version: 8.0.x
     - name: Restore dependencies
       run: dotnet restore
       env:

.gitignore

@@ -395,6 +395,7 @@ FodyWeavers.xsd
 *.msp
 
 # JetBrains Rider
+.idea/
 *.sln.iml
 
 /BenchmarkDotNet.Artifacts

src/MiniExcel/ExcelFactory.cs

@@ -2,6 +2,7 @@
 {
     using MiniExcelLibs.Csv;
     using MiniExcelLibs.OpenXml;
+    using MiniExcelLibs.OpenXml.SaveByTemplate;
     using System;
     using System.IO;
 

src/MiniExcel/MiniExcelLibs.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
 	<PropertyGroup>
-		<TargetFrameworks>net45;netstandard2.0;net6.0;</TargetFrameworks>
+		<TargetFrameworks>net45;netstandard2.0;net8.0;</TargetFrameworks>
 		<Version>1.34.2</Version>
 	</PropertyGroup>
 	<PropertyGroup>

src/MiniExcel/OpenXml/ExcelOpenXmlTemplate.Impl.cs → src/MiniExcel/SaveByTemplate/ExcelOpenXmlTemplate.Impl.cs

@@ -12,7 +12,7 @@
 using System.Text.RegularExpressions;
 using System.Xml;
 
-namespace MiniExcelLibs.OpenXml
+namespace MiniExcelLibs.OpenXml.SaveByTemplate
 {
     internal partial class ExcelOpenXmlTemplate
     {
@@ -113,7 +113,7 @@ public string ToXmlString(string prefix)
         public List<XMergeCell> NewXMergeCellInfos { get; private set; }
 
         private void GenerateSheetXmlImpl(ZipArchiveEntry sheetZipEntry, Stream stream, Stream sheetStream,
-            Dictionary<string, object> inputMaps, IDictionary<int, string> sharedStrings,
+            IDictionary<string, object> inputMaps, IDictionary<int, string> sharedStrings,
             bool mergeCells = false)
         {
             var doc = new XmlDocument();
@@ -911,7 +911,7 @@ private void ReplaceSharedStringsToStr(IDictionary<int, string> sharedStrings, r
             }
         }
 
-        private void UpdateDimensionAndGetRowsInfo(Dictionary<string, object> inputMaps, ref XmlDocument doc, ref XmlNodeList rows, bool changeRowIndex = true)
+        private void UpdateDimensionAndGetRowsInfo(IDictionary<string, object> inputMaps, ref XmlDocument doc, ref XmlNodeList rows, bool changeRowIndex = true)
         {
             // note : dimension need to put on the top ![image](https://user-images.githubusercontent.com/12729184/114507911-5dd88400-9c66-11eb-94c6-82ed7bdb5aab.png)
 

src/MiniExcel/OpenXml/ExcelOpenXmlTemplate.MergeCells.cs → src/MiniExcel/SaveByTemplate/ExcelOpenXmlTemplate.MergeCells.cs

@@ -9,7 +9,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace MiniExcelLibs.OpenXml
+namespace MiniExcelLibs.OpenXml.SaveByTemplate
 {
     internal partial class ExcelOpenXmlTemplate
     {

src/MiniExcel/SaveByTemplate/ExcelOpenXmlTemplate.cs

@@ -0,0 +1,124 @@
+namespace MiniExcelLibs.OpenXml.SaveByTemplate
+{
+    using MiniExcelLibs.Utils;
+    using MiniExcelLibs.Zip;
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.IO.Compression;
+    using System.Linq;
+    using System.Text;
+    using System.Text.RegularExpressions;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using System.Xml;
+
+    internal partial class ExcelOpenXmlTemplate : IExcelTemplate, IExcelTemplateAsync
+    {
+        private static readonly XmlNamespaceManager _ns;
+        private static readonly Regex _isExpressionRegex;
+
+        static ExcelOpenXmlTemplate()
+        {
+            _isExpressionRegex = new Regex("(?<={{).*?(?=}})");
+            _ns = new XmlNamespaceManager(new NameTable());
+            _ns.AddNamespace("x", Config.SpreadsheetmlXmlns);
+            _ns.AddNamespace("x14ac", Config.SpreadsheetmlXml_x14ac);
+        }
+
+        private readonly Stream _stream;
+        private readonly OpenXmlConfiguration _configuration;
+        private readonly StringBuilder _calcChainContent = new StringBuilder();
+
+        public ExcelOpenXmlTemplate(Stream stream, IConfiguration configuration)
+        {
+            _stream = stream;
+            _configuration = (OpenXmlConfiguration)configuration ?? OpenXmlConfiguration.DefaultConfig;
+        }
+
+        public void SaveAsByTemplate(string templatePath, object value)
+        {
+            using (var stream = FileHelper.OpenSharedRead(templatePath))
+                SaveAsByTemplateImpl(stream, value);
+        }
+
+        public void SaveAsByTemplate(byte[] templateBtyes, object value)
+        {
+            using (Stream stream = new MemoryStream(templateBtyes))
+                SaveAsByTemplateImpl(stream, value);
+        }
+
+        public void SaveAsByTemplateImpl(Stream templateStream, object value)
+        {
+            //only support xlsx
+            templateStream.CopyTo(_stream);
+
+            var reader = new ExcelOpenXmlSheetReader(_stream, null);
+            var _archive = new ExcelOpenXmlZip(_stream, mode: ZipArchiveMode.Update, true, Encoding.UTF8);
+            {
+                //read sharedString
+                var sharedStrings = reader._sharedStrings;
+                StringBuilder calcSheetContent = new StringBuilder();
+
+                //read all xlsx sheets
+                var sheets = _archive.zipFile.Entries.Where(w =>
+                    w.FullName.StartsWith("xl/worksheets/sheet", StringComparison.OrdinalIgnoreCase)
+                    || w.FullName.StartsWith("/xl/worksheets/sheet", StringComparison.OrdinalIgnoreCase)
+                ).ToList();
+
+                int sheetIdx = 0;
+                foreach (var sheet in sheets)
+                {
+                    this.XRowInfos =
+                        new List<XRowInfo>(); //every time need to use new XRowInfos or it'll cause duplicate problem: https://user-images.githubusercontent.com/12729184/115003101-0fcab700-9ed8-11eb-9151-ca4d7b86d59e.png
+                    this.XMergeCellInfos = new Dictionary<string, XMergeCell>();
+                    this.NewXMergeCellInfos = new List<XMergeCell>();
+
+                    var sheetStream = sheet.Open();
+                    var fullName = sheet.FullName;
+
+                    ZipArchiveEntry entry = _archive.zipFile.CreateEntry(fullName);
+                    using (var zipStream = entry.Open())
+                    {
+                        GenerateSheetXmlImpl(sheet, zipStream, sheetStream,
+                            InputValueExtractor.ToValueDictionary(value), sharedStrings, false);
+                        //doc.Save(zipStream); //don't do it because : ![image](https://user-images.githubusercontent.com/12729184/114361127-61a5d100-9ba8-11eb-9bb9-34f076ee28a2.png)
+                    }
+
+                    // disposing writer disposes streams as well. reopen the entry to read and parse calc functions
+                    using (var filledStream = entry.Open())
+                    {
+                        sheetIdx++;
+                        _calcChainContent.Append(CalcChainHelper.GetCalcChainContent(CalcChainCellRefs, sheetIdx));
+                    }
+                }
+
+                var calcChain = _archive.zipFile.Entries.FirstOrDefault(e => e.FullName.Contains("xl/calcChain.xml"));
+                if (calcChain != null)
+                {
+                    string calcChainPathname = calcChain.FullName;
+                    calcChain.Delete();
+                    var calcChainEntry = _archive.zipFile.CreateEntry(calcChainPathname);
+                    using (var calcChainStream = calcChainEntry.Open())
+                    {
+                        CalcChainHelper.GenerateCalcChainSheet(calcChainStream, _calcChainContent.ToString());
+                    }
+                }
+            }
+
+            _archive.zipFile.Dispose();
+        }
+
+        public Task SaveAsByTemplateAsync(string templatePath, object value,
+            CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return Task.Run(() => SaveAsByTemplate(templatePath, value), cancellationToken);
+        }
+
+        public Task SaveAsByTemplateAsync(byte[] templateBtyes, object value,
+            CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return Task.Run(() => SaveAsByTemplate(templateBtyes, value), cancellationToken);
+        }
+    }
+}

src/MiniExcel/SaveByTemplate/InputValueExtractor.cs

@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Reflection;
+using MiniExcelLibs.Utils;
+
+namespace MiniExcelLibs.OpenXml.SaveByTemplate
+{
+    public static class InputValueExtractor
+    {
+        public static IDictionary<string, object> ToValueDictionary(object valueObject)
+            => valueObject is Dictionary<string, object> valueDictionary
+                ? GetValuesFromDictionary(valueDictionary)
+                : GetValuesFromObject(valueObject);
+
+        private static IDictionary<string, object> GetValuesFromDictionary(Dictionary<string, object> valueDictionary)
+        {
+            return valueDictionary
+                .ToDictionary(
+                    x => x.Key,
+                    x => x.Value is IDataReader dataReader
+                        ? TypeHelper.ConvertToEnumerableDictionary(dataReader).ToList()
+                        : x.Value);
+        }
+
+        private static IDictionary<string, object> GetValuesFromObject(object valueObject)
+        {
+            var type = valueObject.GetType();
+
+            var propertyValues = type
+                .GetProperties(BindingFlags.Public | BindingFlags.Instance)
+                .Select(property => new { property.Name, Value = property.GetValue(valueObject) });
+
+            var fieldValues = type
+                .GetFields(BindingFlags.Public | BindingFlags.Instance)
+                .Select(field => new { field.Name, Value = field.GetValue(valueObject) });
+
+            return propertyValues
+                .Concat(fieldValues)
+                .ToDictionary(x => x.Name, x => x.Value);
+        }
+    }
+}