DevBitsLab.Feeds.WinUI 0.0.11

DevBitsLab.Feeds.WinUI

WinUI extensions for DevBitsLab.Feeds, providing virtualized list loading support via ISupportIncrementalLoading.

📦 Installation

dotnet add package DevBitsLab.Feeds.WinUI

Note: This package requires DevBitsLab.Feeds as a dependency (installed automatically).

🚀 Quick Start

IncrementalListFeed

IncrementalListFeed<T> implements ISupportIncrementalLoading for efficient virtualized loading in WinUI ListView, GridView, and other list controls.

using DevBitsLab.Feeds.WinUI;

public partial class ProductsViewModel : ObservableObject
{
    public IncrementalListFeed<Product> Products { get; }

    public ProductsViewModel(IProductService productService)
    {
        Products = new IncrementalListFeed<Product>(async (count, ct) =>
        {
            // Load items on-demand as user scrolls
            var products = await productService.GetProductsAsync(
                skip: Products.Count,
                take: (int)count,
                cancellationToken: ct);
            
            // Return items and whether more are available
            return (products, hasMore: products.Count == count);
        });
    }
}

XAML Binding

IncrementalListFeed<T> implements INotifyCollectionChanged, so bind it directly—no ObservableCollection wrapper needed.

<ListView ItemsSource="{x:Bind ViewModel.Products}">
    <ListView.ItemTemplate>
        <DataTemplate x:DataType="models:Product">
            <TextBlock Text="{x:Bind Name}" />
        </DataTemplate>
    </ListView.ItemTemplate>
</ListView>

That's it! The ListView will automatically call LoadMoreItemsAsync as the user scrolls.

📖 How It Works

┌─────────────────────────────────────────────────────────────┐
│                        ListView                              │
│  ┌─────────────────────────────────────────────────────┐    │
│  │  Item 1                                              │    │
│  │  Item 2                                              │    │
│  │  Item 3                                              │    │
│  │  Item 4  ← User scrolls here                         │    │
│  │  ...                                                 │    │
│  │  ────────────────────────────────────────────────    │    │
│  │  Loading more...  ← ISupportIncrementalLoading       │    │
│  └─────────────────────────────────────────────────────┘    │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
            LoadMoreItemsAsync(count: 20)
                              │
                              ▼
         ┌────────────────────────────────────┐
         │  Your async loading function       │
         │  - Fetches from API                │
         │  - Returns (items, hasMore)        │
         └────────────────────────────────────┘
                              │
                              ▼
         Items added to underlying ListFeed<T>
         INotifyCollectionChanged fired
         ListView updates automatically

🔧 API Reference

IncrementalListFeed<T>

Constructor

public IncrementalListFeed(
    Func<uint, CancellationToken, Task<(IEnumerable<T> Items, bool HasMore)>> loadMoreAsync)

Properties

Methods

Events

📋 Common Patterns

Pagination with Page Numbers

private int _currentPage = 0;
private const int PageSize = 20;

Products = new IncrementalListFeed<Product>(async (count, ct) =>
{
    var products = await api.GetProductsAsync(
        page: _currentPage++,
        pageSize: PageSize,
        ct);
    
    return (products, hasMore: products.Count == PageSize);
});

Cursor-Based Pagination

private string? _cursor = null;

Products = new IncrementalListFeed<Product>(async (count, ct) =>
{
    var response = await api.GetProductsAsync(cursor: _cursor, limit: count, ct);
    _cursor = response.NextCursor;
    
    return (response.Items, hasMore: response.NextCursor != null);
});

Pull-to-Refresh

[RelayCommand]
private async Task RefreshAsync()
{
    _currentPage = 0;  // Reset pagination
    Products.Reset();  // Clear items and allow reloading
    
    // ListView will automatically load first page
}

Error Handling

Products = new IncrementalListFeed<Product>(async (count, ct) =>
{
    try
    {
        var products = await api.GetProductsAsync(skip: Products.Count, take: count, ct);
        return (products, hasMore: products.Count == count);
    }
    catch (HttpRequestException)
    {
        // Return empty with hasMore=true to allow retry
        return ([], hasMore: true);
    }
});

Accessing the Inner Feed

// Add item manually
Products.InnerFeed.Add(newProduct);

// Remove item
Products.InnerFeed.RemoveAt(index);

// Subscribe to typed changes
Products.InnerFeed.ItemsChanged += (s, e) =>
{
    if (e.Change is ListChange<Product>.ItemAdded added)
        Debug.WriteLine($"Added: {added.Item.Name}");
};

🎯 Best Practices

1. Use with virtualized controls - IncrementalListFeed is designed for ListView, GridView, etc. that support ISupportIncrementalLoading.

2. Handle cancellation - Always pass the CancellationToken to your async operations.

3. Return accurate hasMore - The ListView stops requesting items when hasMore is false.

4. Keep batch sizes reasonable - The ListView typically requests 20-50 items at a time.

5. Dispose when done - Call Dispose() or use [BindableFeed] for automatic disposal.

📦 Related Packages

📄 License

MIT License - see LICENSE for details.