disable LoadFromQueryableAsync on .NET Framework, add some doccomments

Author: exyi

src/Framework/Core/Controls/GridViewDataSetExtensions.cs

@@ -8,7 +8,9 @@ namespace DotVVM.Framework.Controls
 {
     public static class GridViewDataSetExtensions
     {
-
+        /// <summary>
+        /// Loads dataset from the specified <paramref name="queryable" />: Applies filtering, sorting and paging options, and collects the results. If <see cref="PagingOptions"/> is used, the total number of items (after applying filtering) is retrieved and stored in the PagingOptions property.
+        /// </summary>
         public static void LoadFromQueryable<T>(this IGridViewDataSet<T> dataSet, IQueryable<T> queryable)
         {
             if (dataSet.FilteringOptions is not IApplyToQueryable filteringOptions)
@@ -37,6 +39,11 @@ public static void LoadFromQueryable<T>(this IGridViewDataSet<T> dataSet, IQuery
             dataSet.IsRefreshRequired = false;
         }
 
+#if NET6_0_OR_GREATER
+        /// <summary>
+        /// Loads dataset from the specified <paramref name="queryable" />: Applies filtering, sorting and paging options, and collects the results using IAsyncEnumerable. If <see cref="PagingOptions"/> is used, the total number of items (after applying filtering) is retrieved and stored in the PagingOptions property.
+        /// </summary>
+        /// <exception cref="ArgumentException">The specified IQueryable does not support async enumeration.</exception>
         public static async Task LoadFromQueryableAsync<T>(this IGridViewDataSet<T> dataSet, IQueryable<T> queryable, CancellationToken cancellationToken = default)
         {
             if (dataSet.FilteringOptions is not IApplyToQueryable filteringOptions)
@@ -69,36 +76,48 @@ public static async Task LoadFromQueryableAsync<T>(this IGridViewDataSet<T> data
 
             if (pagingOptions is IPagingOptionsLoadingPostProcessor pagingOptionsLoadingPostProcessor)
             {
+                cancellationToken.ThrowIfCancellationRequested();
                 await pagingOptionsLoadingPostProcessor.ProcessLoadedItemsAsync(filtered, result, cancellationToken);
             }
 
             dataSet.IsRefreshRequired = false;
         }
+#endif
 
+        /// <summary> Sets <see cref="IPagingOptions"/> to the first page, and sets the <see cref="IRefreshableGridViewDataSet.IsRefreshRequired"/> property to true. </summary>
+        /// <remarks> To reload the dataset, you must then call <see cref="LoadFromQueryable{T}(IGridViewDataSet{T}, IQueryable{T})"/> or a similar method. </remarks>
         public static void GoToFirstPageAndRefresh(this IPageableGridViewDataSet<IPagingFirstPageCapability> dataSet)
         {
             dataSet.PagingOptions.GoToFirstPage();
             (dataSet as IRefreshableGridViewDataSet)?.RequestRefresh();
         }
 
+        /// <summary> Sets <see cref="IPagingOptions"/> to the last page, and sets the <see cref="IRefreshableGridViewDataSet.IsRefreshRequired"/> property to true. </summary>
+        /// <remarks> To reload the dataset, you must then call <see cref="LoadFromQueryable{T}(IGridViewDataSet{T}, IQueryable{T})"/> or a similar method. </remarks>
         public static void GoToLastPageAndRefresh(this IPageableGridViewDataSet<IPagingLastPageCapability> dataSet)
         {
             dataSet.PagingOptions.GoToLastPage();
             (dataSet as IRefreshableGridViewDataSet)?.RequestRefresh();
         }
 
+        /// <summary> Sets <see cref="IPagingOptions"/> to the previous page, and sets the <see cref="IRefreshableGridViewDataSet.IsRefreshRequired"/> property to true. </summary>
+        /// <remarks> To reload the dataset, you must then call <see cref="LoadFromQueryable{T}(IGridViewDataSet{T}, IQueryable{T})"/> or a similar method. </remarks>
         public static void GoToPreviousPageAndRefresh(this IPageableGridViewDataSet<IPagingPreviousPageCapability> dataSet)
         {
             dataSet.PagingOptions.GoToPreviousPage();
             (dataSet as IRefreshableGridViewDataSet)?.RequestRefresh();
         }
 
+        /// <summary> Sets <see cref="IPagingOptions"/> to the next page, and sets the <see cref="IRefreshableGridViewDataSet.IsRefreshRequired"/> property to true. </summary>
+        /// <remarks> To reload the dataset, you must then call <see cref="LoadFromQueryable{T}(IGridViewDataSet{T}, IQueryable{T})"/> or a similar method. </remarks>
         public static void GoToNextPageAndRefresh(this IPageableGridViewDataSet<IPagingNextPageCapability> dataSet)
         {
             dataSet.PagingOptions.GoToNextPage();
             (dataSet as IRefreshableGridViewDataSet)?.RequestRefresh();
         }
 
+        /// <summary> Sets <see cref="IPagingOptions"/> to the page number <paramref name="pageIndex"/> (indexed from 0), and sets the <see cref="IRefreshableGridViewDataSet.IsRefreshRequired"/> property to true. </summary>
+        /// <remarks> To reload the dataset, you must then call <see cref="LoadFromQueryable{T}(IGridViewDataSet{T}, IQueryable{T})"/> or a similar method. </remarks>
         public static void GoToPageAndRefresh(this IPageableGridViewDataSet<IPagingPageIndexCapability> dataSet, int pageIndex)
         {
             dataSet.PagingOptions.GoToPage(pageIndex);

src/Framework/Core/Controls/GridViewDataSetResult.cs

@@ -2,6 +2,7 @@
 
 namespace DotVVM.Framework.Controls
 {
+
     public class GridViewDataSetResult<TItem, TFilteringOptions, TSortingOptions, TPagingOptions>
         where TFilteringOptions : IFilteringOptions
         where TSortingOptions : ISortingOptions
@@ -23,12 +24,16 @@ public GridViewDataSetResult(IReadOnlyList<TItem> items, GridViewDataSetOptions<
             PagingOptions = options.PagingOptions;
         }
 
+        /// <summary> New items to replace the old <see cref="IBaseGridViewDataSet{T}.Items"/> </summary>
         public IReadOnlyList<TItem> Items { get; }
 
+        /// <summary> New filtering options to replace the old <see cref="IFilterableGridViewDataSet{T}.FilteringOptions"/>, if null the old options are left unchanged. </summary>
         public TFilteringOptions? FilteringOptions { get; }
 
+        /// <summary> New sorting options to replace the old <see cref="ISortableGridViewDataSet{T}.SortingOptions"/>, if null the old options are left unchanged. </summary>
         public TSortingOptions? SortingOptions { get; }
 
+        /// <summary> New paging options to replace the old <see cref="IPageableGridViewDataSet{T}.PagingOptions"/>, if null the old options are left unchanged. </summary>
         public TPagingOptions? PagingOptions { get; }
     }
 }

src/Framework/Core/Controls/Options/PagingImplementation.cs

@@ -24,7 +24,8 @@ public static IQueryable<T> ApplyPagingToQueryable<T, TPagingOptions>(IQueryable
                 : queryable;
         }
 
-        /// <summary> Attempts to count the queryable asynchronously. EF Core IQueryables are supported, and IQueryables which return IAsyncEnumerable from GroupBy operator also work correctly. Otherwise, a synchronous fallback is user, or <see cref="CustomAsyncQueryableCountDelegate" /> may be set to add support for an ORM mapper of choice. </summary>
+#if NET6_0_OR_GREATER
+        /// <summary> Attempts to count the queryable asynchronously. EF Core IQueryables are supported, and IQueryables which return IAsyncEnumerable from GroupBy operator also work correctly. Otherwise, a synchronous fallback is used, or <see cref="CustomAsyncQueryableCountDelegate" /> may be set to add support for an ORM mapper of choice. </summary>
         public static async Task<int> QueryableAsyncCount<T>(IQueryable<T> queryable, CancellationToken ct = default)
         {
             if (CustomAsyncQueryableCountDelegate is {} customDelegate)
@@ -37,9 +38,14 @@ public static async Task<int> QueryableAsyncCount<T>(IQueryable<T> queryable, Ca
             }
 
             var queryableType = queryable.GetType();
+            // Note: there is not a standard way to get a count from IAsyncEnumerable instance, without enumerating it.
+            //       we use two heuristics to try to get the count using the query provider:
+            //          * if we detect usage of EF Core, call its CountAsync method
+            //          * otherwise, do it as .GroupBy(_ => 1).Select(group => group.Count()).SingleOrDefault()
+            //  (if you are reading this and need a separate hack for your favorite ORM, you can set
+            //   CustomAsyncQueryableCountDelegate, and we do accept PRs adding new heuristics ;) )
             return await (
-                EfCoreAsyncCountHack(queryable, queryableType, ct) ?? // TODO: test this
-                Ef6AsyncCountHack(queryable, ct) ?? // TODO: test this
+                EfCoreAsyncCountHack(queryable, queryableType, ct) ??
                 StandardAsyncCountHack(queryable, ct)
             );
         }
@@ -64,34 +70,14 @@ public static async Task<int> QueryableAsyncCount<T>(IQueryable<T> queryable, Ca
             return (Task<int>)countMethodGeneric.Invoke(null, new object[] { queryable, ct })!;
         }
 
-        static readonly Type? ef6IDbAsyncQueryProvider = Type.GetType("System.Data.Entity.Infrastructure.IDbAsyncQueryProvider, EntityFramework"); // https://learn.microsoft.com/en-us/dotnet/api/system.data.entity.infrastructure.idbasyncqueryprovider?view=entity-framework-6.2.0
-        static MethodInfo? ef6MethodCache;
-        static Task<int>? Ef6AsyncCountHack<T>(IQueryable<T> queryable, CancellationToken ct)
-        {
-            if (ef6IDbAsyncQueryProvider is null)
-                return null;
-            if (!ef6IDbAsyncQueryProvider.IsInstanceOfType(queryable.Provider))
-                return null;
-
-            var countMethod = ef6MethodCache ?? Type.GetType("System.Data.Entity.QueryableExtensions, EntityFramework")!.GetMethods().SingleOrDefault(m => m.Name == "CountAsync" && m.GetParameters() is { Length: 2 } parameters && parameters[1].ParameterType == typeof(CancellationToken))!;
-            if (countMethod is null)
-                return null;
-
-            if (ef6MethodCache is null)
-                Interlocked.CompareExchange(ref ef6MethodCache, countMethod, null);
-
-            var countMethodGeneric = countMethod.MakeGenericMethod(typeof(T));
-            return (Task<int>)countMethodGeneric.Invoke(null, new object[] { queryable, ct })!;
-        }
-
         static Task<int> StandardAsyncCountHack<T>(IQueryable<T> queryable, CancellationToken ct)
         {
 #if NETSTANDARD2_1_OR_GREATER
             var countGroupHack = queryable.GroupBy(_ => 1).Select(group => group.Count());
-            // if not IAsyncEnumerable, just use synchronous Count
+            // if not IAsyncEnumerable, just use synchronous Count on a new thread
             if (countGroupHack is not IAsyncEnumerable<int> countGroupEnumerable)
             {
-                return Task.FromResult(queryable.Count());
+                return Task.Factory.StartNew(() => queryable.Count(), TaskCreationOptions.LongRunning);
             }
 
             return FirstOrDefaultAsync(countGroupEnumerable, ct);
@@ -105,5 +91,6 @@ static Task<int> StandardAsyncCountHack<T>(IQueryable<T> queryable, Cancellation
             throw new Exception("IAsyncEnumerable is not supported on .NET Framework and the queryable does not support EntityFramework CountAsync.");
 #endif
         }
+#endif
     }
 }

src/Framework/Core/Controls/Options/PagingOptions.cs

@@ -125,11 +125,29 @@ public virtual IQueryable<T> ApplyToQueryable<T>(IQueryable<T> queryable)
 
         public virtual void ProcessLoadedItems<T>(IQueryable<T> filteredQueryable, IList<T> items)
         {
-            TotalItemsCount = filteredQueryable.Count();
+            if (items.Count < PageSize)
+            {
+                TotalItemsCount = PageIndex * PageSize + items.Count;
+            }
+            else
+            {
+                TotalItemsCount = filteredQueryable.Count();
+            }
         }
         public async Task ProcessLoadedItemsAsync<T>(IQueryable<T> filteredQueryable, IList<T> items, CancellationToken cancellationToken)
         {
-            TotalItemsCount = await PagingImplementation.QueryableAsyncCount(filteredQueryable, cancellationToken);
+#if NET6_0_OR_GREATER
+            if (items.Count < PageSize)
+            {
+                TotalItemsCount = PageIndex * PageSize + items.Count;
+            }
+            else
+            {
+                TotalItemsCount = await PagingImplementation.QueryableAsyncCount(filteredQueryable, cancellationToken);
+            }
+#else
+            throw new NotSupportedException("LoadFromQueryableAsync and ProcessLoadedItemsAsync methods are not supported on .NET Framework.");
+#endif
         }
 
     }

src/Tests/DotVVM.Framework.Tests.csproj

@@ -49,8 +49,8 @@
   <ItemGroup>
     <PackageReference Include="AngleSharp" Version="0.17.0" />
     <PackageReference Include="Ben.Demystifier" Version="0.4.1" />
-    <PackageReference Include="Microsoft.Extensions.Logging" Version="6.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="8.0.1" />
     <PackageReference Include="Newtonsoft.Json" Version="13.*" />
     <PackageReference Include="coverlet.collector" Version="3.1.2">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>