Hi Daniel,

It is valid in the sense that it tells the grid how many records there are in total - if you know that you will immediately fire a filter operation it could serve.

The point of virtualization and the OnRead event (mostly of the OnRead event) is to NOT load all the records at once, but to only load the current page. Thus, actual paging, filtering and other operations are given to the server where the performance is better, and also less data has to travel to the client. Perhaps the following sample projects can also help you get started with server filtering too: https://github.com/telerik/blazor-ui/tree/master/grid/datasourcerequest-on-server.

Regards,
Marin Bratanov
Progress Telerik

Hi Daniel,

Here's what happens:

1. The grid data source is filtered with the first button. The grid now has a small number of items (31 in this case).
2. The "filter" string is reset with the second button, but the grid data is still filtered - and so there are still only 31 items.
3. The new Skip is applied and the grid tries to scroll down. There are, however, not enough items in the data for that to happen so the grid scrolls only as far as possible (TotalCount minus the PageSize which is 31 minus 10 => here's where 21 comes from for the Skip).
4. The change of the Skip setting in the state causes the OnRead event to fire, and since the application logic now returns different data there, the grid has more items and can now scroll down to Skip=21.

If you try to Skip a smaller number (say, 15), it would "work" because there is enough data to perform step 3 as expected. When the current data set is too small, you must ensure there is enough data to scroll that far down.

To solve this, you must update the grid data source so it has those items before scrolling to them. The key thing is that there are two distinct operations here - a filter (data source change) and a page (scroll, skip) change - so this needs two separate data requests.

Here's the changed code:

    public async Task ResetSearchValueAndSetGridSkip32()
    {
        SearchValue = "";

        // the fix - request the new grid data so the grid has enough items to scroll down 31 items
        await ReadGridItems();
        StateHasChanged();
        // end fix

        await GridSetSkip(Grid, 32);
    }

and

    // this is refactored to store the last data source request so you can call it from the method above
    public Telerik.DataSource.DataSourceRequest LastRequest { get; set; }

    protected Task ReadGridItemsHandler(GridReadEventArgs args)
    {
        LastRequest = args.Request;

        return ReadGridItems();
    }

    protected async Task ReadGridItems()
    {
        var skip = LastRequest.Skip;
        var pageSize = LastRequest.PageSize;

        LastSkip = skip;

        var httpClient = HttpClientFactory.CreateClient("MyHttpClient");
        var response = await httpClient.GetAsync("api/values/get");

        var responseContent = await response.Content.ReadAsStringAsync();

        var result = Newtonsoft.Json.JsonConvert.DeserializeObject<GridData>(responseContent);

        var query = result
            .Rows
            .AsQueryable()
            .Where(r =>
                r.Kurztext != null && r.Kurztext.ToUpper().Contains(SearchValue.ToUpper()) ||
                r.Langtext != null && r.Langtext.ToUpper().Contains(SearchValue.ToUpper())
            );

        Items = query
            .OrderBy(o => o.Ordnungszahl)
            .Skip(skip)
            .Take(pageSize)
            .ToList();

        TotalCount = query.Count();
    }
    // end refactor

Regards,
Marin Bratanov
Progress Telerik