LINQ: можем ли мы создать плоский список из иерархии

EDIT: теперь, когда у нас есть немного больше контекста, похоже, у вас действительно есть XML для начала. Однако мы все еще не знаем, какую обработку вы выполняете над элементами. В XSLT мая быть правильным подходом, но другим было бы использовать LINQ to XML и его Descendants способ:

var doc = XDocument.Load(stream);
var descendants = doc.Descendants("Folder");
// Use descendants now

это мая в конечном итоге еще проще, чем подход XSLT. Например, если вы хотите преобразовать его в List<string>, принимая атрибут от каждого элемента:

var doc = XDocument.Load(stream);
var names = doc.Descendants("Folder")
               .Select(x => (strong) x.Attribute("name"))
               .ToList();   

один недостаток заключается в том, что это все равно загрузит весь XML-файл в память как XElement (и т. д.) объектов. Вполне возможно, что версия XSLT может обрабатывать это потоковым способом с более эффективным использованием памяти. Дмитрий, без сомнения, может дать больше информации, если это имеет отношение.

в LINQ нет ничего, чтобы сгладить несколько уровни иерархии без рекурсии себя. SelectMany выполняет один уровень выравнивания, но вам нужно рекурсивно сгладить многоуровневую иерархию до одного списка.

теперь, если вы используете LINQ to XML, это тут поддержка его очень легко - вы можете просто использовать Descendants способ:

var allFolders = root.Descendants("Folder");

чтобы написать что-то подобное для вашего класса домена, вам нужно будет написать больше кода. Если вы можете дать больше информации о том, что ты действительно got (классы XML или домена) мы возможно, это поможет вам больше.

EDIT: Хорошо, похоже, что XML - это отвлекающий маневр. Но найти всех потомков довольно легко. Вы can сделайте это с помощью блоков итератора, но это становится довольно неприятно неэффективным довольно быстро. Вот еще одна простая альтернатива:

public IList<Folder> SelfAndDescendants()
{
    List<Folder> ret = new List<Folder>();
    AddSelfAndDescendants(ret);
    return ret;
}

private void AddSelfAndDescendants(IList<Folder> list)
{
    list.Add(this);
    foreach (var child in children)
    {
        AddSelfAndDescendants(list);
    }
}

вы можете настроить точный алгоритм, основанный на порядке, в котором вы хотите вернуть детей.

вы можете использовать SelectMany, чтобы сгладить наследственность

http://msdn.microsoft.com/en-us/library/bb534336.aspx

вот метод расширения linq-style, который делает то, что вы просите (без рекурсии, обрабатываемых циклов).

    public static IEnumerable<T> WalkTreeDepthFirst<T>(this IEnumerable<T> source,
       Func<T, IEnumerable<T>> childFunction)
    {
        // http://en.wikipedia.org/wiki/Depth-first_search
        HashSet<T> seenIt = new HashSet<T>();
        Stack<T> toVisit = new Stack<T>();

        foreach (T item in source.Reverse())
        {
            toVisit.Push(item);
        }

        while (toVisit.Any())
        {
            T item = toVisit.Pop();
            if (!seenIt.Contains(item))
            {
                seenIt.Add(item);
                foreach (T child in childFunction(item).Reverse())
                {
                    toVisit.Push(child);
                }
                yield return item;
            }
        }
    }

Это было бы с моей первой попытки:

    public static IEnumerable<Folder> SelfPlusChildren(Folder f)
    {
        return new[] {f}.Concat(f.Children.SelectMany(SelfPlusChildren));
    }

вы можете написать простой метод расширения, чтобы сделать это:

public static IEnumerable<Folder> GetFolders(this Folder rootFolder)
{
    yield return rootFolder;

    foreach (var child in rootFolder.Children)
        foreach(var folder in GetFolders(child))
            yield return folder;
}

или короче с помощью SelectMany():

public static IEnumerable<Folder> GetFolders(this Folder rootFolder)
{
    yield return rootFolder;

    foreach (var folder in rootFolder.Children.SelectMany(GetFolders))
        yield return folder;
}

в .Net framework нет стандартной реализации, но вы можете реализовать ее самостоятельно.

вот как вы можете сделать это:

public static IEnumerable<T> FlattenTree<T>(this T root, Func<T, IEnumerable<T>> getChildren)
{
    var state = new Stack<T>();
    state.Push(root);

    while (state.Count != 0)
    {
        T top = state.Pop();
        yield return top;

        IEnumerable<T> children = getChildren(top) ?? Enumerable.Empty<T>();
        foreach (T child in children.Reverse())
        {
            state.Push(child);
        }
    }
}