War diese Seite hilfreich?
Ihr Feedback ist uns wichtig. Teilen Sie uns Ihre Meinung mit.
Weiteres Feedback?
1500 verbleibende Zeichen
Exportieren (0) Drucken
Alle erweitern
Erweitern Minimieren

Ersetzen von API-Aufrufen durch .NET Framework-Klassen

Veröffentlicht: 30. Apr 2002 | Aktualisiert: 20. Jun 2004
Von Ken Getz

Verlassen Sie sich weniger auf Win32-API-Aufrufe, indem Sie spezielle und hilfreiche Klassen im Microsoft .NET Framework kennen lernen. Jede der hier vorgestellten Klassen ersetzt einen oder mehrere Win32-API-Aufrufe, die Sie zum Erreichen derselben Ziele in Microsoft Visual Basic 6.0 ausführen mussten.

Auf dieser Seite

Vermeiden des Win32-API Vermeiden des Win32-API
Bearbeiten der Registrierung Bearbeiten der Registrierung
Verwenden von Standarddialogfeldern Verwenden von Standarddialogfeldern
Abrufen von Dateiversionsinformationen Abrufen von Dateiversionsinformationen
Abrufen von Umgebungsinformationen Abrufen von Umgebungsinformationen
Zusammenfassung Zusammenfassung

Ziele

  • Ermitteln spezifischer Ersetzungen für vorhandene Win32-API-Aufrufe

  • Kennenlernen der Registry-Klasse

  • Verwenden der FileVersionInfo-Klasse

  • Verwenden von Umgebungs- und Systeminformationen

Vermeiden des Win32-API

Wenn Sie als Entwickler Microsoft Visual Basic 6.0 verwenden, können Sie früher oder später Aufrufe des Win32-API nicht mehr umgehen. Es gibt zu viele Aufgaben,
mit denen ein Entwickler umgehen muss, für die Visual Basic keine Mittel zur Verfügung stellt. Wie können Sie
zum Beispiel in Visual Basic 6.0 folgende Aufgaben ausführen:

  • Ermitteln von Dateiversionsinformationen

  • Lesen und Schreiben an beliebigen Stellen in der Registrierung

  • Ermitteln der speziellen Ordner eines Benutzers, z.B. den Ordner Favoriten in Microsoft Windows oder persönliche Ordner

  • Abrufen einer Liste aller verfügbaren Laufwerke

  • Ermitteln des Benutzernamens eines Benutzers oder des Computernamens

  • Abrufen einer Liste aller geöffneten Fenster


Sie können keine dieser Aufgaben lösen, wenn Sie nur die in Visual Basic 6.0 verfügbaren Werkzeuge verwenden. Für jede dieser Aufgaben müssen Entwickler die Windows-API verwenden, und zahlreiche Entwickler haben entsprechende Lösungen für diese (und viele andere) Aufgaben unter Verwendung der Windows-API entwickelt.

Welchen Nachteil hat die Windows-API?

Warum sollte die Windows-API nicht weiterhin in der .NET-Umgebung verwendet werden? Natürlich können Sie dies tun, indem Sie die Aufrufdienste der .NET-Plattform verwenden (P/Invoke genannt). Aus der Sicht des Visual-Basic-Entwicklers ist das Aufrufen der Windows-API nicht schwieriger als das Verwenden der bekannten Declare-Anweisung. In der Welt von .NET hat die Verwendung der Windows-API jedoch einige schwerwiegende Nachteile. Daher sollten Sie auf jeden Fall versuchen, die Windows-API zu vermeiden. Beispiel:

  • Die .NET Common Language Runtime soll plattformunabhängig sein. Bei jedem Aufruf der Windows-API binden Sie Ihren Code an die spezifische Plattform, in der Sie den Code geschrieben haben (d.h. an eine spezifische Version von Windows und an Windows selbst, im Gegensatz zu einem anderen Betriebssystem). Sollte es zu irgendeinem Zeitpunkt notwendig werden, den Code zu einer anderen Plattform zu konvertieren, müssen in jeder Codezeile, in der der API-Aufruf verwendet wird, Änderungen vorgenommen werden.

  • Das Aufrufen der Windows-API (oder eines anderen nicht verwalteten Codes in Dlls) mithilfe von .NET ist komplexer als in Visual Basic 6.0. Beschränkungen bei der Funktionsweise von Strukturen erschweren z.B. die Übergabe von Strukturen an API-Aufrufe. Zudem müssen API-Deklarationen aus Visual Basic 6.0 bearbeitet werden, da Datentypen geändert wurden und strengere Typenkonvertierungen gelten.

  • Techniken zur Verwendung der Windows-API (und von externem Code allgemein) sind von Sprache zu Sprache unterschiedlich. Wenn Sie in mehreren .NET-Sprachen arbeiten möchten, müssen Sie für jede Sprache unterschiedliche Techniken beherrschen.

  • Wenn die Windows-API über Code aufgerufen wird, müssen die Benutzer, die diesen Code aufrufen, über entsprechende Berechtigungen verfügen. Dadurch kann das Sicherheitsschema Ihrer Anwendung gefährdet werden. Beziehen Sie diese Anforderung daher rechtzeitig in Ihre Planung ein.


Obwohl Sie also weiterhin die Windows-API aus Visual Basic .NET-Anwendungen verwenden können, sollten Sie generell möglichst nach Alternativen suchen, die durch das .NET Framework bereitgestellt werden. Mit dem .NET Framework soll zwar nicht verhindert werden, dass Sie die Windows-Funktionalität direkt verwenden müssen, das Framework stellt jedoch eine Vielzahl von Klassen bereit, die Sie beim Ersetzen der Windows-API-Aufrufe unterstützen.

Eine vollständige Liste der Win32-API-Aufrufe und ggf. der entsprechenden Technik zum Erreichen desselben Ziels im .NET Framework wäre sehr hilfreich, diese Aufgabe wird jedoch nicht in diesem Dokument erfüllt. Vielmehr lernen Sie in diesem Dokument einige spezifische und hilfreiche Klassen kennen, die zur Erleichterung Ihrer Arbeit im .NET Framework bereitgestellt sind. Jede der in diesem Dokument erläuterten Klasse ersetzt einen oder mehrere Win32-API-Aufrufe, die Sie möglicherweise in Visual Basic 6.0 zum Erreichen derselben Ziele ausführen mussten.

Bearbeiten der Registrierung

Wie die meisten Entwickler in Visual Basic 6.0 haben vielleicht auch Sie die in Microsoft Visual Basic für Applikationen (VBA) integrierten, mehr oder weniger hilfreichen Methoden SaveSetting, GetSetting, GetAllSettings und DeleteSetting entdeckt, waren jedoch sehr von ihren Einschränkungen enttäuscht: alle genannten Methoden konnten nur mit Schlüsseln unter dem Schlüssel HKEY_CURRENT_USER\Software\VB and VBA Program Settings in der Registrierung verwendet werden. Wenn Sie Schlüssel oder Werte an anderer Stelle in der Registrierung lesen oder schreiben wollten, mussten Sie auf komplexe API-Aufrufe zurückgreifen oder den Code eines anderen Entwicklers verwenden, der diese Aufgabe für Sie erledigt hat.

Das .NET Framework stellt zwei robuste Klassen (Registry und RegistryKey) im Namespace Microsoft.Win32 bereit, mit deren Hilfe die Arbeit mit der Registrierung vereinfacht wird - es sind keine API-Aufrufe mehr erforderlich!

Klicken Sie zur Erläuterung auf die Schaltfläche Work with the Registry im Hauptformular des Beispielprojekts. Dieses Formular enthält eine Liste aller Werte in der Struktur HKEY_LOCAL_MACHINE unter dem Schlüssel SOFTWARE\Microsoft\Windows\CurrentVersion\Run. Sie können mit der rechten Maustaste auf ein Element in der Liste klicken und angeben, dass ein neues Element eingefügt werden soll, oder Sie können das markierte Element bearbeiten oder löschen (siehe Abbildung 1).

Tipp Das Beispielformular wurde so konzipiert, dass Sie durch Drücken auf die EINGABETASTE im Listenfeld das aktuell markierte Element bearbeiten können. Wenn Sie auf die ENTF-TASTE drücken, wird das Element gelöscht, und wenn Sie auf die EINFG-TASTE drücken, wird ein neuer Wert hinzugefügt. Diese Elemente entsprechen den Elementen im Kontextmenü des Listenfeldes.

Bild01

Abbildung 1. Informationen in der Windows-Registrierung können mithilfe der Klassen "Registry" und "RegistryKey" auf einfache Art abgerufen und geändert werden


.NET Framework stellt zwei hilfreiche Klassen zur Verfügung, mit denen Sie auf einfache Art und Weise die Windows-Registrierung bearbeiten können. Die erste Klasse, Registry, stellt Felder bereit, die jeder einzelnen standardmäßigen Struktur in der Registrierung entsprechen:

  • ClassesRoot (HKEY_CLASSES_ROOT)

  • CurrentConfig (HKEY_CURRENT_CONFIG)

  • CurrentUser (HKEY_CURRENT_USER)

  • DynData (HKEY_DYN_DATA)

  • LocalMachine (HKEY_LOCAL_MACHINE)

  • PerformanceData (HKEY_PERFORMANCE_DATA)

  • Users (HKEY_USERS)


Wenn Sie die Registry-Klasse verwenden möchten, rufen Sie einfach einen Verweis auf die benötigte Struktur ab. Die LoadList-Prozedur des Beispielformulars enthält Code wie diesen, um mit der Struktur HKEY_LOCAL_MACHINE in der Registrierung zu arbeiten:

Imports Microsoft.Win32
Dim reg As RegistryKey = Registry.LocalMachine

Die RegistryKey-Klasse führt die gesamte Arbeit aus. Sie stellt eine Gruppe von Methoden für die Bearbeitung der Registrierung zur Verfügung. In Tabelle 1 sind alle hilfreichen Methoden der RegistryKey-Klasse aufgeführt.

Methode

Beschreibung

CreateSubKey

Erstellt einen neuen Unterschlüssel oder öffnet einen vorhandenen Unterschlüssel.

DeleteSubKey

Löscht den angegebenen Unterschlüssel.

DeleteSubKeyTree

Löscht einen Unterschlüssel und untergeordnete Unterschlüssel rekursiv.

DeleteValue

Löscht den angegebenen Wert aus diesem Schlüssel.

GetSubKeyNames

Ruft ein Array mit Zeichenfolgen ab, das die Namen aller Unterschlüssel enthält.

GetValue

Ruft den angegebenen Wert ab.

GetValueNames

Ruft ein Array mit Zeichenfolgen ab, das die Namen aller Werte enthält, die mit diesem Schlüssel verbunden sind.

OpenSubKey

Ruft einen angegebenen Unterschlüssel ab, mit optionalem Schreibzugriff.

SetValue

Legt den angegebenen Wert fest.

Zudem enthält die RegistryKey-Klasse die folgenden drei Eigenschaften:

  • Name: Ruft den Namen des Schlüssels ab.

  • SubkeyCount: Ruft die Anzahl von Unterschlüsseln ab, die mit dem Schlüssel verbunden sind.

  • ValueCount: Ruft die Anzahl von Werten ab, die mit dem Schlüssel verbunden sind.


Die ListLoad-Prozedur aus dem Beispielformular ruft alle Werte aus dem angeforderten Schlüssel ab und fügt sie dem Listenfeld des Formulars hinzu:

Private Const conRegKey As String = _
 "SOFTWARE\Microsoft\Windows\CurrentVersion\Run"
Private Structure RegData
    Public Value As String
    Public Data As String
    Public Overrides _
     Function ToString() As String
        Return Me.Value
    End Function
End Structure
Private Sub ListLoad()
    Dim reg As RegistryKey = Registry.LocalMachine
    Dim astrValues() As String
    Dim strValue As String
    Dim rd As RegData
    ' Die vorhandenen Elemente aus dem Listenfeld löschen.
    lstItems.BeginUpdate()
    lstItems.Items.Clear()
    ' Den Registrierungsschlüssel öffnen, dann das
    ' Listenfeld mit den Werten aus dem Schlüssel laden.
    reg = reg.OpenSubKey(conRegKey)
    astrValues = reg.GetValueNames()
    For Each strValue In astrValues
        rd.Value = strValue.ToString
        rd.Data = reg.GetValue(strValue)
        lstItems.Items.Add(rd)
    Next
    lstItems.EndUpdate()
End Sub


Wenn Sie angeben, dass ein Wert im Beispielformular bearbeitet oder neu hinzugefügt werden soll, wird der folgende Code ausgeführt:

Private Sub AddOrEdit( _
 ByVal rd As RegData, _
 ByVal Mode As frmAddValue.AccessMode)
    Dim reg As RegistryKey = Registry.LocalMachine
    Dim frm As New frmAddValue(Mode)
    frm.KeyName = rd.Value
    frm.KeyData = rd.Data
    If frm.ShowDialog() = DialogResult.OK Then
        If frm.KeyName <> String.Empty Then
            reg = reg.OpenSubKey(conRegKey, True)
            reg.SetValue(frm.KeyName, frm.KeyData)
            ListLoad()
        End If
    End If
End Sub

Mit diesem Code wird der Registrierungsschlüssel erneut geöffnet, dieses Mal wird die Schreibberechtigung für den Schlüssel angefordert (der zweite Parameter für OpenSubKey enthält diese Anforderung). Der Code ruft anschließend die SetValue-Methode auf, wobei Schlüsselname und Wert aus dem Dialogfeld des Formulars übergeben werden, das in Abbildung 1 dargestellt ist. Zur Vereinfachung kann die SetValue-Methode entweder einen neuen Wert hinzufügen oder einen vorhandenen Wert ändern. Falls der Wert noch nicht vorhanden ist, fügt die SetValue-Methode ihn hinzu.

Um einen Wert zu löschen, ruft das Beispielformular den folgenden Code auf:

Private Sub DeleteKey(ByVal rd As RegData)
    Dim strText As String
    Dim reg As RegistryKey = Registry.LocalMachine
    If lstItems.SelectedIndex = -1 Then
        Exit Sub
    End If
    ' Den ausgewählten Schlüssel löschen.
    strText = String.Format( _
     "Are you sure you want to delete ""{0}""?", _
     rd.Value)
    If MessageBox.Show(strText, _
     "Delete Registry Value", _
     MessageBoxButtons.YesNo, _
     MessageBoxIcon.Question) = DialogResult.Yes Then
        ' Den Schlüssel zum Bearbeiten öffnen.
        reg = reg.OpenSubKey(conRegKey, True)
        reg.DeleteValue(rd.Value)
        ' Das Listenfeld neu laden.
        ListLoad()
    End If
End Sub

Dieser Code öffnet den Schlüssel mit einer Anforderung des Schreibzugriffs, anschließend ruft er die DeleteValue-Methode zum Löschen des ausgewählten Werts auf.

Mithilfe der Informationen im Beispielformular und der mit dem .NET Framework bereitgestellten Dokumentation können Sie alle mit der Registrierung verbundenen Aufgaben lösen, ohne dass Sie die Windows-API verwenden müssen. Dieses einfache Objektmodell stellt mehr Effizienz zur Verfügung als für Entwickler in Visual Basic 6.0 zuvor bereitgestellt wurde.

Tipp Wenn Sie über die entsprechenden Berechtigungen verfügen, können Sie die Registrierung auch auf Remotecomputern bearbeiten. Rufen Sie die RegistryKey.OpenRemoteBaseKey-Methode auf, um einen Basisschlüssel auf anderen Computern aufzurufen, anstatt einfach eine der Eigenschaften der Registry-Klasse zum Darstellen von Registrierungsstrukturen auf Ihrem Computer zu verwenden.

Verwenden von Standarddialogfeldern

Windows stellt eine Gruppe Standarddialogfelder bereit, so dass Entwickler auf einfache Art und Weise Informationen von ihren Benutzern anfordern können. Sie haben bestimmt schon die Standarddialogfelder Datei öffnen und Datei speichern, Farbe, Drucker und Schriftart gesehen und verwendet. Entwickler mit Visual Basic 6.0 hatten zwei Möglichkeiten, diese Dialogfelder zu verwenden. Sie konnten wie folgt vorgehen:

  • Verwenden eines Microsoft ActiveX-Steuerelements, das ein einfaches Objektmodell bereitgestellt und die Standarddialogfelder eingeschlossen hat. Bei diesem Steuerelement gab es jedoch auf der Grundlage der Anzahl unterschiedlicher Versionen des Steuerelements und der zugrunde liegenden DLLs schwerwiegende Bereitstellungsprobleme. (Dieses Einzelproblem war für viele Entwickler in Visual Basic 6.0 das größte Problem der "DLL-Hölle".)

  • Direkte Verwendung der Windows-API, Senden von Nachrichten und Bereitstellen von Rückruffunktionen, um die unterschiedlichen Standarddialogfelder zu verwalten.


Keine der Lösungen war perfekt, und keine der Lösungen ist wegen der Ergänzungen zum .NET Framework zurzeit erforderlich. Wenn Sie den System.Windows.Forms-Namespace durchsuchen, finden Sie die Klassen ColorDialog, FileDialog, FontDialog und PrintDialog. Diese Klassen sind alle in das Framework integriert (d.h. sie erfordern keine API-Aufrufe und kein ActiveX-Steuerelement) und vereinfachen Ihnen das Integrieren dieser Standardfunktionalität in Ihre Anwendungen.

Jede dieser Klassen stellt eine Reihe von Eigenschaften bereit, die Sie festlegen können, ehe das Dialogfeld angezeigt wird. Verwenden Sie hierzu die ShowDialog-Methode der Klasse. Eine ausführliche Erläuterung jeder einzelnen Klasse würde den Rahmen dieses Artikels sprengen, das Beispielprojekt verwendet jedoch die FileDialog-Klasse, mit deren Hilfe Sie eine Datei auswählen können. Wenn Sie die Schaltfläche Dateiversionsinformationen im Hauptformular ausgewählt haben, können Sie mithilfe der Schaltfläche Datei wählen im Beispielformular das Dialogfeld Öffnen anzeigen (siehe Abbildung 2).

Bild02

Abbildung 2. Verwenden der "FileDialog"-Klasse zum Anzeigen von allgemeinen Windows-Dialogfeldern


Obwohl die FileDialog-Klasse nicht die gleiche Flexibilität bietet wie beim direkten Programmieren der Windows-API, stellt sie trotzdem eine umfassende Gruppe von Eigenschaften zur Verfügung, die Sie zum Steuern der Verhaltensweise des Dialogfeldes verwenden können. Sie können festlegen, wo nach Dateien gesucht werden soll, Sie können eine oder mehrere Dateien auswählen, und Sie können anschließend den bzw. die Dateinamen abrufen. In Tabelle 2 ist die Teilmenge der Eigenschaften und Methoden der FileDialog-Klasse dargestellt, die Sie wahrscheinlich verwenden werden.

Eigenschaft/Methode

Beschreibung

AddExtension

Gibt an, ob das Dialogfeld einem Dateinamen automatisch eine Erweiterung hinzufügt, falls der Benutzer keine Erweiterung angibt.

CheckFileExists

Gibt an, ob das Dialogfeld eine Warnung anzeigt, falls der Benutzer einen nicht vorhandenen Dateinamen angibt.

CheckPathExists

Gibt an, ob das Dialogfeld eine Warnung anzeigt, falls der Benutzer einen nicht vorhandenen Pfad angibt.

DefaultExt

Die Standarddateierweiterung.

DereferenceLinks

Gibt an, ob das Dialogfeld den Speicherort der Datei zurückgibt, auf die durch die Verknüpfung verwiesen wird, oder ob es den Speicherort der Verknüpfung zurückgibt (LNK).

FileName

Der im Dialogfeld Datei ausgewählte Dateiname.

FileNames

(Schreibgeschützt) Die Dateinamen aller ausgewählten Dateien im Dialogfeld.

Filter

Die aktuelle Dateinamen-Filterzeichenfolge, die die im Dialogfeld Save as file type oder Files of type angezeigten Optionen angibt.

FilterIndex

Der Index des aktuell im Dialogfeld Datei ausgewählten Filters.

InitialDirectory

Das erste im Dialogfeld Datei angezeigte Verzeichnis.

RestoreDirectory

Gibt an, ob das Dialogfeld das aktuelle Verzeichnis wiederherstellt, bevor es geschlossen wird.

ShowHelp

Gibt an, ob die Schaltfläche Hilfe im Dialogfeld Datei angezeigt wird.

Title

Der Titel des Dialogfeldes Datei.

ValidateNames

Gibt an, ob das Dialogfeld nur gültige Dateinamen akzeptiert.

Reset (Methode)

Setzt alle Eigenschaften auf ihre Standardwerte zurück.

ShowDialog (Methode)

Zeigt das Dialogfeld Datei an. Gibt DialogResult.OK zurück, wenn der Benutzer auf die Schaltfläche OK gedrückt hat. Ansonsten wird DialogResult.Cancel zurückgegeben.

Das Beispielformular frmFileVersionInfo ruft folgenden Code auf, wenn Sie auf Datei wählen klicken:

Private Sub btnSelectFile_Click( _
 ByVal sender As System.Object, _
 ByVal e As System.EventArgs) _
 Handles btnSelectFile.Click
    Dim ofd As OpenFileDialog = New OpenFileDialog()
    ofd.Filter = _
        "Ausführbare Dateien (*.exe;*.dll;*.ocx)|" & _
        "*.exe;*.dll;*.ocx|" & _
        "Treiber (*.sys;*.drv;*.fnt)|" & _
        "*.sys;*.drv;*.fnt|" & _
        "Alle Dateien (*.*)|*.*"
    ofd.FilterIndex = 1
    ofd.ShowReadOnly = False
    ofd.RestoreDirectory = True
    If ofd.ShowDialog() = DialogResult.OK Then
        If ofd.FileName.Length > 0 Then
            ' Dateiversionsinformationen anzeigen.
            DisplayFileInfo(ofd.FileName)
        End If
    End If
End Sub


Tipp Wie beim Verwenden des ActiveX-Steuerelements CommonDialog in Visual Basic 6.0 legen Sie die Filter-Eigenschaft der FileDialog-Klasse auf eine Zeichenfolge fest, die Paare von Werten enthält, welche durch einen vertikalen Balken getrennt sind, zum Beispiel: Description|FileSpec.

Hier zeigt das Beispielformular, nachdem Sie einen Dateinamen ausgewählt haben, Informationen zu der Datei im ListView-Steuerelement des Formulars an. Im folgenden Abschnitt wird die FileVersionInfo-Klasse erläutert, die dies ermöglicht.

Abrufen von Dateiversionsinformationen

Entwickler und Compiler können Versionsinformationen in ausführbare, DLL- und Treiberdateien einbetten. Möglicherweise müssen Sie einige oder alle dieser Informationen als Teil Ihrer Anwendungen abrufen. Hierzu waren in Visual Basic 6.0 eine Vielzahl von API-Aufrufen erforderlich. Zur Lösung dieser Aufgabe waren Aufrufe der Win32-API-Funktionen GetVersionInfoSize, VerQueryValue und GetFileVersionInfo erforderlich, und die Arbeit mit all diesen Funktionen gestaltete sich in Visual Basic als schwierig.

.NET Framework kommt auch hier wieder zur Hilfe - in diesem Fall wird der Vorgang durch das FileVersionInfo-Objekt stark vereinfacht. Sie müssen nur noch die freigegebene GetVersionInfo-Methode des FileVersionInfo-Objekts aufrufen und einen Dateinamen übergeben. Das Beispielformular verwendet Code wie diesen:

Dim fvi As FileVersionInfo = _
 FileVersionInfo.GetVersionInfo(strFile)


Danach können die Eigenschaften des FileVersionInfo-Objekts auf einfache Art und Weise abgerufen werden. Das Beispielformular verwendet eine kleine Prozedur (siehe unten), die jeden Namen und Wert einer Eigenschaft zu einem ListView-Steuerelement im Formular hinzufügt:

Private Sub AddItem( _
ByVal strProperty As String, _
ByVal strValue As String)
    With lvwInfo.Items.Add(strProperty)
        .SubItems.Add(strValue)
    End With
End Sub


Der Code, der die eigentliche Aufgabe ausführt, ruft dann immer wieder AddItem auf, für jede Eigenschaft einmal:

AddItem("Comments", fvi.Comments)
AddItem("CompanyName", fvi.CompanyName)
AddItem("Language", fvi.Language)
' Hier wurden Zeilen entfernt.
AddItem("Product", fvi.ProductName)
AddItem("ProductPrivatePart", _
 fvi.ProductPrivatePart.ToString())
AddItem("ProductVersion", fvi.ProductVersion)
AddItem("SpecialBuild", fvi.SpecialBuild)


Das Ergebnisformular (siehe Abbildung 3) zeigt Ihnen alle verfügbaren Versionsinformationen programmgesteuert an.

Bild03

Abbildung 3. Abrufen von Dateiversionsinformationen mithilfe der Klasse "FileVersionInfo"

Abrufen von Umgebungsinformationen

Die Win32-API stellt einige Funktionen zur Verfügung, mit deren Hilfe Sie Umgebungseinstellungen des Benutzers ermitteln können. GetSystemMetrics und SystemParametersInfo sind zwei dieser Funktionen. Obwohl Sie weiterhin diese API-Funktionen aus Ihren .NET-Anwendungen aufrufen können, wird dies sehr wahrscheinlich nicht mehr erforderlich sein. Die Environment-Klasse (im System-Namespace) und die SystemInformation-Klasse (im System.Windows.Forms-Namespace) stellen fast dieselben Informationen wie die API-Funktionen zur Verfügung. Dieser Abschnitt enthält Beispiele, in denen die Funktionen dieser beiden Klassen gezeigt werden.

Achtung Versuchen Sie nicht, die Umgebungseinstellungen der Benutzer innerhalb dieser Klassen festzulegen. Alle hier angezeigten Informationen sind schreibgeschützt. Wenn Sie die Umgebung ändern möchten, müssen Sie andere Verfahren einsetzen.

Verwenden der Klasse "System.Environment"

Die System.Environment-Klasse stellt mehrere unterschiedliche Informationen bereit. Für einen Abruf wären ansonsten mehrere unterschiedliche Windows-API-Aufrufe erforderlich. Mithilfe der System.Environment-Klasse können Sie Folgendes abfragen:

  • Informationen zu verfügbaren Laufwerken (die GetLogicalDrives-Methode)

  • Die Anzahl von Millisekunden seit dem Start von Windows (die TickCount-Eigenschaft)

  • Allgemeine Umgebungseinstellungen, die durch die Eigenschaften CurrentDirectory, MachineName, OSVersion, SystemDirectory, UserDomainName, UserInteractive, UserName und WorkingSet zur Verfügung gestellt werden.

  • Eine Liste der speziellen Ordner, die mithilfe der GetFolderPath-Methode bereitgestellt wird.


Wenn Sie zuvor die Windows-API verwendet haben, ist Ihnen bekannt, dass durch diese Auswahl an Methoden und Eigenschaften zahlreiche API-Aufrufe ersetzt werden, darunter GetTickCount, GetLogicalDrives, GetSystemDirectory, GetComputerName, GetUserName, GetVersionEx usw.

Das in Abbildung 4 dargestellte Beispielformular (klicken Sie im Hauptformular auf Environment Info) zeigt die Ergebnisse der GetLogicalDrives-Methode im Listenfeld im oberen Bereich an. Es enthält eine Liste aller speziellen Ordner (die mithilfe der GetFolderPath-Methode abgerufen werden), und das Listenfeld weiter unten im Formular zeigt die Ergebnisse vieler Eigenschaften der Klasse.

Bild04

Abbildung 4. Formular mit den von der "System.Environment"-Klasse verwendeten Eigenschaften und Methoden


Wenn Sie darüber hinaus die TickCount-Eigenschaft testen möchten, klicken Sie auf Test TickCount, um die Ergebnisse der Arbeit mit der StopWatch-Klasse anzuzeigen, die im Beispielformular definiert ist, und verwenden Sie diesen Code:

Public Class StopWatch
    Private mintStart As Integer
    Public Sub Start()
        mintStart = Environment.TickCount
    End Sub
    Public Function Elapsed() As Integer
        Return Environment.TickCount - mintStart
    End Function
    Public Overrides Function ToString() As String
        Return String.Format( _
         "Gestartet: {0}, Verstrichen: {1}", _
         mintStart, Me.Elapsed)
    End Function
End Class


Die hier dargestellte FillProperties-Methode verwendet eine Kopie der zuvor gezeigten AddItem-Methode, um ein ListView-Steuerelement mit Eigenschaftennamen und Ergebnissen zu füllen:

Private Sub FillProperties()
    AddItem("CurrentDirectory", _
     Environment.CurrentDirectory)
    AddItem("MachineName", Environment.MachineName)
    AddItem("OSVersion.Platform", _
     Environment.OSVersion.Platform.ToString)
    AddItem("OSVersion.Version", _
     Environment.OSVersion.Version.ToString)
    AddItem("SystemDirectory", _
     Environment.SystemDirectory)
    AddItem("UserDomainName", Environment.UserDomainName)
    AddItem("UserInteractive", _
     Environment.UserInteractive)
    AddItem("UserName", Environment.UserName)
    AddItem("WorkingSet", Environment.WorkingSet)
End Sub


Die FillFolderList-Methode enthält neben der Verwendung der Environment-Klasse wirklich interessanten Code. Das Ziel dieser Prozedur liegt darin, alle Mitglieder der durch die Environment-Klasse bereitgestellten SpecialFolder-Enumeration zu durchlaufen. (Diese Enumeration enthält logische Namen für physische Ordner, z.B. Favoriten, Verlauf usw.) Die Prozedur fügt den Namen jedes Enumerationswertes zum ListView-Steuerelement im Formular hinzu, zudem fügt sie das Ergebnis der Übergabe des Enumerationswertes zur GetFolderPath-Methode des Environment-Objekts hinzu. Die hier gezeigte Prozedur führt alle genannten Schritte aus:

Private Sub FillFolderList()
    Dim strName As String
    Dim astrNames() As String
    Dim aintValues As Array
    Dim i As Integer
    ' Die erste Spalte im ListView-Steuerelement mit den 
    ' Namen in der SpecialFolder-Enumeration füllen.
    astrNames = System.Enum.GetNames( _
     GetType(Environment.SpecialFolder))
    aintValues = System.Enum.GetValues( _
     GetType(Environment.SpecialFolder))
    For i = 0 To astrNames.Length - 1
        With lvwFolders.Items.Add(astrNames(i))
            .SubItems.Add( _
             Environment.GetFolderPath(aintValues(i)))
        End With
    Next
End Sub


Anstatt die an das Environment-Objekt gesendeten Parameter hartzucodieren, verwendet dieses Beispiel die freigegebenen Methoden GetNames und GetValues der Enum-Klasse. Durch das Übergeben der Ergebnisse vom Aufruf der GetType-Funktion von Visual Basic .NET an GetNames (wobei der spezifische Enumerationstyp übergeben wird) rufen Sie ein Array ab, das mit den Namen aller Mitglieder der Enumeration gefüllt ist. Wenn Sie den Vorgang mit der GetValues-Methode wiederholen, wird ein Array-Objekt zurückgeben, das alle Werte der Enumeration enthält:

astrNames = System.Enum.GetNames( _
 GetType(Environment.SpecialFolder))
aintValues = System.Enum.GetValues( _
 GetType(Environment.SpecialFolder))


Nachdem diese beiden Arrays vorliegen, durchläuft die Prozedur die beiden Arrays und fügt die Werte aus astrNames zum ListView-Steuerelement hinzu. Dann ruft sie die GetFolderPath-Methode der Environment-Klasse zum Abrufen der entsprechenden Pfade ab:

For i = 0 To astrNames.Length - 1
    With lvwFolders.Items.Add(astrNames(i))
        .SubItems.Add( _
         Environment.GetFolderPath(aintValues(i)))
    End With
Next


Das obere ListView-Steuerelement in Abbildung 4 enthält die Ausgabe dieses Codes.


Tipp Mithilfe der Enum-Klasse stehen Ihnen einige praktische Möglichkeiten zur Verfügung, die in Visual Basic 6.0 nicht bereitstanden, z.B. die in diesem Beispiel dargestellten Methoden GetNames und GetValues. Weitere Informationen zu den Vorteilen der Funktionen der Enum-Klasse finden Sie in der Dokumentation zum .NET Framework.

Verwenden der Klasse "Windows.Forms.SystemInformation"

Beim Bereitstellen sorgfältig erstellter Benutzeroberflächen müssen Sie oft aktuelle Windows-Einstellungen ermitteln, wie z.B. die Breite und Höhe von Symbolen oder die Breite von Bildlaufleisten. In Visual Basic 6.0 können Sie die Windows-API-Funktionen GetSystemMetrics und SystemParametersInfo verwenden, um zahlreiche Einstellungen dieser Art zu ermitteln. Wenn Sie .NET Framework verwenden, können Sie die Vorteile der SystemInformation-Klasse verwenden, die im Windows.Forms-Namespace verfügbar ist.

Obwohl der in frmSystemInformation in Abbildung 5 verwendete Code nicht sehr interessant ist, hebt er doch alle Eigenschaften in der Klasse hervor. (Klicken Sie im Hauptformular auf SystemInformation Info, um dieses Beispielformular zu testen.) Das Beispielformular durchläuft alle Eigenschaften der SystemInformation-Klasse und zeigt den Namen und aktuellen Wert jeder Eigenschaft in einem ListView-Steuerelement auf dem Formular an.

Bild05

Abbildung 5. Beispielformular mit allen Eigenschaften der Klasse "Windows.Forms.SystemInformation"


Das Beispielformular verwendet dieselbe AddItem-Methode wie im vorherigen Beispiel und durchläuft alle 60 oder mehr Eigenschaften der SystemInformation-Klasse, wobei folgende Ausgabe angezeigt wird:

AddItem("ArrangeDirection", _
 SystemInformation.ArrangeDirection)
AddItem("StartingPosition", _
 SystemInformation.ArrangeStartingPosition)
AddItem("BootMode", SystemInformation.BootMode)
' usw.

Zusammenfassung

  • Obwohl Sie die Aufrufdienste der .NET-Plattform (P/Invoke) in Visual Basic .NET zum Bearbeiten von nicht verwalteten Code verwenden und die Windows-API direkt aufrufen können, sollten Sie beim Erstellen von Visual Basic .NET-Anwendungen nach Alternativen suchen. Sie müssen jedoch nicht alle Einzelheiten zu p/invoke kennen, da die Declare-Anweisung diese Einzelheiten für Sie erledigt.

  • .NET Framework enthält nicht die gesamte Windows-API-Funktionalität. Für einen Großteil der Arbeit, für die Sie in Visual Basic 6.0 API-Aufrufe verwenden mussten, stehen jedoch Lösungen im Framework zur Verfügung.

  • Die Klassen Registry und RegistryKey erleichtern die Bearbeitung der Windows-Registrierung und ermöglichen es Entwicklern, zahlreiche API-Aufrufe zu vermeiden.

  • Die Klassen FileDialog, ColorDialog, FontDialog und PrinterDialog erleichtern die Verwendung von Standarddialogfeldern in Windows. Dazu sind weder direkte Aufrufe der Windows-API noch die Verwendung des nachteiligen ActiveX-Steuerelements CommonDialog erforderlich.

  • Mithilfe der FileVersionInfo-Klasse können Sie alle Dateiversionsinformationen abrufen, die in ausführbaren, Treiber- und DLL-Dateien eingebettet sind. Diese Klasse ersetzt einen Teil der schwierigen, in Visual Basic 6.0 erforderlichen Codierung der Windows-API.

  • Die Klassen Environment und SystemInformation erleichtern das Abrufen von Systemeinstellungen, für die ansonsten Aufrufe mehrerer unterschiedlicher API-Funktionen erforderlich waren.

Informationen zur Informant Communications Group

Informant Communications Group, Inc. (www.informant.com) ist ein breitgefächertes Medienunternehmen, das auf den Informationstechnologiesektor ausgerichtet ist. ICG wurde 1990 gegründet und ist auf Softwareentwicklungspublikationen, Konferenzen, Katalogveröffentlichungen und Websites spezialisiert. ICG besitzt Niederlassungen in den USA und Großbritannien und hat sich als zuverlässiger Integrator für Marketing- und Medieninhalte erwiesen, der die wachsende Nachfrage von IT-Spezialisten nach qualitativ hochwertigen technischen Informationen abdeckt.


Anzeigen:
© 2015 Microsoft