How to work with List<TreeNode>

Question

Before I have a question about filtering tree view and returning just frst match.( Tree view filtering does not return all the files)

So I try to create list and change the code, is it possible improve the below code for finding nodes and child nodes that match my criteria.

private List<TreeNode> FindNodeByValue(TreeNodeCollection nodes, string searchstring)
{

    // Loop through the tree node collection
    List<TreeNode> nodelist=new List<TreeNode>();

    foreach (TreeNode node in nodes)
    {
        // Does the value match the search string?
        if (node.Value.ToUpper().Contains (searchstring.ToUpper()))
            // Yes it does match - return it
            nodelist.Add(node);
        //  return nodelist;
        else
        {
            // No it does not match - search any child nodes of this node
            List<TreeNode> childNode = SearchChildNodes(node, searchstring);
            // If the childNode is not null it was a match
            if (childNode != null)
                // Return the matching node
                return childNode;
        }
    }
    // If the matching node is not found return null
    return null;
}

/// <summary>
/// This method searches a node's ChildNodes collection to find a matching value
/// with the incoming search string
/// It will iteratively call itself as it drills into each nodes child nodes (if present)
/// </summary>
/// <param name="parentNode">Parent node to search for a match</param>
/// <param name="searchstring">string to be matched with the Nodes Value property</param>
/// <returns>Treenode of the matching node if found.  If not found it will be null</returns>
private List<TreeNode> SearchChildNodes(TreeNode parentNode, string searchstring)
{
    List<TreeNode> nodelist2 = new List<TreeNode>();
    // Loop through the child nodes of the parentNode passed in
    foreach (TreeNode node in parentNode.ChildNodes)
    {
        // Does the value match the search string?
        if (node.Value.ToUpper().Contains(searchstring.ToUpper()))
            // Yes it does match - return it
            nodelist2.Add(node);
            //return nodelist2;
            //return node;
        else
        {
            // No it does not match - recursively search any child nodes of this node
            List<TreeNode> childNode = SearchChildNodes(node, searchstring);
            // If the childNode is not null it was a match
            if (childNode != null)
                childNode.Add(node);
                // Return the matching node
                return childNode;
        }
    }
    // If the matching node is not found OR if there were no child nodes then return null
    return null;
}

protected void Button1_Click(object sender, EventArgs e)
{
    TreeNode trnode=FindNodeByValue(TreeView1.Nodes, fieldFilterTxtBx.Text);
    if (trnode != null)
    {
        TreeView1.Nodes.Clear();
       // TreeNode newnode = new TreeNode("Detail Engineering");
       // TreeView1.Nodes.Add(newnode);
        TreeView1.Nodes.Add(trnode);
        TreeView1.ExpandAll();
    }
    else
    {
        Label1.Text = "No file found";
    }
}

Answer 1

Currently you do not search sub nodes it a matching parent is found. This code fixes that problem and also simplifies the code by removing the unnecessary SearchChildNodes function.

If you only care about the first match use var node = FindNodeByValue(TreeView1.Nodes, fieldFilterTxtBx.Text).FirstOrDefault();

private IEnumerable<TreeNode> FindNodeByValue(TreeNodeCollection nodes, string searchstring)
{
    foreach (TreeNode node in nodes)
    {
        if (node.Value.IndexOf(searchstring, 
              StringComparison.CurrentCultureIgnoreCase) >= 0)
            yield return node;
        else
        {
            foreach (var subNode in FindNodeByValue(node.ChildNodes, searchstring))
                yield return subNode;
        }
    }
}

Answer 2

To make sure that there will be no out of stack (I'm pretty sure JIT wouldn't be able to optimize out recursive calls through several helper objects built for implementing IEnumerable). Here is small modifications to version of @Magnus:

private IEnumerable<TreeNode> SearchNodesByValue(TreeNodeCollection nodes, string searchstring)
{
    var stack = new Stack<T>(nodes.GetEnumerator());
    try
    {
        do
        {
            var frame = stack.Peek();
            var it = frame.Peek();
            if (!it.MoveNext())
            {
                frame.Pop().Dispose();
                continue;
            }
            var node = it.Current;
            if (node.Value.Contains(searchstring)) yield return node;
            else frame.Push(node.ChildNodes.GetEnumerator());
        } while(stack.Count > 0);
    }
    finally
    {
        // cleanup enumerators
        while(stack.Count > 0) stack.Pop().Dispose();
    }
}