Metoda rozszerzenia Linq, jak znaleźć dziecko w kolekcji rekursywnie

Question

Jestem już zaznajomiony z Linq, ale nie mam pojęcia o metodach rozszerzenia Mam nadzieję, że ktoś może mi pomóc.

Więc mam ten kod hierarchiczną kolekcja pseudo IE:

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

I mam listę produktów Lista produktów.

Czy istnieje sposób, w jaki mogę znaleźć produkt w tej kolekcji przez id z metodą rozszerzenia? Innymi słowy potrzebuję jednego przedmiotu gdzieś wewnątrz hierarchii.

Answer 1

Oto ogólny rozwiązanie, które będzie zwarcie przechodzenie hierarchii raz zostanie znaleziony.

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); 
    } 
} 

Aby użyć go w przypadku:

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

Answer 2

można spłaszczyć strukturę drzewa przy użyciu tej metody rozszerzenie:

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

Zastosowanie:

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

Zauważ, że nie jest to prawdopodobnie bardzo szybko. Jeśli wielokrotnie trzeba znaleźć produkt przez ID, utwórz słownika:

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

var product42 = dict[42]; 

Answer 3

jeśli chcesz „sub-iterate” i znaleźć dziecko w wykazie produktów:

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

Można użyj istniejącej metody rozszerzenia SelectMany. SelectMany można użyć do "spłaszczenia" hierarchii dwupoziomowej.

Oto doskonałe wyjaśnienie SelectMany: http://team.interknowlogy.com/blogs/danhanan/archive/2008/10/10/use-linq-s-selectmany-method-to-quot-flatten-quot-collections.aspx

składni chciałby tak:

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

Alternatywnym rozwiązaniem wykorzystaniem zwrotu w celu optymalizacji wyliczeń potrzebne.

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; 
      } 
     } 
    } 
} 

Następnie można znaleźć dopasowanie wywołując coś FirstOrDefault:

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

Answer 6

Ja tylko refaktoringu rozwiązanie DTB, aby uczynić go bardziej rodzajowe. Wypróbuj tę metodę rozszerzenia:

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); 
} 

I można go używać tak:

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