Recursive control search with Linq

Question

If I wanted to find checked check boxes on an ASP.NET page I could use the following Linq.

var checkBoxes = this.Controls
                     .OfType<CheckBox>()
                     .TakeWhile<CheckBox>(cb => cb.Checked);

That works fine if the checkboxes are nested in the current control collection, but I'd like to know how to extend the search by drilling down into the control collections of the top-level controls.

The question was asked here:

Finding controls that use a certain interface in ASP.NET

And received non-Linq answers, I already have my own version of a recursive control search on type and ID as extension methods, but just wondered how easy this is to do in Linq?

Answer 1

Take the type/ID checking out of the recursion, so just have a "give me all the controls, recursively" method, e.g.

public static IEnumerable<Control> GetAllControls(this Control parent)
{
    foreach (Control control in parent.Controls)
    {
        yield return control;
        foreach(Control descendant in control.GetAllControls())
        {
            yield return descendant;
        }
    }
}

That's somewhat inefficient (in terms of creating lots of iterators) but I doubt that you'll have a very deep tree.

You can then write your original query as:

var checkBoxes = this.GetAllControls()
                     .OfType<CheckBox>()
                     .TakeWhile<CheckBox>(cb => cb.Checked);

(EDIT: Changed AllControls to GetAllControls and use it properly as a method.)

Answer 2

My suggestion to make the AllControls recursive is:

    public static IEnumerable<Control> AllControls(this Control parent) 
    {            
        foreach (Control control in parent.Controls) 
        { 
             yield return control;                 
        }
        foreach (Control control in parent.Controls)
        {
            foreach (Control cc in AllControls(control)) yield return cc;
        } 
    }

the second foreach looks weird but this is the only way i know to "flatten" the recursive call.