Add public API for MaxItemCount

Author: SteveSandersonMS

src/Components/Web/src/PublicAPI.Unshipped.txt

@@ -3,5 +3,7 @@ Microsoft.AspNetCore.Components.Web.Internal.IInternalWebJSInProcessRuntime
 Microsoft.AspNetCore.Components.Web.Internal.IInternalWebJSInProcessRuntime.InvokeJS(string! identifier, string? argsJson, Microsoft.JSInterop.JSCallResultType resultType, long targetInstanceId) -> string!
 Microsoft.AspNetCore.Components.Web.KeyboardEventArgs.IsComposing.get -> bool
 Microsoft.AspNetCore.Components.Web.KeyboardEventArgs.IsComposing.set -> void
+Microsoft.AspNetCore.Components.Web.Virtualization.Virtualize<TItem>.MaxItemCount.get -> int
+Microsoft.AspNetCore.Components.Web.Virtualization.Virtualize<TItem>.MaxItemCount.set -> void
 override Microsoft.AspNetCore.Components.HtmlRendering.Infrastructure.StaticHtmlRenderer.RendererInfo.get -> Microsoft.AspNetCore.Components.RendererInfo!
 override Microsoft.AspNetCore.Components.Routing.FocusOnNavigate.BuildRenderTree(Microsoft.AspNetCore.Components.Rendering.RenderTreeBuilder! builder) -> void

src/Components/Web/src/Virtualization/Virtualize.cs

@@ -126,10 +126,6 @@ public sealed class Virtualize<TItem> : ComponentBase, IVirtualizeJsCallbacks, I
     [Parameter]
     public string SpacerElement { get; set; } = "div";
 
-    /*
-    This API will be added in .NET 9 but cannot be added in a .NET 8 or earlier patch,
-    as we can't change public API in patches.
-
     /// <summary>
     /// Gets or sets the maximum number of items that will be rendered, even if the client reports
     /// that its viewport is large enough to show more. The default value is 100.
@@ -140,7 +136,6 @@ as we can't change public API in patches.
     /// </summary>
     [Parameter]
     public int MaxItemCount { get; set; } = 100;
-    */
 
     /// <summary>
     /// Instructs the component to re-request data from its <see cref="ItemsProvider"/>.
@@ -356,12 +351,13 @@ private void CalcualteItemDistribution(
             _itemSize = ItemSize;
         }
 
-        // This AppContext data exists as a stopgap for .NET 8 and earlier, since this is being added in a patch
-        // where we can't add new public API.
+        // This AppContext data was added as a stopgap for .NET 8 and earlier, since it was added in a patch
+        // where we couldn't add new public API. For backcompat we still support the AppContext setting, but
+        // new applications should use the much more convenient MaxItemCount parameter.
         var maxItemCount = AppContext.GetData("Microsoft.AspNetCore.Components.Web.Virtualization.Virtualize.MaxItemCount") switch
         {
-            int val => val, // In .NET 9, this will be Math.Min(val, MaxItemCount)
-            _ => 1000       // In .NET 9, this will be MaxItemCount
+            int val => Math.Min(val, MaxItemCount),
+            _ => MaxItemCount
         };
 
         itemsInSpacer = Math.Max(0, (int)Math.Floor(spacerSize / _itemSize) - OverscanCount);

src/Components/test/E2ETest/Tests/VirtualizationTest.cs

@@ -262,10 +262,21 @@ public void CanRenderHtmlTable()
         Assert.Contains(expectedInitialSpacerStyle, bottomSpacer.GetAttribute("style"));
     }
 
-    [Fact]
-    public void CanLimitMaxItemsRendered()
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void CanLimitMaxItemsRendered(bool useAppContext)
     {
-        Browser.MountTestComponent<VirtualizationMaxItemCount>();
+        if (useAppContext)
+        {
+            // This is to test back-compat with the switch added in a .NET 8 patch.
+            // Newer applications shouldn't use this technique.
+            Browser.MountTestComponent<VirtualizationMaxItemCount_AppContext>();
+        }
+        else
+        {
+            Browser.MountTestComponent<VirtualizationMaxItemCount>();
+        }
 
         // Despite having a 600px tall scroll area and 30px high items (600/30=20),
         // we only render 10 items due to the MaxItemCount setting

src/Components/test/testassets/BasicTestApp/Index.razor

@@ -110,6 +110,7 @@
         <option value="BasicTestApp.VirtualizationComponent">Virtualization</option>
         <option value="BasicTestApp.VirtualizationDataChanges">Virtualization data changes</option>
         <option value="BasicTestApp.VirtualizationMaxItemCount">Virtualization MaxItemCount</option>
+        <option value="BasicTestApp.VirtualizationMaxItemCount_AppContext">Virtualization MaxItemCount (via AppContext)</option>
         <option value="BasicTestApp.VirtualizationTable">Virtualization HTML table</option>
         <option value="BasicTestApp.HotReload.RenderOnHotReload">Render on hot reload</option>
         <option value="BasicTestApp.SectionsTest.ParentComponentWithTwoChildren">Sections test</option>

src/Components/test/testassets/BasicTestApp/VirtualizationMaxItemCount.razor

@@ -1,5 +1,4 @@
-@implements IDisposable
-<p>
+<p>
     MaxItemCount is a safeguard against the client reporting a giant viewport and causing the server to perform a
     correspondingly giant data load and then tracking a lot of render state.
 </p>
@@ -12,23 +11,14 @@
 </p>
 
 <div id="virtualize-scroll-area" style="height: 600px; overflow-y: scroll; outline: 1px solid red; background: #eee;">
-    @* In .NET 8 and earlier, the E2E test uses an AppContext.SetData call to set MaxItemCount *@
-    @* In .NET 9 onwards, it's a Virtualize component parameter *@
-    <Virtualize ItemsProvider="GetItems" ItemSize="30">
+    <Virtualize ItemsProvider="GetItems" ItemSize="30" MaxItemCount="10">
         <div class="my-item" @key="context" style="height: 30px; outline: 1px solid #ccc">
             Id: @context.Id; Name: @context.Name
         </div>
     </Virtualize>
 </div>
 
 @code {
-    protected override void OnInitialized()
-    {
-        // This relies on Xunit's default behavior of running tests in the same collection sequentially,
-        // not in parallel. From .NET 9 onwards this can be removed in favour of a Virtualize parameter.
-        AppContext.SetData("Microsoft.AspNetCore.Components.Web.Virtualization.Virtualize.MaxItemCount", 10);
-    }
-
     private async ValueTask<ItemsProviderResult<MyThing>> GetItems(ItemsProviderRequest request)
     {
         const int numThings = 100000;
@@ -40,9 +30,4 @@
     }
 
     record MyThing(int Id, string Name);
-
-    public void Dispose()
-    {
-        AppContext.SetData("Microsoft.AspNetCore.Components.Web.Virtualization.Virtualize.MaxItemCount", null);
-    }
 }

src/Components/test/testassets/BasicTestApp/VirtualizationMaxItemCount_AppContext.razor

@@ -0,0 +1,41 @@
+@implements IDisposable
+<p>
+    This is a variation of the VirtualizationMaxItemCount test case in which the max count is set using AppContext.
+    This E2E test exists only to verify back-compatibility.
+</p>
+
+<div id="virtualize-scroll-area" style="height: 600px; overflow-y: scroll; outline: 1px solid red; background: #eee;">
+    @* In .NET 8 and earlier, the E2E test uses an AppContext.SetData call to set MaxItemCount *@
+    @* In .NET 9 onwards, it's a Virtualize component parameter *@
+    <Virtualize ItemsProvider="GetItems" ItemSize="30">
+        <div class="my-item" @key="context" style="height: 30px; outline: 1px solid #ccc">
+            Id: @context.Id; Name: @context.Name
+        </div>
+    </Virtualize>
+</div>
+
+@code {
+    protected override void OnInitialized()
+    {
+        // This relies on Xunit's default behavior of running tests in the same collection sequentially,
+        // not in parallel. From .NET 9 onwards this can be removed in favour of a Virtualize parameter.
+        AppContext.SetData("Microsoft.AspNetCore.Components.Web.Virtualization.Virtualize.MaxItemCount", 10);
+    }
+
+    private async ValueTask<ItemsProviderResult<MyThing>> GetItems(ItemsProviderRequest request)
+    {
+        const int numThings = 100000;
+
+        await Task.Delay(100);
+        return new ItemsProviderResult<MyThing>(
+            Enumerable.Range(request.StartIndex, request.Count).Select(i => new MyThing(i, $"Thing {i}")),
+            numThings);
+    }
+
+    record MyThing(int Id, string Name);
+
+    public void Dispose()
+    {
+        AppContext.SetData("Microsoft.AspNetCore.Components.Web.Virtualization.Virtualize.MaxItemCount", null);
+    }
+}