2.0.3

mustaddon · Nov 7, 2021 · 301aaa4 · 301aaa4
1 parent 35cb798
commit 301aaa4
Show file tree

Hide file tree

Showing 11 changed files with 44 additions and 103 deletions.
diff --git a/ArrayToExcel/ArrayToExcel.cs b/ArrayToExcel/ArrayToExcel.cs
@@ -17,10 +17,10 @@ public static byte[] CreateExcel<T>(IEnumerable<T> items, Action<SchemaBuilder<T
         {
             var builder = new SchemaBuilder<T>(items);
             schema?.Invoke(builder);
-            return _createExcel(builder.SheetSchemas);
+            return _createExcel(new[] { builder.Schema }.Concat(builder.Childs));
         }
 
-        static byte[] _createExcel(List<SheetSchema> sheetSchemas)
+        static byte[] _createExcel(IEnumerable<SheetSchema> sheetSchemas)
         {
             using (var ms = new MemoryStream())
             {

diff --git a/ArrayToExcel/ArrayToExcel.csproj b/ArrayToExcel/ArrayToExcel.csproj
@@ -6,16 +6,16 @@
     <Nullable>enable</Nullable>
     <SignAssembly>True</SignAssembly>
     <AssemblyOriginatorKeyFile>..\ArrayToExcel.snk</AssemblyOriginatorKeyFile>
-	<AssemblyVersion>2.0.2</AssemblyVersion>
-    <FileVersion>2.0.2</FileVersion>
-    <Version>2.0.2</Version>
+	<AssemblyVersion>2.0.3</AssemblyVersion>
+    <FileVersion>2.0.3</FileVersion>
+    <Version>2.0.3</Version>
 	<Company></Company>
     <Authors>Leonid Salavatov</Authors>
     <Copyright>Leonid Salavatov 2021</Copyright>
     <PackageId>ArrayToExcel</PackageId>
     <Product>ArrayToExcel</Product>
     <Title>ArrayToExcel</Title>
-    <Description>Create Excel from Array</Description>
+    <Description>Create Excel from Array (List, DataTable, DataSet, ...)</Description>
     <PackageTags>excel xlsx array2excel arraytoexcel array list dataset datatable convert map mapping dotnet</PackageTags>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <PackageProjectUrl>https://github.com/mustaddon/ArrayToExcel</PackageProjectUrl>

diff --git a/ArrayToExcel/Extensions.cs b/ArrayToExcel/Extensions.cs
@@ -12,44 +12,38 @@ public static byte[] ToExcel<T>(this IEnumerable<T> items, Action<SchemaBuilder<
             return ArrayToExcel.CreateExcel(items, schema);
         }
 
-        public static byte[] ToExcel(this DataSet dataSet, Action<SchemaBuilder<DataRow>>? schema = null)
+        public static byte[] ToExcel(this DataSet dataSet, Action<DataTable, SchemaBuilder<DataRow>>? schema = null)
         {
             var tables = dataSet.Tables.AsEnumerable().ToList();
             return ToExcel(tables.First(), builder =>
             {
                 foreach (var table in tables.Skip(1))
-                    builder.AddSheet(table);
+                    builder.AddSheet(table, s => schema?.Invoke(table, s));
 
-                schema?.Invoke(builder);
+                schema?.Invoke(tables.First(), builder);
             });
         }
 
         public static byte[] ToExcel(this DataTable dataTable, Action<SchemaBuilder<DataRow>>? schema = null)
         {
-            return ArrayToExcel.CreateExcel(dataTable.Rows.AsEnumerable(), builder =>
-            {
-                if (!string.IsNullOrWhiteSpace(dataTable.TableName))
-                    builder.SheetName(dataTable.TableName);
-
-                foreach (DataColumn col in dataTable.Columns)
-                    builder.AddColumn(col.ColumnName, x => x[col]);
+            return ArrayToExcel.CreateExcel(dataTable.Rows.AsEnumerable(), b => dataTable.SchemaBuilder(b, schema));
+        }
 
-                schema?.Invoke(builder);
-            });
+        public static SchemaBuilder<T> AddSheet<T>(this SchemaBuilder<T> builder, DataTable dataTable, Action<SchemaBuilder<DataRow>>? schema = null)
+        {
+            return builder.AddSheet(dataTable.Rows.AsEnumerable(), b => dataTable.SchemaBuilder(b, schema));
         }
 
-        public static SchemaBuilder<T> AddSheet<T>(this SchemaBuilder<T> builder, DataTable dataTable, Action<SheetSchemaBuilder<DataRow>>? schema = null)
+
+        private static void SchemaBuilder(this DataTable dataTable, SchemaBuilder<DataRow> builder, Action<SchemaBuilder<DataRow>>? schema)
         {
-            return builder.AddSheet(dataTable.Rows.AsEnumerable(), builder =>
-            {
-                if (!string.IsNullOrWhiteSpace(dataTable.TableName))
-                    builder.SheetName(dataTable.TableName);
+            if (!string.IsNullOrWhiteSpace(dataTable.TableName))
+                builder.SheetName(dataTable.TableName);
 
-                foreach (DataColumn col in dataTable.Columns)
-                    builder.AddColumn(col.ColumnName, x => x[col]);
+            foreach (DataColumn col in dataTable.Columns)
+                builder.AddColumn(col.ColumnName, x => x[col]);
 
-                schema?.Invoke(builder);
-            });
+            schema?.Invoke(builder);
         }
 
         private static IEnumerable<DataRow> AsEnumerable(this DataRowCollection items)

diff --git a/ArrayToExcel/SchemaBuilder.cs b/ArrayToExcel/SchemaBuilder.cs
@@ -6,103 +6,40 @@
 
 namespace ArrayToExcel
 {
-    public class SchemaBuilder<T>
+    public sealed class SchemaBuilder<T>
     {
-        public SchemaBuilder(IEnumerable items)
+        internal SchemaBuilder(IEnumerable items, List<SheetSchema>? parentChilds = null)
         {
-            _rootSheetBuilder = new(DefaultSheetName(), items);
-            SheetSchemas.Add(_rootSheetBuilder.Schema);
-        }
-
-        private readonly SheetSchemaBuilder<T> _rootSheetBuilder;
-
-        internal List<SheetSchema> SheetSchemas { get; } = new();
-
-        private string DefaultSheetName() => $"Sheet{SheetSchemas.Count + 1}";
-
-        public SchemaBuilder<T> AddSheet<TList>(IEnumerable<TList> list, Action<SheetSchemaBuilder<TList>>? schema = null)
-        {
-            var builder = new SheetSchemaBuilder<TList>(DefaultSheetName(), list);
-            schema?.Invoke(builder);
-            SheetSchemas.Add(builder.Schema);
-            return this;
-        }
-
-        public SchemaBuilder<T> SheetName(string name)
-        {
-            _rootSheetBuilder.SheetName(name);
-            return this;
-        }
-
-        public SchemaBuilder<T> ColumnName(Func<ColumnInfo, string> name)
-        {
-            _rootSheetBuilder.ColumnName(name);
-            return this;
-        }
-
-        public SchemaBuilder<T> ColumnWidth(Func<ColumnInfo, uint> width)
-        {
-            _rootSheetBuilder.ColumnWidth(width);
-            return this;
-        }
-
-        public SchemaBuilder<T> ColumnFilter(Func<ColumnInfo, bool> filter)
-        {
-            _rootSheetBuilder.ColumnFilter(filter);
-            return this;
-        }
-
-        public SchemaBuilder<T> ColumnSort<TKey>(Func<ColumnInfo, TKey> sort, bool desc = false)
-        {
-            _rootSheetBuilder.ColumnSort(sort, desc);
-            return this;
-        }
-
-        public SchemaBuilder<T> ColumnValue(Func<ColumnInfo, T, object?> value)
-        {
-            _rootSheetBuilder.ColumnValue(value);
-            return this;
-        }
-
-        public SchemaBuilder<T> AddColumn(string name, Func<T, object?> value, uint width = ColumnSchema.DefaultWidth)
-        {
-            _rootSheetBuilder.AddColumn(name, value, width);
-            return this;
-        }
-    }
-
-    public class SheetSchemaBuilder<T>
-    {
-        public SheetSchemaBuilder(string sheetName, IEnumerable items)
-        {
-            Schema = new(sheetName, DefaultColumns(items), items);
+            Childs = parentChilds ?? new();
+            Schema = new($"Sheet{(parentChilds?.Count + 2) ?? 1}", DefaultColumns(items), items);
         }
 
         private bool _defaultCols = true;
 
         internal SheetSchema Schema { get; }
+        internal List<SheetSchema> Childs { get; }
 
-        public SheetSchemaBuilder<T> SheetName(string name)
+        public SchemaBuilder<T> SheetName(string name)
         {
             Schema.SheetName = name;
             return this;
         }
 
-        public SheetSchemaBuilder<T> ColumnName(Func<ColumnInfo, string> name)
+        public SchemaBuilder<T> ColumnName(Func<ColumnInfo, string> name)
         {
             foreach (var col in Schema.Columns.Select((x, i) => new ColumnInfo(i, x)))
                 col.Schema.Name = name(col);
             return this;
         }
 
-        public SheetSchemaBuilder<T> ColumnWidth(Func<ColumnInfo, uint> width)
+        public SchemaBuilder<T> ColumnWidth(Func<ColumnInfo, uint> width)
         {
             foreach (var col in Schema.Columns.Select((x, i) => new ColumnInfo(i, x)))
                 col.Schema.Width = width(col);
             return this;
         }
 
-        public SheetSchemaBuilder<T> ColumnFilter(Func<ColumnInfo, bool> filter)
+        public SchemaBuilder<T> ColumnFilter(Func<ColumnInfo, bool> filter)
         {
             Schema.Columns = Schema.Columns
                 .Select((x, i) => new ColumnInfo(i, x))
@@ -112,7 +49,7 @@ public SheetSchemaBuilder<T> ColumnFilter(Func<ColumnInfo, bool> filter)
             return this;
         }
 
-        public SheetSchemaBuilder<T> ColumnSort<TKey>(Func<ColumnInfo, TKey> sort, bool desc = false)
+        public SchemaBuilder<T> ColumnSort<TKey>(Func<ColumnInfo, TKey> sort, bool desc = false)
         {
             var colInfos = Schema.Columns.Select((x, i) => new ColumnInfo(i, x)).ToList();
 
@@ -124,14 +61,14 @@ public SheetSchemaBuilder<T> ColumnSort<TKey>(Func<ColumnInfo, TKey> sort, bool
             return this;
         }
 
-        public SheetSchemaBuilder<T> ColumnValue(Func<ColumnInfo, T, object?> value)
+        public SchemaBuilder<T> ColumnValue(Func<ColumnInfo, T, object?> value)
         {
             foreach (var col in Schema.Columns.Select((x, i) => new ColumnInfo(i, x)))
                 col.Schema.Value = x => value(col, (T)x);
             return this;
         }
 
-        public SheetSchemaBuilder<T> AddColumn(string name, Func<T, object?> value, uint width = ColumnSchema.DefaultWidth)
+        public SchemaBuilder<T> AddColumn(string name, Func<T, object?> value, uint width = ColumnSchema.DefaultWidth)
         {
             if (_defaultCols)
             {
@@ -149,6 +86,14 @@ public SheetSchemaBuilder<T> AddColumn(string name, Func<T, object?> value, uint
             return this;
         }
 
+        public SchemaBuilder<T> AddSheet<TList>(IEnumerable<TList> list, Action<SchemaBuilder<TList>>? schema = null)
+        {
+            var builder = new SchemaBuilder<TList>(list, Childs);
+            schema?.Invoke(builder);
+            Childs.Add(builder.Schema);
+            return this;
+        }
+
         private List<ColumnSchema> DefaultColumns(IEnumerable items)
         {
             var type = typeof(T);

diff --git a/Examples/Example.ConsoleApp/Program.cs b/Examples/Example.ConsoleApp/Program.cs
@@ -178,7 +178,9 @@ static void TestDataTable()
             foreach (var x in Enumerable.Range(1, 100))
                 table.Rows.Add($"Text #{x}", x * 1000, DateTime.Now.AddDays(-x));
 
-            var excel = table.ToExcel();
+            var excel = table.ToExcel(s => s
+                .AddSheet(table, ss => ss.SheetName("Table2"))
+                .AddSheet(SomeItems));
 
             File.WriteAllBytes($@"..\{nameof(TestDataTable)}.xlsx", excel);
         }

diff --git a/Examples/example1.xlsx b/Examples/example1.xlsx
diff --git a/Examples/example2.xlsx b/Examples/example2.xlsx
diff --git a/Examples/example3.xlsx b/Examples/example3.xlsx
diff --git a/Examples/example4.xlsx b/Examples/example4.xlsx
diff --git a/Examples/example5.xlsx b/Examples/example5.xlsx
diff --git a/Examples/example6.xlsx b/Examples/example6.xlsx