Laufwerke im Listview

  • VB.NET

Es gibt 37 Antworten in diesem Thema. Der letzte Beitrag () ist von Amelie.

    Laufwerke im Listview

    Moin moin

    Ich habe ein Problem mit dem Listview um die Laufwerke in den entsprechenden Gruppen anzeigen zu lassen. Siehe Bildanhang.
    Habe nun schon etliches versucht, komme aber nicht weiter. :(

    Spoiler anzeigen
    ​

    VB.NET-Quellcode

    1. ​
    2. Private Sub ListDrives()
    3. ' Zuerst die interne Laufwerk-Liste abrufen und dann die externe Laufwerk-Liste
    4. driveManager.ListDrives(CType(2, GetDriveInfo.MediaType)) ' gibt alle internen aus
    5. driveManager.ListDrives(CType(1, GetDriveInfo.MediaType)) ' gibt alle externen aus
    6. End Sub
    8. Private Sub driveManager_DrivesListed(sender As Object, drivesList As List(Of String)) Handles driveManager.DrivesListed
    9. Try
    11. Dim validDrivesInternal As List(Of String) = drivesList.Where(Function(drive) Directory.Exists(drive)).ToList()
    12. ' Erstellen und Hinzufügen der Gruppe "Intern" zum ListView
    13. Dim internGroup As New ListViewGroup("internDrives", "Interne Laufwerke")
    14. lvDrives.Groups.Add(internGroup)
    16. ' Hinzufügen der internen Laufwerke zur Gruppe "Intern"
    17. For Each drive As String In validDrivesInternal
    18. Dim item As New ListViewItem(drive)
    19. lvDrives.Items.Add(item).Group = internGroup
    20. Next
    22. Dim validDrivesExternal As List(Of String) = drivesList.Where(Function(drive) Directory.Exists(drive)).ToList()
    23. ' Erstellen und Hinzufügen der Gruppe "Extern" zum ListView
    24. Dim externGroup As New ListViewGroup("externDrives", "Externe Laufwerke")
    25. lvDrives.Groups.Add(externGroup)
    27. ' Hinzufügen der externen Laufwerke zur Gruppe "Extern"
    28. For Each drive As String In validDrivesExternal
    29. Dim item As New ListViewItem(drive)
    30. lvDrives.Items.Add(item).Group = externGroup
    31. Next
    33. ' Setze die Auswahl auf das erste Laufwerk, wenn verfügbar
    34. If lvDrives.Items.Count > 0 Then
    35. lvDrives.Items(0).Selected = True
    36. Else
    37. lvDrives.Items.Add("No Drive")
    38. End If
    40. Catch ex As Exception
    41. ' Fehlerbehandlung
    42. 'eventlogger.ExceptionToFile("Fehler: " & ex.Message)
    43. End Try
    44. End Sub

    Bilder

    • listview-1.jpg

      129,29 kB, 768×408, 225 mal angesehen
    Asperger Autistin. Brauche immer etwas um gewisse Sachen zu verstehen. :huh:

    Was fehlt, ist die Beschreibung, was Du erwartest. Den ist-Zustand sehen wir, aber nicht den Soll-Zustand. Dass das Bild unlogische Sache zeigt, wenn bei intern und extern das gleiche steht, ist klar. Aber wie wäre es denn inhaltlich richtig?
    Und warum gibt es 4 Kategorien, wobei 2 gleich sind? Was ist der Unterschied zwischen "interne Laufwerke" oben und "interne Laufwerke" unten? Genauso "externe Laufwerke".
    Und wo ist der Code dieser driveManager.ListDrives-Methode?
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    @VaporiZed

    Es sollen die internen und externen Laufwerke in jeweils einer Gruppe im Listview abgebildet werden. Siehe Bildanhang Sollzustand

    Der hier gezeigte Code ist das letzte was ich versuchte. Die Trennung der Drives ist ja richtig, nur bekomme ich die Anzeige im Listview einfach nicht hin.

    Das MainForm
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Private WithEvents driveManager As New GetDriveInfo()
    2. Private WithEvents driveCleaner As WriteFiles
    4. Public Sub New()
    5. driveCleaner = New WriteFiles(driveManager)
    6. InitializeComponent()
    7. ListDrives()
    8. End Sub
    9. Private Sub ListDrives()
    10. ' Zuerst die interne Laufwerk-Liste abrufen und dann die externe Laufwerk-Liste
    11. driveManager.ListDrives(CType(2, GetDriveInfo.MediaType))
    12. driveManager.ListDrives(CType(1, GetDriveInfo.MediaType))
    13. End Sub
    15. Private Sub driveManager_DrivesListed(sender As Object, drivesList As List(Of String)) Handles driveManager.DrivesListed
    16. Try
    17. Dim validDrivesInternal As List(Of String) = drivesList.Where(Function(drive) Directory.Exists(drive)).ToList()
    18. ' Erstellen und Hinzufügen der Gruppe "Intern" zum ListView
    19. Dim internGroup As New ListViewGroup("internDrives", "Interne Laufwerke")
    20. lvDrives.Groups.Add(internGroup)
    21. ' Hinzufügen der internen Laufwerke zur Gruppe "Intern"
    22. For Each drive As String In validDrivesInternal
    23. Dim item As New ListViewItem(drive)
    24. lvDrives.Items.Add(item).Group = internGroup
    25. Next
    26. Dim validDrivesExternal As List(Of String) = drivesList.Where(Function(drive) Directory.Exists(drive)).ToList()
    27. ' Erstellen und Hinzufügen der Gruppe "Extern" zum ListView
    28. Dim externGroup As New ListViewGroup("externDrives", "Externe Laufwerke")
    29. lvDrives.Groups.Add(externGroup)
    30. ' Hinzufügen der externen Laufwerke zur Gruppe "Extern"
    31. For Each drive As String In validDrivesExternal
    32. Dim item As New ListViewItem(drive)
    33. lvDrives.Items.Add(item).Group = externGroup
    34. Next
    35. ' Setze die Auswahl auf das erste Laufwerk, wenn verfügbar
    36. If lvDrives.Items.Count > 0 Then
    37. lvDrives.Items(0).Selected = True
    38. Else
    39. lvDrives.Items.Add("No Drive")
    40. End If
    41. Catch ex As Exception
    42. ' Fehlerbehandlung
    43. 'eventlogger.ExceptionToFile("Fehler: " & ex.Message)
    44. End Try
    45. End Sub



    Die Class:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Class GetDriveInfo
    3. Public Event DrivesListed As EventHandler(Of List(Of String))
    4. Public allDrives() As DriveInfo = DriveInfo.GetDrives()
    6. Friend SelectedDrive As DriveInfo
    8. Public Enum MediaType
    9. ExternalOrRemovable = 1
    10. Fixed = 2
    11. End Enum
    13. Private Const ExternalOrRemovableQuery As String = "SELECT DeviceID FROM Win32_DiskDrive WHERE MediaType='External hard disk media' OR MediaType='Removable media'"
    14. Private Const FixedQuery As String = "SELECT DeviceID FROM Win32_DiskDrive WHERE MediaType='Fixed hard disk media'"
    16. Public Sub ListDrives(driveType As MediaType)
    17. Dim drivesList As New List(Of String)()
    19. Dim query As String = GetQueryByType(driveType)
    20. If query <> "" Then
    21. Dim searcher As New ManagementObjectSearcher(query)
    22. searcher.Options.ReturnImmediately = True
    24. For Each drive As ManagementObject In searcher.Get()
    25. Dim partitionsQuery As String = $"ASSOCIATORS OF {{Win32_DiskDrive.DeviceID='{drive("DeviceID")}'}} WHERE AssocClass = Win32_DiskDriveToDiskPartition"
    26. Dim partitionSearcher As New ManagementObjectSearcher(partitionsQuery)
    28. For Each partition As ManagementObject In partitionSearcher.Get()
    29. Dim logicalDisksQuery As String = $"ASSOCIATORS OF {{Win32_DiskPartition.DeviceID='{partition("DeviceID")}'}} WHERE AssocClass = Win32_LogicalDiskToPartition"
    30. Dim logicalDisksSearcher As New ManagementObjectSearcher(logicalDisksQuery)
    32. For Each logicalDisk As ManagementObject In logicalDisksSearcher.Get()
    33. Dim driveID As String = logicalDisk("DeviceID").ToString() & "\"
    35. ' Prüfe auf Duplikate anhand einer anderen Eigenschaft (hier: DeviceID)
    36. If Not drivesList.Any(Function(d) d.StartsWith(driveID)) Then
    37. drivesList.Add(driveID)
    38. End If
    39. Next
    40. Next
    41. Next
    42. ' Sortiere die Liste der Laufwerksbuchstaben
    43. drivesList.Sort()
    44. RaiseEvent DrivesListed(Me, drivesList)
    45. End If
    46. End Sub
    48. Private Function GetQueryByType(driveType As MediaType) As String
    49. Select Case driveType
    50. Case MediaType.ExternalOrRemovable
    51. Return ExternalOrRemovableQuery
    52. Case MediaType.Fixed
    53. Return FixedQuery
    54. Case Else
    55. Return ""
    56. End Select
    57. End Function

    Bilder

    • listview-2.jpg

      113,97 kB, 768×408, 108 mal angesehen
    Asperger Autistin. Brauche immer etwas um gewisse Sachen zu verstehen. :huh:

    Der Code ist ja auch moppelt gedoppelt. In driveManager_DrivesListed machen doch Zeile#17-#25 genau das gleiche wie Z#26-34. Kein Wunder, dass es da zu Doppelungen kommt.
    Gegenvorschlag:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Private WithEvents driveManager As New GetDriveInfo()
    2. Private WithEvents driveCleaner As WriteFiles
    4. Public Sub New()
    5. driveCleaner = New WriteFiles(driveManager)
    6. InitializeComponent()
    7. ListDrives()
    8. End Sub
    9. Private Sub ListDrives()
    10. ' Zuerst die interne Laufwerk-Liste abrufen und dann die externe Laufwerk-Liste
    11. driveManager.ListDrives(CType(2, GetDriveInfo.MediaType))
    12. driveManager.ListDrives(CType(1, GetDriveInfo.MediaType))
    13. End Sub
    14. Private Sub driveManager_DrivesListed(sender As Object, e As (drivesList As List(Of String), Type As DriveType)) Handles driveManager.DrivesListed
    15. Try
    16. If e.Type = DriveType.Fixed Then
    17. Dim validDrivesInternal As List(Of String) = e.drivesList.Where(Function(drive) Directory.Exists(drive)).ToList()
    18. ' Erstellen und Hinzufügen der Gruppe "Intern" zum ListView
    19. Dim internGroup As New ListViewGroup("internDrives", "Interne Laufwerke")
    20. lvDrives.Groups.Add(internGroup)
    21. ' Hinzufügen der internen Laufwerke zur Gruppe "Intern"
    22. For Each drive As String In validDrivesInternal
    23. Dim item As New ListViewItem(drive)
    24. lvDrives.Items.Add(item).Group = internGroup
    25. Next
    26. Else
    27. Dim validDrivesExternal As List(Of String) = e.drivesList.Where(Function(drive) Directory.Exists(drive)).ToList()
    28. ' Erstellen und Hinzufügen der Gruppe "Extern" zum ListView
    29. Dim externGroup As New ListViewGroup("externDrives", "Externe Laufwerke")
    30. lvDrives.Groups.Add(externGroup)
    31. ' Hinzufügen der externen Laufwerke zur Gruppe "Extern"
    32. For Each drive As String In validDrivesExternal
    33. Dim item As New ListViewItem(drive)
    34. lvDrives.Items.Add(item).Group = externGroup
    35. Next
    36. End If
    37. ' Setze die Auswahl auf das erste Laufwerk, wenn verfügbar
    38. If lvDrives.Items.Count > 0 Then
    39. lvDrives.Items(0).Selected = True
    40. Else
    41. lvDrives.Items.Add("No Drive")
    42. End If
    43. Catch ex As Exception
    44. ' Fehlerbehandlung
    45. 'eventlogger.ExceptionToFile("Fehler: " & ex.Message)
    46. End Try
    47. End Sub
    49. End Class
    51. Public Class GetDriveInfo
    52. Public Event DrivesListed As EventHandler(Of (List(Of String), DriveType As DriveType))
    53. Public allDrives() As DriveInfo = DriveInfo.GetDrives()
    54. Friend SelectedDrive As DriveInfo
    55. Public Enum MediaType
    56. ExternalOrRemovable = 1
    57. Fixed = 2
    58. End Enum
    59. Private Const ExternalOrRemovableQuery As String = "SELECT DeviceID FROM Win32_DiskDrive WHERE MediaType='External hard disk media' OR MediaType='Removable media'"
    60. Private Const FixedQuery As String = "SELECT DeviceID FROM Win32_DiskDrive WHERE MediaType='Fixed hard disk media'"
    61. Public Sub ListDrives(MediaType As MediaType)
    62. Dim drivesList As New List(Of String)()
    63. Dim query As String = GetQueryByType(MediaType)
    64. If query <> "" Then
    65. Dim searcher As New ManagementObjectSearcher(query)
    66. searcher.Options.ReturnImmediately = True
    67. For Each drive As ManagementObject In searcher.Get()
    68. Dim partitionsQuery As String = $"ASSOCIATORS OF {{Win32_DiskDrive.DeviceID='{drive("DeviceID")}'}} WHERE AssocClass = Win32_DiskDriveToDiskPartition"
    69. Dim partitionSearcher As New ManagementObjectSearcher(partitionsQuery)
    70. For Each partition As ManagementObject In partitionSearcher.Get()
    71. Dim logicalDisksQuery As String = $"ASSOCIATORS OF {{Win32_DiskPartition.DeviceID='{partition("DeviceID")}'}} WHERE AssocClass = Win32_LogicalDiskToPartition"
    72. Dim logicalDisksSearcher As New ManagementObjectSearcher(logicalDisksQuery)
    73. For Each logicalDisk As ManagementObject In logicalDisksSearcher.Get()
    74. Dim driveID As String = logicalDisk("DeviceID").ToString() & "\"
    75. ' Prüfe auf Duplikate anhand einer anderen Eigenschaft (hier: DeviceID)
    76. If Not drivesList.Any(Function(d) d.StartsWith(driveID)) Then
    77. drivesList.Add(driveID)
    78. End If
    79. Next
    80. Next
    81. Next
    82. ' Sortiere die Liste der Laufwerksbuchstaben
    83. drivesList.Sort()
    84. RaiseEvent DrivesListed(Me, (drivesList, If(MediaType = MediaType.Fixed, DriveType.Fixed, DriveType.Removable)))
    85. End If
    86. End Sub
    87. Private Function GetQueryByType(driveType As MediaType) As String
    88. Select Case driveType
    89. Case MediaType.ExternalOrRemovable
    90. Return ExternalOrRemovableQuery
    91. Case MediaType.Fixed
    92. Return FixedQuery
    93. Case Else
    94. Return ""
    95. End Select
    96. End Function


    Und hier noch etwas gekürzt:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Private Sub driveManager_DrivesListed(sender As Object, e As (drivesList As List(Of String), Type As DriveType)) Handles driveManager.DrivesListed
    2. Try
    3. Dim GroupData As (Name As String, Title As String) = If(e.Type = DriveType.Fixed, ("internDrives", "Interne Laufwerke"), ("externDrives", "Externe Laufwerke"))
    5. ' Erstellen und Hinzufügen der Gruppe "Extern" zum ListView
    6. Dim Group As New ListViewGroup(GroupData.Name, GroupData.Title)
    7. lvDrives.Groups.Add(Group)
    8. ' Hinzufügen der externen Laufwerke zur Gruppe "Extern"
    9. For Each drive In e.drivesList.Where(Function(x) Directory.Exists(x))
    10. Dim item As New ListViewItem(drive)
    11. lvDrives.Items.Add(item).Group = Group
    12. Next
    14. ' Setze die Auswahl auf das erste Laufwerk, wenn verfügbar
    15. If lvDrives.Items.Count > 0 Then
    16. lvDrives.Items(0).Selected = True
    17. Else
    18. lvDrives.Items.Add("No Drive")
    19. End If
    20. Catch ex As Exception
    21. ' Fehlerbehandlung
    22. 'eventlogger.ExceptionToFile("Fehler: " & ex.Message)
    23. End Try
    24. End Sub


    btw: Eine Klasse GetDriveInfo zu nennen ist schon ziemlich :S
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „VaporiZed“ ()

    @Amelie Probiere folgende Codes nacheinander aus:

    VB.NET-Quellcode

    1. Private Sub ListDrives()
    2. ' Zuerst die interne Laufwerk-Liste abrufen und dann die externe Laufwerk-Liste
    3. 'driveManager.ListDrives(CType(2, GetDriveInfo.MediaType))
    4. driveManager.ListDrives(CType(1, GetDriveInfo.MediaType))
    5. End Sub

    VB.NET-Quellcode

    1. Private Sub ListDrives()
    2. ' Zuerst die interne Laufwerk-Liste abrufen und dann die externe Laufwerk-Liste
    3. driveManager.ListDrives(CType(2, GetDriveInfo.MediaType))
    4. 'driveManager.ListDrives(CType(1, GetDriveInfo.MediaType))
    5. End Sub
    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!

    @RodFromGermany
    Das hatte ich schon alles druch exerziert.

    Ich muss vom Code von @VaporiZed noch etwas ändern dann läuft es glaube ich.
    Ich poste gleich wenn ich es habe.
    Asperger Autistin. Brauche immer etwas um gewisse Sachen zu verstehen. :huh:

    Amelie schrieb:

    Das hatte ich schon alles druch exerziert.
    Dann ist Deine Fragestellung / Problembeschreibung völlig daneben:

    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!

    @RodFromGermany @VaporiZed

    Genau, diese Ausgaben hatte ich auch. Hab dich wohl vorher falsch verstanden.

    Hier nun der Code der funktioniert:

    Spoiler anzeigen
    ​
    Auf dem Form:

    VB.NET-Quellcode

    1. ​
    2. Private Sub driveManager_DrivesListed(sender As Object, e As Tuple(Of List(Of String), DriveType)) Handles driveManager.DrivesListed
    3. Try
    4. Dim drivesList As List(Of String) = e.Item1 ' Zugriff auf die Liste der Laufwerke
    5. Dim driveType As DriveType = e.Item2 ' Zugriff auf den Laufwerkstyp
    7. If driveType = DriveType.Fixed Then
    8. Dim validDrivesInternal As List(Of String) = drivesList.Where(Function(drive) Directory.Exists(drive)).ToList()
    9. ' Erstellen und Hinzufügen der Gruppe "Intern" zum ListView
    10. Dim internGroup As New ListViewGroup("internDrives", "Interne Laufwerke")
    11. lvDrives.Groups.Add(internGroup)
    12. ' Hinzufügen der internen Laufwerke zur Gruppe "Intern"
    13. For Each drive As String In validDrivesInternal
    14. Dim item As New ListViewItem(drive)
    15. lvDrives.Items.Add(item).Group = internGroup
    16. Next
    17. Else
    18. Dim validDrivesExternal As List(Of String) = drivesList.Where(Function(drive) Directory.Exists(drive)).ToList()
    19. ' Erstellen und Hinzufügen der Gruppe "Extern" zum ListView
    20. Dim externGroup As New ListViewGroup("externDrives", "Externe Laufwerke")
    21. lvDrives.Groups.Add(externGroup)
    22. ' Hinzufügen der externen Laufwerke zur Gruppe "Extern"
    23. For Each drive As String In validDrivesExternal
    24. Dim item As New ListViewItem(drive)
    25. lvDrives.Items.Add(item).Group = externGroup
    26. Next
    27. End If
    29. Catch ex As Exception
    30. ' Fehlerbehandlung
    31. ' eventlogger.ExceptionToFile("Fehler: " & ex.Message)
    32. End Try
    33. End Sub


    In der Class:

    VB.NET-Quellcode

    1. ​
    2. Public Class SelectedDrives
    3. Public Event DrivesListed As EventHandler(Of Tuple(Of List(Of String), DriveType))
    5. Public allDrives() As DriveInfo = DriveInfo.GetDrives()
    6. Friend SelectedDrive As DriveInfo
    8. Public Enum MediaType
    9. ExternalOrRemovable = 1
    10. Fixed = 2
    11. End Enum
    12. Private Const ExternalOrRemovableQuery As String = "SELECT DeviceID FROM Win32_DiskDrive WHERE MediaType='External hard disk media' OR MediaType='Removable media'"
    13. Private Const FixedQuery As String = "SELECT DeviceID FROM Win32_DiskDrive WHERE MediaType='Fixed hard disk media'"
    15. Public Sub ListDrives(MediaType As MediaType)
    16. Dim drivesList As New List(Of String)()
    17. Dim query As String = GetQueryByType(MediaType)
    18. If query <> "" Then
    19. Dim searcher As New ManagementObjectSearcher(query)
    20. searcher.Options.ReturnImmediately = True
    21. For Each drive As ManagementObject In searcher.Get()
    22. Dim partitionsQuery As String = $"ASSOCIATORS OF {{Win32_DiskDrive.DeviceID='{drive("DeviceID")}'}} WHERE AssocClass = Win32_DiskDriveToDiskPartition"
    23. Dim partitionSearcher As New ManagementObjectSearcher(partitionsQuery)
    24. For Each partition As ManagementObject In partitionSearcher.Get()
    25. Dim logicalDisksQuery As String = $"ASSOCIATORS OF {{Win32_DiskPartition.DeviceID='{partition("DeviceID")}'}} WHERE AssocClass = Win32_LogicalDiskToPartition"
    26. Dim logicalDisksSearcher As New ManagementObjectSearcher(logicalDisksQuery)
    27. For Each logicalDisk As ManagementObject In logicalDisksSearcher.Get()
    28. Dim driveID As String = logicalDisk("DeviceID").ToString() & "\"
    29. ' Prüfe auf Duplikate anhand einer anderen Eigenschaft (hier: DeviceID)
    30. If Not drivesList.Any(Function(d) d.StartsWith(driveID)) Then
    31. drivesList.Add(driveID)
    32. End If
    33. Next
    34. Next
    35. Next
    36. ' Sortiere die Liste der Laufwerksbuchstaben
    37. drivesList.Sort()
    38. Dim driveType As DriveType = If(MediaType = MediaType.Fixed, DriveType.Fixed, DriveType.Removable)
    40. RaiseEvent DrivesListed(Me, Tuple.Create(drivesList, driveType))
    42. End If
    43. End Sub
    44. Private Function GetQueryByType(driveType As MediaType) As String
    45. Select Case driveType
    46. Case MediaType.ExternalOrRemovable
    47. Return ExternalOrRemovableQuery
    48. Case MediaType.Fixed
    49. Return FixedQuery
    50. Case Else
    51. Return ""
    52. End Select
    53. End Function

    Bilder

    • listview-3.jpg

      79,78 kB, 756×321, 91 mal angesehen
    Asperger Autistin. Brauche immer etwas um gewisse Sachen zu verstehen. :huh:

    @Amelie Noch ein kleiner Aufruf-Tipp:

    VB.NET-Quellcode

    1. Private Sub ListDrives()
    2. ' Zuerst die interne Laufwerk-Liste abrufen und dann die externe Laufwerk-Liste
    3. driveManager.ListDrives(SelectedDrives.MediaType.Fixed)
    4. driveManager.ListDrives(SelectedDrives.MediaType.ExternalOrRemovable)
    5. End Sub

    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!

    Naja, und - wie geschrieben: Den Code zusammenfassen. Außer den unterschiedlichen Gruppennamen/-bezeichnungen gibt es keinen Codeunterschied. Daher sollte sich der If/Else-Block nur um die Unterschiede kümmern, nicht den gleichen Code duplizieren. Stichwort DRY
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    @VaporiZed @RodFromGermany

    Habe die Nacht über noch ein bissel gewerkelt. Wenn alles richtig läuft, schmeiße ich den Try/Catch-Block auch raus.
    Verwende dann:

    VB.NET-Quellcode

    1. AddHandler Application.ThreadException, AddressOf ExceptionHandlerForErrors
    2. AddHandler AppDomain.CurrentDomain.UnhandledException, AddressOf ExceptionHandlerForErrors


    Das ganze ist sicher noch zu verbessern ;)

    Spoiler anzeigen

    Auf dem Form:

    VB.NET-Quellcode

    1. Private WithEvents driveManager As New SelectedDrives()
    2. Private WithEvents driveCleaner As WriteFiles
    4. Public Sub New()
    5. driveCleaner = New WriteFiles(driveManager)
    6. 'AddHandler Application.ThreadException, AddressOf ExceptionHandlerForErrors
    7. 'AddHandler AppDomain.CurrentDomain.UnhandledException, AddressOf ExceptionHandlerForErrors
    8. InitializeComponent()
    9. ListDrives()
    10. End Sub
    11. Private Sub ListDrives()
    12. ' Zuerst die interne Laufwerk-Liste abrufen und dann die externe Laufwerk-Liste
    13. driveManager.ListDrives(SelectedDrives.MediaType.Fixed)
    14. driveManager.ListDrives(SelectedDrives.MediaType.Removable)
    15. driveManager.ListDrives(SelectedDrives.MediaType.External)
    16. End Sub
    18. Private Sub driveManager_DrivesListed(sender As Object, e As Tuple(Of List(Of String), DriveType)) Handles driveManager.DrivesListed
    19. Try
    20. Dim drivesList As List(Of String) = e.Item1 ' Zugriff auf die Liste der Laufwerke
    21. Dim driveType As DriveType = e.Item2 ' Zugriff auf den Laufwerkstyp
    23. Dim validDrives As List(Of String) = drivesList.Where(Function(drive) Directory.Exists(drive)).ToList()
    24. Dim groupName As String = ""
    26. ' Bestimmen des Gruppennamens basierend auf dem Laufwerkstyp
    27. If driveType = DriveType.Fixed Then
    28. groupName = "Interne Festplatten"
    29. ElseIf driveType = DriveType.Removable Then
    30. ' Unterscheidung zwischen USB-Stick und USB-HDD
    31. If validDrives.Any(Function(drive) New DriveInfo(drive).DriveType = DriveType.Removable) Then
    32. groupName = "USB-Stick / SD-Karten"
    33. Else
    34. groupName = "USB-Festplatten"
    35. End If
    36. End If
    38. ' Erstellen und Hinzufügen der entsprechenden Gruppe zum ListView
    39. Dim group As New ListViewGroup($"{groupName}Drives", $"{groupName}")
    40. lvDrives.Groups.Add(group)
    42. ' Hinzufügen der Laufwerke zur entsprechenden Gruppe
    43. For Each drive As String In validDrives
    44. Dim item As New ListViewItem(drive)
    45. lvDrives.Items.Add(item).Group = group
    46. Next
    48. Catch ex As Exception
    49. ' Fehlerbehandlung
    50. ' eventlogger.ExceptionToFile("Fehler: " & ex.Message)
    51. End Try
    52. End Sub


    In der Class:

    VB.NET-Quellcode

    1. Public Class SelectedDrives
    2. Public Event DrivesListed As EventHandler(Of Tuple(Of List(Of String), DriveType))
    4. Public allDrives() As DriveInfo = DriveInfo.GetDrives()
    5. Friend SelectedDrive As DriveInfo
    7. Public Enum MediaType
    8. Fixed = 1
    9. Removable = 2
    10. External = 3
    11. End Enum
    13. Private Function GetQueryByType(driveType As MediaType) As String
    14. Select Case driveType
    15. Case MediaType.Fixed
    16. Return FixedQuery
    17. Case MediaType.Removable
    18. Return RemovableQuery
    19. Case MediaType.External
    20. Return ExternalQuery
    21. Case Else
    22. Return ""
    23. End Select
    24. End Function
    26. Private Const RemovableQuery As String = "SELECT DeviceID FROM Win32_DiskDrive WHERE MediaType='External hard disk media'"
    27. Private Const ExternalQuery As String = "SELECT DeviceID FROM Win32_DiskDrive WHERE MediaType='Removable media'"
    28. Private Const FixedQuery As String = "SELECT DeviceID FROM Win32_DiskDrive WHERE MediaType='Fixed hard disk media'"
    30. Public Sub ListDrives(MediaType As MediaType)
    31. Dim drivesList As New List(Of String)()
    32. Dim query As String = GetQueryByType(MediaType)
    33. If query <> "" Then
    34. Dim searcher As New ManagementObjectSearcher(query)
    35. searcher.Options.ReturnImmediately = True
    36. For Each drive As ManagementObject In searcher.Get()
    37. Dim partitionsQuery As String = $"ASSOCIATORS OF {{Win32_DiskDrive.DeviceID='{drive("DeviceID")}'}} WHERE AssocClass = Win32_DiskDriveToDiskPartition"
    38. Dim partitionSearcher As New ManagementObjectSearcher(partitionsQuery)
    39. For Each partition As ManagementObject In partitionSearcher.Get()
    40. Dim logicalDisksQuery As String = $"ASSOCIATORS OF {{Win32_DiskPartition.DeviceID='{partition("DeviceID")}'}} WHERE AssocClass = Win32_LogicalDiskToPartition"
    41. Dim logicalDisksSearcher As New ManagementObjectSearcher(logicalDisksQuery)
    42. For Each logicalDisk As ManagementObject In logicalDisksSearcher.Get()
    43. Dim driveID As String = logicalDisk("DeviceID").ToString() & "\"
    44. ' Prüfe auf Duplikate anhand einer anderen Eigenschaft (hier: DeviceID)
    45. If Not drivesList.Any(Function(d) d.StartsWith(driveID)) Then
    46. drivesList.Add(driveID)
    47. End If
    48. Next
    49. Next
    50. Next
    51. ' Sortiere die Liste der Laufwerksbuchstaben
    52. drivesList.Sort()
    53. Dim driveType As DriveType = If(MediaType = MediaType.Fixed, DriveType.Fixed, DriveType.Removable)
    55. RaiseEvent DrivesListed(Me, Tuple.Create(drivesList, driveType))
    57. End If
    58. End Sub


    Verbesserungen:

    VB.NET-Quellcode

    1. Public Enum MediaType
    2. Fixed = 1
    3. External = 2
    4. Removable = 3
    5. End Enum
    7. Private Function GetQueryByType(driveType As MediaType) As String
    8. Select Case driveType
    9. Case MediaType.Fixed
    10. Return FixedQuery
    11. Case MediaType.External
    12. Return ExternalQuery
    13. Case MediaType.Removable
    14. Return RemovableQuery
    15. Case Else
    16. Return ""
    17. End Select
    18. End Function
    20. Private Const ExternalQuery As String = "SELECT DeviceID FROM Win32_DiskDrive WHERE MediaType='External hard disk media'"
    21. Private Const RemovableQuery As String = "SELECT DeviceID FROM Win32_DiskDrive WHERE MediaType='Removable media'"
    22. Private Const FixedQuery As String = "SELECT DeviceID FROM Win32_DiskDrive WHERE MediaType='Fixed hard disk media'"






    EDIT : 10:30 Uhr
    ----------------------
    Baue das Form gerade um. Auslagern in eine Class!
    Bilder

    • Listview4.jpg

      87,11 kB, 756×321, 308 mal angesehen
    Asperger Autistin. Brauche immer etwas um gewisse Sachen zu verstehen. :huh:

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

    Amelie schrieb:

    Wenn alles richtig läuft, schmeiße ich den Try/Catch-Block auch raus.
    Du solltest gar nicht mit Try/Catch arbeiten und wenn, dann nur mit expliziten Exceptions.
    Mit nem leeren Catch-Block in der Entwicklungsphase verschleierst Du doch die Ursachen.
    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!

    @VaporiZed @RodFromGermany

    So habe es geschafft. :)
    Die Try/Catch sind weg. Soweit alles in separate Klassen gebracht und noch die Trennung von USB-Festplatten und anderen USB-Datenträgern.
    Ideen etc um es ggf noch mehr an OOP und DRY etc. anzupassen lese ich gerne.


    Das Form: EDIT 21:15 Funktion verschoben
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Class frmMain
    2. Private WithEvents eventlogger As New Eventloger()
    3. Private WithEvents driveManager As New DriveManager()
    4. Private WithEvents driveProperty As New DriveProperty()
    6. Public Sub New()
    7. AddHandler Application.ThreadException, AddressOf ExceptionHandlerForErrors
    8. AddHandler AppDomain.CurrentDomain.UnhandledException, AddressOf ExceptionHandlerForErrors
    9. InitializeComponent()
    10. ListDrives()
    11. End Sub
    13. ' Fehlerbehandlungen
    14. Private Sub ExceptionHandlerForErrors(sender As Object, e As System.Threading.ThreadExceptionEventArgs)
    15. ShowError(e.Exception)
    16. End Sub
    18. Private Sub ExceptionHandlerForErrors(sender As Object, e As System.UnhandledExceptionEventArgs)
    19. ShowError(DirectCast(e.ExceptionObject, Exception))
    20. End Sub
    22. Private Sub ShowError(ex As Exception)
    23. Dim newMessage As String = "Eine Fehlermeldung wurde im LogFile eingetragen!" & Environment.NewLine & ex.Message
    24. eventlogger.ExceptionToFile(newMessage)
    25. End Sub
    27. ' Methode zum Aufrufen der Laufwerkliste
    28. Private Sub ListDrives()
    29. driveManager.ListDrives(DriveManager.MediaType.Fixed) ' Liste der internen Festplatten aufrufen
    30. driveManager.ListDrives(DriveManager.MediaType.External) ' Liste der externen Festplatten aufrufen
    31. driveManager.ListDrives(DriveManager.MediaType.Removable) ' Liste der wechselbaren Laufwerke aufrufen
    32. End Sub
    34. ' Ereignishandler für das "DrivesListed" Ereignis des DriveManagers
    35. Private Sub driveManager_DrivesListed(sender As Object, e As Tuple(Of List(Of String), DriveType)) Handles driveManager.DrivesListed
    36. ' Liste der zurückgegebenen Laufwerke
    37. Dim drivesList As List(Of String) = e.Item1
    38. ' Typ des zurückgegebenen Laufwerks
    39. Dim driveType As DriveType = e.Item2
    40. ' Liste gültiger Laufwerke
    41. Dim validDrives As List(Of String) = drivesList.Where(Function(drive) Directory.Exists(drive)).ToList()
    43. ' Ermitteln des Gruppennamens basierend auf dem Laufwerkstyp
    44. Dim groupName As String = GetDriveGroupName(driveType, validDrives)
    46. ' Hinzufügen einer neuen ListView-Gruppe mit dem ermittelten Gruppennamen
    47. Dim group As New ListViewGroup($"{groupName}Drives", $"{groupName}")
    48. lvDrives.Groups.Add(group)
    50. ' Hinzufügen der Laufwerke zur entsprechenden Gruppe in der ListView
    51. For Each drive As String In drivesList
    52. Dim item As New ListViewItem(drive)
    53. lvDrives.Items.Add(item).Group = group
    54. Next
    56. End Sub
    58. ' EDIT 21:15
    59. ' Die Funktion ist nun auch in der Class !!
    60. '--------------------------------------------------
    62. ' Funktion zur Bestimmung des Gruppennamens basierend auf dem Laufwerkstyp
    63. Private Function GetDriveGroupName(driveType As DriveType, validDrives As List(Of String)) As String
    64. If driveType = DriveType.Fixed Then
    65. ' Gruppenname für interne Festplatten
    66. Return "Interne Festplatten"
    67. ElseIf driveType = DriveType.Removable Then
    68. ' Unterscheidung zwischen USB-Stick / SD-Karten und USB-Festplatten
    69. If validDrives.Any(Function(drive) New DriveInfo(drive).DriveType = DriveType.Removable) Then
    70. ' Gruppenname für USB-Stick oder SD-Karten
    71. Return "USB-Stick / SD-Karten"
    72. Else
    73. ' Gruppenname für USB-Festplatten
    74. Return "USB-Festplatten"
    75. End If
    76. Else
    77. ' Rückgabe eines Standardwerts
    78. Return ""
    79. End If
    80. End Function
    81. ' --------------------------------------------------
    84. ' Methode ein Laufwerk zu setzen
    85. Private Sub lvDrives_ItemSelectionChanged(sender As Object, e As ListViewItemSelectionChangedEventArgs) Handles lvDrives.ItemSelectionChanged
    86. If e.IsSelected Then
    87. For Each item As ListViewItem In lvDrives.Items
    88. If item IsNot e.Item Then
    89. ' Alle anderen Elemente abwählen
    90. item.Selected = False
    91. End If
    92. Next
    93. ' Setze das ausgewählte Laufwerk im driveManager
    94. driveManager.SelectedDrive = New DriveInfo(e.Item.Text)
    95. ' Zeige alle Laufwerkinfos
    96. UpdateDriveInfos()
    97. ' Aktualisiere das Label mit dem ausgewählten Laufwerk
    98. UpdateSelectedDriveLabel()
    99. ' Zeige eine MessageBox, wenn das Laufwerk C:\ ausgewählt wurde
    100. ShowSelectedDriveMessageBox(e.Item.Text)
    101. End If
    102. End Sub
    104. ' Methode zur Aktualisierung der Listbox mit Laufwerk Infos
    105. Private Sub UpdateDriveInfos()
    106. driveProperty.ListDriveInfo(CChar(driveManager.SelectedDrive.Name), lbDriveInfos)
    107. End Sub
    109. ' Methode zur Aktualisierung des Labels mit dem ausgewählten Laufwerk
    110. Private Sub UpdateSelectedDriveLabel()
    111. lblSelectedDrive.Text = "Ausgewähltes Laufwerk: " & driveManager.SelectedDrive.Name
    112. End Sub
    114. ' Methode zum Anzeigen einer MessageBox, wenn das Laufwerk C:\ ausgewählt wurde
    115. Private Sub ShowSelectedDriveMessageBox(selectedDrive As String)
    116. If selectedDrive.ToUpper() = "C:\" Then
    117. MessageBox.Show("Sie haben das Laufwerk C:\ ausgewählt.", "Ausgewähltes Laufwerk", MessageBoxButtons.OK, MessageBoxIcon.Information)
    118. End If
    119. End Sub
    121. End Class



    Eine Class:1
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Class DriveManager
    2. ' Event, das ausgelöst wird, wenn die Laufwerke aufgelistet sind
    3. Public Event DrivesListed As EventHandler(Of Tuple(Of List(Of String), DriveType))
    5. ' Array, das alle Laufwerksinformationen speichert
    6. Public allDrivesInfos() As DriveInfo = DriveInfo.GetDrives()
    8. ' Das ausgewählte Laufwerk
    9. Public SelectedDrive As DriveInfo
    11. ' Enumeration für die verschiedenen Arten von Laufwerken
    12. Public Enum MediaType
    13. Fixed = 1 ' Interne HDDs
    14. External = 2 ' Externe HDDs
    15. Removable = 3 ' USB-Sticks / SD-Karten
    16. End Enum
    18. ' Funktion, die eine WMI-Abfrage je nach Laufwerkstyp zurückgibt
    19. Private Function GetWMIQuery(driveType As MediaType) As String
    20. Select Case driveType
    21. Case MediaType.Fixed
    22. Return "SELECT DeviceID FROM Win32_DiskDrive WHERE MediaType='Fixed hard disk media'"
    23. Case MediaType.External
    24. Return "SELECT DeviceID FROM Win32_DiskDrive WHERE MediaType='External hard disk media'"
    25. Case MediaType.Removable
    26. Return "SELECT DeviceID FROM Win32_DiskDrive WHERE MediaType='Removable media'"
    27. Case Else
    28. Return "" ' Leerer String für den Fall, dass kein gültiger Typ angegeben wurde
    29. End Select
    30. End Function
    32. ' Methode zum Auflisten der Laufwerke basierend auf dem angegebenen Typ
    33. Public Sub ListDrives(MediaType As MediaType)
    34. ' Liste, um die gefundenen Laufwerke zu speichern
    35. Dim drivesList As New List(Of String)()
    37. ' Abrufen der WMI-Abfrage für den angegebenen Laufwerkstyp
    38. Dim query As String = GetWMIQuery(MediaType)
    40. ' Prüfen, ob die Abfrage gültig ist
    41. If query <> "" Then
    42. ' Durchführen der WMI-Abfrage
    43. Dim searcher As New ManagementObjectSearcher(query)
    44. searcher.Options.ReturnImmediately = True
    46. ' Durchlaufen der Ergebnisse der WMI-Abfrage
    47. For Each drive As ManagementObject In searcher.Get()
    48. Dim partitionsQuery As String = $"ASSOCIATORS OF {{Win32_DiskDrive.DeviceID='{drive("DeviceID")}'}} WHERE AssocClass = Win32_DiskDriveToDiskPartition"
    49. Dim partitionSearcher As New ManagementObjectSearcher(partitionsQuery)
    51. ' Durchlaufen der Partitionen für jedes gefundene Laufwerk
    52. For Each partition As ManagementObject In partitionSearcher.Get()
    53. Dim logicalDisksQuery As String = $"ASSOCIATORS OF {{Win32_DiskPartition.DeviceID='{partition("DeviceID")}'}} WHERE AssocClass = Win32_LogicalDiskToPartition"
    54. Dim logicalDisksSearcher As New ManagementObjectSearcher(logicalDisksQuery)
    56. ' Durchlaufen der logischen Laufwerke für jede gefundene Partition
    57. For Each logicalDisk As ManagementObject In logicalDisksSearcher.Get()
    58. Dim driveID As String = logicalDisk("DeviceID").ToString() & "\"
    60. ' Hinzufügen des Laufwerks, wenn es nicht bereits in der Liste vorhanden ist
    61. If Not drivesList.Any(Function(d) d.StartsWith(driveID)) Then
    62. drivesList.Add(driveID)
    63. End If
    64. Next
    65. Next
    66. Next
    68. ' Sortieren der Laufwerksliste
    69. drivesList.Sort()
    71. ' Bestimmen des Laufwerkstyps
    72. Dim driveType As DriveType = If(MediaType = MediaType.Fixed, DriveType.Fixed, DriveType.Removable)
    74. ' Auslösen des Events und Übergeben der Liste und des Laufwerkstyps
    75. RaiseEvent DrivesListed(Me, Tuple.Create(drivesList, driveType))
    77. ' Erstellen einer lesbaren Zeichenfolge für die Laufwerke
    78. Dim drivesString As String = String.Join(" ", drivesList)
    80. ' Anzeige der Laufwerksliste und des Laufwerkstyps in der Debug-Ausgabe
    81. Debug.WriteLine($"Laufwerke: {drivesString}, Laufwerkstyp: {driveType}")
    82. End If
    83. End Sub
    85. Public Function GetDriveInfo(driveLetter As Char) As DriveInfo
    86. ' Gibt die DriveInfo für das angegebene Laufwerk zurück
    87. Return allDrivesInfos.FirstOrDefault(Function(d) d.Name.StartsWith(driveLetter))
    88. End Function
    90. End Class



    Eine Class:2
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Class DriveProperty
    2. Private ReadOnly driveManager As New DriveManager()
    3. Public drive As DriveInfo ' Instanzvariable für DriveInfo
    5. ' Funktion zur Abrufung des Laufwerks basierend auf dem Laufwerksbuchstaben
    6. Public Sub SetDriveInfo(driveLetter As Char)
    7. drive = driveManager.GetDriveInfo(driveLetter)
    8. End Sub
    10. ' Funktion zur Überprüfung, ob das Laufwerk bereit ist
    11. Public Function DriveIsReady(driveLetter As Char) As Boolean
    12. Dim drivePath As String = $"{driveLetter}:\\"
    13. Return Directory.Exists(drivePath)
    14. End Function
    16. ' Methode zur gemeinsamen Überprüfung und Rückgabe von Laufwerksinformationen
    17. Private Function GetDriveInfoAndCheck(driveLetter As Char) As DriveInfo
    18. If Not DriveIsReady(driveLetter) Then
    19. Return Nothing
    20. End If
    21. SetDriveInfo(driveLetter)
    22. Return drive
    23. End Function
    25. ' Methode zur Speicherplatzgewinnung
    26. Public Function GetTotalSpace(driveLetter As Char) As Long
    27. Dim drive As DriveInfo = GetDriveInfoAndCheck(driveLetter)
    28. If drive IsNot Nothing Then
    29. Return drive.TotalSize
    30. End If
    31. Return -1
    32. End Function
    34. ' Methode zur Speicherplatzgewinnung
    35. Public Function GetFreeSpace(driveLetter As Char) As Long
    36. Dim drive As DriveInfo = GetDriveInfoAndCheck(driveLetter)
    37. If drive IsNot Nothing Then
    38. Return drive.AvailableFreeSpace
    39. End If
    40. Return -1
    41. End Function
    43. ' Methode zum Dateisystem auslesen
    44. Public Function GetFileSystem(driveLetter As Char) As String
    45. Dim drive As DriveInfo = GetDriveInfoAndCheck(driveLetter)
    46. If drive IsNot Nothing Then
    47. Return drive.DriveFormat
    48. End If
    49. Return "N/A"
    50. End Function
    52. ' Methode um die Infos zur Listbox
    53. Public Sub ListDriveInfo(driveLetter As Char, listBox As ListBox)
    54. If Not DriveIsReady(driveLetter) Then
    55. listBox.Items.Clear()
    56. listBox.Items.Add($" Laufwerk {driveLetter}: Informationen nicht verfügbar.")
    57. Return ' Verlasse die Methode, wenn das Laufwerk nicht bereit ist
    58. End If
    60. Dim driveInfo As DriveInfo = GetDriveInfoAndCheck(driveLetter)
    61. If driveInfo IsNot Nothing Then
    62. listBox.Items.Clear()
    63. listBox.Items.Add($" Laufwerk: {driveLetter}:\")
    64. listBox.Items.Add($" Dateisystem: {driveInfo.DriveFormat}")
    65. listBox.Items.Add($" Gesamter Speicherplatz: {FormatSpace(driveInfo.TotalSize)}")
    66. listBox.Items.Add($" Freier Speicherplatz: {FormatSpace(driveInfo.AvailableFreeSpace)}")
    67. End If
    68. End Sub
    70. ' Methode zur Speicherplatz-Formatierung
    71. Private Function FormatSpace(space As Long) As String
    72. Dim units() As String = {"Bytes", "KB", "MB", "GB", "TB"}
    73. Dim index As Integer = 0
    74. Dim size As Double = space
    76. While size >= 1024 AndAlso index < units.Length - 1
    77. size /= 1024
    78. index += 1
    79. End While
    81. Return $"{size:N2} {units(index)}"
    82. End Function
    83. End Class

    Bilder

    • Listview5.jpg

      220,75 kB, 1.071×483, 148 mal angesehen

    • Listview5.jpg

      180,01 kB, 831×540, 135 mal angesehen
    Asperger Autistin. Brauche immer etwas um gewisse Sachen zu verstehen. :huh:

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

    @VaporiZed @RodFromGermany @ErfinderDesRades @siycah

    Habe nun mal alles versucht im Sinne von OOP, CleanCode usw.. umzubauen.

    Verwendet habe ich nun ein Treeview für die Laufwerke ( Gruppen der Laufwerke ) und je mal eine ListBox / Listview für die Laufwerks Informationen.
    Das ganze klappt auch mit dem USB-Monitor, den ich aber hier mal weggelassen habe.

    Hier nun mein Code. Bin über weiter Vorschläge offen.

    Das Mainform
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Class frmMain
    2. ' Eigenschaft zum Zugriff auf die DriveManager-Instanz
    3. Public ReadOnly Property DriveManagerInstance As DriveManager
    4. ' Instanz des DriveManagers
    5. Public WithEvents driveManager As New DriveManager()
    6. ' Instanz des TreeManagers
    7. Public WithEvents treeManager As TreeManager
    9. Public Sub New()
    10. ' Fehlerbehandlung für den Anwendungs-Thread und die App-Domäne einrichten
    11. AddHandler Application.ThreadException, AddressOf ExceptionHandlerForErrors
    12. AddHandler AppDomain.CurrentDomain.UnhandledException, AddressOf ExceptionHandlerForErrors
    14. ' Initialisierung des Formulars
    15. InitializeComponent()
    16. ' Übergeben des tvDrives Controls bei der Erstellung der TreeManager-Instanz
    17. treeManager = New TreeManager(driveManager, tvDrives)
    18. ' Auflisten der Laufwerke im TreeView
    19. treeManager.ListDrives()
    20. ' Anzeigen der Laufwerksinformationen in ListBox und ListView
    21. ShowDriveinfosListBox(driveManager.SelectedDrive)
    22. ShowDriveinfosListView(driveManager.SelectedDrive)
    23. End Sub
    25. ' Methoden für die Fehlerbehandlung
    26. #Region "Fehlerbehandlungen"
    27. ' Behandlung von Fehlern im Anwendungsthread
    28. Private Sub ExceptionHandlerForErrors(sender As Object, e As System.Threading.ThreadExceptionEventArgs)
    29. ShowError(e.Exception)
    30. End Sub
    32. ' Behandlung von unbehandelten Ausnahmen
    33. Private Sub ExceptionHandlerForErrors(sender As Object, e As System.UnhandledExceptionEventArgs)
    34. ShowError(DirectCast(e.ExceptionObject, Exception))
    35. End Sub
    37. ' Anzeige von Fehlern in einer MessageBox und Debug-Ausgabe
    38. Private Sub ShowError(ex As Exception)
    39. Dim newMessage As String = $"Ein Fehler wurde registriert!{ Environment.NewLine} {ex.Message} { Environment.NewLine} {ex.StackTrace}"
    40. MessageBox.Show(newMessage, "Information", MessageBoxButtons.OK, MessageBoxIcon.Information)
    41. Debug.WriteLine(newMessage)
    42. End Sub
    43. #End Region
    45. #Region "LaufwerksInfos anzeigen"
    46. ' Event-Handler zum Anzeigen der Laufwerksinformationen
    47. Private Sub HandleShowDriveInfosEvent(driveInfos As DriveInfo) Handles treeManager.ShowDriveInfos
    48. ' Anzeige der Laufwerksinformationen in ListBox und ListView
    49. ShowDriveinfosListBox(driveManager.SelectedDrive)
    50. ShowDriveinfosListView(driveManager.SelectedDrive)
    51. End Sub
    53. ' Methode zur Aktualisierung der Listbox mit Laufwerkinformationen
    54. #Region "Listbox"
    55. Private Sub ShowDriveinfosListBox(driveInfo As DriveInfo)
    56. ' ListBox leeren
    57. listBoxDriveInfo.Items.Clear()
    59. If driveInfo Is Nothing Then
    60. ' Anzeige einer Meldung, wenn kein Laufwerk ausgewählt ist
    61. listBoxDriveInfo.Items.Add("Kein Laufwerk ausgewählt")
    62. Else
    63. ' Laufwerksbuchstabe
    64. Dim driveLetterWithoutBackslash = driveInfo.Name.TrimEnd("\"c)
    65. listBoxDriveInfo.Items.Add($"Laufwerksbuchstabe: ({driveLetterWithoutBackslash})")
    66. listBoxDriveInfo.Items.Add($"Buchstabe & Name: ({driveInfo.Name}) {driveInfo.VolumeLabel}")
    68. ' Dateisystem
    69. listBoxDriveInfo.Items.Add($"Dateisystem: {driveInfo.DriveFormat}")
    71. ' Gesamtspeicherplatz
    72. listBoxDriveInfo.Items.Add($"Gesamtspeicherplatz: {driveManager.FormatSpace(driveInfo.TotalSize)}")
    74. ' Freier Speicherplatz
    75. listBoxDriveInfo.Items.Add($"Freier Speicherplatz: {driveManager.FormatSpace(driveInfo.TotalFreeSpace)}")
    76. End If
    77. End Sub
    78. #End Region
    80. ' Methode zur Aktualisierung der ListView mit Laufwerkinformationen
    81. #Region "Listview"
    82. Private Sub ShowDriveinfosListView(driveInfo As DriveInfo)
    83. listViewDriveInfo.Clear() ' Vorbereitung der ListView
    85. ' Konfiguration der Spalten für die ListView
    86. listViewDriveInfo.View = View.Details
    87. listViewDriveInfo.Columns.Add("Eigenschaft", 180)
    88. listViewDriveInfo.Columns.Add("Wert", 90)
    90. If driveInfo Is Nothing Then
    91. ' Anzeige einer Meldung, wenn kein Laufwerk ausgewählt ist
    92. AddListViewItem("Kein Laufwerk ausgewählt", "")
    93. Else
    94. ' Laufwerksinformationen hinzufügen
    95. Dim driveLetterWithoutBackslash = driveInfo.Name.TrimEnd("\"c)
    96. AddListViewItem("Laufwerksbuchstabe", $"({driveLetterWithoutBackslash})")
    97. AddListViewItem("Buchstabe & Name", $"({driveInfo.Name}) {driveInfo.VolumeLabel}")
    98. AddListViewItem("Dateisystem", driveInfo.DriveFormat)
    99. AddListViewItem("Gesamtspeicherplatz", driveManager.FormatSpace(driveInfo.TotalSize))
    100. AddListViewItem("Freier Speicherplatz", driveManager.FormatSpace(driveInfo.TotalFreeSpace))
    101. End If
    102. End Sub
    104. Private Sub AddListViewItem(PropertyText As String, ValueText As String)
    105. Dim listViewItem As New ListViewItem(PropertyText)
    106. listViewItem.SubItems.Add(ValueText)
    107. listViewDriveInfo.Items.Add(listViewItem)
    108. End Sub
    110. ' Methode zum Verhindern der Spaltenbreitenänderung in der ListView
    111. Private Sub listViewDriveInfo_ColumnWidthChanging(sender As Object, e As System.Windows.Forms.ColumnWidthChangingEventArgs) Handles listViewDriveInfo.ColumnWidthChanging
    112. Dim LstVw As ListView = CType(sender, ListView)
    113. Select Case e.ColumnIndex
    114. Case 0, 1
    115. e.Cancel = True
    116. e.NewWidth = LstVw.Columns(e.ColumnIndex).Width
    117. End Select
    118. End Sub
    119. #End Region
    121. #End Region
    123. End Class


    Die DriveManager Class
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Class DriveManager
    2. ' Event, das ausgelöst wird, wenn die Laufwerke aufgelistet sind
    3. Public Event DrivesListed As EventHandler(Of Tuple(Of List(Of String), DriveType))
    4. ' Array, das alle Laufwerksinformationen speichert
    5. Public allDrivesInfos() As DriveInfo = DriveInfo.GetDrives()
    6. ' Das ausgewählte Laufwerk
    7. Public SelectedDrive As DriveInfo
    9. ' Enumeration für die verschiedenen Arten von Laufwerken
    10. Public Enum MediaType
    11. Fixed = 1 ' Interne HDDs
    12. External = 2 ' Externe HDDs
    13. Removable = 3 ' USB-Sticks / SD-Karten
    14. End Enum
    16. ' Funktion, die eine WMI-Abfrage je nach Laufwerkstyp zurückgibt
    17. Private Function GetWMIQuery(driveType As MediaType) As String
    18. Select Case driveType
    19. Case MediaType.Fixed
    20. Return "SELECT DeviceID FROM Win32_DiskDrive WHERE MediaType='Fixed hard disk media'"
    21. Case MediaType.External
    22. Return "SELECT DeviceID FROM Win32_DiskDrive WHERE MediaType='External hard disk media'"
    23. Case MediaType.Removable
    24. Return "SELECT DeviceID FROM Win32_DiskDrive WHERE MediaType='Removable media'"
    25. Case Else
    26. Return Nothing 'für den Fall, dass kein gültiger Typ angegeben wurde
    27. End Select
    28. End Function
    30. ' Methode zum Auflisten der Laufwerke basierend auf dem angegebenen Typ
    31. Public Sub ListDrives(MediaType As MediaType)
    32. ' Liste, um die gefundenen Laufwerke zu speichern
    33. Dim drivesList As New List(Of String)()
    35. ' Abrufen der WMI-Abfrage für den angegebenen Laufwerkstyp
    36. Dim query As String = GetWMIQuery(MediaType)
    38. ' Prüfen, ob die Abfrage gültig ist
    39. If query <> "" Then
    40. ' Durchführen der WMI-Abfrage
    41. Dim searcher As New ManagementObjectSearcher(query)
    42. searcher.Options.ReturnImmediately = True
    44. ' Durchlaufen der Ergebnisse der WMI-Abfrage
    45. For Each drive As ManagementObject In searcher.Get()
    46. Dim partitionsQuery As String = $"ASSOCIATORS OF {{Win32_DiskDrive.DeviceID='{drive("DeviceID")}'}} WHERE AssocClass = Win32_DiskDriveToDiskPartition"
    47. Dim partitionSearcher As New ManagementObjectSearcher(partitionsQuery)
    49. ' Durchlaufen der Partitionen für jedes gefundene Laufwerk
    50. For Each partition As ManagementObject In partitionSearcher.Get()
    51. Dim logicalDisksQuery As String = $"ASSOCIATORS OF {{Win32_DiskPartition.DeviceID='{partition("DeviceID")}'}} WHERE AssocClass = Win32_LogicalDiskToPartition"
    52. Dim logicalDisksSearcher As New ManagementObjectSearcher(logicalDisksQuery)
    54. ' Durchlaufen der logischen Laufwerke für jede gefundene Partition
    55. For Each logicalDisk As ManagementObject In logicalDisksSearcher.Get()
    57. Dim driveID As String = logicalDisk("DeviceID").ToString() '& "\"
    59. ' Hinzufügen des Laufwerks, wenn es nicht bereits in der Liste vorhanden ist
    60. If Not drivesList.Any(Function(d) d.StartsWith(driveID)) Then
    61. drivesList.Add(driveID)
    62. End If
    63. Next
    64. Next
    65. Next
    67. ' Sortieren der Laufwerksliste
    68. drivesList.Sort()
    70. ' Bestimmen des Laufwerkstyps
    71. Dim driveType As DriveType = If(MediaType = MediaType.Fixed, DriveType.Fixed, DriveType.Removable)
    73. ' Auslösen des Events und Übergeben der Liste und des Laufwerkstyps
    74. RaiseEvent DrivesListed(Me, Tuple.Create(drivesList, driveType))
    76. ' Erstellen einer lesbaren Zeichenfolge für die Laufwerke
    77. Dim drivesString As String = String.Join(" ", drivesList)
    79. ' Anzeige der Laufwerksliste und des Laufwerkstyps in der Debug-Ausgabe
    80. Debug.WriteLine($"Laufwerke: {drivesString}, Laufwerkstyp: {driveType}")
    81. End If
    82. End Sub
    84. Public Function GetDriveInfo(driveLetter As Char) As DriveInfo
    85. ' Gibt die DriveInfo für das angegebene Laufwerk zurück
    86. Return allDrivesInfos.FirstOrDefault(Function(d) d.Name.StartsWith(driveLetter))
    87. End Function
    89. ' Formatieren der Bytewerte
    90. Public Function FormatSpace(space As Long) As String
    91. Dim units() As String = {"Bytes", "KB", "MB", "GB", "TB"}
    92. Dim index As Integer = CInt(Math.Floor(Math.Log(space, 1024)))
    93. Dim size As Double = space / Math.Pow(1024, index)
    94. Return $"{size:N2} {units(index)}"
    95. End Function
    97. ' Methode um den Computernamen zu ermitteln
    98. Public Shared Function GetComputerName() As String
    99. Return Environment.MachineName
    100. End Function
    102. ' Methode im DriveManager, um das Laufwerk C: zu überprüfen
    103. Public Function IsDriveCSelected() As Boolean
    104. Dim drives As DriveInfo() = DriveInfo.GetDrives()
    106. For Each drive As DriveInfo In drives
    107. If drive.Name.ToUpper() = "C:\" Then
    108. Return True
    109. End If
    110. Next
    112. Return False
    113. End Function
    115. End Class


    Die TreeManager Class
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Class TreeManager
    2. Private ReadOnly driveManagerInstance As DriveManager
    3. Private ReadOnly tvDrivesInstance As TreeView
    4. Public Event ShowDriveInfos(driveInfos As DriveInfo)
    6. Public Sub New(driveManager As DriveManager, tvDrives As TreeView)
    7. Me.driveManagerInstance = driveManager
    8. Me.tvDrivesInstance = tvDrives
    9. ' Abonniere das Ereignis des DriveManagers
    10. AddHandler driveManagerInstance.DrivesListed, AddressOf driveManager_DrivesListedForTreeView
    11. ' Ereignisbehandlungsmethode hinzufügen
    12. AddHandler tvDrivesInstance.BeforeSelect, AddressOf tvDrives_BeforeSelect
    13. ' Ereignisbehandlungsmethode hinzufügen
    14. AddHandler tvDrivesInstance.AfterSelect, AddressOf tvDrives_AfterSelect
    15. End Sub
    17. ' Methode zum Aufrufen der Laufwerkliste
    18. Public Sub ListDrives()
    19. ' Zugriff auf das tvDrives Control für die weitere Verarbeitung
    20. If tvDrivesInstance IsNot Nothing Then
    21. ' Hier den TreeView leeren
    22. tvDrivesInstance.Nodes.Clear()
    24. ' Füge den Hauptknoten im Treeview mit einem separaten Icon und den Computernamen hinzu
    25. Dim computerName As String = DriveManager.GetComputerName()
    26. tvDrivesInstance.Nodes.Add("PC", computerName, 1)
    28. ' Laufwerke aus der DriveManager-Klasse abrufen
    29. driveManagerInstance.ListDrives(DriveManager.MediaType.External)
    30. driveManagerInstance.ListDrives(DriveManager.MediaType.Removable)
    31. driveManagerInstance.ListDrives(DriveManager.MediaType.Fixed)
    32. End If
    33. End Sub
    35. ' Ereignisbehandlungsmethode, die aufgerufen wird, wenn die Laufwerke aufgelistet sind
    36. Private Sub driveManager_DrivesListedForTreeView(sender As Object, e As Tuple(Of List(Of String), DriveType))
    37. Dim drivesList As List(Of String) = e.Item1
    38. Dim driveType As DriveType = e.Item2
    39. Dim validDrives As List(Of String) = drivesList.Where(Function(drive) Directory.Exists(drive)).ToList()
    41. ' Ermitteln des Gruppennamens basierend auf dem Laufwerkstyp
    42. Dim groupName As String = GetDriveGroupName(driveType, validDrives)
    44. ' Finde oder erstelle den entsprechenden Knoten basierend auf dem Gruppennamen
    45. Dim groupNode As TreeNode = FindOrCreateGroupNode(groupName)
    47. ' Hinzufügen der Laufwerke zum entsprechenden Knoten im TreeView
    48. For Each drive As String In drivesList
    49. Dim driveNode As New TreeNode(GetDriveDisplayName(drive))
    50. ' Speichern des Laufwerkspfads im Tag des TreeView-Knotens
    51. driveNode.Tag = drive
    52. groupNode.Nodes.Add(driveNode)
    53. ' Setze das Bild für das Laufwerk
    54. SetDriveImageTV(driveNode, driveType, drive)
    55. Next
    57. ' Alle Knoten im TreeView erweitern, um die Laufwerke anzuzeigen
    58. tvDrivesInstance.ExpandAll()
    60. End Sub
    62. ' Methode um die Icons zuzuweisen
    63. Private Sub SetDriveImageTV(driveNode As TreeNode, driveType As DriveType, drivePath As String)
    64. Select Case driveType
    65. Case DriveType.Fixed
    66. If drivePath.ToUpper() = "C:" Then
    67. driveNode.ImageIndex = 5 ' Spezielles Bilde für Laufwerk C:\
    68. Else
    69. driveNode.ImageIndex = 3 ' Standardbild für feste Laufwerke
    70. End If
    71. Case DriveType.Removable
    72. If IsRemovableDriveTV(drivePath) Then
    73. driveNode.ImageIndex = 6 ' Standardbild für SD-Cards / USB-Sticks
    74. Else
    75. driveNode.ImageIndex = 2 ' Standardbild für USB-Festplatten
    76. End If
    77. Case Else
    78. driveNode.ImageIndex = 7 ' Standardbild für andere Laufwerkstypen
    79. End Select
    80. End Sub
    82. ' Methode um die Gruppen zu erstellen
    83. Private Function FindOrCreateGroupNode(groupName As String) As TreeNode
    84. ' Versuche den Gruppenknoten zu finden
    85. Dim nodes As TreeNode() = tvDrivesInstance.Nodes.Find(groupName, False)
    86. ' Überprüfe, ob der Knoten gefunden wurde und mindestens ein Element enthält
    87. If nodes IsNot Nothing AndAlso nodes.Length > 0 Then
    88. ' Der Knoten wurde gefunden, gib ihn zurück
    89. Return nodes(0)
    90. Else
    91. ' Der Knoten wurde nicht gefunden, erstelle einen neuen Knoten und füge ihn hinzu
    92. Dim newNode As New TreeNode(groupName)
    93. ' Setze den Namen des neuen Knotens
    94. newNode.Name = groupName
    95. tvDrivesInstance.Nodes.Add(newNode)
    96. Return newNode
    97. End If
    98. End Function
    100. ' Methode um die Gruppennamen zu erstellen
    101. Public Function GetDriveGroupName(driveType As DriveType, validDrives As List(Of String)) As String
    102. Dim groupName As String = ""
    104. Select Case driveType
    105. ' Gruppenname für Interne Laufwerke
    106. Case DriveType.Fixed
    107. groupName = "Interne Festplatten"
    108. ' Gruppenname für Externe Laufwerke
    109. Case DriveType.Removable
    111. ' Überprüfen auf WechselMedien oder Festplatten
    112. Dim isRemovable As Boolean = validDrives.Any(Function(drive) New DriveInfo(drive).DriveType = DriveType.Removable)
    114. ' Gruppenname basierend auf dem Ergebnis setzen
    115. Select Case isRemovable
    116. Case True
    117. groupName = "USB-Stick / SD-Karten"
    118. Case Else
    119. groupName = "USB-Festplatten"
    120. End Select
    121. Case Else
    122. ' Kein gültiger Typ
    123. groupName = Nothing
    124. End Select
    126. Return groupName
    127. End Function
    129. ' Methode zum formatieren der Laufwerksanzeige im Treeview
    130. Private Function GetDriveDisplayName(drive As String) As String
    131. Dim driveInfo As New DriveInfo(drive)
    132. Dim driveLabel As String = If(Not String.IsNullOrEmpty(driveInfo.VolumeLabel), $"({drive}) {driveInfo.VolumeLabel}", drive)
    133. Return $"{driveLabel}"
    134. End Function
    136. ' Überprüft, ob der Laufwerkstyp wechselbar ist, basierend auf dem Laufwerkspfad
    137. Private Function IsRemovableDriveTV(drivePath As String) As Boolean
    138. Return New DriveInfo(drivePath).DriveType = DriveType.Removable
    139. End Function
    141. Private Sub tvDrives_BeforeSelect(sender As Object, e As TreeViewCancelEventArgs)
    142. ' Überprüfen, ob der ausgewählte Knoten ein Hauptknoten ist
    143. If e.Node.Parent Is Nothing Then
    144. ' Den Klick auf den Hauptknoten verhindern, indem e.Cancel auf True gesetzt wird
    145. e.Cancel = True
    146. End If
    147. End Sub
    149. ' Methode das Laufwerk auszuählen
    150. Private Sub tvDrives_AfterSelect(sender As Object, e As TreeViewEventArgs)
    151. Dim selectedNode As TreeNode = e.Node
    153. ' Überprüfen, ob der ausgewählte Knoten kein Hauptknoten ist
    154. If selectedNode.Parent IsNot Nothing Then
    155. ' Setze das ausgewählte Laufwerk im driveManager
    156. driveManagerInstance.SelectedDrive = New DriveInfo(selectedNode.Tag.ToString())
    157. ' Sende alle Laufwerkinfos an die Listbox auf dem frmMain
    158. RaiseEvent ShowDriveInfos(driveManagerInstance.SelectedDrive)
    159. ' Zeige eine MessageBox, wenn das Laufwerk C:\ ausgewählt wurde
    161. ' Überprüfe, ob Laufwerk C: ausgewählt wurde
    162. If driveManagerInstance.SelectedDrive.Name.ToUpper() = "C:\" Then
    163. ' Zeige eine MessageBox nur für das Laufwerk C:
    164. Dim newMessage As String = $"Sie haben das System-Laufwerk {driveManagerInstance.SelectedDrive.Name} ausgewählt."
    165. MessageBox.Show(newMessage, "Information", MessageBoxButtons.OK, MessageBoxIcon.Information)
    166. End If
    167. End If
    168. End Sub
    170. End Class

    Bilder

    • treeview-2.jpg

      159,93 kB, 548×315, 95 mal angesehen
    Asperger Autistin. Brauche immer etwas um gewisse Sachen zu verstehen. :huh:

    Das sieht tatsächlich schon gar nicht mal so schlecht aus.

    Kommentare
    Was ich dir an erster Stelle mitgeben würde, ist dass du unbedingt Dokumentationskommentare verwenden solltest, statt den "normalen" Kommentaren im Code.
    Die machst du mit drei Apostrophen ('), VS (Code) übernimmt dann den Rest für dich. Da schreibst du rein, was die Methoden/Properties usw. machen und beschreibst die Parameter.

    Strings
    Du verwendest jede Menge Strings in deinem Code - soweit alles erstmal in Ordnung.
    Ich würde dir raten, anstatt "Magic Strings" zu verwenden, wie du es gerade tust, lagerer die Strings soweit es geht in Konstanten aus und setze dann erst entsprechende Werte ein.
    Das erhöht mitunter die Wiederverwendbarkeit.

    Du solltest ebenfalls versuchen, Backslashes zu vermeiden. VB lässt das ohne Weiteres zu, aber sobald du versuchst, diese Strings mit einer anderen Sprache zu verwenden, wirst du teils merkwürdige Phänomene erhalten.

    Parameter
    Mir ist aufgefallen, dass du an ein oder zwei Stellen einen Parameter nach einem Datentypen benannt hast. Visual Basic ist case insensitive und kennt den Unterschied, weshalb das funktionieren mag.
    Es ist allerdings nicht sonderlich gut zu lesen. Hier solltest du aussagekräftigere Namen verwenden und nach Möglichkeit (auch wenn es VB egal ist) auf Groß-/Kleinschreibung achten.

    Klare Rückgabewerte
    Dim query As String = GetWMIQuery(MediaType)
    Deine Methode gibt zwar einen String zurück, aber auch null. Das ist nicht dokumentiert und könnte beim Überfliegen übersehen werden.
    Was hier besser wäre, ist wenn du das A) dokumentierst und B) als Rückgabetyp string? verwendest. Dann ist es sowohl im Code, als auch in der Doku ersichtlich, was genau diese Method zurückgibt.

    Im gleichen Zuge, solltest du auch auf null oder nothing prüfen. Wenn der String tatsächlich null ist, dann könnte das einen Fehler werfen oder fehlerhaftes Verhalten aufzeigen.

    Klassenstruktur und Verkapselung
    Grundsätzlich finde ich, ist deine Klasse sauber und logisch aufgeteilt. Großes Lob dafür, ich habe schon viiieel kleinere und unübersichtlichere Klassen geschrieben gesehen.

    Allerdings solltest du drauf achten, öffentliche Eigenschaften immer als soche zu deklarieren. Entweder mit Getter/Setter, oder als property.
    Das dient der Verkapselung deiner Daten. Das ist insbesondere dann wichtig, wenn du ungefilterten Input filtern/parsen musst.

    Dazu solltest du vermeiden, nested Klassen/Enums zu schreiben. Es gibt Fälle, wo es Sinn macht, das Namespace nicht mit irgendwelchen Sachen vollzumüllen, aber wenn das ein enum ist, den auch andere (Klassen) verwenden, dann leg sie am besten direkt ins Namespace.
    Wenn ich mehr als ein/zwei Mal MyFoo.EnumType schreiben muss, dann habe ich direkt das Verlangen, die Struktur komplett zu refactoren. Macht den ganzen Code einfach nur schwer zu verstehen.

    Nesting und Vereinfachung von Abfragen
    Das ist mMn noch subjektiver als die meisten anderen Themen, erwähnen möchte ich es dennoch.

    Du schreibst:

    VB.NET-Quellcode

    1. if x isnot nothing then
    2. ' do stuff
    3. ' do stuff
    4. 'do stuff
    5. end if


    viel lesbarer wird es (find ich), wenn man die If invertiert.

    VB.NET-Quellcode

    1. if x is nothing then return
    2. ' or
    3. if x is nothing then
    4. return
    5. end if
    7. ' do stuff
    8. ' do stuff
    9. 'do stuff


    Implicit Typing
    Ich habe es hier im Forum kürzlich wieder erwähnt.
    Lasst den Compiler ruhig die Arbeit machen.

    Anhand des Methoden-/Variablennamens oder der Doku-Kommentare sollte ersichtlich sein, was die Methode macht.
    Dementsprechend ist aus dem Kontext schon klar, was die (wichtigsten) Parameter sind.

    Spar dir das as TreeViewNode und schreibe schlicht Dim selectedNode = e.Node. Der Compiler muss schließlich auch was für seine Brötchen tun. Einfaches lexisches Analysieren und deinen Code in Tokens brechen reicht heutzutage nimmer. Ich muss ja auch Softwareingenieur, -Tester und Release-Manager spielen :)

    Debug-Fehler-Nachrichten
    Am besten gleich sein lassen.
    Wenn du einen Fehler ausgibst und das Programm von Otto-Normal-Verbrauchen genutzt werden soll, wollen die keinen Stack Trace (den es bei einem optimierten Build ohnehin nicht wirklich* gibt) sehen. Die denken, der Rechner sei in die Luft geflogen.
    Benutz einen Logger wie Serilog o.Ä. und schmeiß da deine Stacktraces rein als Debug-Ausgabe. Die Fehlermeldung alleine sollte reichen.

    Zu guter Letzt: Testen
    Das ist ein Thema, das hört kein Softwaremensch gerne (außer vielleicht der @RodFromGermany :p).
    Es ist aber ein elementarer Teil unserer Aufgabe/unseres Hobby. Wir wollen schließlich keine Software rausgeben, die unentdeckte Fehler hat.

    Schreib Unit Tests (MSTest ist dafür super). Es gibt auch Tools, die wie Affen wild in deiner UI rumklicken und auf die Tastatur rumhacken - um eben unerwartete UI-Fehler aufzudecken.
    Da gibt's zahlreiche Themen im Internet zu. Für .net habe ich persönlich nie eins gebraucht, aber für Qt/C++ gibt's z.B. Squish.



    Ich find's übrigens super, dass du nach Feedback fragst! Nur so kann man dazulernen.
    Man geht immer mit einem Tunnelblick an seinen eigenen Code. Man überliest/übersieht/ignoriert Sachen, oder hat einfach einen Spaten im Gehirn stecken, der genau die zwei Neuronen blockiert, die man braucht, um das Problem zu erkennen.
    Diesen Tunnelblick haben Fremde (ob nun fremde Menschen wie wir, oder Kollegen, die projektfremd sind) selten bis gar nicht.

    Wenn du was von dem Feedback gebrauchen kannst, freut es mich. Wenn du das liest und dir denkst "was'n Spinner. Leute gibt's..." ist das natürlich auch in Ordnung :D Da bin ich nicht so empfindlich

    EDIT: Scheinbar bin ich zu blöd, für die Line-Funktion im Editor. Kann mich da jemand aufschlauen? Egal ob ich's leer lasse oder was eingebe, der parst das nicht...

    Inhalt zwischen den Line-Tags entfernt, um eine Linie anzuzeigen ~VaporiZed
    Quellcode lizensiert unter CC by SA 2.0 (Creative Commons Share-Alike)

    Meine Firma: Procyon Systems

    Selbstständiger Softwareentwickler & IT-Techniker.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „VaporiZed“ ()

    @siycah
    Moin moin und Danke für dein Feedback. :rolleyes:

    Ja wo fange ich an.
    Ein Logger: Ich habe einen, den ich mir selbst geschrieben habe, nur eben hier bzgl der Übersicht weggelassen, wie auch den USB-Monitor, der das Treeview immer aktuell halten würde.
    Die DebugAusgaben mache ich mir immer um zu sehen ob das auch ankommt, was ich da erwarte. Hatte gerade am Anfang immer Probleme weiter zukommen, weil einfach nicht das ankam und so meine Codes nie liefen.
    In der Release-Version sind die ja eh weg.


    So etwas meinst du, gelle. ;)
    Spoiler anzeigen
    ​

    VB.NET-Quellcode

    1. Private Const internelDrives As String = "Interne Festplatten"
    2. Private Const externelDrives As String = "USB Festplatten"
    3. Private Const removableDrives As String = "USB Sticks / SD-Karten"


    XML-Quellcode

    1. ''' <summary>
    2. ''' Initialisiert eine neue Instanz der TreeManager-Klasse.
    3. ''' </summary>
    4. ''' <param name="driveManager">Die Instanz des DriveManagers.</param>
    5. ''' <param name="tvDrives">Die Instanz des TreeView-Controls.</param>



    Die <summary> fand ich jetzt hier ein wenig viel aber eigentlich haste ja Recht, sollte mir ja selber helfen alte Codes wieder zu lesen.
    Deine anderen Anmerkungen werde ich in meinem "Übungsprojekt" nochmal überarbeiten. :thumbup:
    Asperger Autistin. Brauche immer etwas um gewisse Sachen zu verstehen. :huh:

    ich finde, man soll immer sparsam dokumentieren - auch Doku-Kommentare.
    Zuviele Kommentare (auch Doku-Kommentare) machen Code unleserlich
    • wenn sie einfach nur das nachlabern, was sowieso prominent im Code steht
      wichtiger als schlau daherzukommentieren ist, seinen Code sinnig zu benamen, dass er sich selbst erklärt - ohne Comment
    • oder wenn sie gar inhaltlich falsch sind.
      das passiert insbesondere dann, wenn Code nachgebessert wird (also sehr oft).
    Keinesfalls sollten Kommentare dasjenige nochmal hinlabern, was sowieso im Code steht.
    Also genau sowas ist mir ein Graus:

    VB.NET-Quellcode

    1. ''' <summary>
    2. ''' Initialisiert eine neue Instanz der TreeManager-Klasse.
    3. ''' </summary>
    4. ''' <param name="driveManager">Die Instanz des DriveManagers.</param>
    5. ''' <param name="tvDrives">Die Instanz des TreeView-Controls.</param>
    6. Public Sub New(driveManager As DriveManager, tvDrives As TreeView)
    7. '...

    • zeile #2: enthält keine Information. Bzw wer nicht weiss, dass Sub New eine neue Instanz initialisiert, sollte erst garkein Code angucken dürfen.
    • #4: enthält keine Information. Das der Parameter ein DriveManager ist, steht ja im Code selbst
    • #5 enthält keine Information. Das der Parameter ein TreeView ist, steht ja im Code selbst
    Also da würde ich dir genau zustimmen, wenn du sagst:

    Amelie schrieb:

    Die <summary> fand ich jetzt hier ein wenig viel...
    und auch dabei bleiben


    Hingegen sowas

    VB.NET-Quellcode

    1. ' Methode zum Aufrufen der Laufwerkliste
    2. Public Sub ListDrives()
    ist durchaus eines Doku-Comments wert.
    Nur soll der Comment auch sagen, was die Methode tut - nicht einfach nochmal hinlabern, was im Code sowieso schon steht - also tätichs mir so wünschen:

    VB.NET-Quellcode

    1. ''' <summary>Legt im Treeview Nodes an mit Laufwerks-Informationen</summary>
    2. Public Sub ListDrives()
    Noch besser aber wäre, wenn du der Methode einen Namen gibst, der sagt, was sie tut:

    VB.NET-Quellcode

    1. Public Sub PopulateDrivesTreeview()
    und gut ist.

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

    @ErfinderDesRades

    Ehrlich gesagt, tut ich mich immer etwas schwer die "richtigen / passenden" Worte für solche Kommentare zu finden.
    Denke aber das es mit der Zeit besser wird, wenn ich da dranbleibe. ;)

    Das hier finde ich einen guten Kompromiss bzgl der Länge der Kommentare / Summarys.

    XML-Quellcode

    1. ​
    2. ' Methode zum Aufrufen der Laufwerkliste
    3. ''' <summary>Legt im Treeview Nodes an mit Laufwerks-Informationen</summary>
    4. Public Sub ListDrives()
    Asperger Autistin. Brauche immer etwas um gewisse Sachen zu verstehen. :huh: