LINQ to Tree - A Generic Technique for Querying Tree-like Structures

<#@ template language="C#" #>

using System.Linq;
using System.Collections.Generic;
using System;

<#

string typeName = "System.Windows.DependencyObject";
string adapterType = "LinqToVisualTree.VisualTreeAdapter";

 #>
 
 

namespace TreeExtensions
{
    public interface ILinqTree<T>
    {
        IEnumerable<T> Children();

        T Parent { get; }
    }
  
    public static class TreeExtensions
    {
        /// <summary>
        /// Returns a collection of descendant elements.
        /// </summary>
	    public static IEnumerable<<#=typeName#>> Descendants(this <#=typeName#> item)
        {
            ILinqTree<<#=typeName#>> adapter = new <#=adapterType#>(item);
            foreach (var child in adapter.Children())
            {
                yield return child;

                foreach (var grandChild in child.Descendants())
                {
                    yield return grandChild;
                }
            }
        }    
           
        /// <summary>
        /// Returns a collection containing this element and all descendant elements.
        /// </summary>
	    public static IEnumerable<<#=typeName#>> DescendantsAndSelf(this <#=typeName#> item)
        {            
            yield return item;

            foreach (var child in item.Descendants())
            {
                yield return child;
            }
        }
        
        /// <summary>
        /// Returns a collection of ancestor elements.
        /// </summary>
	    public static IEnumerable<<#=typeName#>> Ancestors(this <#=typeName#> item)
        {
            ILinqTree<<#=typeName#>> adapter = new <#=adapterType#>(item);
            
            var parent = adapter.Parent;
            while(parent != null)
            {
                yield return parent;
                adapter = new <#=adapterType#>(parent);
                parent = adapter.Parent;
            }
        } 
        
        /// <summary>
        /// Returns a collection containing this element and all ancestor elements.
        /// </summary>
	    public static IEnumerable<<#=typeName#>> AncestorsAndSelf(this <#=typeName#> item)
        {
            yield return item;

            foreach (var ancestor in item.Ancestors())
            {
                yield return ancestor;
            }
        }
        
        /// <summary>
        /// Returns a collection of child elements.
        /// </summary>
	    public static IEnumerable<<#=typeName#>> Elements(this <#=typeName#> item)
        {
            ILinqTree<<#=typeName#>> adapter = new <#=adapterType#>(item);
            foreach (var child in adapter.Children())
            {
                yield return child;                
            }
        }
        
        /// <summary>
        /// Returns a collection containing this element and all child elements.
        /// </summary>
	    public static IEnumerable<<#=typeName#>> ElementsAndSelf(this <#=typeName#> item)
        {
            yield return item;

            foreach (var child in item.Elements())
            {
                yield return child;
            }
        }
        
        /// <summary>
        /// Returns a collection of descendant elements which match the given type.
        /// </summary>
	    public static IEnumerable<T> Descendants<T>(this <#=typeName#> item)
        {
            return item.Descendants().Where(i => i is T).Cast<T>();
        }
        
        /// <summary>
        /// Returns a collection containing this element and all descendant elements.
        /// which match the given type.
        /// </summary>
	    public static IEnumerable<T> DescendantsAndSelf<T>(this <#=typeName#> item)
        {
            return item.DescendantsAndSelf().Where(i => i is T).Cast<T>();
        }
        
        /// <summary>
        /// Returns a collection of ancestor elements which match the given type.
        /// </summary>
	    public static IEnumerable<T> Ancestors<T>(this <#=typeName#> item)
        {
            return item.Ancestors().Where(i => i is T).Cast<T>();
        }
        
        /// <summary>
        /// Returns a collection containing this element and all ancestor elements.
        /// which match the given type.
        /// </summary>
	    public static IEnumerable<T> AncestorsAndSelf<T>(this <#=typeName#> item)
        {
            return item.AncestorsAndSelf().Where(i => i is T).Cast<T>();
        }
        
        /// <summary>
        /// Returns a collection of child elements which match the given type.
        /// </summary>
	    public static IEnumerable<T> Elements<T>(this <#=typeName#> item)
        {
            return item.Elements().Where(i => i is T).Cast<T>();
        }
        
        /// <summary>
        /// Returns a collection containing this element and all child elements.
        /// which match the given type.
        /// </summary>
	    public static IEnumerable<T> ElementsAndSelf<T>(this <#=typeName#> item)
        {
            return item.ElementsAndSelf().Where(i => i is T).Cast<T>();
        }
    }
    
    public static class EnumerableTreeExtensions
    {
        public static IEnumerable<<#=typeName#>> DrillDown(this IEnumerable<<#=typeName#>> items,
            Func<<#=typeName#>, IEnumerable<<#=typeName#>>> function)
        {
            foreach(var item in items)
            {
                foreach(var itemChild in function(item))
                {
                    yield return itemChild;
                }
            }
        }
        
        public static IEnumerable<T> DrillDown<T>(this IEnumerable<<#=typeName#>> items,
            Func<<#=typeName#>, IEnumerable<<#=typeName#>>> function)
            where T : <#=typeName#>
        {
            foreach(var item in items)
            {
                foreach(var itemChild in function(item))
                {
                    if (itemChild is T)
                    {
                        yield return (T)itemChild;
                    }
                }
            }
        }
    
        /// <summary>
        /// Returns a collection of descendant elements.
        /// </summary>
	    public static IEnumerable<<#=typeName#>> Descendants(this IEnumerable<<#=typeName#>> items)
        {
            return items.DrillDown(i => i.Descendants());
        }    
           
        /// <summary>
        /// Returns a collection containing this element and all descendant elements.
        /// </summary>
	    public static IEnumerable<<#=typeName#>> DescendantsAndSelf(this IEnumerable<<#=typeName#>> items)
        {            
            return items.DrillDown(i => i.DescendantsAndSelf());
        }
        
        /// <summary>
        /// Returns a collection of ancestor elements.
        /// </summary>
	    public static IEnumerable<<#=typeName#>> Ancestors(this IEnumerable<<#=typeName#>> items)
        {
            return items.DrillDown(i => i.Ancestors());
        } 
        
        /// <summary>
        /// Returns a collection containing this element and all ancestor elements.
        /// </summary>
	    public static IEnumerable<<#=typeName#>> AncestorsAndSelf(this IEnumerable<<#=typeName#>> items)
        {
            return items.DrillDown(i => i.AncestorsAndSelf());
        }
        
        /// <summary>
        /// Returns a collection of child elements.
        /// </summary>
	    public static IEnumerable<<#=typeName#>> Elements(this IEnumerable<<#=typeName#>> items)
        {
            return items.DrillDown(i => i.Elements());
        }
        
        /// <summary>
        /// Returns a collection containing this element and all child elements.
        /// </summary>
	    public static IEnumerable<<#=typeName#>> ElementsAndSelf(this IEnumerable<<#=typeName#>> items)
        {
            return items.DrillDown(i => i.ElementsAndSelf());
        }
        
        /// <summary>
        /// Returns a collection of descendant elements which match the given type.
        /// </summary>
	    public static IEnumerable<T> Descendants<T>(this IEnumerable<<#=typeName#>> items)
	        where T : <#=typeName#>
        {
            return items.DrillDown<T>(i => i.Descendants());
        }
        
        /// <summary>
        /// Returns a collection containing this element and all descendant elements.
        /// which match the given type.
        /// </summary>
	    public static IEnumerable<T> DescendantsAndSelf<T>(this IEnumerable<<#=typeName#>> items)
	        where T : <#=typeName#>
        {
            return items.DrillDown<T>(i => i.DescendantsAndSelf());
        }
        
        /// <summary>
        /// Returns a collection of ancestor elements which match the given type.
        /// </summary>
	    public static IEnumerable<T> Ancestors<T>(this IEnumerable<<#=typeName#>> items)
	        where T : <#=typeName#>
        {
            return items.DrillDown<T>(i => i.Ancestors());
        }
        
        /// <summary>
        /// Returns a collection containing this element and all ancestor elements.
        /// which match the given type.
        /// </summary>
	    public static IEnumerable<T> AncestorsAndSelf<T>(this IEnumerable<<#=typeName#>> items)
	        where T : <#=typeName#>
        {
            return items.DrillDown<T>(i => i.AncestorsAndSelf());
        }
        
        /// <summary>
        /// Returns a collection of child elements which match the given type.
        /// </summary>
	    public static IEnumerable<T> Elements<T>(this IEnumerable<<#=typeName#>> items)
	        where T : <#=typeName#>
        {
            return items.DrillDown<T>(i => i.Elements());
        }
        
        /// <summary>
        /// Returns a collection containing this element and all child elements.
        /// which match the given type.
        /// </summary>
	    public static IEnumerable<T> ElementsAndSelf<T>(this IEnumerable<<#=typeName#>> items)
	        where T : <#=typeName#>
        {
            return items.DrillDown<T>(i => i.ElementsAndSelf());
        }
    }
}