MVVM AsyncExecute causing lag

Question

AsyncExecute method causing lag in my treeview application when I am expanding a branch. Important parts of my TreeView

public DirectoryItemViewModel(string fullPath, DirectoryItemType type, long size)
{
     this.ExpandCommand = new AsyncCommand(Expand, CanExecute);
     this.FullPath = fullPath;
     this.Type = type;
     this.Size = size;
     this.ClearChildren();
}
public bool CanExecute()
{
     return !isBusy;
}
public IAsyncCommand ExpandCommand { get; set; }
private async Task Expand()
{
     isBusy = true;
     if (this.Type == DirectoryItemType.File)
     {
         return;
     }
     List<Task<long>> tasks = new();
     var children = DirectoryStructure.GetDirectoryContents(this.FullPath);
     this.Children = new ObservableCollection<DirectoryItemViewModel>(
                         children.Select(content => new DirectoryItemViewModel(content.FullPath, content.Type, 0)));

//If I delete the remaining part of code in this method everything works fine, in my idea it should output the folders without lag, and then start calculating their size in other threads, but it first lags for 1-2 sec, then output the content of the folder, and then start calculating.

     foreach (var item in children)
     {
          if (item.Type == DirectoryItemType.Folder)
          {
              tasks.Add(Task.Run(() => GetDirectorySize(new DirectoryInfo(item.FullPath))));
          }
     }
     var results = await Task.WhenAll(tasks);
     for (int i = 0; i < results.Length; i++)
     {
         Children[i].Size = results[i];
     }
     isBusy = false;
}

My command Interface and class

public interface IAsyncCommand : ICommand
{
    Task ExecuteAsync();
    bool CanExecute();
}

public class AsyncCommand : IAsyncCommand
{
    public event EventHandler CanExecuteChanged;
    private bool _isExecuting;
    private readonly Func<Task> _execute;
    private readonly Func<bool> _canExecute;
    public AsyncCommand(
        Func<Task> execute,
        Func<bool> canExecute = null)
    {
        _execute = execute;
        _canExecute = canExecute;           
    }
    public bool CanExecute()
    {
        return !_isExecuting && (_canExecute?.Invoke() ?? true);
    }
    public async Task ExecuteAsync()
    {
        if (CanExecute())
        {
            try
            {
                _isExecuting = true;
                await _execute();
            }
            finally
            {
                _isExecuting = false;
            }
        }

        RaiseCanExecuteChanged();
    }

    public void RaiseCanExecuteChanged()
    {
        CanExecuteChanged?.Invoke(this, EventArgs.Empty);
    }

    bool ICommand.CanExecute(object parameter)
    {
        return CanExecute();
    }
    void ICommand.Execute(object parameter)
    {

//I suppose that here is the problem cause IDE is hinting me that I am not awaiting here, but I don't know how to change it if it is.

        ExecuteAsync();
    }
}