Can someone improve upon my solution as I worked it out below to make it a little more elegate(ie remove the result list from the recursive function.

public static class ProjectTemplateExtensions
{
public static IEnumerable RazorTemplates(this ProjectTemplate projectTemplate)
{
var razorTemplates = new List();
foreach (var folder in projectTemplate.Folders)
{
PopulateRazorTemplates(folder, ref razorTemplates);
}
}

public static void PopulateRazorTemplates(Folder folder, ref List razorTemplates)
{
razorTemplates.AddRange(folder.RazorTemplates);

foreach (var childFolder in folder.Folders)
{
PopulateRazorTemplates( childFolder, ref razorTemplates);
}
}
}

It does not expose an sub-list, but the elements exposed by the Controls colection expose the Controls property.

I did your homework (in C#) ;) I made a new class LevelAndData, which is used both internally in the new FlattenHierarchyWithLevels method and as the return type.

I think this does what you ask:

public static class LinqToHierarchical
{
	public class LevelAndData<T>
	{
		public int Level { get; set; }
		public T Data { get; set; }
	}
 
	public static IEnumerable<LevelAndData<T>> FlattenHierarchyWithLevel<T>(this T node, Func<T, IEnumerable<T>> getChildEnumerator)
	{
		yield return new LevelAndData<T> {Level = 1, Data = node};
		if (getChildEnumerator(node) != null)
		{
			foreach (var child in getChildEnumerator(node))
			{
				foreach (var childOrDescendant in child.FlattenHierarchyWithLevel(getChildEnumerator))
				{
					yield return new LevelAndData<T>{ Level = childOrDescendant.Level+1, Data = childOrDescendant.Data};
				}
			}
		}
	}
}

Here’s how to use it:

class Program
{
	private static void Main(string[] args)
	{
		var q = from directory in new DirectoryInfo(@"c:\")
					.FlattenHierarchyWithLevel(x => x.GetDirectories())
				select directory;
 
		foreach (var levelAndData in q.Take(10))
		{
			Console.WriteLine(levelAndData.Level + " - " + levelAndData.Data.Name);
		}
 
		Console.WriteLine("\nPress ENTER...");
		Console.ReadLine();
	}
}

You’ll need to VB-ify it yourself. Hope it helps!

I was a “C” programmer for more than a decade but have become much more comfortable using VB.net.

I like the idea of having recursive calls because then I dont have to code for each level, but am struggling with your suggestion of how to return the depth.

Would it be just add one to the current depth on each return?

Could you post a little snippet (in vb 2010) of how that would be done?

I am really intrigued by your concept of flatting the hiearachy. Seems much more elegant than the way I am doing it now but keeping track of which level I am in and reading the next node to see if there are any children. The way I am doing it now, I have to know ahead of time how many levels to program for. Ugh…

Any futher help would be very much appreciated.

Putting the results in a list, would allow you to walk to next or previous node with the indexer. But part of your problem is that you don’t have the depth/level of the original node.

Well, this article is really about flattening the hierarchy, so any information about depth or level in the hierarchy will be lost.

You can however modify my code, and add a level counter mechanism to it. The steps would be something like this:
1. Take in an aditional parameter to the FlattenHierarchy method. (int depth)
2. On both yield return statements you could return a new object that has both the depth+1 and the data to return.
3. Modify the calls to the FlattenHierarchy method to include current depth.

Hope this helps you on your way!

E:\DVDs
–Awaydays
–Dog Days
–Die Hard Series
—-Die Hard 1
—-Die Hard 2
—-Die Hard 3
–Get Smart
–Happy Gilmore
F:\DVDs

I have tried using a recursive call down the tree and storing that in a List(of T), but the problem comes in trying to assign the Selected method to the List…

TreeView1.Selected = t_myDVDs.MovieName

Should I store a List(of Nodes) perhaps?

By traversing the List instead of the tree, it would seem to make the “Previous” trip back up the tree less complicated, yes?

Please help. I have been fighting this for days.

I can do it to a certian degree, but it has problems.

The problem occurs when you step into a child. For example.

+MyDVDs
–Awaydays
–Dog Days
–Die Hard Series
—-Die Hard 1
—-Die Hard 2
—-Die Hard 3
–Get Smart
–Happy Gilmore

How can I click “Next” and have it traverse down the tree, one step at a time, and then at any point, traverse back up the tree?

Please help.

Imports System.Runtime.CompilerServices
Imports System.IO

Public Class Form1

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

Dim ctrls = From ctrl In CType(Me, Control).FlattenHierarchy(Function(x As Control) x.Controls.Cast(Of Control)())
Select ctrl

Dim directories = From directory In New DirectoryInfo(“C:\temp”).FlattenHierarchy(Function(x As DirectoryInfo) x.GetDirectories())
Select directory.FullName

End Sub
End Class

Module X
_
Public Function FlattenHierarchy(Of T)(ByVal node As T, ByVal getChildEnumerator As System.Func(Of T, IEnumerable(Of T))) As IEnumerable(Of T)
Dim q As New List(Of T) From {node}
Dim children As IEnumerable(Of T) = getChildEnumerator(node)

If children IsNot Nothing Then
For Each child As T In children
For Each childOrDescendant In child.FlattenHierarchy(getChildEnumerator)
q.Add(childOrDescendant)
Next
Next
End If

Return q
End Function
End Module

…and you obviously understand how most people think or feel challenged on the subject.

I also like the part where you encourage some tests rather than none. After a while you and your team might understand their true value, what works and what does not…