feat(MiniExcelDataReaderBase): add asynchronous support

src/MiniExcel/Csv/CsvWriter.cs

@@ -140,10 +140,8 @@ public void Insert()
             await Task.Run(() => SaveAs(), cancellationToken).ConfigureAwait(false);
         }
 
-        private void GenerateSheetByIDataReader(object value, string seperator, string newLine, StreamWriter writer)
+        private void GenerateSheetByIDataReader(IDataReader reader, string seperator, string newLine, StreamWriter writer)
         {
-            var reader = (IDataReader)value;
-
             int fieldCount = reader.FieldCount;
             if (fieldCount == 0)
                 throw new InvalidDataException("fieldCount is 0");

src/MiniExcel/IMiniExcelDataReader.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Data;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MiniExcelLibs
+{
+#if !NET8_0_OR_GREATER
+    public interface IMiniExcelDataReader : IDataReader
+#else
+    public interface IMiniExcelDataReader : IDataReader, IAsyncDisposable
+#endif
+    {
+        Task CloseAsync();
+
+        Task<string> GetNameAsync(int i, CancellationToken cancellationToken = default);
+
+        Task<object> GetValueAsync(int i, CancellationToken cancellationToken = default);
+
+        Task<bool> NextResultAsync(CancellationToken cancellationToken = default);
+
+        Task<bool> ReadAsync(CancellationToken cancellationToken = default);
+    }
+}

src/MiniExcel/MiniExcelDataReader.cs

@@ -65,6 +65,7 @@ public override string GetName(int i)
         {
             return _keys[i];
         }
+
         /// <inheritdoc/>
         protected override void Dispose(bool disposing)
         {

src/MiniExcel/MiniExcelDataReaderBase.cs

@@ -2,11 +2,13 @@
 {
     using System;
     using System.Data;
+    using System.Threading;
+    using System.Threading.Tasks;
 
     /// <summary>
-    /// IDataReader Base Class
+    /// IMiniExcelDataReader Base Class
     /// </summary>
-    public abstract class MiniExcelDataReaderBase : IDataReader
+    public abstract class MiniExcelDataReaderBase : IMiniExcelDataReader
     {
         /// <summary>
         /// <inheritdoc/>
@@ -202,26 +204,124 @@ public abstract class MiniExcelDataReaderBase : IDataReader
         /// <returns></returns>
         public virtual bool NextResult() => false;
 
+        /// <summary>
+        /// <inheritdoc/>
+        /// </summary>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public virtual Task<bool> NextResultAsync(CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return MiniExcelTask.FromCanceled<bool>(cancellationToken);
+            }
+            else
+            {
+                try
+                {
+                    return NextResult() ? Task.FromResult(true) : Task.FromResult(false);
+                }
+                catch (Exception e)
+                {
+                    return MiniExcelTask.FromException<bool>(e);
+                }
+            }
+        }
+
         /// <summary>
         /// <inheritdoc/>
         /// </summary>
         /// <param name="i"></param>
         /// <returns></returns>
         public abstract string GetName(int i);
 
+        /// <summary>
+        /// <inheritdoc/>
+        /// </summary>
+        /// <param name="i"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public virtual Task<string> GetNameAsync(int i, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return MiniExcelTask.FromCanceled<string>(cancellationToken);
+            }
+            else
+            {
+                try
+                {
+                    return Task.FromResult(GetName(i));
+                }
+                catch (Exception e)
+                {
+                    return MiniExcelTask.FromException<string>(e);
+                }
+            }
+        }
+
         /// <summary>
         /// <inheritdoc/>
         /// </summary>
         /// <param name="i"></param>
         /// <returns></returns>
         public abstract object GetValue(int i);
 
+        /// <summary>
+        /// <inheritdoc/>
+        /// </summary>
+        /// <param name="i"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public virtual Task<object> GetValueAsync(int i, CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return MiniExcelTask.FromCanceled<object>(cancellationToken);
+            }
+            else
+            {
+                try
+                {
+                    return Task.FromResult(GetValue(i));
+                }
+                catch (Exception e)
+                {
+                    return MiniExcelTask.FromException<object>(e);
+                }
+            }
+        }
+
         /// <summary>
         /// <inheritdoc/>
         /// </summary>
         /// <returns></returns>
         public abstract bool Read();
 
+        /// <summary>
+        /// <inheritdoc/>
+        /// </summary>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public virtual Task<bool> ReadAsync(CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return MiniExcelTask.FromCanceled<bool>(cancellationToken);
+            }
+            else
+            {
+                try
+                {
+                    return Read() ? Task.FromResult(true) : Task.FromResult(false);
+                }
+                catch (Exception e)
+                {
+                    return MiniExcelTask.FromException<bool>(e);
+                }
+            }
+        }
+
         /// <summary>
         /// <inheritdoc/>
         /// </summary>
@@ -233,10 +333,18 @@ public virtual void Close()
         /// <summary>
         /// <inheritdoc/>
         /// </summary>
-        /// <param name="disposing"></param>
-        protected virtual void Dispose(bool disposing)
+        /// <returns></returns>
+        public virtual Task CloseAsync()
         {
-
+            try
+            {
+                Close();
+                return MiniExcelTask.CompletedTask;
+            }
+            catch (Exception e)
+            {
+                return MiniExcelTask.FromException(e);
+            }
         }
 
         /// <summary>
@@ -247,5 +355,30 @@ public void Dispose()
             Dispose(true);
             GC.SuppressFinalize(this);
         }
+
+#if NET8_0_OR_GREATER
+        /// <summary>
+        /// <inheritdoc/>
+        /// </summary>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public virtual ValueTask DisposeAsync()
+        {
+            Dispose();
+            return default;
+        }
+#endif
+
+        /// <summary>
+        /// <inheritdoc/>
+        /// </summary>
+        /// <param name="disposing"></param>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                Close();
+            }
+        }
     }
 }

src/MiniExcel/MiniExcelLibs.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 	<PropertyGroup>
 		<TargetFrameworks>net45;netstandard2.0;net8.0;</TargetFrameworks>
-		<Version>1.36.0</Version>
+		<Version>1.36.1</Version>
 	</PropertyGroup>
 	<PropertyGroup>
 		<AssemblyName>MiniExcel</AssemblyName>

src/MiniExcel/MiniExcelTask.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MiniExcelLibs
+{
+    internal class MiniExcelTask
+    {
+#if NET45
+        public static Task CompletedTask = Task.FromResult(0);
+#else
+        public static Task CompletedTask = Task.CompletedTask;
+#endif
+
+        public static Task FromException(Exception exception)
+        {
+#if NET45
+            var tcs = new TaskCompletionSource<object>();
+            tcs.SetException(exception);
+            return tcs.Task;
+#else
+            return Task.FromException(exception);
+#endif
+        }
+
+        public static Task<T> FromException<T>(Exception exception)
+        {
+#if NET45
+            var tcs = new TaskCompletionSource<T>();
+            tcs.SetException(exception);
+            return tcs.Task;
+#else
+            return Task.FromException<T>(exception);
+#endif
+        }
+
+        public static Task FromCanceled(CancellationToken cancellationToken)
+        {
+#if NET45
+            var tcs = new TaskCompletionSource<object>();
+            cancellationToken.Register(() => tcs.SetCanceled());
+            return tcs.Task;
+#else
+            return Task.FromCanceled(cancellationToken);
+#endif
+        }
+
+        public static Task<T> FromCanceled<T>(CancellationToken cancellationToken)
+        {
+#if NET45
+            var tcs = new TaskCompletionSource<T>();
+            cancellationToken.Register(() => tcs.SetCanceled());
+            return tcs.Task;
+#else
+            return Task.FromCanceled<T>(cancellationToken);
+#endif
+        }
+    }
+}