Systeminformationen mit WMI auslesen ab .NET 3.0 oder früher

    • VB.NET

      Systeminformationen mit WMI auslesen ab .NET 3.0 oder früher

      Aus Lust und Laune dachte ich mir, da es ein öfters gefragtes und ebenso hilfreiches Themengebiet ist, dass ich mir einmal ein bisschen Zeit.
      Natürlich benötigt man für die erfolgreiche Ausführung dieses Tutorials diverse Grundkenntnisse.
      Den Stil dieses Tutorials habe ich von @nikeee13 übernommen.

      Diesen Artikel können Sie ebenfalls auf meiner Website finden: gather.pf-control.de (Website im Aufbau).
      Dieser besitzt dort mehr Features bzw. ist ausgebauter und besser Formatiert, da dies hier nicht möglich war.


      Was ist WMI?
      WMI oder auf Windows-Management Instrument ist eine grundlegende Verwaltungstechnologie in Windows.
      Mit Hilfe von ihr, können sie sowohl lokale Computer als auch Remotecomputer verwalten. Ebenso bietet WMI eine ausgezeichnete Schnittstelle,
      zum Auslesen von Systeminformationen. Mit dieser werden wir uns in diesem Tutorial befassen. Wir werden Informationen über die CPU, die Grafikkarte,
      das BIOS uvm. auslesen. Natürlich ist noch mehr ganz einfach möglich.

      Ein paar andere Features die WMI Ihnen bietet sind neben dem Starten von Prozessen auf Remotecomputern, das Planen eines Prozesses oder das Neustarten
      auf bzw. eines Remotecomputers.

      MSDN-Seite zu WMI: msdn.microsoft.com/en-us/libra…op/aa394582(v=vs.85).aspx
      Wikipedia-Artikel: en.wikipedia.org/wiki/Windows_Management_Instrumentation


      Was benötigen Sie?
      Die Grundvorraussetzung für das Nutzen von WMI ist logischerweise die System.Management.dll, die normalerweise in dem Framework 3.0 zu finden ist.
      Wenn Sie dennoch WMI unter einem niedrigerem Framework benutzen wollen, müssen Sie sich die .dll manuell herunterladen. Diese finden Sie unten im Anhang.

      Ebenso ein sehr hilfreiches Produkt von Microsoft ist der WMI Code-Creator, der das Nutzen und Auslesen von Systeminformationen mit WMI erheblich vereinfacht.
      Diesen können Sie hier herunterladen:
      microsoft.com/en-us/download/details.aspx?id=8572


      Los geht's!
      Grundsätzlich funktioniert das Auslesen von Systeminformationen mit Hilfe des WMI-Codecreators kinderleicht.
      Man startet Ihn, und lässt sich den Code in der gewünschten Sprache ausgeben.
      In meinem Falle habe ich mir sehr einfach den Prozessor-Namen ausgeben lassen:

      VB.NET-Quellcode

      1. Imports System
      2. Imports System.Management
      3. Imports System.Windows.Forms
      5. Namespace WMISample
      7. Public Class MyWMIQuery
      9. Public Overloads Shared Function Main() As Integer
      11. Try
      12. Dim searcher As New ManagementObjectSearcher( _
      13. "root\CIMV2", _
      14. "SELECT * FROM Win32_Processor")
      16. For Each queryObj As ManagementObject In searcher.Get()
      18. Console.WriteLine("-----------------------------------")
      19. Console.WriteLine("Win32_Processor instance")
      20. Console.WriteLine("-----------------------------------")
      21. Console.WriteLine("Name: {0}", queryObj("Name"))
      22. Next
      23. Catch err As ManagementException
      24. MessageBox.Show("An error occurred while querying for WMI data: " & err.Message)
      25. End Try
      26. End Function
      27. End Class
      28. End Namespace


      Grundsätzlich kann man das schon so lassen, und in einer Konsolenanwendung einbauen bzw. verwenden.
      Dies würde schon zu einem guten und hilfreichen Ergebnis kommen. In meinem Fall sieht meine erhaltene Informationen in der Konsolen-Anwendung so aus:

      Brainfuck-Quellcode

      1. -----------------------------------
      2. Win32_Processor instance
      3. -----------------------------------
      4. Name: Name (Ich habe ihn nicht eingefügt)


      Nun stellen wir uns für wir wollen diesen Code in einer WPF-Anwendung oder einer Windows Forms Anwendungs zum Laufen bringen.
      Dazu müssen wir logischerweise eine Funktion erstellen.

      VB.NET-Quellcode

      1. ''' <summary>
      2. ''' Funktion um den Namen der CPU zu ermitteln
      3. ''' </summary>
      4. ''' <returns> String </returns>
      5. ''' <remarks></remarks>
      6. Shared Function getName() As String
      7. Try
      9. Dim searcher As New ManagementObjectSearcher( _
      10. "root\CIMV2", _
      11. "SELECT * FROM Win32_Processor")
      13. For Each queryObj As ManagementObject In searcher.Get()
      15. Return queryObj("Name").ToString
      16. Next
      18. Catch err As ManagementException
      19. Return "Error"
      20. End Try
      21. End Function

      Schauen wir uns nun, diese Funktion etwas genauer an…
      Als aller ersten, müssen wir einen “Sucher” erstellen. Da wir mit WMI arbeiten, müssen wir diesen als New ManagementObjectSearcher definieren.
      Natürlich benötigt unser “Sucher” noch Informationen wo, und was er suchen soll. Dies ist in unserem Fall das Oberverzeichnis “root\CIMV2“. Hier befinden sich die meisten Systeminformationen.
      Nun müssen wir ihm noch genauere Informationen übergeben. Diese sind in meinem Fall, da ich den CPU Namen auslesen will: “SELECT * FROM Win32_Processor“

      Und schon ist unser Such-Objekt erstellt.

      VB.NET-Quellcode

      1. Dim searcher As New ManagementObjectSearcher( _
      2. "root\CIMV2", _
      3. "SELECT * FROM Win32_Processor")

      Als nächster Schritt müssen wir dem Query, der sich “in” unserem Such-Objekt befindet noch das QueryObjekt übergeben.
      Dies ist die Informationen die wir in Win32_Processor suchen wollen. In meinem Fall ist dies der Prozessorname.
      Dazu müssen Sie zuerst das QueryObjekt erstellen bzw. definieren.

      VB.NET-Quellcode

      1. For Each queryObj As ManagementObject In searcher.Get()

      Wie Sie erkennen können, habe ich das QueryObjekt in eine For Each Schleife eingebaut.
      Grundsätzlich habe ich das deshalb gemacht, weil es machmal mehr als nur eine Information zu einem Punkt gibt.

      Da wir schon unser QueryObjekt erstellt haben übergeben wir dem Sucher nun die Information, dass er nach dem Namen des Prozessors suchen soll.

      VB.NET-Quellcode

      1. Return queryObj("Name").ToString

      Natürlich sollten Sie nun noch die For Each Schleife mit einem Next schließen.
      Eigentlich war das schon unsere komplette Funktion. In meinem Fall habe ich jedoch die Such-Routine noch in einen Try – Catch – Block eingebaut damit, fall ein Fehler auftritt, mir das mit einem “Error” übermittelt wird.


      Mit dem WMI Code-Creator arbeiten.
      Kommen wir nun zu dem Teil, in dem ich Ihnen zeigen möchte wie Sie mit Hilfe des WMI Code-Creators (o. Generators) arbeiten können.
      Ich persönlich verwende ihn nicht zur Code-Ausgabe, sondern nur zum Durchforsten der diversen Verzeichnisse. Wie mache ich das?
      Im Großen und Ganzen ist dies sehr simpel. Sie laden sich den WMI Code-Creator herunter, und starten ihn einfach. Nun können Sie oben in den zwei Comboboxen den Namespace bzw. die Klasse auswählen.
      Wenn Sie ebenfalls nach Systeminformationen suchen, empfehle ich Ihnen den CIMV2 Namespace, da sich hier die meisten Informationen befinden. Nun können Sie in der Combobox darunter die Klasse auswählen. Dort finden Sie massenhaft Informationen zu Ihrer Grafikkarte, Ihrem BIOS, Ihrem Motherboard, Ihrem Akku , Ihrer CPU, Ihren USB-Geräten uvm.
      Nachdem Sie Ihre gewünschte Klasse gefunden haben, können Sie es wie ich machen. Wir haben uns ja oben schon eine Grundfunktion zusammengestellt. Diese können wir nun weiterhin nutzen, müssen aber natürlich die Klasse und das QueryObjekt umschreiben. Dazu benötige wir den Klassennamen bzw. den Namen der Eigenschaft für das QueryObjekt. Diese haben wir beide, entweder im schon vom WMI Code-Creator erstelltem Code rechts, oder in der Combo- bzw. Listbox, in der wir das Objekt ausgewählt haben.


      Abb. 1: Der WMI Code-Creator. Ausgewählt wurde der CPU Name.


      Diverse andere Funktionen.
      Zum Abschluss möchte ich Ihnen noch ein paar andere hilfreiche Snippets und Informationen auf den Weg geben, mit denen Sie arbeiten können.
      Im Prinzip arbeiten sie alle gleich, jedoch habe ich sie deswegen hinzugefügt, weil sie sehr oft gefragt sind. Desweiteren sind dies alles nur Beispiele.

      Grafikkarte (GPU)

      Grafikkartenname auslesen

      VB.NET-Quellcode

      1. Shared Function getName() As String
      2. Try
      3. Dim searcher As New ManagementObjectSearcher( _
      4. "root\CIMV2", _
      5. "SELECT * FROM Win32_VideoController")
      7. For Each queryObj As ManagementObject In searcher.Get()
      9. Return queryObj("Name").ToString
      10. Next
      12. Catch err As ManagementException
      13. Return "Error"
      14. End Try
      15. End Function


      Grafikkartentreiber auslesen

      VB.NET-Quellcode

      1. Shared Function getDriverVersion() As String
      2. Try
      3. Dim searcher As New ManagementObjectSearcher( _
      4. "root\CIMV2", _
      5. "SELECT * FROM Win32_VideoController")
      7. For Each queryObj As ManagementObject In searcher.Get()
      9. Return queryObj("DriverVersion").ToString
      10. Next
      12. Catch err As ManagementException
      13. Return "Error"
      14. End Try
      15. End Function


      Prozessor (CPU)


      ProzessorID auslesen

      VB.NET-Quellcode

      1. Shared Function getProcessorId() As String
      2. Try
      3. Dim searcher As New ManagementObjectSearcher( _
      4. "root\CIMV2", _
      5. "SELECT * FROM Win32_Processor")
      7. For Each queryObj As ManagementObject In searcher.Get()
      9. Return queryObj("ProcessorId").ToString
      10. Next
      12. Catch err As ManagementException
      13. Return "Error"
      14. End Try
      15. End Function

      BIOS


      BIOS-Namen auslesen

      VB.NET-Quellcode

      1. Shared Function getName() As String
      2. Try
      3. Dim searcher As New ManagementObjectSearcher( _
      4. "root\CIMV2", _
      5. "SELECT * FROM Win32_BIOS")
      7. For Each queryObj As ManagementObject In searcher.Get()
      9. Return queryObj("Name").ToString
      10. Next
      12. Catch err As ManagementException
      13. Return "Error"
      14. End Try
      15. End Function


      BIOS-Seriennummer auslesen

      VB.NET-Quellcode

      1. Shared Function getSerialNumber() As String
      2. Try
      3. Dim searcher As New ManagementObjectSearcher( _
      4. "root\CIMV2", _
      5. "SELECT * FROM Win32_BIOS")
      7. For Each queryObj As ManagementObject In searcher.Get()
      9. Return queryObj("SerialNumber").ToString
      10. Next
      12. Catch err As ManagementException
      13. Return "Error"
      14. End Try
      15. End Function


      Sound-Geräte


      Namen der Sound-Geräte auslesen

      VB.NET-Quellcode

      1. Shared Function getNames() As List(Of String)
      3. Dim Liste As New List(Of String)
      4. Try
      5. Dim searcher As New ManagementObjectSearcher( _
      6. "root\CIMV2", _
      7. "SELECT * FROM Win32_SoundDevice")
      9. For Each queryObj As ManagementObject In searcher.Get()
      11. Liste.Add(queryObj("Name").ToString)
      13. Next
      15. Catch err As ManagementException
      17. End Try
      19. Return Liste
      20. End Function

      Diverse andere hilfreiche Klassen

      Ich habe an dieser Stelle eine kleine Liste von den meiner Meinung nach meistegefragtesten Klassen zusammengestellt.
      Diese ist dafür da, damit Sie nicht lange suchen müssen. All diese Klassen befinden sich in dem CIMV2 Namespace

      • Win32_BaseBoard
      • Win32_Battery
      • Win32_BIOS
      • Win32_Bus
      • Win32_CDROMDrive
      • Win32_CurrentProbe
      • Win32_Desktop
      • Win32_DesktopMonitor
      • Win32_DiskDrive
      • Win32_Fan
      • Win32_FloppyDrive
      • Win32_HeatPipe
      • Win32_Keyboard
      • Win32_LocalTime
      • Win32_LoggedOnUser
      • Win32_LogicalDisk
      • Win32_MotherboardDevice
      • Win32_OnBoardDevice
      • Win32_OperatingSystem
      • Win32_PNPDevice
      • Win32_Printer
      • Win32_Processor
      • Win32_SerialPort
      • Win32_SoundDevice
      • Win32_TapeDrive
      • Win32_SystemDriver
      • Win32_USBController
      • Win32_USBHub
      • Win32_VideoController
      • Win32_VoltageProbe




      Das war's!
      Das war auch schon das komplette Tutorial.
      Ich hoffe ich konnte Ihnen damit weiterhelfen.

      Ich habe für Sie zum Schluss noch ein paar Downloads hinzugefügt. Diese finden Sie im Anhang.

      Mit freundlichen Grüßen
      Martin Pfeiffer (Gather)
      Dateien
      Mfg: Gather
      Private Nachrichten bezüglich VB-Fragen werden Ignoriert!

    Facebook
    Telefonspende