Performance Problem bei Aktualisieren einer ListView

  • VB.NET

Es gibt 11 Antworten in diesem Thema. Der letzte Beitrag () ist von RodFromGermany.

    Performance Problem bei Aktualisieren einer ListView

    Hallo zusammen,

    ich habe folgendes Problem beim aktualisieren einer ListView, nämlich dass der Code bis zu 13% meines
    Prozessors beansprucht, außerdem läuft das Programm nicht mehr wirklich gut.
    Ich habe eine ListView mit fogenden Columns: Name ID Status
    In dieser ListView werden sämtliche laufende Prozesse des Systems + ID und Status aufgelistet.
    Aktualisieren tu ich die ListView folgendermaßen:

    Code

    Visual Basic-Quellcode

    1. Dim schonVorhanden As Boolean = False
    2. Dim nichtMehrVorhanden As Boolean = True
    4. For Each Prozess As Process In Process.GetProcesses
    6. schonVorhanden = False
    8. For Each idItem As ListViewItem In LbProzesse.Items
    10. If idItem.SubItems(1).Text = Prozess.Id Then
    12. schonVorhanden = True
    14. End If
    16. If Prozess.Responding = True And Not idItem.SubItems(2).Text = "Wird ausgeführt" Then
    18. idItem.SubItems(2).Text = "Wird ausgeführt"
    20. ElseIf Prozess.Responding = False And Not idItem.SubItems(2).Text = "Keine Rückmeldung" Then
    22. idItem.SubItems(2).Text = "Keine Rückmeldung"
    24. End If
    26. Next
    28. If schonVorhanden = False Then
    30. With LbProzesse.Items.Add(Prozess.ProcessName)
    31. .SubItems.Add(Prozess.Id)
    33. If Prozess.Responding = True Then
    35. .SubItems.Add("Wird ausgeführt")
    36. Else
    37. .SubItems.Add("Keine Rückmeldung")
    39. End If
    40. End With
    42. End If
    44. Next
    46. For Each item As ListViewItem In LbProzesse.Items
    48. nichtMehrVorhanden = True
    50. For Each Prozess As Process In Process.GetProcesses
    52. If Prozess.Id = item.SubItems(1).Text Then
    54. nichtMehrVorhanden = False
    56. End If
    58. Next
    60. If nichtMehrVorhanden = True Then
    62. Me.Invoke(Sub()
    63. item.Remove()
    64. End Sub)
    66. End If
    68. Next



    Kennt jemand eine bessere Methode eine ListView zu aktualisieren (inkl. ob der Prozess noch ausgeführt wird)
    ohne die ListView ständig zu clearen und neu zu befüllen (da die aktualisierung alle 0,5 sek mittels eines Timers ausgeführt wird)

    Danke schon mal für alle Antworten

    @Kilian_98 Nimm ein DataGridView und eine entsperechende DataTable.
    Ein Beispiel mit Double findest Du hier, musst nur DeineDatentypen reinschreiben.
    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!

    Afaik könntest du mit ListView.BeginUpdate und ListView.EndUpdate arbeiten.

    Dann wird das ganze erst neugezeichnet, nachdem alle Items reingepackt bzw. aktualisiert wurden
    und das ganze sollte wesentlich schneller gehen und weniger Leistung fressen.

    Kilian_98 schrieb:

    wie aktualisier ich das dann ?
    Mach mal ganz unvoreingenommen das Beispiel aus meinem Post #3.
    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!

    @SplittyDev Gute Idee, werde es mal testen

    @RodFromGermany hatte mich noch nie damit damit beschäftigt, und als ichs mir auf die Form gezogen hab,
    sahs für mich aus wie eine Tabelle, die ich eigentlich nicht brauche. Hab mir nun ein paar Videos angeschaut, und werde
    es mal ausprobieren

    Danke für alle bisherigen Antworten

    EDIT: Mit ListView.BeginUpdate und ListView.EndUpdate bleibt die Performance gleich, es verbessert sich leider nichts.

    Aber irgendwie muss es doch gehen, andere Programme schaffens ja auch


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

    Vielleicht wendest du BeginUpdate und EndUpdate falsch an..
    Das sollte ungefähr so aussehen:

    Spoiler anzeigen

    Visual Basic-Quellcode

    1. Dim schonVorhanden As Boolean = False
    2. Dim nichtMehrVorhanden As Boolean = True
    4. ListView.BeginUpdate () ' Vor allen aktionen aufrufen
    6. For Each Prozess As Process In Process.GetProcesses
    8. schonVorhanden = False
    10. For Each idItem As ListViewItem In LbProzesse.Items
    12. If idItem.SubItems(1).Text = Prozess.Id Then
    14. schonVorhanden = True
    16. End If
    18. If Prozess.Responding = True And Not idItem.SubItems(2).Text = "Wird ausgeführt" Then
    20. idItem.SubItems(2).Text = "Wird ausgeführt"
    22. ElseIf Prozess.Responding = False And Not idItem.SubItems(2).Text = "Keine Rückmeldung" Then
    24. idItem.SubItems(2).Text = "Keine Rückmeldung"
    26. End If
    28. Next
    30. If schonVorhanden = False Then
    32. With LbProzesse.Items.Add(Prozess.ProcessName)
    33. .SubItems.Add(Prozess.Id)
    35. If Prozess.Responding = True Then
    37. .SubItems.Add("Wird ausgeführt")
    38. Else
    39. .SubItems.Add("Keine Rückmeldung")
    41. End If
    42. End With
    44. End If
    46. Next
    48. For Each item As ListViewItem In LbProzesse.Items
    50. nichtMehrVorhanden = True
    52. For Each Prozess As Process In Process.GetProcesses
    54. If Prozess.Id = item.SubItems(1).Text Then
    56. nichtMehrVorhanden = False
    58. End If
    60. Next
    62. If nichtMehrVorhanden = True Then
    64. Me.Invoke(Sub()
    65. item.Remove()
    66. End Sub)
    68. End If
    70. Next
    72. ListView.EndUpdate () ' Nach allen aktionen aufrufen

    Nein, am Anfang hab ichs tatsächlich falsch gemacht, aber Visual Basic hat mir schnell gesagt, wie es richtig ist, trotzdem danke für die Antwort.

    @Rod: Da müsste ich mich erst richtig einarbeiten, außerdem ist doch das DataGridView eher ne Tabelle (oder hab ich da ein paar Einstellungen über sehen, sodass sich das einarbeiten lohnen würde?)
    Wäre das geeignet für einen Taskmanager?

    Gibt es da nicht noch ne andere Möglichkeit, mit weniger Schleifen (das Programm muss schließlich ca 2000 Abfragen in nicht mal einer halben Sekunde ausführen). Kennt jemand noch ne Methode ohne so viele Schleifen ?
    Gibt es schon eine eingebaute?
    Bin für jeden Tipp/Link dankbar (bei Google kam nichts gescheitert heraus)

    @Kilian_98 Machma Option Strict On und poste ein C&P-Snippet, das Deinen effekt reproduziert.
    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!

    Code hatte ich doch schon gepostet ? Oder was meinst du mit 'C&P-Snippet, das Deinen effekt reproduziert.' ?
    Hier jedenfalls der Code noch mal mit Option Strict On:
    Code fürs Aktualisieren

    VB.NET-Quellcode

    1. Option Strict On
    3. LbProzesse.BeginUpdate()
    5. Dim schonVorhanden As Boolean = False
    6. Dim nichtMehrVorhanden As Boolean = True
    8. For Each Prozess As Process In Process.GetProcesses
    10. schonVorhanden = False
    12. For Each idItem As ListViewItem In LbProzesse.Items
    14. If idItem.SubItems(1).Text = cStr(Prozess.Id) Then
    16. schonVorhanden = True
    18. End If
    20. If Prozess.Responding = True And Not idItem.SubItems(2).Text = "Wird ausgeführt" Then
    22. idItem.SubItems(2).Text = "Wird ausgeführt"
    24. ElseIf Prozess.Responding = False And Not idItem.SubItems(2).Text = "Keine Rückmeldung" Then
    26. idItem.SubItems(2).Text = "Keine Rückmeldung"
    28. End If
    30. Next
    32. If schonVorhanden = False Then
    34. With LbProzesse.Items.Add(Prozess.ProcessName)
    35. .SubItems.Add(CStr(Prozess.Id))
    37. If Prozess.Responding = True Then
    39. .SubItems.Add("Wird ausgeführt")
    40. Else
    41. .SubItems.Add("Keine Rückmeldung")
    43. End If
    44. End With
    46. End If
    48. Next
    50. For Each item As ListViewItem In LbProzesse.Items
    52. nichtMehrVorhanden = True
    54. For Each Prozess As Process In Process.GetProcesses
    56. If cStr(Prozess.Id) = item.SubItems(1).Text Then
    58. nichtMehrVorhanden = False
    60. End If
    62. Next
    64. If nichtMehrVorhanden = True Then
    66. Me.Invoke(Sub()
    67. item.Remove()
    68. End Sub)
    70. End If
    72. Next
    74. LbProzesse.EndUpdate()




    EDIT: Habs nun hinbekommen. Nun hab ich eine CPU Auslastung von 1-2%. Ich denke das geht noch ;)
    Für alle die ein ähnliches Problem haben, hab ich hier mal meinen Code reingeschrieben:

    besser funktionierender Code

    VB.NET-Quellcode

    1. Option Strict On
    3. Dim ListView2 As New ListView
    4. ListView2.Columns.Add("Name")
    5. ListView2.Columns.Add("ID")
    7. Dim schonDa As Boolean = False
    9. 'füllt die "Virtuelle" ListView2 mit den aktuellen Prozessen
    11. ListView2.Items.Clear()
    13. For Each prozess As Process In Process.GetProcesses
    15. With ListView2.Items.Add(prozess.ProcessName)
    16. .SubItems.Add(CStr(prozess.Id))
    17. End With
    19. Next
    21. gehezu:
    23. For Each item As ListViewItem In ListView2.Items 'geht alle listview items durch und vergleicht sie mit der anderen listview
    25. If Not item.SubItems(1).Text = ListView1.Items(item.Index).SubItems(1).Text Then
    27. Dim index As Integer = item.Index
    29. 'schaut nach, ob der prozess an anderer Stelle schon vorhanden ist (wenn sich ein nicht mehr laufender prozess dazwischendrängt) hier: sucht in den nächsten sechs Prozessen und nicht in allen, da es sehr unwahrscheinlich ist, dass mehr als sechs Prozesse gleichzeitig beendet werden
    30. For a = 1 To 6
    31. index += 1
    33. Try
    34. If item.SubItems(1).Text = ListView1.Items(index).SubItems(1).Text Then
    36. schonDa = True
    38. End If
    39. Catch ex As Exception
    40. GoTo gehezu
    41. End Try
    43. Next
    45. If schonDa = True Then 'wenn sich ein anderer Prozess dazwischengedrängt hat, wird dieser entfernt
    47. ListView1.Items.RemoveAt(item.Index)
    48. GoTo gehezu 'da sich eine listview verändert hat, wird noch mal von vorne durchgegangen
    50. Else 'ist der Prozess noch nicht vorhanden, wird er an der selben Stelle wie in der "virtuellen" listview hinzugefügt
    52. With ListView1.Items.Insert(item.Index, ListView2.Items(item.Index).Text)
    54. .SubItems.Add(ListView2.Items(item.Index).SubItems(1).Text)
    56. End With
    57. GoTo gehezu 'da sich eine listview verändert hat, wird noch mal von vorne durchgegangen
    59. End If
    61. End If
    63. Next
    65. 'Die Listbox ist Aktualisiert, ohne Performance Probleme (bis zu 2% CPU Last) und ohne dass Markierung oder Position der Scrollbar verlorengeht




    Danke nochmal für alle Antworten

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

    Kilian_98 schrieb:

    'C&P-Snippet, das Deinen effekt reproduziert.'
    Ich kopiere Deinen Code in mein Projekt und sehe den von Dir beschriebenen Effekt.
    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!