TreeListChildrenLoadingEventArgs.Parent Property

Returns the data item that corresponds to the current node.

Namespace: DevExpress.Blazor

Assembly: DevExpress.Blazor.v24.1.dll

NuGet Package: DevExpress.Blazor

Declaration

public object Parent { get; }

Property Value

Type	Description
Object	The data item.

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