Отложенная загрузка ветвей TreeView через команды в MVVM

public class GeneralObject
{
    public int Id { get; set; }
    public string Product { get; set; }
    public BitmapSource IconType { get; set; }
    public BitmapSource IconState { get; set; }
}
 
public class Materials : GeneralObject
{
    public string Number { get; set; }
    public List<TypeFolder> TypeFolders { get; set; }
}
 
public class TypeFolder : GeneralObject
{
    public List<Shop> Shops { get; set; }
}
 
public class Shop : GeneralObject
{
    public string Code { get; set; }
    public string Site { get; set; }
 
    public List<Something> Somethings { get; set; }
}
 
public class Something : GeneralObject
{
    public byte[] File { get; set; }
    public Shop Parent { get; set; }
}

   public class xTreeView : TreeView
   {
       public xTreeView()
       {
           var itemStyle = new Style( typeof( TreeViewItem ) );
           itemStyle.Setters.Add( new EventSetter( TreeViewItem.LoadedEvent, new RoutedEventHandler( ItemLoaded ) ) );
           itemStyle.Setters.Add( new EventSetter( TreeViewItem.UnloadedEvent, new RoutedEventHandler( ItemUnloaded ) ) );
           itemStyle.Setters.Add( new EventSetter( TreeViewItem.MouseDoubleClickEvent, new MouseButtonEventHandler( ItemDoubleClick ) ) );
 
           ItemContainerStyle = itemStyle;
       }
       void ItemLoaded( object sender, RoutedEventArgs e )
       {
           if( sender is TreeViewItem item )
           {
               item.Expanded += itemExpanded;
               item.Collapsed += itemCollapsed;
           }
       }
       void ItemUnloaded( object sender, RoutedEventArgs e )
       {
           if( sender is TreeViewItem item )
           {
               item.Expanded -= itemExpanded;
               item.Collapsed -= itemCollapsed;
           }
       }
       void itemExpanded( object sender, RoutedEventArgs e )
       {
           if( sender is TreeViewItem item )
               if( ExpandCommand?.CanExecute( item.DataContext ) == true )
                   ExpandCommand.Execute( item.DataContext );
           e.Handled = true;
       }
       void itemCollapsed( object sender, RoutedEventArgs e )
       {
           if( sender is TreeViewItem item )
               if( CollapseCommand?.CanExecute( item.DataContext ) == true )
                   CollapseCommand.Execute( item.DataContext );
           e.Handled = true;
       }
       void ItemDoubleClick( object sender, RoutedEventArgs e )
       {
           // create command and execute from here           
       }
 
       public RelayCommand ExpandCommand { get { return ( RelayCommand ) GetValue( ExpandCommandProperty ); } set { SetValue( ExpandCommandProperty, value ); } }
       public static readonly DependencyProperty ExpandCommandProperty = DependencyProperty.Register( "ExpandCommand", typeof( RelayCommand ), typeof( xTreeView ), new PropertyMetadata( null ) );
 
       public RelayCommand CollapseCommand { get { return ( RelayCommand ) GetValue( CollapseCommandProperty ); } set { SetValue( CollapseCommandProperty, value ); } }
       public static readonly DependencyProperty CollapseCommandProperty = DependencyProperty.Register( "CollapseCommand", typeof( RelayCommand ), typeof( xTreeView ), new PropertyMetadata( null ) );
   }

   void ExpandExe( object obj )
   {
       if( obj is Item item ) // твои типы
       {
       
       }           
   }

public class TreeViewItemExpandedBehavior : Behavior<TreeViewItem>
{
    public static readonly DependencyProperty CommandProperty =
        DependencyProperty.Register("Command", typeof(ICommand), typeof(TreeViewItemExpandedBehavior));
 
    public ICommand Command
    {
        get
        {
            return (ICommand)GetValue(CommandProperty);
        }
        set
        {
            SetValue(CommandProperty, value);
        }
    }
 
    protected override void OnAttached()
    {
        base.OnAttached();
        AssociatedObject.Expanded += OnTreeViewItemExpanded;
    }
 
    protected override void OnDetaching()
    {
        base.OnDetaching();
        AssociatedObject.Expanded -= OnTreeViewItemExpanded;
    }
 
    private void OnTreeViewItemExpanded(object sender, RoutedEventArgs e)
    {
        if (Command != null && Command.CanExecute(AssociatedObject.DataContext))
            Command.Execute(AssociatedObject.DataContext);
    }
}

    public class TreeViewItemExpandedBehavior : Behavior<TreeView>
    {
        public static readonly DependencyProperty CommandProperty =
            DependencyProperty.Register("Command", typeof(ICommand), typeof(TreeViewItemExpandedBehavior));
 
        public ICommand Command
        {
            get
            {
                return (ICommand)GetValue(CommandProperty);
            }
            set
            {
                SetValue(CommandProperty, value);
            }
        }
 
        protected override void OnAttached()
        {
            base.OnAttached();
            AssociatedObject.AddHandler(TreeViewItem.ExpandedEvent, (RoutedEventHandler)OnTreeViewItemExpanded);
        }
 
        protected override void OnDetaching()
        {
            base.OnDetaching();
            AssociatedObject.RemoveHandler(TreeViewItem.ExpandedEvent, (RoutedEventHandler)OnTreeViewItemExpanded);
        }
 
        private void OnTreeViewItemExpanded(object sender, RoutedEventArgs e)
        {
            object? item = (e.OriginalSource as TreeViewItem)?.DataContext;
            if (Command != null && Command.CanExecute(item))
                Command.Execute(item);
        }
    }

    public class Shop : GeneralObject
    {
        public string? Code { get; set; }
        public string? Site { get; set; }
 
        public List<Something>? Somethings { get; set; }
    }
 
 
    public class ShopsViewModel : BaseInpc
    {
        private GeneralObject? _selectObject;
 
        public ShopsViewModel()
        {
            LoadSomething = new RelayCommand<object>(obj => SelectObject=obj as GeneralObject);
        }
 
        public ObservableCollection<Shop> Shops { get; } =
        [
            new Shop { Id = 1 , Code="qw", Somethings=[new Something()]},
            new Shop { Id = 2 , Code="er", Somethings=[new Something()]},
            new Shop { Id = 3 , Code="ty", Somethings=[new Something()]},
        ];
 
        public RelayCommand LoadSomething { get; }
 
        public GeneralObject? SelectObject { get => _selectObject; set => Set(ref _selectObject, value); }
    }

AssociatedObject.AddHandler(TreeViewItem.ExpandedEvent, (RoutedEventHandler)OnTreeViewItemExpanded);

public class TreeObject
{
    public TreeObject()
    {
        Children = new ObservableCollection<TreeObject>();
    }
 
    public GeneralObject CurrentObjeсt { get; set; }
    public GeneralObject Parent { get; set; }
    public ObservableCollection<TreeObject> Children { get; set; }
    public bool IsExpanded { get; set; }
    public string ToolTip { get; set; }
}

private void OnNodeExpandedCommand(object p)
{
    var obj = p as TreeObject;
    
    if (obj.CurrentObjeсt is Shop)
    {
        obj.Children.Clear();
        obj.Children = _builder.Build(obj);
    }
}

public class TreeObject
{
    // public TreeObject()
    // {
    //     Children = new ObservableCollection<TreeObject>();
    // }
 
    public GeneralObject CurrentObjeсt { get; set; }
    public GeneralObject Parent { get; set; }
    public ObservableCollection<TreeObject> Children { get; /* set; */ } = new();
    public bool IsExpanded { get; set; }
    public string ToolTip { get; set; }
}

    public ObservableCollection<TreeObject> Children { get; /* set; */ } = [new TreeObject()];

public ObservableCollection<TreeObject> Children { get; } = new ObservableCollection<TreeObject>();
public void AddChildren(List<TreeObject> children)
{
    Children.Clear();
 
    children.ForEach(x => Children.Add(x));
}

public GeneralObject SelectObject {get => ....; set => ...;} // Свойство с уведомлением через INPC