TreeListChildrenLoadingOnDemandEventArgs Class

Stores data for the ChildrenLoadingOnDemand event.

Namespace: DevExpress.Blazor

Assembly: DevExpress.Blazor.v25.1.dll

NuGet Package: DevExpress.Blazor

Declaration

C#

public class TreeListChildrenLoadingOnDemandEventArgs :
    TreeListChildrenLoadingEventArgs

Remarks

The TreeList component gives you an option to initially load only root nodes. It retrieves child nodes on demand when a user expands a node for the first time. Follow the steps below to enable this behavior:

1. Bind the Data parameter to a C# property.
2. Populate this property with root data items in the OnInitialized or OnInitializedAsync lifecycle method.
3. Specify the HasChildrenFieldName property. The component uses this property to determine which nodes require expand buttons.
4. Handle the ChildrenLoadingOnDemand event. In the event handler, use the Parent event argument to determine the processed node and assign the node’s children to the Children collection.

Read Tutorial: Bind Blazor TreeList to Data Run Demo: Load Data on Demand

Example

In the following example, the TreeList component displays the file structure:

Razor

@inject FileSystemDataProvider FileSystemDataProvider

<DxTreeList Data="TreeListData"
            HasChildrenFieldName="HasChildren"
            ChildrenLoadingOnDemand="TreeList_ChildrenLoadingOnDemand"
            CustomizeCellDisplayText="TreeList_CustomizeCellDisplayText">
    <Columns>
        <DxTreeListDataColumn FieldName="Name" />
        <DxTreeListDataColumn FieldName="Type" Width="100" />
        <DxTreeListDataColumn FieldName="DateModified" Width="120" />
        <DxTreeListDataColumn FieldName="Size" Width="100" />
    </Columns>
</DxTreeList>

@code {
    object TreeListData { get; set; }

    protected override async Task OnInitializedAsync() {
        TreeListData = await FileSystemDataProvider.GetRootItemsAsync();
    }

    Task TreeList_ChildrenLoadingOnDemand(TreeListChildrenLoadingOnDemandEventArgs e) {
        var item = e.Parent as FileSystemDataItem;
        e.Children = item.Children;
        return Task.CompletedTask;
    }

    void TreeList_CustomizeCellDisplayText(TreeListCustomizeCellDisplayTextEventArgs e) {
        if(e.FieldName == "Size") {
            var item = (FileSystemDataItem)e.DataItem;
            e.DisplayText = GetSizeColumnDisplayText(item.Type, item.Size);
        }
    }

    string GetSizeColumnDisplayText(FileType fileType, long size) {
        if(fileType == FileType.Folder)
            return null;
        if(size >= 1024)
            return string.Format("{0:### ### ###} KB", size / 1024);
        return string.Format("{0} Bytes", size);
    }
}

FileSystemDataItem

using System.Collections.Generic;

public class FileSystemDataItem {
    public string Name { get; set; }
    public FileType Type { get; set; }
    public DateTime DateCreated { get; set; }
    public DateTime DateModified { get; set; }
    public long Size { get; set; }

    public List<FileSystemDataItem> Children { get; set; }
    public bool HasChildren => Children != null && Children.Count > 0;
}

public enum FileType { File, Folder }

FileSystemDataProvider

public class FileSystemDataProvider {
    List<FileSystemDataItem> _rootItems;

    public FileSystemDataProvider(DataSourcesFileContentProvider fileContentProvider) {
        FileContentProvider = fileContentProvider;
    }

    DataSourcesFileContentProvider FileContentProvider { get; }

    public async Task<List<FileSystemDataItem>> GetRootItemsAsync() {
        if(_rootItems == null) {
            var json = await FileContentProvider.GetFileSystemDataItemsContentAsync();
            _rootItems = JsonSerializer.Deserialize<List<FileSystemDataItem>>(json);
        }
        return _rootItems;
    }
}

public class DataSourcesFileContentProvider{
    string _fileSystemDataItemsContent;

    public async Task<string> GetFileSystemDataItemsContentAsync() {
        if(_fileSystemDataItemsContent == null) {
            string pathToDataFile = Path.Combine(AppContext.BaseDirectory, "DataSources", "FileSystemDataItems.json");
            _fileSystemDataItemsContent = await File.ReadAllTextAsync(pathToDataFile);
        }
        return _fileSystemDataItemsContent;
    }
}

Program.cs

// ...
builder.Services.AddSingleton<FileSystemDataProvider>();
builder.Services.AddSingleton<DataSourcesFileContentProvider>();

Limitations

The on-demand mode has the following specifics and limitations:

• Child data items should not contain fields that are not present in parent data items.
• Filter and export operations force the component to load all data.
• Summary calculation is not supported.
• ExpandAll() and CollapseAll() methods are not supported.
• AllPages mode of the Select All checkbox is not supported.
• The SelectAllAsync and DeselectAllAsync method calls force the component to load all data.
• The second call to the SelectAllAsync or DeselectAllAsync method cancels the operation initiated by the previously called method.
• Sort and filter operations cancel incomplete “select all” and “deselect all” processes.
• Call the WaitForRemoteSourceRowLoadAsync method before those that accept a row’s visible index as a parameter (SelectRow, ExpandRow, and so on) to ensure that the specified data row is loaded.

Inheritance

Object

TreeListChildrenLoadingEventArgs

TreeListChildrenLoadingOnDemandEventArgs