Unplanned
Last Updated: 27 Jan 2022 10:40 by ADMIN
Rob
Created on: 20 Jan 2022 18:44
Category: UI for Blazor
Type: Feature Request
1
Add trigger source to ComboBoxReadEventArgs
My OnRead method works differently depending on what triggered the call. Can we add information to the ComboBoxReadEventArgs that specifies if it's been called due to Initialization, filter change or virtualization scrolling?
1 comment
ADMIN
Dimo
Posted on: 27 Jan 2022 10:40

Hi Rob,

This is a valid request and I am marking it as "Unplanned" for future prioritization.

In the meantime, anyone who is interested, can save the relevant DataSourceRequest parameters and compare them with the parameters of the next request.

The same approach is feasible for all other components. On a side note, the Grid exposes an OnStateChanged event, which can be used together with OnRead if needed.

@using Telerik.DataSource
@using Telerik.DataSource.Extensions

<p>RequestTrigger: <strong>@RequestTrigger</strong> at @Ticks.</p>

<TelerikComboBox TItem="@Person" TValue="@int"
                 ScrollMode="@DropDownScrollMode.Virtual"
                 OnRead="@GetRemoteData"
                 ValueMapper="@GetModelFromValue"
                 ItemHeight="30"
                 PageSize="20"
                 TextField="@nameof(Person.Name)"
                 ValueField="@nameof(Person.Id)"
                 @bind-Value="@SelectedValue"
                 Filterable="true"
                 FilterOperator="@StringFilterOperator.Contains"
                 Width="200px">
    <ComboBoxSettings>
        <ComboBoxPopupSettings Height="200px" />
    </ComboBoxSettings>
</TelerikComboBox>

@code{
    int SelectedValue { get; set; } = 1234;
    string RequestTrigger { get; set; } = "N/A";
    string Ticks { get; set; } = "N/A";
    DataSourceRequest LastRequest { get; set; }


    async Task GetRemoteData(ComboBoxReadEventArgs args)
    {
        Ticks = DateTime.Now.Ticks.ToString();

        // compare request parameters - start

        if (LastRequest == null)
        {
            // initial request
            RequestTrigger = "initial";
        }
        else if (
            (LastRequest.Filters.FirstOrDefault() as FilterDescriptor)?.Value !=
            (args.Request.Filters.FirstOrDefault() as FilterDescriptor)?.Value
        )
        {
            // filtering
            RequestTrigger = "filter";
        }
        else if (LastRequest.Skip != args.Request.Skip)
        {
            // virtual scrolling
            RequestTrigger = "scroll";
        }
        else
        {
            RequestTrigger = "other";
        }

        // compare request parameters - end

        // cache the DataSourceRequest - start

        var filters = new List<IFilterDescriptor>() {
            new FilterDescriptor() {
                Value = (args.Request.Filters.FirstOrDefault() as FilterDescriptor)?.Value
            }
        };

        LastRequest = new DataSourceRequest()
        {
            Skip = args.Request.Skip,
            Filters = filters
        };

        // cache the DataSourceRequest - end

        DataEnvelope<Person> result = await MyService.GetItems(args.Request);

        args.Data = result.Data;
        args.Total = result.Total;
    }

    async Task<Person> GetModelFromValue(int selectedValue)
    {
        return await MyService.GetItemFromValue(selectedValue);
    }

    public static class MyService
    {
        static List<Person> AllData { get; set; }

        public static async Task<DataEnvelope<Person>> GetItems(DataSourceRequest request)
        {
            if (AllData == null)
            {
                AllData = Enumerable.Range(1, 12345).Select(x => new Person { Id = x, Name = $"Name {x}" }).ToList();
            }

            await Task.Delay(400); // simulate real network and database delays. Remove in a real app

            var result = await AllData.ToDataSourceResultAsync(request);
            DataEnvelope<Person> dataToReturn = new DataEnvelope<Person>
            {
                Data = result.Data.Cast<Person>().ToList(),
                Total = result.Total
            };

            return await Task.FromResult(dataToReturn);
        }

        public static async Task<Person> GetItemFromValue(int selectedValue)
        {
            await Task.Delay(400); // simulate real network and database delays. Remove in a real app

            return await Task.FromResult(AllData.FirstOrDefault(x => selectedValue == x.Id));
        }
    }

    public class DataEnvelope<T>
    {
        public int Total { get; set; }
        public List<T> Data { get; set; }
    }

    public class Person
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }
}

 

Regards,
Dimo
Progress Telerik

Learn about the important changes coming in UI for Blazor 3.0 in January 2022!