Refactor ExcelService and optimize PDFService export

Removed IStringLocalizer from ExcelService and added helper methods for cell styling and value conversion. Rewrote template, export, and import methods for clarity, type safety, and improved error handling. In PDFService, optimized column width calculation and row rendering by pre-evaluating mapper values and simplifying loops. Improved code readability and performance.

Author: neozhu

src/Infrastructure/Services/ExcelService.cs

@@ -3,165 +3,226 @@
 
 using System.Data;
 using ClosedXML.Excel;
-using Microsoft.Extensions.Localization;
 
 namespace CleanArchitecture.Blazor.Infrastructure.Services;
 
 public class ExcelService : IExcelService
 {
-    private readonly IStringLocalizer<ExcelService> _localizer;
+    public ExcelService()
+    {
+    }
 
-    public ExcelService(IStringLocalizer<ExcelService> localizer)
+    /// <summary>
+    /// Applies the header cell style.
+    /// </summary>
+    /// <param name="cell">The cell to style.</param>
+    private void ApplyHeaderStyle(IXLCell cell)
     {
-        _localizer = localizer;
+        var style = cell.Style;
+        style.Fill.PatternType = XLFillPatternValues.Solid;
+        style.Fill.BackgroundColor = XLColor.LightBlue;
+        style.Border.BottomBorder = XLBorderStyleValues.Thin;
     }
 
-    public Task<byte[]> CreateTemplateAsync(IEnumerable<string> fields, string sheetName = "Sheet1")
+    /// <summary>
+    /// Converts a CLR value to an <see cref="XLCellValue"/> that preserves the
+    /// native Excel type (Number, Boolean, DateTime, TimeSpan) instead of
+    /// falling back to a string representation.
+    /// </summary>
+    private static XLCellValue ConvertToXLCellValue(object? value)
     {
-        using (var workbook = new XLWorkbook())
+        return value switch
         {
-            workbook.Properties.Author = "";
-            var ws = workbook.Worksheets.Add(sheetName);
-            var colIndex = 1;
-            var rowIndex = 1;
-            foreach (var header in fields)
-            {
-                var cell = ws.Cell(rowIndex, colIndex);
-                var style = cell.Style;
-                style.Fill.PatternType = XLFillPatternValues.Solid;
-                style.Fill.BackgroundColor = XLColor.LightBlue;
-                style.Border.BottomBorder = XLBorderStyleValues.Thin;
+            null => Blank.Value,
+            bool b => b,
+            DateTime dt => dt,
+            DateTimeOffset dto => dto.DateTime,
+            TimeSpan ts => ts,
+            byte n => n,
+            sbyte n => n,
+            short n => n,
+            ushort n => n,
+            int n => n,
+            uint n => n,
+            long n => n,
+            ulong n => (double)n,
+            float n => n,
+            double n => n,
+            decimal n => (double)n,
+            string s => s,
+            _ => value.ToString() ?? string.Empty
+        };
+    }
 
-                cell.Value = header;
+    /// <summary>
+    /// Converts an <see cref="IXLCell"/> to its native CLR value based on
+    /// <see cref="XLDataType"/>, so that <see cref="DataRow"/> consumers
+    /// receive properly typed values instead of plain strings.
+    /// Numbers are returned as <see cref="decimal"/> to preserve precision
+    /// when downstream code converts to <c>int</c>, <c>decimal</c>, etc.
+    /// via <see cref="Convert.ChangeType(object, Type)"/>.
+    /// </summary>
+    private static object ConvertFromXLCell(IXLCell cell)
+    {
+        return cell.DataType switch
+        {
+            XLDataType.Blank => DBNull.Value,
+            XLDataType.Boolean => cell.GetBoolean(),
+            XLDataType.Number => (decimal)cell.GetDouble(),
+            XLDataType.DateTime => cell.GetDateTime(),
+            XLDataType.TimeSpan => cell.GetTimeSpan(),
+            XLDataType.Text => cell.GetString(),
+            _ => cell.Value.ToString()
+        };
+    }
 
-                colIndex++;
-            }
+    /// <summary>
+    /// Saves the given workbook to a byte array.
+    /// </summary>
+    /// <param name="workbook">The workbook to save.</param>
+    /// <returns>A byte array representing the workbook.</returns>
+    private static byte[] SaveWorkbookToByteArray(XLWorkbook workbook)
+    {
+        using var stream = new MemoryStream();
+        workbook.SaveAs(stream);
+        stream.Seek(0, SeekOrigin.Begin);
+        return stream.ToArray();
+    }
 
-            using (var stream = new MemoryStream())
-            {
-                workbook.SaveAs(stream);
-                stream.Seek(0, SeekOrigin.Begin);
-                return Task.FromResult(stream.ToArray());
-            }
+    public Task<byte[]> CreateTemplateAsync(IEnumerable<string> fields, string sheetName = "Sheet1")
+    {
+        using var workbook = new XLWorkbook();
+        workbook.Properties.Author = string.Empty;
+        var ws = workbook.Worksheets.Add(sheetName);
+        int rowIndex = 1;
+        int colIndex = 1;
+        foreach (var header in fields)
+        {
+            var cell = ws.Cell(rowIndex, colIndex++);
+            ApplyHeaderStyle(cell);
+            cell.Value = header;
         }
+
+        return Task.FromResult(SaveWorkbookToByteArray(workbook));
     }
 
     public Task<byte[]> ExportAsync<TData>(IEnumerable<TData> data, Dictionary<string, Func<TData, object?>> mappers, string sheetName = "Sheet1")
     {
-        using (var workbook = new XLWorkbook())
+        using var workbook = new XLWorkbook();
+        workbook.Properties.Author = string.Empty;
+        var ws = workbook.Worksheets.Add(sheetName);
+        int rowIndex = 1;
+        int colIndex = 1;
+        var headers = mappers.Keys.ToList();
+
+        // Write header row
+        foreach (var header in headers)
         {
-            workbook.Properties.Author = "";
-            var ws = workbook.Worksheets.Add(sheetName);
-            var colIndex = 1;
-            var rowIndex = 1;
-            var headers = mappers.Keys.ToList();
-            foreach (var header in headers)
-            {
-                var cell = ws.Cell(rowIndex, colIndex);
-                var style = cell.Style;
-                style.Fill.PatternType = XLFillPatternValues.Solid;
-                style.Fill.BackgroundColor = XLColor.LightBlue;
-                style.Border.BottomBorder = XLBorderStyleValues.Thin;
-
-                cell.Value = header;
-
-                colIndex++;
-            }
-
-            var dataList = data.ToList();
-            foreach (var item in dataList)
-            {
-                colIndex = 1;
-                rowIndex++;
-
-                var result = headers.Select(header => mappers[header](item));
+            var cell = ws.Cell(rowIndex, colIndex++);
+            ApplyHeaderStyle(cell);
+            cell.Value = header;
+        }
 
-                foreach (var value in result)
-                {
-                    ws.Cell(rowIndex, colIndex).Value = value == null ? Blank.Value : value.ToString();
-                    colIndex++;
-                }
-            }
+        // Write data rows
+        var dataList = data.ToList();
+        foreach (var item in dataList)
+        {
+            colIndex = 1;
+            rowIndex++;
 
-            using (var stream = new MemoryStream())
+            foreach (var header in headers)
             {
-                workbook.SaveAs(stream);
-                stream.Seek(0, SeekOrigin.Begin);
-                return Task.FromResult(stream.ToArray());
+                var value = mappers[header](item);
+                var cell = ws.Cell(rowIndex, colIndex++);
+                cell.Value = ConvertToXLCellValue(value);
             }
         }
+
+        return Task.FromResult(SaveWorkbookToByteArray(workbook));
     }
 
-    public async Task<IResult<IEnumerable<TEntity>>> ImportAsync<TEntity>(byte[] data, Dictionary<string, Func<DataRow, TEntity, object?>> mappers, string sheetName = "Sheet1")
+    public async Task<IResult<IEnumerable<TEntity>>> ImportAsync<TEntity>(
+        byte[] data,
+        Dictionary<string, Func<DataRow, TEntity, object?>> mappers,
+        string sheetName = "Sheet1")
     {
-        using (var workbook = new XLWorkbook(new MemoryStream(data)))
+        using var workbook = new XLWorkbook(new MemoryStream(data));
+        if (!workbook.Worksheets.TryGetWorksheet(sheetName, out var ws))
         {
-            if (!workbook.Worksheets.TryGetWorksheet(sheetName, out var ws))
-            {
-                return await Result<IEnumerable<TEntity>>.FailureAsync(string.Format(_localizer["Sheet with name {0} does not exist!"], sheetName));
-            }
-
-            var dt = new DataTable();
-            var titlesInFirstRow = true;
-
-            foreach (var firstRowCell in ws.Range(1, 1, 1, ws.LastCellUsed().Address.ColumnNumber).Cells())
+            ws = workbook.Worksheets.Count > 0 ? workbook.Worksheets.First() : null;
+            if (ws is null)
             {
-                dt.Columns.Add(titlesInFirstRow ? firstRowCell.GetString() : $"Column {firstRowCell.Address.ColumnNumber}");
+                return await Result<IEnumerable<TEntity>>.FailureAsync("Workbook contains no worksheets.");
             }
+        }
 
-            var startRow = titlesInFirstRow ? 2 : 1;
-            var headers = mappers.Keys.ToList();
-            var errors = new List<string>();
+        // Check if the worksheet contains any cells.
+        var lastCellUsed = ws.LastCellUsed()?.Address.ColumnNumber ?? 0;
+        if (lastCellUsed == 0)
+        {
+            var msg = $"Sheet with name {sheetName} is empty!";
+            return await Result<IEnumerable<TEntity>>.FailureAsync(msg);
+        }
 
-            foreach (var header in headers)
-            {
-                if (!dt.Columns.Contains(header))
-                {
-                    errors.Add(string.Format(_localizer["Header '{0}' does not exist in table!"], header));
-                }
-            }
+        // Create a DataTable from the header row.
+        var dt = new DataTable();
+        bool titlesInFirstRow = true;
+        foreach (var cell in ws.Range(1, 1, 1, lastCellUsed).Cells())
+        {
+            string colName = titlesInFirstRow ? cell.GetString() : $"Column {cell.Address.ColumnNumber}";
+            dt.Columns.Add(colName, typeof(object));
+        }
+        int startRow = titlesInFirstRow ? 2 : 1;
 
-            if (errors.Any())
+        // Validate that all expected headers exist.
+        var headers = mappers.Keys.ToList();
+        var errors = new List<string>();
+        foreach (var header in headers)
+        {
+            if (!dt.Columns.Contains(header))
             {
-                return await Result<IEnumerable<TEntity>>.FailureAsync(errors.ToArray());
+                errors.Add($"Header '{header}' does not exist in table!");
             }
+        }
+        if (errors.Any())
+        {
+            return await Result<IEnumerable<TEntity>>.FailureAsync(errors.ToArray());
+        }
 
-            var lastRow = ws.LastRowUsed();
-            var list = new List<TEntity>();
+        var lastRowNumber = ws.LastRowUsed()?.RowNumber() ?? 0;
+        var list = new List<TEntity>();
 
-            foreach (var row in ws.Rows(startRow, lastRow.RowNumber()))
+        // Process each row in the worksheet.
+        for (int rowIndex = startRow; rowIndex <= lastRowNumber; rowIndex++)
+        {
+            var row = ws.Row(rowIndex);
+            try
             {
-                try
+                var dataRow = dt.NewRow();
+                // Populate the DataRow with cell values, preserving native types.
+                foreach (var cell in row.Cells(1, dt.Columns.Count))
                 {
-                    var dataRow = dt.Rows.Add();
-                    var item = (TEntity?)Activator.CreateInstance(typeof(TEntity)) ?? throw new NullReferenceException($"{nameof(TEntity)}");
-
-                    foreach (var cell in row.Cells())
-                    {
-                        if (cell.DataType == XLDataType.DateTime)
-                        {
-                            dataRow[cell.Address.ColumnNumber - 1] = cell.GetDateTime().ToString("yyyy-MM-dd HH:mm:ss");
-                        }
-                        else
-                        {
-                            dataRow[cell.Address.ColumnNumber - 1] = cell.Value.ToString();
-                        }
-                    }
-
-                    foreach (var header in headers)
-                    {
-                        mappers[header](dataRow, item);
-                    }
-
-                    list.Add(item);
+                    int colIndex = cell.Address.ColumnNumber - 1;
+                    dataRow[colIndex] = ConvertFromXLCell(cell);
                 }
-                catch (Exception e)
+                dt.Rows.Add(dataRow);
+
+                // Create an instance of TEntity and apply the mapping functions.
+                var item = (TEntity)Activator.CreateInstance(typeof(TEntity))!; // using null-forgiving operator
+                foreach (var header in headers)
                 {
-                    return await Result<IEnumerable<TEntity>>.FailureAsync(string.Format(_localizer["Sheet name {0}:{1}"], sheetName, e.Message));
+                    mappers[header](dataRow, item);
                 }
+                list.Add(item);
+            }
+            catch (Exception e)
+            {
+                var errorMsg = $"Error in sheet {sheetName}: {e.Message}";
+                return await Result<IEnumerable<TEntity>>.FailureAsync(errorMsg);
             }
-
-            return await Result<IEnumerable<TEntity>>.SuccessAsync(list);
         }
+
+        return await Result<IEnumerable<TEntity>>.SuccessAsync(list);
     }
 }
+