WPF: How do I loop through the all controls in a window?

Question

How do I loop through the all controls in a window in WPF?

Answer 1

I tried it myself and I found an elegant solution that also works in any scenario, not like all the solutions posted here that are overengineered and broken. The majority of the answers here are over-engineered and unstable.

The idea is to loop through a parent control in Windows Presentation Foundation to get the children controls of the desired type or types.

First you need a loop that has an integer, set to zero preferably, with the use of indexing and a VisualTreeHelper object that is counting all the objects within the parent control as the loop's condition.

  for(int ControlCounter = 0; ControlCounter <= VisualTreeHelper.GetChildrenCount(MaterialsContentComputerSystemsFoundationYear) - 1; ControlCounter++)
  {
          if(VisualTreeHelper.GetChild(MaterialsContentComputerSystemsFoundationYear, ControlCounter).GetType() == File1.GetType())
          {

                    Button b = (Button)VisualTreeHelper.GetChild(MaterialsContentComputerSystemsFoundationYear, ControlCounter);

                    if (ActualButtonControlIndex == App.FileIndex[ActualButtonControlIndex])
                    {
                      
                    }
                    else
                    {
                        b.Visibility = Visibility.Hidden;
                    }

                    ActualButtonControlIndex++;

                    System.Diagnostics.Debug.WriteLine(ActualButtonControlIndex + "  Button");
          }         
  }

Within the for loop you can make a conditional statement that is verifying if the type of the current control at the current index is equal with the type of control that is desired. In this example I used a control that is named and is part of the desired type of control that is currently searched. You can use a variable that is storing a button instead, for type comparison.

  var b = new Button();

  for(int ControlCounter = 0; ControlCounter <= VisualTreeHelper.GetChildrenCount(MaterialsContentComputerSystemsFoundationYear) - 1; ControlCounter++)
  {
          if(VisualTreeHelper.GetChild(MaterialsContentComputerSystemsFoundationYear, ControlCounter).GetType() == b.GetType())
          {

                    Button B = (Button)VisualTreeHelper.GetChild(MaterialsContentComputerSystemsFoundationYear, ControlCounter);

                    if (ActualButtonControlIndex == App.FileIndex[ActualButtonControlIndex])
                    {
                      
                    }
                    else
                    {
                        B.Visibility = Visibility.Hidden;
                    }

                    ActualButtonControlIndex++;

                    System.Diagnostics.Debug.WriteLine(ActualButtonControlIndex + "  Button");
          }         
  }

Within the for loop's conditional statement, an object of the type of the desired control is created that has its value set with the value of the VisualTreeHelper object at the current index casted to the type Button.

You can use the previously mentioned button to set proprieties like size, with and content, colour, etc. to the control in the application's window, within the parent control within that window, at the current index.

  var b = new Button();

  for(int ControlCounter = 0; ControlCounter <= VisualTreeHelper.GetChildrenCount(MaterialsContentComputerSystemsFoundationYear) - 1; ControlCounter++)
  {
          if(VisualTreeHelper.GetChild(MaterialsContentComputerSystemsFoundationYear, ControlCounter).GetType() == b.GetType())
          {

                    Button B = (Button)VisualTreeHelper.GetChild(MaterialsContentComputerSystemsFoundationYear, ControlCounter);

                    if (ActualButtonControlIndex == App.FileIndex[ActualButtonControlIndex])
                    {
                        B.Content = "Hello";
                        B.FontSize = 20;
                        B.BackGround = new SolidColorBrush(Colors.Red);
                        
                    }
                    else
                    {
                        B.Visibility = Visibility.Hidden;
                    }

                    ActualButtonControlIndex++;

                    System.Diagnostics.Debug.WriteLine(ActualButtonControlIndex + "  Button");
          }         
  }

This solution is modular, simple and super-stable and thus useful in any scenario, give a like.

Answer 2

The previous answers will all return the children that are identified by VisualTreeHelper.GetChildrenCount and VisualTreeHelper.GetChild. However, I have found that for a TabControl, the TabItems and their content are not identified as children. Thus, these would be omitted, and I think the original question ("all controls in a window") would like to have them included.

To properly loop through tabbed controls as well, you will need something like this (modified from the answer of @BrainSlugs83):

public static IEnumerable<Visual> GetChildren(this Visual parent, bool recurse = true)
{
    if (parent != null)
    {
        int count = VisualTreeHelper.GetChildrenCount(parent);
        for (int i = 0; i < count; i++)
        {
            // Retrieve child visual at specified index value.
            var child = VisualTreeHelper.GetChild(parent, i) as Visual;

            if (child != null)
            {
                yield return child;

                if (recurse)
                {
                    foreach (var grandChild in child.GetChildren(true))
                    {
                        yield return grandChild;
                    }
                    
                    // Tabs and their content are not picked up as visual children
                    if (child is TabControl childTab)
                    {
                        foreach (var childTabItem in childTab.Items)
                        {
                            yield return childTabItem;
                            foreach (var childTabItemChild in childTabItem.GetChildren(true))
                            {
                                yield return childTabItemChild;
                            }
                            if (childTabItem.Content != null && childTabItem.Content is Visual childTabItemContentAsVisual)
                            {
                                yield return childTabItemContentAsVisual;
                                foreach (var childTabItemGrandChild in childTabItemContentAsVisual.Children(true)
                                {
                                    yield return childTabItemGrandChild;
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

Alternatively, you could iterate over the logical tree instead of the visual tree:

public static IEnumerable<DependencyObject> GetLogicalChildren(this DependencyObject parent, bool recurse = true)
{
    if (parent == null) yield break;

    foreach (var child in LogicalTreeHelper.GetChildren(parent).OfType<DependencyObject>())
    {
        yield return child;
        if (recurse)
        {
            foreach (var grandChild in child.GetLogicalChildren(true))
            {
                yield return grandChild;
            }
        }
    }
}

Answer 3

I've used the following to get all controls.

    public static IList<Control> GetControls(this DependencyObject parent)
    {            
        var result = new List<Control>();
        for (int x = 0; x < VisualTreeHelper.GetChildrenCount(parent); x++)
        {
            DependencyObject child = VisualTreeHelper.GetChild(parent, x);
            var instance = child as Control;

            if (null != instance)
                result.Add(instance);

            result.AddRange(child.GetControls());
        } 
        return result;
    }

Answer 4

This way is superior to the MSDN method, in that it's reusable, and it allows early aborting of the loop (i.e. via, break;, etc.) -- it optimizes the for loop in that it saves a method call for each iteration -- and it also lets you use regular for loops to loop through a Visual's children, or even recurse it's children and it's grand children -- so it's much simpler to consume.

To consume it, you can just write a regular foreach loop (or even use LINQ):

foreach (var ctrl in myWindow.GetChildren())
{
    // Process children here!
}

Or if you don't want to recurse:

foreach (var ctrl in myWindow.GetChildren(false))
{
    // Process children here!
}

To make it work, you just need put this extension method into any static class, and then you'll be able to write code like the above anytime you like:

public static IEnumerable<Visual> GetChildren(this Visual parent, bool recurse = true)
{
    if (parent != null)
    {
        int count = VisualTreeHelper.GetChildrenCount(parent);
        for (int i = 0; i < count; i++)
        {
            // Retrieve child visual at specified index value.
            var child = VisualTreeHelper.GetChild(parent, i) as Visual;

            if (child != null)
            {
                yield return child;

                if (recurse)
                {
                    foreach (var grandChild in child.GetChildren(true))
                    {
                        yield return grandChild;
                    }
                }
            }
        }
    }
}

Also, if you don't like recursion being on by default, you can change the extension method's declaration to have recurse = false be the default behavior.

Answer 5

I found this in the MSDN documenation so it helps.

// Enumerate all the descendants of the visual object.
static public void EnumVisual(Visual myVisual)
{
    for (int i = 0; i < VisualTreeHelper.GetChildrenCount(myVisual); i++)
    {
        // Retrieve child visual at specified index value.
        Visual childVisual = (Visual)VisualTreeHelper.GetChild(myVisual, i);

        // Do processing of the child visual object.

        // Enumerate children of the child visual object.
        EnumVisual(childVisual);
    }
}

Looks simpler to me. I used it to find textboxes in a form and clear their data.

Answer 6

A slight variation on the MSDN answer ... just pass in an empty List of Visual objects into it and your collection will be populated with all the child visuals:

/// <summary>
/// Enumerate all the descendants (children) of a visual object.
/// </summary>
/// <param name="parent">Starting visual (parent).</param>
/// <param name="collection">Collection, into which is placed all of the descendant visuals.</param>
public static void EnumVisual(Visual parent, List<Visual> collection)
{
    for (int i = 0; i < VisualTreeHelper.GetChildrenCount(parent); i++)
    {
        // Get the child visual at specified index value.
        Visual childVisual = (Visual)VisualTreeHelper.GetChild(parent, i);

        // Add the child visual object to the collection.
        collection.Add(childVisual);

        // Recursively enumerate children of the child visual object.
        EnumVisual(childVisual, collection);
    }
}

Answer 7

Class to get a list of all the children's components of a control:

class Utility
    {
        private static StringBuilder sbListControls;

        public static StringBuilder GetVisualTreeInfo(Visual element)
        {
            if (element == null)
            {
                throw new ArgumentNullException(String.Format("Element {0} is null !", element.ToString()));
            }

            sbListControls = new StringBuilder();

            GetControlsList(element, 0);

            return sbListControls;
        }

        private static void GetControlsList(Visual control, int level)
        {
            const int indent = 4;
            int ChildNumber = VisualTreeHelper.GetChildrenCount(control);

            for (int i = 0; i <= ChildNumber - 1; i++)
            {
                Visual v = (Visual)VisualTreeHelper.GetChild(control, i);

                sbListControls.Append(new string(' ', level * indent));
                sbListControls.Append(v.GetType());
                sbListControls.Append(Environment.NewLine);

                if (VisualTreeHelper.GetChildrenCount(v) > 0)
                {
                    GetControlsList(v, level + 1);
                }
            }
        }
    }