Question

使用WinForms.TreeView过滤Treeview节点的最佳/有效方法是什么？

例如：我输入“abc”，只有包含“abc”的节点变得可见。然后我键入“abcd”，我应该看到唯一包含“abcd”文本的节点。等等，所以每当我更改过滤条件时，树视图内容也会发生变化。

有什么想法吗？

- 最好的祝愿，穆拉特

Answer 1

如果您正在寻找最佳性能，请克隆树，然后从克隆树中删除所有项目，然后只需用克隆（和过滤）树替换现有树。

我还保留一个始终未经过滤的支持树。

这适用于1000到2000个节点的大树。

Answer 2

我继承TreeView来过滤它（仅适用于第一级，我正在处理它）：

public partial class winTree : TreeView
{
    private NodesCollection allNodes = new NodesCollection();

    [ReadOnly(true)]
    public new NodesCollection Nodes { get { return allNodes; } }

    private string filtro = string.Empty;
    public String Filtro
    {
        get { return filtro; }
        set { filtro = value; filtrarNodos(); }
    }

    public winTree()
    {
        InitializeComponent();

        allNodes.NodeAdd += OnNodeAdd;
        allNodes.NodeRemove += OnNodeRemove;
        allNodes.NodesClear += OnNodesClear;
    }


    private void OnNodeAdd(object sender, EventArgs e)
    {
        TreeNode n = (TreeNode)sender;

        if (passFilter(n))
        {
            base.Nodes.Add(n);
        }
    }

    private void OnNodeRemove(object sender, EventArgs e)
    {
        base.Nodes.Remove((TreeNode)sender);
    }

    private void OnNodesClear(object sender, EventArgs e)
    {
        base.Nodes.Clear();
    }


    private void filtrarNodos()
    {
        this.BeginUpdate();

        base.Nodes.Clear();

        foreach(TreeNode n in this.Nodes)
        {
            if (passFilter(n))
            {
                base.Nodes.Add(n);
            }
        }

        this.EndUpdate();
    }

    private bool passFilter(TreeNode nodo)
    {
        if (string.IsNullOrWhiteSpace(filtro))
        {
            return true;
        }
        else
        {
            return nodo.Text.ToLower().Contains(filtro.ToLower());
        }
    }
}

public class NodesCollection : IList<TreeNode>
{
    private List<TreeNode> nodos = new List<TreeNode>();

    public event EventHandler NodeAdd;
    public event EventHandler NodeRemove;
    public event EventHandler NodesClear;

    private void OnNodeAdd(TreeNode nodo)
    {
        if (NodeAdd != null)
        {
            NodeAdd(nodo, EventArgs.Empty);
        }
    }

    private void OnNodeRemove(TreeNode nodo)
    {
        if (NodeRemove != null)
        {
            NodeRemove(nodo, EventArgs.Empty);
        }
    }

    private void OnNodesClear()
    {
        if (NodeRemove != null)
        {
            NodesClear(this, EventArgs.Empty);
        }
    }


    #region IList<TreeNode>

        public int IndexOf(TreeNode item)
        {
            return nodos.IndexOf(item);

            OnNodeAdd(item);
        }

        public void Insert(int index, TreeNode item)
        {
            nodos.Insert(index, item);

            OnNodeAdd(item);
        }

        public void RemoveAt(int index)
        {
            TreeNode nodo = nodos[index];

            nodos.RemoveAt(index);

            OnNodeRemove(nodo);
        }

        public TreeNode this[int index]
        {
            get
            {
                return nodos[index];
            }
            set
            {
                OnNodeRemove(nodos[index]);
                nodos[index] = value;
                OnNodeAdd(nodos[index]);
            }
        }

        public void Add(TreeNode item)
        {
            nodos.Add(item);

            OnNodeAdd(item);
        }

        public void Clear()
        {
            nodos.Clear();

            OnNodesClear();
        }

        public bool Contains(TreeNode item)
        {
            return nodos.Contains(item);
        }

        public void CopyTo(TreeNode[] array, int arrayIndex)
        {
            nodos.CopyTo(array, arrayIndex);
        }

        public int Count
        {
            get { return nodos.Count(); }
        }

        public bool IsReadOnly
        {
            get { return true; }
        }

        public bool Remove(TreeNode item)
        {
            bool res = nodos.Remove(item);

            if (res)
            {
                OnNodeRemove(item);
            }

            return res;
        }

        public IEnumerator<TreeNode> GetEnumerator()
        {
            return nodos.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return nodos.GetEnumerator();
        }

    #endregion
}

Answer 3

如果从leaf循环到parent，你可以找到那些根目录中不包含任何字符串匹配的根节点。

Answer 4

我想提供一个更好的解决方案，问题是我不想从一个新的类和更少的代码中派生出来。

我的解决方案：

在没有过滤的情况下正常构建树
备份树（代码如下）（我只在进行搜索时使用它，而不是以防万一）
搞乱树删除节点和一切

如果您需要像最初一样重置树，请调用 _backup.Restore()

  using System.Linq;
  using System.Windows.Forms;

  public class TreeViewBackup : List<TreeViewBackup>
  {
      public TreeNode Parent { get; }
      public TreeNodeCollection Children { get; }

      public TreeViewBackup(TreeNodeCollection children, TreeNode parent = null)
      {
          Parent = parent;
          Children = children;
          AddRange(Children.Cast<TreeNode>().Select(child => new TreeViewBackup(child.Nodes, child)));
      }

      public void Restore()
      {
          Children.Clear();
          this.ForEach(clone => clone.Restore());
          Children.AddRange(this.Select(n => n.Parent).ToArray());
      }
  }

  public class Form1
  {
      public void Filter()
      {
         _backup = new TreeViewBackup(_treeView.Nodes);
         _treeView.BeginUpdate();
         MessWithMe();
         _treeView.EndUpdate();
      }

      public void Undo()
      {
         _treeView.BeginUpdate();
         _backup.Restore();
         _treeView.EndUpdate();
      }
  }

WinForms.TreeView - 过滤节点的最佳方式

4 个答案: