Comment faire une recherche Hiérarchique des Données avec Linq

Une autre solution sans récursivité...

var result = FamilyToEnumerable(familyRoot)
                .Where(f => f.Name == "FamilyD");


IEnumerable<Family> FamilyToEnumerable(Family f)
{
    Stack<Family> stack = new Stack<Family>();
    stack.Push(f);
    while (stack.Count > 0)
    {
        var family =  stack.Pop();
        yield return family;
        foreach (var child in family.Children)
            stack.Push(child);
    }
}

OriginalL'auteur EZI

J'aime Kenneth Bo Christensen de la réponse à l'aide de la pile, il fonctionne très bien, il est facile à lire et c'est rapide (et ne pas utiliser la récursivité).
La seule mauvaise chose, c'est qu'il inverse l'ordre des éléments enfants (parce que la pile FIFO). Si l'ordre de tri n'est pas question pour vous, alors il est ok.
Si il n', le tri peut être réalisé facilement à l'aide du sélecteur(en cours).Reverse() dans la boucle foreach (le reste du code est le même que dans Kenneth original post)...

public static IEnumerable<T> Flatten<T>(this T source, Func<T, IEnumerable<T>> selector)
{            
    var stack = new Stack<T>();
    stack.Push(source);
    while (stack.Count > 0)
    {
        var current = stack.Pop();
        yield return current;
        foreach (var child in selector(current).Reverse())
            stack.Push(child);
    }
}

OriginalL'auteur sth_Weird

Ainsi, l'option la plus simple est d'écrire une fonction qui parcourt votre hiérarchie et produit une seule séquence. Ensuite, cela se passe au début de votre LINQ opérations, par exemple

    IEnumerable<T> Flatten<T>(this T source)
    {
      foreach(var item in source) {
        yield item;
        foreach(var child in Flatten(item.Children)
          yield child;
      }
    }

D'appeler simplement: familyRoot.Aplatir().Où(n => n.Nom == "Bob");

Une légère alternative serait de vous donner un moyen rapide pour ignorer une branche entière:

    IEnumerable<T> Flatten<T>(this T source, Func<T, bool> predicate)
    {
      foreach(var item in source) {
         if (predicate(item)) {          
            yield item;
            foreach(var child in Flatten(item.Children)
               yield child;
      }
    }

Ensuite, vous pouvez faire des choses comme: la famille.Aplatir(n => n.Les enfants.Count > 2).Où(...)

OriginalL'auteur DamienG

Quelques variantes sur les réponses de'sNotALie., MarcinJuraszek et DamienG.

Tout d'abord, les deux anciens de donner un contre-intuitif de la commande. Pour obtenir un joli arbre de la traversée de la commande pour les résultats, il suffit d'inverser la concaténation (mettre la "source" de la première).

Deuxième, si vous travaillez avec une chère comme EF, et que vous souhaitez limiter l'ensemble d'une branche, Damien suggestion que vous injectez le prédicat est bon et qui peut encore être fait avec Linq.

Enfin, pour un chers à la source, il peut aussi être bon pour pré-sélectionner les champs d'intérêt de chaque nœud avec l'injection d'une sélection.

Mettre tous ces ensemble:

public static IEnumerable<R> Flatten<T,R>(this T source, Func<T, IEnumerable<T>> children
    , Func<T, R> selector
    , Func<T, bool> branchpredicate = null
) {
    if (children == null) throw new ArgumentNullException("children");
    if (selector == null) throw new ArgumentNullException("selector");
    var pred = branchpredicate ?? (src => true);
    if (children(source) == null) return new[] { selector(source) };

    return new[] { selector(source) }
        .Concat(children(source)
        .Where(pred)
        .SelectMany(c => Flatten(c, children, selector, pred)));
}

OriginalL'auteur Marc L.