Linq Erweiterung Methode, wie Kind in Sammlung rekursiv zu finden

Question

Ich bin bereits vertraut mit Linq, aber habe wenig Verständnis für Erweiterungsmethoden Ich hoffe, dass jemand mir helfen kann. So

Ich habe diese hierarchische Sammlung Pseudo-Code, dh:

class Product 
    prop name 
    prop type 
    prop id 
    prop List<Product> children 

Und ich habe eine Liste der Produkte Liste Produkte.

Gibt es eine Möglichkeit, Produkt in dieser Sammlung von der ID mit einer Erweiterungsmethode zu suchen? Mit anderen Worten, ich brauche einen Gegenstand irgendwo in der Hierarchie.

Answer 1

Dies ist eine generische Lösung, die Kurzschlussdurchlauf der Hierarchie wird, sobald eine Übereinstimmung gefunden wird.

public static class MyExtensions 
{ 
    public static T FirstOrDefaultFromMany<T>(
     this IEnumerable<T> source, Func<T, IEnumerable<T>> childrenSelector, 
     Predicate<T> condition) 
    { 
     // return default if no items 
     if(source == null || !source.Any()) return default(T); 

     // return result if found and stop traversing hierarchy 
     var attempt = source.FirstOrDefault(t => condition(t)); 
     if(!Equals(attempt,default(T))) return attempt; 

     // recursively call this function on lower levels of the 
     // hierarchy until a match is found or the hierarchy is exhausted 
     return source.SelectMany(childrenSelector) 
      .FirstOrDefaultFromMany(childrenSelector, condition); 
    } 
} 

Um es in Ihrem Fall zu verwenden:

var matchingProduct = products.FirstOrDefaultFromMany(p => p.children, p => p.Id == 27); 

Answer 2

Sie können Ihre Baumstruktur mit dieser Erweiterung Methode glätten:

static IEnumerable<Product> Flatten(this IEnumerable<Product> source) 
{ 
    return source.Concat(source.SelectMany(p => p.Children.Flatten())); 
} 

Verbrauch:

var product42 = products.Flatten().Single(p => p.Id == 42); 

Beachten Sie, dass dies wahrscheinlich nicht sehr schnell ist. Wenn Sie wiederholt ein Produkt von ID finden müssen, erstellen Sie ein Wörterbuch:

var dict = products.Flatten().ToDictionary(p => p.Id); 

var product42 = dict[42]; 

Answer 3

Wenn Sie auf „sub-iterate“ wollen und ein Kind in einer Liste der Produkte finden:

List<Product> 
    Product 
     Child 
     Child 
     Child 
     Child 
    Product 
     Child 
     Child *find this one 
     Child 

können Sie Verwenden Sie die vorhandene Erweiterungsmethode . SelectMany kann verwendet werden, um eine zweistufige Hierarchie zu "glätten".

Hier ist eine große Erklärung von Select: http://team.interknowlogy.com/blogs/danhanan/archive/2008/10/10/use-linq-s-selectmany-method-to-quot-flatten-quot-collections.aspx

Ihre Syntax wie folgt möchte:

List<Product> p = GetProducts(); //Get a list of products 
var child = from c in p.SelectMany(p => p.Children).Where(c => c.Id == yourID); 

Answer 4

static IEnumerable<Product> FindProductById(this IEnumerable<Product> source, int id) 
{ 
    return source.FirstOrDefault(product => product.Id = id) ?? source.SelectMany(product => product.Children).FindProductById(id); 
} 

Answer 5

Eine alternative Lösung, um die Ausbeute unter Verwendung erforderlich, um die Aufzählungen zu optimieren.

public static IEnumerable<T> SelectManyRecursive<T>(
    this IEnumerable<T> source, 
    Func<T, IEnumerable<T>> childrenSelector) 
{ 
    if (source == null) 
     throw new ArgumentNullException("source"); 

    foreach (var i in source) 
    { 
     yield return i; 
     var children = childrenSelector(i); 
     if (children != null) 
     { 
      foreach (var child in SelectManyRecursive(children, childrenSelector)) 
      { 
       yield return child; 
      } 
     } 
    } 
} 

Dann können Sie ein Spiel finden, indem Sie so etwas wie FirstOrDefault Aufruf:

var match = People.SelectManyRecursive(c => c.Children) 
         .FirstOrDefault(x => x.Id == 5); 

Answer 6

Ich bin nur dtb Lösung Refactoring es allgemeinere zu machen. Versuchen Sie, diese Erweiterung Methode:

public static IEnumerable<T> Flatten<T, R>(this IEnumerable<T> source, Func<T, R> recursion) where R : IEnumerable<T> 
{ 
    return source.SelectMany(x => (recursion(x) != null && recursion(x).Any()) ? recursion(x).Flatten(recursion) : null) 
       .Where(x => x != null); 
} 

Und Sie es wie folgt verwenden können:

productList.Flatten(x => x.Children).Where(x => x.ID == id);