Refactored enumerable parent/child visual tree extensions

Author: Sergio0694

Microsoft.Toolkit.Uwp.UI/Extensions/Tree/LogicalTree.cs

@@ -135,7 +135,6 @@ public static class LogicalTree
         public static T? FindChild<T, TState>(this FrameworkElement element, TState state, Func<T, TState, bool> predicate)
             where T : notnull, FrameworkElement
         {
-
             if (element is Panel panel)
             {
                 foreach (UIElement child in panel.Children)
@@ -282,71 +281,60 @@ public static class LogicalTree
         }
 
         /// <summary>
-        /// Find all logical child controls of the specified type.
+        /// Find all logical child elements of the specified element. This method can be chained with
+        /// LINQ calls to add additional filters or projections on top of the returned results.
+        /// <para>
+        /// This method is meant to provide extra flexibility in specific scenarios and it should not
+        /// be used when only the first item is being looked for. In those cases, use one of the
+        /// available <see cref="FindChild{T}(FrameworkElement)"/> overloads instead, which will
+        /// offer a more compact syntax as well as better performance in those cases.
+        /// </para>
         /// </summary>
-        /// <typeparam name="T">Type to search for.</typeparam>
-        /// <param name="element">Parent element.</param>
-        /// <returns>Child controls or empty if not found.</returns>
-        public static IEnumerable<T> FindChildren<T>(this FrameworkElement element)
-            where T : FrameworkElement
+        /// <param name="element">The root element.</param>
+        /// <returns>All the child <see cref="FrameworkElement"/> instance from <paramref name="element"/>.</returns>
+        public static IEnumerable<FrameworkElement> FindChildren(this FrameworkElement element)
         {
-            if (element == null)
-            {
-                yield break;
-            }
-
-            if (element is Panel)
+            if (element is Panel panel)
             {
-                foreach (var child in (element as Panel).Children)
+                foreach (UIElement child in panel.Children)
                 {
-                    if (child is T)
+                    if (child is not FrameworkElement current)
                     {
-                        yield return child as T;
+                        continue;
                     }
 
-                    var childFrameworkElement = child as FrameworkElement;
+                    yield return current;
 
-                    if (childFrameworkElement != null)
+                    foreach (FrameworkElement childOfChild in FindChildren(current))
                     {
-                        foreach (T childOfChild in childFrameworkElement.FindChildren<T>())
-                        {
-                            yield return childOfChild;
-                        }
+                        yield return childOfChild;
                     }
                 }
             }
-            else if (element is ItemsControl)
+            else if (element is ItemsControl itemsControl)
             {
-                foreach (var item in (element as ItemsControl).Items)
+                foreach (object item in itemsControl.Items)
                 {
-                    var childFrameworkElement = item as FrameworkElement;
+                    if (item is not FrameworkElement current)
+                    {
+                        continue;
+                    }
 
-                    if (childFrameworkElement != null)
+                    yield return current;
+
+                    foreach (FrameworkElement childOfChild in FindChildren(current))
                     {
-                        foreach (T childOfChild in childFrameworkElement.FindChildren<T>())
-                        {
-                            yield return childOfChild;
-                        }
+                        yield return childOfChild;
                     }
                 }
             }
-            else
+            else if (element.TryGetContentControl() is FrameworkElement contentControl)
             {
-                var content = element.TryGetContentControl();
+                yield return contentControl;
 
-                if (content is T)
+                foreach (FrameworkElement childOfChild in FindChildren(contentControl))
                 {
-                    yield return content as T;
-                }
-
-                var childFrameworkElement = content as FrameworkElement;
-
-                if (childFrameworkElement != null)
-                {
-                    foreach (T childOfChild in childFrameworkElement.FindChildren<T>())
-                    {
-                        yield return childOfChild;
-                    }
+                    yield return childOfChild;
                 }
             }
         }
@@ -544,6 +532,33 @@ public static IEnumerable<T> FindChildren<T>(this FrameworkElement element)
             return FindParent(element, state, predicate);
         }
 
+        /// <summary>
+        /// Find all parent elements of the specified element. This method can be chained with
+        /// LINQ calls to add additional filters or projections on top of the returned results.
+        /// <para>
+        /// This method is meant to provide extra flexibility in specific scenarios and it should not
+        /// be used when only the first item is being looked for. In those cases, use one of the
+        /// available <see cref="FindParent{T}(FrameworkElement)"/> overloads instead, which will
+        /// offer a more compact syntax as well as better performance in those cases.
+        /// </para>
+        /// </summary>
+        /// <param name="element">The root element.</param>
+        /// <returns>All the parent <see cref="FrameworkElement"/> instance from <paramref name="element"/>.</returns>
+        public static IEnumerable<FrameworkElement> FindParents(this FrameworkElement element)
+        {
+            while (true)
+            {
+                if (element.Parent is not FrameworkElement parent)
+                {
+                    yield break;
+                }
+
+                yield return parent;
+
+                element = parent;
+            }
+        }
+
         /// <summary>
         /// Tries to retrieve the content property of this element as defined by <see cref="ContentPropertyAttribute"/>.
         /// </summary>

Microsoft.Toolkit.Uwp.UI/Extensions/Tree/VisualTree.cs

@@ -228,28 +228,30 @@ public static class VisualTree
         }
 
         /// <summary>
-        /// Find all descendant controls of the specified type.
+        /// Find all descendant elements of the specified element. This method can be chained with
+        /// LINQ calls to add additional filters or projections on top of the returned results.
+        /// <para>
+        /// This method is meant to provide extra flexibility in specific scenarios and it should not
+        /// be used when only the first item is being looked for. In those cases, use one of the
+        /// available <see cref="FindDescendant{T}(DependencyObject)"/> overloads instead, which will
+        /// offer a more compact syntax as well as better performance in those cases.
+        /// </para>
         /// </summary>
-        /// <typeparam name="T">Type to search for.</typeparam>
-        /// <param name="element">Parent element.</param>
-        /// <returns>Descendant controls or empty if not found.</returns>
-        public static IEnumerable<T> FindDescendants<T>(this DependencyObject element)
-            where T : DependencyObject
+        /// <param name="element">The root element.</param>
+        /// <returns>All the descendant <see cref="DependencyObject"/> instance from <paramref name="element"/>.</returns>
+        public static IEnumerable<DependencyObject> FindDescendants(this DependencyObject element)
         {
-            var childrenCount = VisualTreeHelper.GetChildrenCount(element);
+            int childrenCount = VisualTreeHelper.GetChildrenCount(element);
 
             for (var i = 0; i < childrenCount; i++)
             {
-                var child = VisualTreeHelper.GetChild(element, i);
-                var type = child as T;
-                if (type != null)
-                {
-                    yield return type;
-                }
+                DependencyObject child = VisualTreeHelper.GetChild(element, i);
 
-                foreach (T childofChild in child.FindDescendants<T>())
+                yield return child;
+
+                foreach (DependencyObject childOfChild in FindDescendants(child))
                 {
-                    yield return childofChild;
+                    yield return childOfChild;
                 }
             }
         }
@@ -454,18 +456,31 @@ public static IEnumerable<T> FindDescendants<T>(this DependencyObject element)
         }
 
         /// <summary>
-        /// Find all visual ascendants for the element.
+        /// Find all ascendant elements of the specified element. This method can be chained with
+        /// LINQ calls to add additional filters or projections on top of the returned results.
+        /// <para>
+        /// This method is meant to provide extra flexibility in specific scenarios and it should not
+        /// be used when only the first item is being looked for. In those cases, use one of the
+        /// available <see cref="FindAscendant{T}(DependencyObject)"/> overloads instead, which will
+        /// offer a more compact syntax as well as better performance in those cases.
+        /// </para>
         /// </summary>
-        /// <param name="element">Child element.</param>
-        /// <returns>A collection of parent elements or null if none found.</returns>
+        /// <param name="element">The root element.</param>
+        /// <returns>All the descendant <see cref="DependencyObject"/> instance from <paramref name="element"/>.</returns>
         public static IEnumerable<DependencyObject> FindAscendants(this DependencyObject element)
         {
-            var parent = VisualTreeHelper.GetParent(element);
-
-            while (parent != null)
+            while (true)
             {
+                DependencyObject? parent = VisualTreeHelper.GetParent(element);
+
+                if (parent is null)
+                {
+                    yield break;
+                }
+
                 yield return parent;
-                parent = VisualTreeHelper.GetParent(parent);
+
+                element = parent;
             }
         }
     }