Replace Task.Run wrappers with real asynchronous methods

.editorconfig

@@ -13,4 +13,18 @@ dotnet_style_qualification_for_property = false
 dotnet_style_qualification_for_method = false
 
 # IDE0065: Misplaced using directive
-csharp_using_directive_placement = outside_namespace
+csharp_using_directive_placement = outside_namespace
+
+# CA1835: Prefer the memory-based overloads of ReadAsync/WriteAsync methods in stream-based classes
+dotnet_diagnostic.CA1835.severity = error
+
+# CA1849: Call async methods when in an async method
+dotnet_diagnostic.CA1849.severity = error
+
+dotnet_diagnostic.CA2000.severity = error
+
+# CA2007: Do not directly await a Task
+dotnet_diagnostic.CA2007.severity = error
+
+# CA2016: Forward the CancellationToken parameter to methods that take one
+dotnet_diagnostic.CA2016.severity = error

benchmarks/MiniExcel.Benchmarks/MiniExcel.Benchmarks.csproj

@@ -7,6 +7,7 @@
 		<ImplicitUsings>enable</ImplicitUsings>
 		<LangVersion>latest</LangVersion>
 		<RootNamespace>MiniExcelLibs.Benchmarks</RootNamespace>
+		<NoWarn>$(NoWarn);CA2000;CA2007</NoWarn>
 	</PropertyGroup>
 
 	<ItemGroup>

src/MiniExcel/Csv/CsvReader.cs

@@ -8,10 +8,11 @@
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Runtime.CompilerServices;
 
 namespace MiniExcelLibs.Csv
 {
-    internal class CsvReader : IExcelReader
+    internal partial class CsvReader : IExcelReader
     {
         private Stream _stream;
         private CsvConfiguration _config;
@@ -22,8 +23,11 @@ public CsvReader(Stream stream, IConfiguration configuration)
             _config = configuration == null ? CsvConfiguration.DefaultConfiguration : (CsvConfiguration)configuration;
         }
 
-        public IEnumerable<IDictionary<string, object>> Query(bool useHeaderRow, string sheetName, string startCell)
+        [Zomp.SyncMethodGenerator.CreateSyncVersion]
+        public async IAsyncEnumerable<IDictionary<string, object>> QueryAsync(bool useHeaderRow, string sheetName, string startCell, [EnumeratorCancellation] CancellationToken cancellationToken = default)
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             if (startCell != "A1")
                 throw new NotImplementedException("CSV does not implement parameter startCell");
 
@@ -35,14 +39,22 @@ public IEnumerable<IDictionary<string, object>> Query(bool useHeaderRow, string
             var headRows = new Dictionary<int, string>();
 
             string row;
-            for (var rowIndex = 1; (row = reader.ReadLine()) != null; rowIndex++)
+            for (var rowIndex = 1; (row = await reader.ReadLineAsync(
+#if NET7_0_OR_GREATER
+cancellationToken
+#endif
+                ).ConfigureAwait(false)) != null; rowIndex++)
             {
                 string finalRow = row;
                 if (_config.ReadLineBreaksWithinQuotes)
                 {
                     while (finalRow.Count(c => c == '"') % 2 != 0)
                     {
-                        var nextPart = reader.ReadLine();
+                        var nextPart = await reader.ReadLineAsync(
+#if NET7_0_OR_GREATER
+cancellationToken
+#endif
+                            ).ConfigureAwait(false);
                         if (nextPart == null)
                         {
                             break;
@@ -107,62 +119,37 @@ public IEnumerable<IDictionary<string, object>> Query(bool useHeaderRow, string
             }
         }
 
-        public IEnumerable<T> Query<T>(string sheetName, string startCell, bool hasHeader) where T : class, new()
+        [Zomp.SyncMethodGenerator.CreateSyncVersion]
+        public IAsyncEnumerable<T> QueryAsync<T>(string sheetName, string startCell, bool hasHeader, CancellationToken cancellationToken = default) where T : class, new()
         {
-            var dynamicRecords = Query(false, sheetName, startCell);
-            return ExcelOpenXmlSheetReader.QueryImpl<T>(dynamicRecords, startCell, hasHeader, _config);
+            var dynamicRecords = QueryAsync(false, sheetName, startCell, cancellationToken);
+            return ExcelOpenXmlSheetReader.QueryImplAsync<T>(dynamicRecords, startCell, hasHeader, _config, cancellationToken);
         }
 
-        public IEnumerable<IDictionary<string, object>> QueryRange(bool useHeaderRow, string sheetName, string startCell, string endCell)
+        [Zomp.SyncMethodGenerator.CreateSyncVersion]
+        public IAsyncEnumerable<IDictionary<string, object>> QueryRangeAsync(bool useHeaderRow, string sheetName, string startCell, string endCell, CancellationToken cancellationToken = default)
         {
             throw new NotImplementedException("CSV does not implement QueryRange");
         }
 
-        public IEnumerable<T> QueryRange<T>(string sheetName, string startCell, string endCell, bool hasHeader) where T : class, new()
+        [Zomp.SyncMethodGenerator.CreateSyncVersion]
+        public IAsyncEnumerable<T> QueryRangeAsync<T>(string sheetName, string startCell, string endCell, bool hasHeader, CancellationToken cancellationToken = default) where T : class, new()
         {
-            var dynamicRecords = QueryRange(false, sheetName, startCell, endCell);
-            return ExcelOpenXmlSheetReader.QueryImpl<T>(dynamicRecords, startCell, hasHeader, this._config);
+            var dynamicRecords = QueryRangeAsync(false, sheetName, startCell, endCell, cancellationToken);
+            return ExcelOpenXmlSheetReader.QueryImplAsync<T>(dynamicRecords, startCell, hasHeader, this._config, cancellationToken);
         }
 
-        public IEnumerable<IDictionary<string, object>> QueryRange(bool useHeaderRow, string sheetName, int startRowIndex, int startColumnIndex, int? endRowIndex, int? endColumnIndex)
+        [Zomp.SyncMethodGenerator.CreateSyncVersion]
+        public IAsyncEnumerable<IDictionary<string, object>> QueryRangeAsync(bool useHeaderRow, string sheetName, int startRowIndex, int startColumnIndex, int? endRowIndex, int? endColumnIndex, CancellationToken cancellationToken = default)
         {
             throw new NotImplementedException("CSV does not implement QueryRange");
         }
 
-        public IEnumerable<T> QueryRange<T>(string sheetName, int startRowIndex, int startColumnIndex, int? endRowIndex, int? endColumnIndex, bool hasHeader) where T : class, new()
-        {
-            var dynamicRecords = QueryRange(false, sheetName, startRowIndex, startColumnIndex, endRowIndex, endColumnIndex);
-            return ExcelOpenXmlSheetReader.QueryImpl<T>(dynamicRecords, ReferenceHelper.ConvertXyToCell(startRowIndex, startColumnIndex), hasHeader, this._config);
-        }
-
-        public Task<IEnumerable<IDictionary<string, object>>> QueryAsync(bool useHeaderRow, string sheetName, string startCell, CancellationToken cancellationToken = default)
-        {
-            return Task.Run(() => Query(useHeaderRow, sheetName, startCell), cancellationToken);
-        }
-
-        public async Task<IEnumerable<T>> QueryAsync<T>(string sheetName, string startCell, bool hasHeader, CancellationToken cancellationToken = default) where T : class, new()
-        {
-            return await Task.Run(() => Query<T>(sheetName, startCell, hasHeader), cancellationToken).ConfigureAwait(false);
-        }
-
-        public Task<IEnumerable<IDictionary<string, object>>> QueryRangeAsync(bool useHeaderRow, string sheetName, string startCell, string endCel, CancellationToken cancellationToken = default)
-        {
-            return Task.Run(() => QueryRange(useHeaderRow, sheetName, startCell, endCel), cancellationToken);
-        }
-
-        public async Task<IEnumerable<T>> QueryRangeAsync<T>(string sheetName, string startCell, string endCel, bool hasHeader, CancellationToken cancellationToken = default) where T : class, new()
-        {
-            return await Task.Run(() => QueryRange<T>(sheetName, startCell, endCel, hasHeader), cancellationToken).ConfigureAwait(false);
-        }
-
-        public Task<IEnumerable<IDictionary<string, object>>> QueryRangeAsync(bool useHeaderRow, string sheetName, int startRowIndex, int startColumnIndex, int? endRowIndex, int? endColumnIndex, CancellationToken cancellationToken = default)
-        {
-            return Task.Run(() => QueryRange(useHeaderRow, sheetName, startRowIndex, startColumnIndex, endRowIndex, endColumnIndex), cancellationToken);
-        }
-
-        public async Task<IEnumerable<T>> QueryRangeAsync<T>(string sheetName, int startRowIndex, int startColumnIndex, int? endRowIndex, int? endColumnIndex, bool hasHeader, CancellationToken cancellationToken = default) where T : class, new()
+        [Zomp.SyncMethodGenerator.CreateSyncVersion]
+        public IAsyncEnumerable<T> QueryRangeAsync<T>(string sheetName, int startRowIndex, int startColumnIndex, int? endRowIndex, int? endColumnIndex, bool hasHeader, CancellationToken cancellationToken = default) where T : class, new()
         {
-            return await Task.Run(() => QueryRange<T>(sheetName, startRowIndex, startColumnIndex, endRowIndex, endColumnIndex, hasHeader), cancellationToken).ConfigureAwait(false);
+            var dynamicRecords = QueryRangeAsync(false, sheetName, startRowIndex, startColumnIndex, endRowIndex, endColumnIndex, cancellationToken);
+            return ExcelOpenXmlSheetReader.QueryImplAsync<T>(dynamicRecords, ReferenceHelper.ConvertXyToCell(startRowIndex, startColumnIndex), hasHeader, this._config, cancellationToken);
         }
 
         private string[] Split(string row)

src/MiniExcel/Csv/CsvWriter.cs

@@ -115,22 +115,38 @@ private async Task<int> WriteValuesAsync(StreamWriter writer, object values, str
             {
                 writeAdapter = MiniExcelWriteAdapterFactory.GetWriteAdapter(values, _configuration);
             }
-            var props = writeAdapter != null ? writeAdapter.GetColumns() : await asyncWriteAdapter.GetColumnsAsync();
+            var props = writeAdapter != null ? writeAdapter.GetColumns() : await asyncWriteAdapter.GetColumnsAsync().ConfigureAwait(false);
 #else
             IMiniExcelWriteAdapter writeAdapter =  MiniExcelWriteAdapterFactory.GetWriteAdapter(values, _configuration);
             var props = writeAdapter.GetColumns();
 #endif
             if (props == null)
             {
-                await _writer.WriteAsync(_configuration.NewLine);
-                await _writer.FlushAsync();
+                await _writer.WriteAsync(_configuration.NewLine
+#if NET5_0_OR_GREATER
+                    .AsMemory(), cancellationToken
+#endif
+                    ).ConfigureAwait(false);
+                await _writer.FlushAsync(
+#if NET8_0_OR_GREATER
+                    cancellationToken
+#endif
+                    ).ConfigureAwait(false);
                 return 0;
             }
 
             if (_printHeader)
             {
-                await _writer.WriteAsync(GetHeader(props));
-                await _writer.WriteAsync(newLine);
+                await _writer.WriteAsync(GetHeader(props)
+#if NET5_0_OR_GREATER
+                    .AsMemory(), cancellationToken
+#endif
+                    ).ConfigureAwait(false);
+                await _writer.WriteAsync(newLine
+#if NET5_0_OR_GREATER
+                    .AsMemory(), cancellationToken
+#endif
+                    ).ConfigureAwait(false);
             }
 
             var rowBuilder = new StringBuilder();
@@ -148,29 +164,45 @@ private async Task<int> WriteValuesAsync(StreamWriter writer, object values, str
                     }
 
                     RemoveTrailingSeparator(rowBuilder);
-                    await _writer.WriteAsync(rowBuilder.ToString());
-                    await _writer.WriteAsync(newLine);
+                    await _writer.WriteAsync(rowBuilder.ToString()
+#if NET5_0_OR_GREATER
+                        .AsMemory(), cancellationToken
+#endif
+                    ).ConfigureAwait(false);
+                    await _writer.WriteAsync(newLine
+#if NET5_0_OR_GREATER
+                        .AsMemory(), cancellationToken
+#endif
+                    ).ConfigureAwait(false);
 
                     rowsWritten++;
                 }
             }
 #if NETSTANDARD2_0_OR_GREATER || NET
             else
             {
-                await foreach (var row in asyncWriteAdapter.GetRowsAsync(props, cancellationToken))
+                await foreach (var row in asyncWriteAdapter.GetRowsAsync(props, cancellationToken).ConfigureAwait(false))
                 {
                     cancellationToken.ThrowIfCancellationRequested();
                     rowBuilder.Clear();
 
-                    await foreach (var column in row)
+                    await foreach (var column in row.ConfigureAwait(false))
                     {
                         cancellationToken.ThrowIfCancellationRequested();
                         AppendColumn(rowBuilder, column);
                     }
 
                     RemoveTrailingSeparator(rowBuilder);
-                    await _writer.WriteAsync(rowBuilder.ToString());
-                    await _writer.WriteAsync(newLine);
+                    await _writer.WriteAsync(rowBuilder.ToString()
+#if NET5_0_OR_GREATER
+                    .AsMemory(), cancellationToken
+#endif
+                    ).ConfigureAwait(false);
+                    await _writer.WriteAsync(newLine
+#if NET5_0_OR_GREATER
+                    .AsMemory(), cancellationToken
+#endif
+                    ).ConfigureAwait(false);
 
                     rowsWritten++;
                 }
@@ -188,20 +220,32 @@ public async Task<int[]> SaveAsAsync(CancellationToken cancellationToken = defau
 
             if (_value == null)
             {
-                await _writer.WriteAsync("");
-                await _writer.FlushAsync();
+                await _writer.WriteAsync(""
+#if NET5_0_OR_GREATER
+                    .AsMemory(), cancellationToken
+#endif
+                    ).ConfigureAwait(false);
+                await _writer.FlushAsync(
+#if NET8_0_OR_GREATER
+                    cancellationToken
+#endif
+                    ).ConfigureAwait(false);
                 return new int[0];
             }
 
-            var rowsWritten = await WriteValuesAsync(_writer, _value, seperator, newLine, cancellationToken);
-            await _writer.FlushAsync();
+            var rowsWritten = await WriteValuesAsync(_writer, _value, seperator, newLine, cancellationToken).ConfigureAwait(false);
+            await _writer.FlushAsync(
+#if NET8_0_OR_GREATER
+                    cancellationToken
+#endif
+                ).ConfigureAwait(false);
 
             return new[] { rowsWritten };
         }
 
         public async Task<int> InsertAsync(bool overwriteSheet = false, CancellationToken cancellationToken = default)
         {
-            var rowsWritten = await SaveAsAsync(cancellationToken);
+            var rowsWritten = await SaveAsAsync(cancellationToken).ConfigureAwait(false);
             return rowsWritten.FirstOrDefault();
         }
 

src/MiniExcel/ExcelFactory.cs

@@ -5,17 +5,20 @@
     using MiniExcelLibs.OpenXml.SaveByTemplate;
     using System;
     using System.IO;
+    using System.Threading;
+    using System.Threading.Tasks;
 
-    internal static class ExcelReaderFactory
+    internal static partial class ExcelReaderFactory
     {
-        internal static IExcelReader GetProvider(Stream stream, ExcelType excelType, IConfiguration configuration)
+        [Zomp.SyncMethodGenerator.CreateSyncVersion]
+        internal static async Task<IExcelReader> GetProviderAsync(Stream stream, ExcelType excelType, IConfiguration configuration, CancellationToken cancellationToken = default)
         {
             switch (excelType)
             {
                 case ExcelType.CSV:
                     return new CsvReader(stream, configuration);
                 case ExcelType.XLSX:
-                    return new ExcelOpenXmlSheetReader(stream, configuration);
+                    return await ExcelOpenXmlSheetReader.CreateAsync(stream, configuration, cancellationToken: cancellationToken).ConfigureAwait(false);
                 default:
                     throw new NotSupportedException("Something went wrong. Please report this issue you are experiencing with MiniExcel.");
             }

src/MiniExcel/IExcelReader.cs

@@ -1,23 +1,22 @@
 using System;
 using System.Collections.Generic;
 using System.Threading;
-using System.Threading.Tasks;
 
 namespace MiniExcelLibs
 {
-    internal interface IExcelReader : IDisposable
+    internal partial interface IExcelReader : IDisposable
     {
-        IEnumerable<IDictionary<string, object>> Query(bool useHeaderRow, string sheetName, string startCell);
-        IEnumerable<T> Query<T>(string sheetName, string startCell, bool hasHeader) where T : class, new();
-        Task<IEnumerable<IDictionary<string, object>>> QueryAsync(bool useHeaderRow, string sheetName, string startCell, CancellationToken cancellationToken = default);
-        Task<IEnumerable<T>> QueryAsync<T>(string sheetName, string startCell, bool hasHeader, CancellationToken cancellationToken = default) where T : class, new();
-        IEnumerable<IDictionary<string, object>> QueryRange(bool useHeaderRow, string sheetName, string startCell, string endCell);
-        IEnumerable<T> QueryRange<T>(string sheetName, string startCell, string endCell, bool hasHeader) where T : class, new();
-        Task<IEnumerable<IDictionary<string, object>>> QueryRangeAsync(bool useHeaderRow, string sheetName, string startCell, string endCell, CancellationToken cancellationToken = default);
-        Task<IEnumerable<T>> QueryRangeAsync<T>(string sheetName, string startCell, string endCell, bool hasHeader, CancellationToken cancellationToken = default) where T : class, new();
-        IEnumerable<IDictionary<string, object>> QueryRange(bool useHeaderRow, string sheetName, int startRowIndex, int startColumnIndex, int? endRowIndex, int? endColumnIndex);
-        IEnumerable<T> QueryRange<T>(string sheetName, int startRowIndex, int startColumnIndex, int? endRowIndex, int? endColumnIndex, bool hasHeader) where T : class, new();
-        Task<IEnumerable<IDictionary<string, object>>> QueryRangeAsync(bool useHeaderRow, string sheetName, int startRowIndex, int startColumnIndex, int? endRowIndex, int? endColumnIndex, CancellationToken cancellationToken = default);
-        Task<IEnumerable<T>> QueryRangeAsync<T>(string sheetName, int startRowIndex, int startColumnIndex, int? endRowIndex, int? endColumnIndex, bool hasHeader, CancellationToken cancellationToken = default) where T : class, new();
+        [Zomp.SyncMethodGenerator.CreateSyncVersion]
+        IAsyncEnumerable<IDictionary<string, object>> QueryAsync(bool useHeaderRow, string sheetName, string startCell, CancellationToken cancellationToken = default);
+        [Zomp.SyncMethodGenerator.CreateSyncVersion]
+        IAsyncEnumerable<T> QueryAsync<T>(string sheetName, string startCell, bool hasHeader, CancellationToken cancellationToken = default) where T : class, new();
+        [Zomp.SyncMethodGenerator.CreateSyncVersion]
+        IAsyncEnumerable<IDictionary<string, object>> QueryRangeAsync(bool useHeaderRow, string sheetName, string startCell, string endCell, CancellationToken cancellationToken = default);
+        [Zomp.SyncMethodGenerator.CreateSyncVersion]
+        IAsyncEnumerable<T> QueryRangeAsync<T>(string sheetName, string startCell, string endCell, bool hasHeader, CancellationToken cancellationToken = default) where T : class, new();
+        [Zomp.SyncMethodGenerator.CreateSyncVersion]
+        IAsyncEnumerable<IDictionary<string, object>> QueryRangeAsync(bool useHeaderRow, string sheetName, int startRowIndex, int startColumnIndex, int? endRowIndex, int? endColumnIndex, CancellationToken cancellationToken = default);
+        [Zomp.SyncMethodGenerator.CreateSyncVersion]
+        IAsyncEnumerable<T> QueryRangeAsync<T>(string sheetName, int startRowIndex, int startColumnIndex, int? endRowIndex, int? endColumnIndex, bool hasHeader, CancellationToken cancellationToken = default) where T : class, new();
     }
 }