Wie Sortiere ich eine Liste und deren Kinder und deren Kinder mit linq?

Habe ich eine Eltern-Kind-Beziehung, so etwas wie:

public class MyType {

    public IList<MyType> Children {get;set;}
    public int Order {get;set;}

}

Möchte ich wählen Sie die Liste, so dass jeder level ist in Ordnung.

Kann ich dies leicht tun für die top-level:

mylist.Children.OrderBy(x => x.Order)

Aber wie Mach ich es, für jede Gruppe von Kindern?

Das Endergebnis wäre die Liste, oder geben Sie mit all Ihren Kindern, und es Kinder (und so weiter) alle richtig sortiert Auftrag.

Dank.

InformationsquelleAutor shenku | 2012-09-15

c#linq

Können Sie tun, Rekursive, Um durch das hinzufügen einer Methode zu MyType wie diese:

public class MyType
{
    public IList<MyType> Childrens { get; set; }
    public int Order { get; set; }

    public void RecursiveOrder()
    {
        Childrens = Childrens.OrderBy(x => x.Order)
            .ToList();

        Childrens.ToList().ForEach(c => c.RecursiveOrder());
    }
}

InformationsquelleAutor cuongle

2

Können Sie halten die Kinder sortiert, wenn Sie eine SortedList als Ihre zugrunde liegenden Kinder-Kollektion. Dann können Sie setzen die Values - Eigenschaft, um die Werte. Drücken Sie die Elemente, die durch Ihre order wenn Sie der Liste hinzufügen.

z.B.,
```
public class MyType
{
    public MyType(int order)
    {
        this.order = order;
    }

    private int order;
    private SortedList<int, MyType> children = new SortedList<int, MyType>();

    public int Order { get { return order; } }
    public IList<MyType> Children { get { return children.Values; } }

    public void AddChild(MyType child)
    {
        children.Add(child.order, child);
    }
}
```
Sonst, würden Sie wahrscheinlich wollen, um die Sortierung der Listen rekursiv. Mit LINQ wäre nicht angemessen. Am besten, LINQ erlauben würde, Sie Durchlaufen die Kinder in einer sortierten Reihenfolge aber es hat nicht wirklich Sortieren der zugrunde liegenden Liste, es sei denn, Sie ersetzen Sie die list-Instanz mit der sortierten version. Wenn die zugrunde liegende Liste ist ein Sort() - Methode (die den generischen List<T> hat), dann verwenden Sie diese.
```
private List<MyType> children;
public void EnsureSorted()
{
    children.Sort();
    foreach (var child in children)
        child.EnsureSorted();
}
```
Beginnend mit einer sortierten Liste wäre viel einfacher, aber.

InformationsquelleAutor Jeff Mercado
1

Stimme ich mit Jeff, der die einfachste Antwort ist, die Daten zu speichern sortiert, wenn das ist Ihre Haupt-access-Muster. Aber können sagen, Sie wirklich wollen, dies zu tun mit Linq:

First off, wenn Sie wusste, Sie wollte nur zwei Ebenen, die die Bestellung, die Sie tun könnten, so etwas wie dieses:
```
myList.Children.OrderBy(x => x.Order)
    .Select(c => c.Children.OrderBy(x => x.Order))
```
Aber was, wenn das, was Sie wirklich wollen, ist Total rekursive bestellen, die alle der Weg nach unten?
```
delegate IEnumerable<MyType> RecursiveFunc(MyType data, RecursiveFunc self);
RecursiveFunc op = (data, func) => data.Children.OrderBy(x => x.Order)
    .Select(x => func(x, func));

IEnumerable<MyType> result = op(myList, op);
```
Einfach nur zu schreiben, dass macht mein Gehirn verletzt, und ich habe nicht versucht, läuft es, also viel Glück! Was es kommt darauf an, vorbei an einem linq-Ausdruck(lambda) zu sich selbst, um rekursiv anwenden, sich den Baum hinunter.

InformationsquelleAutor Chris Pitman

thry diese

mylist.Children.OrderBy(x => x.Order).ThenBy( x => x.order).ToList();

InformationsquelleAutor Anant Dabhi

0

Wenn das Ergebnis am Ende einfach eine Liste von Kindern (anstatt eine Liste von Eltern mit verschachtelten Kinder), die Sie verwenden können, eine SelectMany
```
IEnumerable<Child> result  = parents
    .SelectMany(p => p.Children)
    .OrderBy(child => child.Order);
```
InformationsquelleAutor Olivier Jacot-Descombes

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.