Added more finite interfaces for adaptablility.

Moved GetDescendants and GetNodes to ParentExtensions.

Author: electricessence

IChild.cs

@@ -0,0 +1,42 @@
+using System.Collections.Generic;
+
+namespace Open.Hierarchy
+{
+	public interface IChild
+	{
+		object Parent { get; }
+	}
+
+	public interface IChild<out TParent> : IChild
+    {
+		new TParent Parent { get; }
+    }
+
+	public static class ChildExtensions
+	{
+		public static IEnumerable<TNode> GetAncestors<TNode>(
+			this TNode node)
+			where TNode : IChild<TNode>
+		{
+			TNode parent;
+			while ((parent = node.Parent) != null)
+			{
+				yield return parent;
+				node = parent;
+			}
+		}
+
+		public static TNode GetRoot<TNode>(
+			this TNode node)
+			where TNode : IChild<TNode>
+		{
+			TNode parent;
+			while ((parent = node.Parent) != null)
+			{
+				node = parent;
+			}
+			return node;
+		}
+	}
+
+}

IHaveRoot.cs

@@ -1,7 +1,12 @@
 namespace Open.Hierarchy
 {
-	public interface IHaveRoot<TRoot>
+	public interface IHaveRoot
+	{
+		object Root { get; }
+	}
+
+	public interface IHaveRoot<out TRoot> : IHaveRoot
     {
-		TRoot Root { get; }
+		new TRoot Root { get; }
     }
 }

INode.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace Open.Hierarchy
+{
+	public interface INode<TNode> : ICollection<TNode>, IChild<TNode>, IParent<TNode>, IHaveRoot<TNode>
+		where TNode : INode<TNode>
+	{
+    }
+	
+}

IParent.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Open.Hierarchy
 {
@@ -12,4 +13,63 @@ public interface IParent<out TChild> : IParent
 		new IReadOnlyList<TChild> Children { get; }
 	}
 
+	public static class ParentExtensions
+	{
+
+		/// <summary>
+		/// Returns all descendant nodes.
+		/// </summary>
+		/// <param name="traversal">The mode by which the tree is traversed.</param>
+		/// <returns>The enumeration of all the descendant nodes.</returns>
+		public static IEnumerable<TNode> GetDescendants<TNode>(
+			this TNode node, TraversalMode traversal = TraversalMode.BreadthFirst)
+			where TNode : IParent<TNode>
+		{
+			// Attempt to be more breadth first.
+			switch (traversal)
+			{
+				case TraversalMode.BreadthFirst:
+					foreach (var child in node.Children)
+						yield return child;
+
+					var grandchildren = node.Children.SelectMany(c => c.Children);
+					foreach (var grandchild in grandchildren)
+						yield return grandchild;
+
+					foreach (var descendant in grandchildren
+						.SelectMany(c => c.GetDescendants()))
+						yield return descendant;
+
+					break;
+
+
+				case TraversalMode.DepthFirst:
+
+					foreach (var descendant in node.Children
+						.SelectMany(c => c.GetDescendants(TraversalMode.DepthFirst)))
+						yield return descendant;
+
+					break;
+			}
+
+		}
+
+		/// <summary>
+		/// Returns all descendant nodes and includes this node.
+		/// Breadth first returns this node first.  Depth first returns this node last.
+		/// </summary>
+		/// <param name="traversal">The mode by which the tree is traversed.</param>
+		/// <returns>The enumeration of all the descendant nodes including this one.</returns>
+		public static IEnumerable<TNode> GetNodes<TNode>(
+			this TNode node, TraversalMode traversal = TraversalMode.BreadthFirst)
+			where TNode : IParent<TNode>
+		{
+			if (traversal == TraversalMode.BreadthFirst)
+				yield return node;
+			foreach (var descendant in node.GetDescendants(traversal))
+				yield return descendant;
+			if (traversal == TraversalMode.DepthFirst)
+				yield return node;
+		}
+	}
 }

Node.cs

@@ -6,15 +6,19 @@
 
 namespace Open.Hierarchy
 {
-
-	public sealed class Node<T> : ICollection<Node<T>>, IHaveRoot<Node<T>>, IParent<Node<T>>
+	public sealed class Node<T> : INode<Node<T>>
 	{
+		#region IChild<Node<T>> Implementation
 		Node<T> _parent;
 		public Node<T> Parent => _parent;
+		object IChild.Parent => _parent;
+		#endregion
 
+		#region IParent<Node<T>> Implementation
 		readonly List<Node<T>> _children;
 		public IReadOnlyList<Node<T>> Children { get; private set; }
 		IReadOnlyList<object> IParent.Children => Children;
+		#endregion
 
 		public T Value { get; set; }
 
@@ -23,6 +27,9 @@ public sealed class Node<T> : ICollection<Node<T>>, IHaveRoot<Node<T>>, IParent<
 			_children = new List<Node<T>>();
 			Children = _children.AsReadOnly();
 		}
+
+		// WARNING: Care must be taken not to have duplicate nodes anywhere in the tree but having duplicate values are allowed.
+
 		#region ICollection<Node<T>> Implementation
 		public bool IsReadOnly => false;
 
@@ -98,66 +105,47 @@ public void Detatch()
 		}
 
 
-		/// <summary>
-		/// Iterates through all of the descendants of this node starting breadth first.
-		/// </summary>
-		/// <returns>All the descendants of this node.</returns>
-		public IEnumerable<Node<T>> GetDescendants()
-		{
-			// Attempt to be more breadth first.
-
-			foreach (var child in _children)
-				yield return child;
-
-			var grandchildren = _children.SelectMany(c => c);
-			foreach (var grandchild in grandchildren)
-				yield return grandchild;
-
-			foreach (var descendant in grandchildren.SelectMany(c => c.GetDescendants()))
-				yield return descendant;
-		}
-
-		/// <returns>This and all of its descendants.</returns>
-		public IEnumerable<Node<T>> GetNodes()
-		{
-			yield return this;
-			foreach (var descendant in GetDescendants())
-				yield return descendant;
-		}
-
 		/// <summary>
 		/// Finds the root node of this tree.
 		/// </summary>
 		public Node<T> Root
 		{
 			get
 			{
-				var current = this;
-				while (current._parent != null)
-					current = current._parent;
+				Node<T> current = this;
+				Node<T> parent;
+				while ((parent = current._parent) != null)
+				{
+					current = parent;
+				}
 				return current;
 			}
 		}
 
-		internal void Teardown(Factory factory = null)
+		object IHaveRoot.Root => Root;
+
+		internal void Teardown()
 		{
 			Value = default(T);
 			Detatch(); // If no parent then this does nothing...
-			if (factory == null)
+			foreach (var c in _children)
 			{
-				foreach (var c in _children)
-				{
-					c._parent = null; // Don't initiate a 'Detach' (which does a lookup) since we are clearing here;
-					c.Teardown();
-				}
+				c._parent = null; // Don't initiate a 'Detach' (which does a lookup) since we are clearing here;
+				c.Teardown();
 			}
-			else
+			_children.Clear();
+		}
+
+		internal void Recycle(Factory factory)
+		{
+			if (factory == null) throw new ArgumentNullException("factory");
+
+			Value = default(T);
+			Detatch(); // If no parent then this does nothing...
+			foreach (var c in _children)
 			{
-				foreach (var c in _children)
-				{
-					c._parent = null; // Don't initiate a 'Detach' (which does a lookup) since we are clearing here;
-					factory.RecycleInternal(c);
-				}
+				c._parent = null; // Don't initiate a 'Detach' (which does a lookup) since we are clearing here;
+				factory.RecycleInternal(c);
 			}
 			_children.Clear();
 		}
@@ -201,12 +189,10 @@ internal void RecycleInternal(Node<T> n)
 
 			void PrepareForPool(Node<T> n)
 			{
-				n.Teardown(this);
+				n.Recycle(this);
 			}
 			#endregion
 
-			// WARNING: Care must be taken not to have duplicate nodes anywhere in the tree but having duplicate values are allowed.
-
 			/// <summary>
 			/// Clones a node by recreating the tree and copying the values.
 			/// </summary>
@@ -268,7 +254,7 @@ public Node<T> CloneTree(Node<T> target)
 			/// <param name="root">The root instance.</param>
 			/// <returns>The full map of the root.</returns>
 			public Node<T> Map<TRoot>(TRoot root)
-			where TRoot : T
+				where TRoot : T
 			{
 				AssertIsAlive();
 

TraversalMode.cs

@@ -0,0 +1,8 @@
+namespace Open.Hierarchy
+{
+	public enum TraversalMode
+    {
+		DepthFirst,
+		BreadthFirst
+    }
+}