Restructured + infinite scroll

Author: MackinnonBuck

src/Components/Components/ref/Microsoft.AspNetCore.Components.netcoreapp.cs

@@ -0,0 +1,32 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Threading.Tasks;
+
+namespace Microsoft.AspNetCore.Components.Virtualization
+{
+    /// <summary>
+    /// Describes a helper for detecting and relaying virtualization events.
+    /// </summary>
+    public interface IVirtualizationHelper : IAsyncDisposable
+    {
+        /// <summary>
+        /// Performs platform-specific initialization.
+        /// </summary>
+        /// <param name="topSpacer">The <see cref="ElementReference"/> representing the top spacer.</param>
+        /// <param name="bottomSpacer">The <see cref="ElementReference"/> representing the bottom spacer.</param>
+        /// <returns>The <see cref="ValueTask"/> associated with the completion of this operation.</returns>
+        ValueTask InitAsync(ElementReference topSpacer, ElementReference bottomSpacer);
+
+        /// <summary>
+        /// Invoked when the top spacer becomes visible.
+        /// </summary>
+        event EventHandler<SpacerEventArgs> TopSpacerVisible;
+
+        /// <summary>
+        /// Invoked when the bottom spacer becomes visible.
+        /// </summary>
+        event EventHandler<SpacerEventArgs> BottomSpacerVisible;
+    }
+}

src/Components/Components/src/Virtualization/IVirtualizationHelper.cs

@@ -0,0 +1,17 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.AspNetCore.Components.Virtualization
+{
+    /// <summary>
+    /// Describes services enabling platform-specific virtualization.
+    /// </summary>
+    public interface IVirtualizationService
+    {
+        /// <summary>
+        /// Creates a helper used for detecting and relaying virtualization events.
+        /// </summary>
+        /// <returns></returns>
+        IVirtualizationHelper CreateVirtualizationHelper();
+    }
+}

src/Components/Components/src/Virtualization/IVirtualizationService.cs

@@ -0,0 +1,84 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.AspNetCore.Components.Virtualization
+{
+    /// <summary>
+    /// Provides functionality for rendering a virtualized, infinite list of items.
+    /// </summary>
+    /// <typeparam name="TItem">The <c>context</c> type for the items being rendered.</typeparam>
+    public sealed class InfiniteScroll<TItem> : VirtualizeBase<TItem>
+    {
+        private readonly ConcurrentQueue<TItem> _loadedItems = new ConcurrentQueue<TItem>();
+
+        private int _fetchingItems;
+
+        protected override int ItemCount => InfiniteScrollFooter == null ? _loadedItems.Count : _loadedItems.Count + 1;
+
+        /// <summary>
+        /// Gets or sets the list item template.
+        /// </summary>
+        [Parameter]
+        public RenderFragment<TItem> Item { get; set; } = default!;
+
+        /// <summary>
+        /// Gets or sets the infinite scroll footer template.
+        /// </summary>
+        [Parameter]
+        public RenderFragment? InfiniteScrollFooter { get; set; }
+
+        /// <summary>
+        /// Gets or sets the function that provides items for the inifinite scroll.
+        /// </summary>
+        [Parameter]
+        public Func<Range, Task<IEnumerable<TItem>>> ItemsProvider { get; set; } = default!;
+
+        /// <summary>
+        /// The batch size in which items are fetched.
+        /// </summary>
+        [Parameter]
+        public int ItemBatchSize { get; set; }
+
+        protected override IEnumerable<RenderFragment> GetItems(int start, int count)
+        {
+            if (start + count >= _loadedItems.Count)
+            {
+                // Fetch more items if we're not already
+                FetchItemsAsync();
+
+                var items = _loadedItems.Skip(start).Select(item => Item(item));
+
+                return InfiniteScrollFooter == null ? items : items.Append(InfiniteScrollFooter);
+            }
+            else
+            {
+                return _loadedItems.Skip(start).Take(count).Select(item => Item(item));
+            }
+        }
+
+        private void FetchItemsAsync()
+        {
+            if (Interlocked.Exchange(ref _fetchingItems, 1) == 0)
+            {
+                ItemsProvider(new Range(_loadedItems.Count, _loadedItems.Count + ItemBatchSize)).ContinueWith(t =>
+                {
+                    foreach (var item in t.Result)
+                    {
+                        _loadedItems.Enqueue(item);
+                    }
+
+                    _fetchingItems = 0;
+
+                    InvokeAsync(() => StateHasChanged());
+                });
+            }
+        }
+    }
+}

src/Components/Components/src/Virtualization/InfiniteScroll.cs

@@ -0,0 +1,34 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+
+namespace Microsoft.AspNetCore.Components.Virtualization
+{
+    /// <summary>
+    /// Describes an event involving a spacer in a virtualized list.
+    /// </summary>
+    public class SpacerEventArgs : EventArgs
+    {
+        /// <summary>
+        /// The new size of the spacer.
+        /// </summary>
+        public float SpacerSize { get; }
+
+        /// <summary>
+        /// The current size of the spacer's container.
+        /// </summary>
+        public float ContainerSize { get; }
+
+        /// <summary>
+        /// Instantiates a new <see cref="SpacerEventArgs"/> instance.
+        /// </summary>
+        /// <param name="spacerSize">The new size of the spacer.</param>
+        /// <param name="containerSize">The current size of the spacer's container.</param>
+        public SpacerEventArgs(float spacerSize, float containerSize)
+        {
+            SpacerSize = spacerSize;
+            ContainerSize = containerSize;
+        }
+    }
+}

src/Components/Components/src/Virtualization/SpacerEventArgs.cs

@@ -0,0 +1,36 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Microsoft.AspNetCore.Components.Virtualization
+{
+    /// <summary>
+    /// Provides functionality for rendering a virtualized, fixed-size list of items.
+    /// </summary>
+    /// <typeparam name="TItem">The <c>context</c> type for the items being rendered.</typeparam>
+    public sealed class Virtualize<TItem> : VirtualizeBase<TItem>
+    {
+        protected override int ItemCount => Items.Count;
+
+        /// <summary>
+        /// Gets or sets the content template for list items.
+        /// </summary>
+        [Parameter]
+        public RenderFragment<TItem>? ChildContent { get; set; }
+
+        /// <summary>
+        /// Gets or sets the collection of items used to generate the list.
+        /// </summary>
+        [Parameter]
+        public ICollection<TItem> Items { get; set; } = default!;
+
+        protected override IEnumerable<RenderFragment> GetItems(int start, int count)
+        {
+            return ChildContent == null ?
+                Enumerable.Empty<RenderFragment>() :
+                Items.Skip(start).Take(count).Select(item => ChildContent.Invoke(item));
+        }
+    }
+}