Linq-extension-Methode, wie Sie finden, Kinder in der Sammlung rekursive

Ich bin bereits vertraut mit Linq, haben aber wenig Verständnis von extension-Methoden ich hoffe jemand kann mir helfen.

So habe ich diese hierarchische Auflistung pseudo-code an, dh:

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

Und ich haben eine Liste der Produkte Liste der Produkte.

Gibt es eine Möglichkeit, ich kann sehen für Produkte in dieser Kollektion durch die id mit einer Erweiterung Methode ? In anderen Worten muss ich ein Element irgendwo innerhalb der Hierarchie.

  • Du meinst: productsList.Where(x => x.Id = = "deine_id");?
  • Oder productsList.FirstOrDefault(x => x.Id = = "deine_id");? Diese gibt ein einzelnes Objekt ist, und null, wenn kein entsprechendes Objekt gefunden wird.
  • Nein, ich meine, ich schauen müssen sowohl die ProductsList und ProductList->Produkt->die Kinder, Dass ist mein problem, ich kann es mit rekursiven Methode, aber ich Frage mich, Ob es eine Möglichkeit gibt, tun Sie es mit linq-Erweiterung.
InformationsquelleAutor sushiBite | 2010-08-27
  1. 17

    Hier ist eine generische Lösung, Kurzschluss-Traversierung der Hierarchie, wenn 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);
    }
}

    Verwenden es in Ihrem Fall:

    var matchingProduct = products.FirstOrDefaultFromMany(p => p.children, p => p.Id == 27);
    • Hallo, ich machte eine kleine änderung zu diesem code und das funktioniert 🙂 ich änderte dies, wenn(Gleich(Versuch,default(T))) return Versuch; if(Equals(Versuch != null) return versuchen; Es funktioniert wie ein Charme vielen Dank für Eure Hilfe.
    • Ich denke, es sollte eigentlich if(!Equals(attempt, default(T))) return attempt; da der Standardwert von T vielleicht nicht null (wenn T ist ein Wert, Typ).
    • vielen Dank, tolle Methode!
    • Schön gemacht 😉
    InformationsquelleAutor Jay
  2. 8

    Können Sie reduzieren Ihre Baumstruktur mit dieser Erweiterung Methode:

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

    Verwendung:

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

    Beachten Sie, dass dies wahrscheinlich nicht sehr schnell. Wenn Sie immer wieder benötigen, um ein Produkt zu finden, die von id haben, erstellen Sie ein Wörterbuch:

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

var product42 = dict[42];
    • Schön, ich mag, dass Flatten-Methode. Wenn ich mich nicht Irre, es werde Durchlaufen breadth-first (edit: täusche ich mich, es ist nicht breadthfirst, Frage ist immer noch relevant, obwohl). Bedeutet das, wenn das Produkt ist das erste Element in der Liste aus, und verwenden Sie Zuerst anstelle von Einzelnen, es wird nicht Glätten Sie die gesamte Hierarchie? Wird linq verzögerte Ausführung hier helfen?
    • Das sieht wie eine gute Lösung, aber ignoriert die Möglichkeit, dass die Liste der Kinder sein könnte null.
    • Du hast Recht. Wenn Sie First dann, Dank verspäteter Ausführung, Flatten nur glätten, so viel wie nötig.
    InformationsquelleAutor dtb
  3. 1

    Ich bin nur refactoring dtb-Lösung zu machen, mehr generische. 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 können es verwenden, wie diese:

    productList.Flatten(x => x.Children).Where(x => x.ID == id);
    InformationsquelleAutor Jonathas Costa
  4. 0
    static IEnumerable<Product> FindProductById(this IEnumerable<Product> source, int id) 
{
    return source.FirstOrDefault(product => product.Id = id) ?? source.SelectMany(product => product.Children).FindProductById(id);
}
    InformationsquelleAutor Jimmy Hoffa
  5. 0

    Alternative Lösung mit der Ausbeute zu optimieren, sind die Aufzählungen benötigt.

    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 finden Sie ein Spiel, indem Sie etwas rufen wie FirstOrDefault:

        var match = People.SelectManyRecursive(c => c.Children)
                      .FirstOrDefault(x => x.Id == 5);
    InformationsquelleAutor kampsj
  6. -1

    Wenn Sie wollen, um "sub- "iterate" und ein Kind finden, das in einer Liste der Produkte:

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

    Können Sie die vorhandenen SelectMany - Erweiterung-Methode. SelectMany kann verwendet werden, um "reduzieren" ein zwei-Ebenen-Hierarchie.

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

    Ihre würde die syntax wie diese:

    List<Product> p = GetProducts(); //Get a list of products
var child = from c in p.SelectMany(p => p.Children).Where(c => c.Id == yourID);
    • Gut, das ist gut, aber die Hierarchie und die werden x viele Ebenen tief für jedes Produkt, also Ein Produkt haben kann, 3 Kinder, 5 Enkelkinder und 100 grand Enkel und Produkt kann vielleicht nur 1 Kind und keine große Kind, es gibt keine Möglichkeit für mich zu wissen. wenn ich verstehe das richtig das ich verwenden würde SelectMany() für jede Ebene der Hierarchie ?
    • Sie können Kette SelectMany zusammen so weit wie nötig, um zu der Ebene, die Sie wollen.
    InformationsquelleAutor Dave Swersky
Schreibe einen Kommentar