WPF: Comment faire une boucle sur tous les contrôles dans une fenêtre?

Question

Comment faire une boucle sur tous les contrôles dans une fenêtre dans WPF?

Answer 1

classe pour obtenir une liste de tous les composants des enfants d'un contrôle:

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); 
       } 
      } 
     } 
    } 

Answer 2

Je trouve cela dans le MSDN documenation il aide.

// 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); 
    } 
} 

Cela me semble plus simple. Je l'ai utilisé pour trouver des zones de texte dans un formulaire et effacer leurs données.

Answer 3

Une légère variation de la réponse MSDN ... il suffit de passer dans une liste vide d'objets visuels dans votre collection et sera peuplée avec tous les visuels de l'enfant:

/// <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 4

De cette façon, est supérieure à la Méthode MSDN, en ce sens qu'il est réutilisable, et permet l'abandon prématuré de la boucle (par exemple, break;, etc.) - il optimise la boucle for en ce qu'il enregistre un appel de méthode pour chaque itération - et il vous permet également d'utiliser régulièrement pour que les boucles circulent à travers les enfants d'un Visual, ou même pour recurse ses enfants et ses grands enfants - il est donc beaucoup plus simple de consommer.

A consommer, vous pouvez simplement écrire une boucle régulière foreach (ou même utiliser LINQ):

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

Ou si vous ne voulez pas récursif:

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

Pour le rendre travail, vous avez juste besoin de mettre cette méthode d'extension dans une classe statique, et puis vous serez capable d'écrire du code comme ci-dessus quand vous le souhaitez:

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; 
        } 
       } 
      } 
     } 
    } 
} 

En outre, si vous ne souhaitez pas que la récursivité soit activée par défaut, vous pouvez modifier la déclaration de la méthode d'extension afin que recurse = false devienne le comportement par défaut.

Answer 5

J'ai utilisé ce qui suit pour obtenir tous les contrôles.

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; 
    }