Zusammenfassen via LINQ

  • VB.NET
  • .NET (FX) 4.5–4.8

Es gibt 7 Antworten in diesem Thema. Der letzte Beitrag () ist von hal2000.

    Zusammenfassen via LINQ

    Hallo Leute!

    Ich habe eine List Of(Foo), jeweiliges Item hat noch eine List(Of SubFoo).

    Nun würde ich gerne alle SubFoos der Parents in eine Liste zusammenfassen (zum Beispiel die Quantities). Ein Beispiel wie ichs bisher machen würde, findet ihr hier drunter.
    Kann jemand mit mehr LINQ Erfahrung vllt. erklären wie es damit machbar wäre?

    Vermutlich klappt das mit nem Select + Sum Befehl?

    Code ist Folgender, bitte kopieren, 2 Buttons auf die Form packen und testen.
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Imports System.Collections.ObjectModel
    3. Public Class Form1
    5. Public Property Foos As ObservableCollection(Of Foo)
    7. Sub New()
    8. InitializeComponent()
    9. Foos = New ObservableCollection(Of Foo)
    10. End Sub
    12. Public Class Foo
    14. Public Property ID As Integer
    15. Public Property SubFoos As ObservableCollection(Of SubFoo)
    16. ' und mehr Properties...
    18. Sub New(ID As Integer)
    19. SubFoos = New ObservableCollection(Of SubFoo)
    20. End Sub
    22. End Class
    24. Public Class SubFoo
    26. Public Property Name As String
    27. Public Property Quantity As Short
    28. ' und mehr Properties...
    30. Sub New(Name As String, Quantity As Short)
    31. Me.Name = Name
    32. Me.Quantity = Quantity
    33. End Sub
    35. End Class
    37. Private Sub GenerateTestData()
    38. Dim foo1 = New Foo(1)
    39. foo1.SubFoos.Add(New SubFoo("Testding", 8))
    40. foo1.SubFoos.Add(New SubFoo("Testding1", 7))
    42. Dim foo2 = New Foo(2)
    43. foo2.SubFoos.Add(New SubFoo("Testding", 5))
    45. Foos.Add(foo1)
    46. Foos.Add(foo2)
    47. End Sub
    49. Private Sub Form1_Load(sender As Object, e As EventArgs) Handles Me.Load
    50. GenerateTestData()
    51. End Sub
    53. Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
    54. ' normale Variante wie ichs sonst machen würde:
    55. Dim together As New List(Of SubFoo)
    57. For Each f In Foos
    58. For Each sf In f.SubFoos
    59. Dim alreadyInside = together.SingleOrDefault(Function(x) x.Name = sf.Name)
    60. If alreadyInside Is Nothing Then
    61. together.Add(sf)
    62. Else
    63. alreadyInside.Quantity += sf.Quantity
    64. End If
    65. Next
    66. Next
    68. For Each sf In together
    69. MessageBox.Show(String.Format("Name: {0}, Quantity: {1}", sf.Name, sf.Quantity))
    70. Next
    72. End Sub
    74. Private Sub Button2_Click(sender As Object, e As EventArgs) Handles Button2.Click
    75. ' geht das einfacher?? Vllt. mit LINQ direkt?
    76. End Sub
    78. End Class


    Vielen Dank für eure Zeit!

    :thumbup:
    Polling is trolling!

    Achtung: Ich habe die komische Angewohnheit, simple Dinge zu verkomplizieren..

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „Rootbob91“ ()

    @Rootbob91 Verstehe ich das richtig:
    Im Prinzip so was wie ein TreeNode mit MainNode und ChildNode?
    Wenn Foo und SubFoo eine gemeinsame Basisklasse FooBase haben, musst Du die Listen nur mit AddRange() aneinander hängen. Das geht ohne LINQ.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Hallo ihr zwei,

    im Endeffekt eine zusammengefasste Liste. Also eine Liste von allen SubFoos, allerdings zusammengefasst.

    Nicht mehr:
    Testding mit Quantity 8 aus Foo1 und aus Foo2 mit Quantity 5.

    Sondern:
    Testding mit Quantity 13 (insgesamt).

    Und das dann für alle SubFoos.

    Habt ihr euch das Beispiel mal angesehen?
    Polling is trolling!

    Achtung: Ich habe die komische Angewohnheit, simple Dinge zu verkomplizieren..

    Keine Ahnung ob das schön ist oder performant, aber es funktioniert.

    Quellcode

    1. var a = data.SelectMany(x => x.SubFoos).GroupBy(x => x.Name).Select(y => new SubFoo(y.Key, y.Sum(z => z.Quantity))).ToList()

    Hallo @slice!

    Das kommt meinem Wunsch schon sehr nah. Was ich noch nicht ganz rausbekommen habe ist, wie ich an andere Properties drankomme.

    Oben selektierst du den Key und die Summe, wie komme ich an ggf. noch andere Properties eines jeweiligen SubFoos (wenns mehr hätte)?
    Ich verstehe natürlich das hier pro Group Mehrere zurückkommen..

    Beispiel:

    C#-Quellcode

    1. var a = data.SelectMany(x => x.SubFoos).GroupBy(x => x.Name).Select(y => new SubFoo(y.Key, y.Sum(z => z.Quantity), y.Category, y.Whatever)).ToList()


    So hatte ich es hinbekommen, kann mir aber kaum vorstellen, dass das so richtig ist:

    C#-Quellcode

    1. var a = data.SelectMany(x => x.SubFoos).GroupBy(x => x.Name).Select(y => new SubFoo(y.Key, y.Sum(z => z.Quantity), y.Select(p => p.Catgory).First(), y.Select(p => p.Whatever).First())).ToList()


    In SQL wärs für mich so:

    SQL-Abfrage

    1. SELECT ID, Name, SUM(Quantity), Category, Whatever FROM tabelle GROUP BY key ...

    Polling is trolling!

    Achtung: Ich habe die komische Angewohnheit, simple Dinge zu verkomplizieren..

    Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von „Rootbob91“ ()

    Also die Problemdefinition ist mir noch unklar, es ist zum einen Teil ein einfaches SelectMany, wo die SubFoos bei rauskommen. Dann aber gruppierst du die SubFoos nach Name, und summierst die Quantities auf.
    Auch das ist mit Linq die leichteste Übung - nur kommen dabei Objekte eines anonymen Datentypes heraus.
    Aber die kann man ja umwandeln, mit Select

    Jo, haut hin - so wärs wohl das kürzest-mögliche:

    VB.NET-Quellcode

    1. Dim together = From sf In Foos.SelectMany(Function(f) f.SubFoos) Group By sf.Name Into Sum(sf.Quantity) Select New SubFoo(Name, Sum)
    Man muss halt dazu die vb-Linq-Spezialität verstehen, dass anonyme Klassenmember-Namen unter bestimmten Umständen abgeleitet werden können.
    Daher sind Name, Sum in New SubFoo(Name, Sum) keine Methoden oder hexerei, sondern einfach aus dem vorherigen Ausruck abgeleitete Eigenschafts-Namen.

    wie komme ich an ggf. noch andere Properties eines jeweiligen SubFoos (wenns mehr hätte)?
    Genauso, wie du an Quantity "kommst".
    Wobei "an Property kommen" natürlich der absolute Wischi-Waschi-Anti-Begriff ist - definier erstmal, was das bedeuten soll: "an Property kommen"

    (Tatsächlich kommst du ja nicht an Quantity (was ja keinen Sinn ergibt), sondern an die Summe der Quantities)

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „ErfinderDesRades“ ()

    Du willst also eine List(Of List(Of T)) plattmachen, und zwar in eine List(Of T). Das geht kürzer:

    VB.NET-Quellcode

    1. Dim x = From f In Foos From s In f.SubFoos Select s

    Beispiel:

    VB.NET-Quellcode

    1. Module Module1
    3. Sub Main()
    5. Dim foos As New List(Of Foo)
    6. foos.Add(New Foo)
    7. foos.Add(New Foo)
    8. foos.Add(New Foo)
    10. Dim ints = From f In foos From s In f.SubFoo Select s
    11. ' Ergibt: 123123123
    13. End Sub
    15. End Module
    17. Class Foo
    18. Property SubFoo As New List(Of Int32)
    20. Public Sub New()
    21. SubFoo.Add(1)
    22. SubFoo.Add(2)
    23. SubFoo.Add(3)
    24. End Sub
    26. End Class
    Gruß
    hal2000

Facebook
Telefonspende