TreeListChildrenLoadingEventArgs.Children Property

Specifies data items that are children of the Parent node.

Namespace: DevExpress.Blazor

Assembly: DevExpress.Blazor.v25.1.dll

NuGet Package: DevExpress.Blazor

Declaration

public IEnumerable<object> Children { get; set; }

Property Value

Type	Description
IEnumerable<Object>	A collection of child data items.

Remarks

Handle the ChildrenLoading or ChildrenLoadingOnDemand event to populate the TreeList component with hierarchical data in code. 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

The following example switches the TreeList component to on-demand mode:

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>();