LINQ grupa przez dominującego porządku nieruchomości przez dziecko

Question

Basicly co próbuję zrobić, to coraz rodzica spis Parent.type gdzie ich Child.type ma status „y” uporządkowane według child.Date

Jako przykład ja utworzono te klasy:

public class Collection 
{ 
    public IEnumerable<Parent> Parents { get; set; } 
    public int Id { get; set; } 
} 

public class Parent 
{ 
    public int Id { get; set; } 
    public Type type { get; set; }  
    public IEnumerable<Child> Children { get; set; } 
} 

public class Child 
{ 
    public int Id { get; set; } 
    public Status Status { get; set; } 
    public DateTime Date { get; set; } 
} 

public enum Type 
{ 
    a, 
    b 
} 

public enum Status 
{ 
    x, 
    y 
} 

Czego chcę, to lista Rodziców każdego typu, w którym Data Dziecka ma najwyższą wartość.

Aby uzyskać ten przykład dzieje dodałem trochę danych testowych:

Collection collection= new Collection 
     { 
      Id = 1, 
      Parents = new List<Parent> 
      { 
       new Parent 
       { 
        Id= 1, 
        type = Type.a, 
        Children = new List<Child> 
        { 
         new Child 
         { 
          Id = 1, 
          Status = Status.y, 
          Date = DateTime.Now.AddDays(-1) 
         }, 
         new Child 
         { 
          Id = 2, 
          Status = Status.x, 
          Date = DateTime.Now.AddDays(-1) 
         } 
        } 
       }, 
       new Parent 
       { 
        Id= 2, 
        type = Type.b, 
        Children = new List<Child> 
        { 
         new Child 
         { 
          Id = 3, 
          Status = Status.y, 
          Date = DateTime.Now.AddDays(-2) 
         }, 
         new Child 
         { 
          Id = 4, 
          Status = Status.x, 
          Date = DateTime.Now.AddDays(-2) 
         } 
        } 
       }, 
       new Parent 
       { 
        Id= 3, 
        type = Type.a, 
        Children = new List<Child> 
        { 
         new Child 
         { 
          Id = 5, 
          Status = Status.y, 
          Date = DateTime.Now.AddDays(-3) 
         } 
        } 
       }, 
       new Parent 
       { 
        Id= 4, 
        type = Type.b, 
        Children = new List<Child> 
        { 
         new Child 
         { 
          Id = 6, 
          Status = Status.y, 
          Date = DateTime.Now.AddDays(-3) 
         }, 
         new Child 
         { 
          Id = 7, 
          Status = Status.y, 
          Date = DateTime.Now.AddDays(-4) 
         }, 
         new Child 
         { 
          Id = 8, 
          Status = Status.x, 
          Date = DateTime.Now.AddDays(-4) 
         } 
        } 
       }, 
      } 
     }; 

Wynik select powinna być lista zawierająca 2 rodziców. Jeden dla każdego typu (aib). Oba nadal zawierają wszystkie swoje obiekty podrzędne.

Czy jest jakieś proste rozwiązanie?

Próbowałem coś takiego:

List<Parent> test = collection.Parents 
       .GroupBy(m => m.type) 
       .Select(
       m => m.OrderByDescending(
        mm => mm.Children.Select(
         r => r).OrderByDescending(
          r => r.Date)).FirstOrDefault()).ToList(); 

Ale to nie kończy się dobrze.

===== UPDATE =====

Dzięki przykładzie Enigmativity ten problem został rozwiązany. Wprowadziłem niewielką modyfikację zapytania linq, ponieważ oryginalna zawartość, której używam, jest dostarczana przez Entity Framework (6). Oznaczało to dla mnie, że wybrany obiekt nadrzędny nie zawierał żadnych elementów potomnych, więc musiałem wybrać nowy typ obiektu (ponieważ nie można utworzyć nowego obiektu typu udostępnionego przez model Entity Framework). Również moi Rodzice byli w innym IEnumerable, więc musiałem użyć SelectMany również na Rodzicach.

Spowodowało to mniej więcej tak: (To nie będzie działać z klas testowych chociaż)

var result = 
    collection 
     .SelectMany(c => c.Parents) 
     .GroupBy(p => p.type) 
     .SelectMany(gps => 
      gps 
       .SelectMany(
        gp => gp.Children.Where(c => c.Status == Status.y), 
        (gp, c) => new { gp, c }) 
       .OrderByDescending(gpc => gpc.c.Date) 
       .Take(1) 
       .Select(gpc => new ParentData {Id = gpc.gp.Id, Children= gpc.gp.Children})) 
     .ToList(); 

Answer 1

Jeśli mam rozumieć swoje wymagania poprawnie chcesz grupie wszystkich rodziców ze względu na rodzaj, a następnie wybrali tylko jedno z rodziców z każdej grupy na podstawie tego rodzica posiadającego dziecko z najwyższą datą ze wszystkich dzieci w tej grupie.

Oto co wymyśliłem:

var result = 
    collection 
     .Parents 
     .GroupBy(p => p.type) 
     .SelectMany(gps => 
      gps 
       .SelectMany(
        gp => gp.Children.Where(c => c.Status == Status.y), 
        (gp, c) => new { gp, c }) 
       .OrderByDescending(gpc => gpc.c.Date) 
       .Take(1) 
       .Select(gpc => gpc.gp)) 
     .ToList(); 

który daje mi:

Answer 2

Dzieci naprawdę nie można być filtrowane, nakazał, itd., Gdy rodzice są tymi, że zapytania/są stosowane projekcje.

Musisz albo:

• Break relacje i projekt do innej struktury danych (jak słownika lub IGrouping gdzie rodzic jest kluczem, a dzieci są sortowane wartość)
• koniecznie Sort() lub przypisanie Children w pętli bez LINQ
• zapisu lambdy wielu linii, gdzie druga linia jest efektem ubocznym jak sortowania lub przypisanie dzieci (niezalecane)

Osobiście uważam, że łatwiej jest wyświetlać tylko te dane, które są potrzebne, do uproszczonej reprezentacji, zamiast próbować utrzymywać hierarchię w dół.

Answer 3

Moje rozumienie pytania polega na tym, że należy utworzyć listę rodziców pogrupowanych według rodzaju i zagregować wszystkie dzieci o statusie y dla każdego typu rodzica.

Należy zauważyć, że nie można zwinąć listy według typu nadrzędnego i zachować strukturę macierzystą (co oznacza, że ​​identyfikator również musi zostać zwinięty, właśnie wzięłam pierwszą wartość, wybór zależy od ciebie) .W przeciwnym razie to powinno być rozwiązaniem szukasz:

var result = collection.Parents.GroupBy(c => c.type) 
    .Select(g => new Parent 
       { 
        type = g.Key,  
        Id = g.Select(p => p.Id).FirstOrDefault(), 
        Children = g.SelectMany(p => p.Children 
           .Where(c => c.Status == Status.y) 
           .OrderByDescending(c => c.Date)).ToList()       
       }).ToList();