tree

.cs

public class TreeNode
{
    protected TreeNode(string part)
        : this(part, -1, null)

    private TreeNode(
       string part, 
       int level, 
       TreeNode? parent)
    {
        Part = part;
        Level = level;
        Parent = parent;
        Root = parent?.Root ?? this;
    }

    private bool _updateEnqueued;
    public string Part {get;set;}
    public int Level {get;}
    public TreeNode? Parent {get;}
    public TreeNode Root {get;}

    public bool Add(
      string[] subTopic,
      MqttDelivery delivery)
      => Add(subTopic, Level + 1; delivery);

    public void ForceResync()
      => Root.Update();

    public void EnqueueUpdate()
    {
       if(_updateEnqueued)
          return;
 
       _updateEnqueued = true;
       Dispatcher.UIThread.Post(
           Update, 
           DispatcherPriority.Background);
    }

    private bool Add(string[] topic, int level, MqttDelivery delivery)
    {
       if(level >= topic.Length)
       {
          Topic = delivery.Topic;
          Header = delivery.Header?.ToJsonString(true);
          Payload = delivery.Payload?.ToJsonString(true);
          Delivery = delivery;

          AddToHistory(delivery);
          return false;
       }
       
       var part = topic[level];
       if(!_treeChildren.Value.TryGetValue(part, out var trie))
       {
          TopicsCount++;
          _treeChildren.Value.Add(part, trie = new TreeNode(part,level,this));
       }

       MessagesCount++;
       trie.Add(topic, level + 1, delivery);
       return true;
    }

    private void AppendItems()
    {
       _updateEnqueued = false;
       var flatTreeList = new AvaloniaList<TreeNode>();
       AppendItems(flatTreeList, this);
       _visibleChildren = flatTreeList;
    }
    
    private void AppendItems(
        AvaloniaList<TreeNode> flatTreeList,
        TreeNode treeNode)
   {
      flatTreeList.Add(treeNode);
      if(!treeNode.IsExpanded)
         return;

      foreach(var ch in treeNode._treeChildren.Value)
         AppendItems(flatTreeList, ch.Value);
   } 

   public void Update()
   {
      AppendItems();
      Root.RaisePropertyChanged(nameof(Root.VisibleChildren));
   }

   public void AddToHistory(MqttDelivery mqttMessage)
   {
      while(UiHistoryMessages.Count >= 30)
         UiHistoryMessages.RemoveAt(UiHistoryMessages.Count - 1);

      UiHistoryMessages.Insert(0, new ReceivedHistoryMessage{..});
   }
}


public class TreeRoot
    : TreeNode
{
    public TreeRoot()
        : base("")
    {
        var timer = new Timer(1000);
        timer.Elapsed += OnTimerElapsed;
        timer.Start();
    }

    private void OnTimerElapsed(object? sender, ElapsedEventArgs e)
    {
        Root.EnqueueUpdate();
    }
    
}