Enumerating Collections that are not inherently IEnumerable?

by

This code should do the trick

public static class Extensions
{
    public static IEnumerable<T> GetRecursively<T>(this IEnumerable collection,
        Func<T, IEnumerable> selector)
    {
        foreach (var item in collection.OfType<T>())
        {
            yield return item;

            IEnumerable<T> children = selector(item).GetRecursively(selector);
            foreach (var child in children)
            {
                yield return child;
            }
        }
    }
}

Here’s an example of how to use it

TreeView view = new TreeView();

// ...

IEnumerable<TreeNode> nodes = view.Nodes.
    .GetRecursively<TreeNode>(item => item.Nodes);

Update: In response to Eric Lippert’s post.

Here’s a much improved version using the technique discussed in All About Iterators.

public static class Extensions
{
    public static IEnumerable<T> GetItems<T>(this IEnumerable collection,
        Func<T, IEnumerable> selector)
    {
        Stack<IEnumerable<T>> stack = new Stack<IEnumerable<T>>();
        stack.Push(collection.OfType<T>());

        while (stack.Count > 0)
        {
            IEnumerable<T> items = stack.Pop();
            foreach (var item in items)
            {
                yield return item;

                IEnumerable<T> children = selector(item).OfType<T>();
                stack.Push(children);
            }
        }
    }
}

I did a simple performance test using the following benchmarking technique. The results speak for themselves. The depth of the tree has only marginal impact on the performance of the second solution; whereas the performance decreases rapidly for the first solution, eventually leadning to a StackOverflowException when the depth of the tree becomes too great.

benchmarking

More Related Contents:

  1. Dynamic LINQ OrderBy on IEnumerable / IQueryable
  2. Returning IEnumerable vs. IQueryable
  3. IEnumerable vs List – What to Use? How do they work?
  4. Optimal LINQ query to get a random sub collection – Shuffle
  5. How to get the index of an element in an IEnumerable?
  6. How to check if IEnumerable is null or empty?
  7. Differences between IQueryable, List, IEnumerator?
  8. Is there an IEnumerable implementation that only iterates over it’s source (e.g. LINQ) once?
  9. Split an IEnumerable into fixed-sized chunks (return an IEnumerable where the inner sequences are of fixed length) [duplicate]
  10. Get previous and next item in a IEnumerable using LINQ
  11. Pair-wise iteration in C#, or sliding window enumerator
  12. how do I chunk an enumerable?
  13. What is the purpose of AsQueryable()?
  14. Finding symmetric difference with LINQ
  15. Binding hierarchical xml to treeview
  16. Why use .AsEnumerable() rather than casting to IEnumerable?
  17. Performance of Skip (and similar functions, like Take)
  18. Map two lists into a dictionary in C#
  19. linq query as datagrid source
  20. Quickest way to compare two generic lists for differences
  21. How do I use LINQ Contains(string[]) instead of Contains(string)
  22. Func with out parameter
  23. Linq to EntityFramework DateTime
  24. LINQ Inner-Join vs Left-Join
  25. Return all enumerables with yield return at once; without looping through
  26. Filter a list by another list C#
  27. Easiest way to Rotate a List in c#
  28. List sort based on another list
  29. Linq Select 5 items per Iteration [duplicate]
  30. LINQ to SQL Where Clause Optional Criteria

Leave a Comment