Verwenden der Registrierungs-API zum Speichern und Abrufen von Einstellungen

SPRACHE AUSWÄHLEN SPRACHE AUSWÄHLEN
Artikel-ID: 145679 - Produkte anzeigen, auf die sich dieser Artikel bezieht
Dieser Artikel wurde zuvor veröffentlicht unter D145679
Dieser Artikel ist eine Übersetzung des folgenden englischsprachigen Artikels der Microsoft Knowledge Base:
145679 HOWTO: Use the Registry API to Save and Retrieve Setting
Alles erweitern | Alles schließen

Auf dieser Seite

Zusammenfassung

Visual Basic enthält zwar die SaveSetting- und GetSetting-Funktionen, um Informationen von der Registrierung zu speichern und abzurufen, diese Funktionen sind jedoch nur auf einen bestimmten Bereich der Registrierung anwendbar, die Visual Basic- und VBA-Programmeinstellungen des Stammschlüssels HKEY_CURRENT_USER.

Dieser Artikel beschreibt die Verwendung von 32-Bit Windows API-Funktionen zum Setzen und Abrufen von Werten in beliebigen Bereichen der Registrierung. Die in diesem Artikel beschriebenen Themen und Funktionsverweise können verallgemeinert zum Programmieren der 16-Bit-Registrierung verwendet werden.

Die 32-Bit API-Funktionen unterstützen zwar auch Sicherheitsfunktionen, dieses Thema wird jedoch im Rahmen dieses Artikels nicht behandelt.

Hinweis: Die SaveSetting- und GetSetting-Funktionen sind nicht Teil der VBA-Funktionsbibliothek. Der unten aufgeführte Beispielcode gilt dennoch für 32-Bit-Anwendungen, die VBA implementieren.

Weitere Informationen

Allgemeine Informationen zur Registrierung

Die Registrierung wird von Anwendungen und von Windows zum Speichern von Konfigurationsdaten verwendet. Die Registrierung ersetzt die große Anzahl von INI-Dateien auf Windows 3.x-Computern und wird auch von OLE intensiv genutzt.

Die Registrierung ist in einer hierarchischen Baumstruktur von Schlüsseln und Werten organisiert. Jeder Schlüssel geht von einem der sechs vordefinierten Stammschlüssel aus und kann über Teilschlüssel und damit verbundene Werte verfügen. Die Schlüssel fungieren als Namens- und Organisationseinheiten und erscheinen in den Windows-Registrierungseditoren als Dateiordner. Werte sind Dateneinträge und erscheinen im rechten Fensterbereich des Registrierungseditor-Fensters als Texteinträge. Schlüssel müssen keine Werte enthalten, können jedoch viele Werte enthalten. Mit jedem Wert ist ein Datentyp verbunden. Die beiden am häufigsten verwendeten Datentypen in der Registrierung sind REG_SZ, eine mit Null abgeschlossene Zeichenfolge, und REG_DWORD, eine 32-Bit-Nummer.

Der grundlegende Vorgang beim Schreiben oder Lesen einer Position in der Registrierung ist derselbe. Um auf einen bestimmten Schlüssel oder Wert zu verweisen, müssen Sie über ein Handle auf den Schlüssel verfügen. Sobald Sie dieses Handle erhalten haben, können Werte und Teilschlüssel des Schlüssels, auf den dieses Handle verweist, gelesen, gesetzt oder aufgelistet (enumeriert) werden.

Um ein Handle zu einem bestimmten Schlüssel in der Registrierung zu erhalten, müssen Sie bei einem der sechs vordefinierten Schlüssel (HKEY_CLASSES_ROOT, HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE, HKEY_USERS, HKEY_CURRENT_CONFIG und HKEY_DYN_DATA) starten und durch die Registrierungsstruktur navigieren, bis der gewünschte Schlüssel erreicht ist. Bei Benutzerprogrammen erfolgt das Lesen und Schreiben am häufigsten über die Schlüssel HKEY_CURRENT_USER und HKEY_LOCAL_MACHINE. Wenn die Schlüssel, durch die Sie navigieren, bereits vorhanden sind, können Sie eine Reihe von Aufrufen der RegOpenKey- oder RegOpenKeyEx-Funktionen verwenden. Wenn die Schlüssel erstellt werden müssen, wird dies von den RegCreateKey- und RegCreateKeyEx-Funktionen übernommen.

Wenn Sie über das Handle auf den gewünschten Schlüssel verfügen, können die Funktionen zum Auflisten, Setzen und Abrufen von Informationen aufgerufen werden. In allen Fällen sind die Funktionen mit dem Suffix "Ex" nur auf 32-Bit-Plattformen anwendbar. Funktionen ohne das Suffix können sowohl auf 16-Bit- als auch auf 32-Bit-Versionen von Windows angewendet werden. Beachten Sie, dass nicht alle Registrierungsfunktionen ohne das Suffix "Ex" 16-Bit-kompatibel sind. Das Suffix "Ex" wurde nur bei 16-Bit-Funktionen hinzugefügt, deren Funktionalität erweitert wurde. Gänzlich neue Funktionen, die für 32-Bit-Plattformen entwickelt wurden, besitzen nicht die Erweiterung "Ex".

Die RegSetValue- und RegSetValueEx-Funktionen ermöglichen das Ändern der Einstellung eines Wertes, während mit den RegQueryValue- und RegQueryValueEx-Funktionen die aktuelle Einstellung eines Wertes abgerufen werden kann. Die Einschränkungen der 16-Bit-Versionen (ohne "Ex") dieser APIs treten hier deutlich zutage. Beim Verwenden der 16-Bit RegSetValue-Funktion besteht keine Möglichkeit, einen Wert zu benennen, und aus diesem Grund kann RegSetValue nicht verwendet werden, um mehr als einen Wert mit jedem Schlüssel zu verbinden. Außerdem weisen alle mit RegSetValue geschriebenen Werte den Datentyp REG_SZ auf. Diese Einschränkungen sind mit der 16-Bit-Registrierung verbunden. RegSetValueEx ermöglicht das Erstellen mehrerer Werte mit jedem verfügbaren Datentyp.

Schreiben in einen bestimmten Ort in der Registrierung

Nachdem Sie bestimmt haben, welche Funktionen Sie für Ihr Projekt benötigen, kopieren Sie die relevanten Deklarationen von dem Code am Ende dieses Artikels in ein Basismodul. Die beiden enthaltenen Visual Basic-Prozeduren (SetValueEx und QueryValueEx) stellen Wrapper für die API-Funktionen RegSetValueEx und RegQueryValue dar und erleichtern deren Anwendung erheblich. Die unten stehenden Hinweise beziehen sich auf diese Visual Basic-Funktionen; es steht Ihnen jedoch frei, Aufrufe direkt an die API zu tätigen.

Erstellen/Ändern von Schlüsseln und Werten:

Wenn die entsprechenden Deklarationen und Prozeduren verfügbar sind, können Sie Schlüssel erstellen und öffnen sowie Werte hinzufügen, ändern und lesen. In den drei folgenden Abschnitten wird erklärt, wie Sie einen Schlüssel erstellen und einen Wert setzen, ändern oder abfragen können.

Erstellen eines neuen Schlüssels:

Verwenden Sie einfach die folgende Prozedur, um einen neuen Schlüssel zu erstellen. Für CreateNewKey werden der Name des zu erstellenden Schlüssels und die Konstante benötigt, die den vordefinierten Schlüssel darstellt, unter dem der Schlüssel erstellt werden soll. Beim Aufruf von RegCreateKeyEx werden nicht die zulässigen Sicherheitsmechanismen genutzt, obwohl dies mit Hilfe einer Modifizierung des Aufrufs möglich wäre. Eine Diskussion der Registrierungs-Sicherheit ist jedoch nicht Thema dieses Artikels.
 
   Private Sub CreateNewKey (sNewKeyName As String, lPredefinedKey As Long)
       Dim hNewKey As Long         'handle to the new key
       Dim lRetVal As Long         'result of the RegCreateKeyEx function

       lRetVal = RegCreateKeyEx(lPredefinedKey, sNewKeyName, 0&, _
                 vbNullString, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, _
                 0&, hNewKey, lRetVal)
       RegCloseKey (hNewKey)
   End Sub 

Bei dieser Prozedur wird durch den Aufruf von:
 
   CreateNewKey "TestKey", HKEY_LOCAL_MACHINE 

ein Schlüssel mit dem Namen "TestKey" direkt unter HKEY_LOCAL_MACHINE erstellt.

Durch den folgenden Aufruf von CreateNewKey:
 
      CreateNewKey "TestKey\SubKey1\SubKey2", HKEY_LOCAL_MACHINE 

werden dreifach verschachtelte Schlüssel erstellt, wobei "TestKey" direkt unter HKEY_CURRENT_USER beginnt, während "SubKey1" "TestKey" untergeordnet ist und "SubKey2" "SubKey1" untergeordnet ist.

Setzen/Ändern eines Wertes:

Das Erstellen und Setzen eines Wertes kann mit Hilfe der folgenden kurzen Prozedur erfolgen. Für SetKeyValue werden der Schlüssel, mit dem der Wert verbunden werden soll, der Name des Wertes, die Einstellung des Wertes und der Typ des Wertes (die SetValueEx-Funktion unterstützt nur REG_SZ und REG_DWORD, dies kann jedoch bei Bedarf geändert werden) benötigt. Wenn für einen vorhandenen sValueName ein neuer Wert angegeben wird, wird die aktuelle Einstellung dieses Wertes geändert.
 
   Private Sub SetKeyValue (sKeyName As String, sValueName As String, _
   vValueSetting As Variant, lValueType As Long)
       Dim lRetVal As Long         'result of the SetValueEx function
       Dim hKey As Long         'handle of open key

       'open the specified key
       lRetVal = RegOpenKeyEx(HKEY_CURRENT_USER, sKeyName, 0, _
                                 KEY_SET_VALUE, hKey)
       lRetVal = SetValueEx(hKey, sValueName, lValueType, vValueSetting)
       RegCloseKey (hKey)
   End Sub 

Durch Aufrufen von:
 
   SetKeyValue "TestKey\SubKey1", "StringValue", "Hello", REG_SZ 

wird ein Wert des Typs REG_SZ mit dem Namen "StringValue" und der Einstellung "Hello" erstellt. Dieser Wert wird mit dem Teilschlüssel "SubKey1" von "TestKey" verbunden.

In diesem Fall ist "TestKey" ein Teilschlüssel von HKEY_CURRENT_USER, dies kann jedoch durch Ändern des Aufrufs an RegOpenKeyEx geändert werden. Dieser Aufruf schlägt fehl, wenn "TestKey\SubKey1" nicht existiert. Verwenden Sie einen Aufruf an RegCreateKeyEx statt an RegOpenKeyEx, um dieses Problem zu verhindern. Wenn ein angegebener Schlüssel bereits existiert, wird er mit RegCreateKeyEx geöffnet.

Abfragen eines Wertes:

Die nächste Prozedur kann verwendet werden, um die Einstellung eines vorhandenen Wertes abzurufen. Für QueryValue werden der Name des Schlüssels und der Name des mit dem Schlüssel verbundenen Wertes benötigt. Die Funktion zeigt ein Meldungsfeld mit dem entsprechenden Wert an. Es wird ein Aufruf an die unten definierte QueryValueEx-Wrapperfunktion verwendet, die nur die Typen REG_SZ und REG_DWORD unterstützt.
 
   Private Sub QueryValue (sKeyName As String, sValueName As String)
       Dim lRetVal As Long         'result of the API functions
       Dim hKey As Long         'handle of opened key
       Dim vValue As Variant      'setting of queried value

       lRetVal = RegOpenKeyEx(HKEY_CURRENT_USER, sKeyName, 0, _
   KEY_QUERY_VALUE, hKey)
       lRetVal = QueryValueEx(hKey, sValueName, vValue)
       MsgBox vValue
       RegCloseKey (hKey)
   End Sub 

Bei dieser Prozedur wird durch den Aufruf von:
 
   QueryValue "TestKey\SubKey1", "StringValue" 

ein Meldungsfeld mit der aktuellen Einstellung des Wertes "StringValue" angezeigt, wobei vorausgesetzt wird, dass "StringValue" im Schlüssel "TestKey\SubKey1" existiert.

Wenn der abgefragte Wert nicht existiert, gibt QueryValue den Fehlercode 2 - 'ERROR_BADKEY' - zurück.

Zusätzliche Hinweise:

Die oben aufgeführten Beispiele verwenden exklusiv die erweiterten 32-Bit-Versionen der Registrierungsfunktionen. Diese Funktionen ermöglichen es, mehr als einen Wert mit jedem Schlüssel zu verbinden. Wie oben bereits angeführt, werden die 16-Bit RegSetValue- und RegQueryValue-Funktionen auf einen einzelnen mit dem aktuellen Schlüssel verbundenen Wert angewendet (der immer den Typ REG_SZ aufweist). Diese Funktionen erscheinen im 32-Bit-Registrierungseditor mit dem Namen <NO NAME>. Sie müssen 16-Bit-Registrierungsfunktionen verwenden, um diesen speziellen verbundenen Wert zu setzen, zu ändern oder abzufragen. Das Lesen und Schreiben in der Registrierung ist in einer 16-Bit-Umgebung weitaus einfacher als in einer 32-Bit-Umgebung. Es ist dieselbe grundlegende Prozedur durchzuführen (Öffnen eines Schlüssels, Beschaffen eines Handles und Aufrufen der Änderungsfunktion mit diesem Handle), wobei jedoch weder mehrere verbundene Werte noch unterschiedliche Datentypen für Werte zu berücksichtigen sind. Mit einer 16-Bit-Anwendung können Schlüssel und Werte mit den Deklarationen der Funktionen RegCreateKey, RegOpenKey, RegQueryValue, RegSetValue und RegCloseKey erstellt und geändert werden.

In einigen Fällen müssen überhaupt keine Werte mit einem Schlüssel verbunden sein. Eine Anwendung muss möglicherweise nur wissen, ob ein bestimmter Schlüssel oder Wert existiert, während die Beschaffenheit der Werte des Schlüssels unerheblich ist. In einer solchen Situation können die Funktionen RegEnumKey, RegEnumKeyEx und RegEnumValue verwendet werden, um zu bestimmen, ob ein bestimmter Schlüssel oder Wert existiert. Weitere Informationen zu diesen Funktionen erhalten Sie über den API-Textviewer und/oder die Windows API-Dokumentation.

API-Funktion und Konstantendeklarationen

 
   Option Explicit

   Public Const REG_SZ As Long = 1
   Public Const REG_DWORD As Long = 4

   Public Const HKEY_CLASSES_ROOT = &H80000000
   Public Const HKEY_CURRENT_USER = &H80000001
   Public Const HKEY_LOCAL_MACHINE = &H80000002
   Public Const HKEY_USERS = &H80000003

   Public Const ERROR_NONE = 0
   Public Const ERROR_BADDB = 1
   Public Const ERROR_BADKEY = 2
   Public Const ERROR_CANTOPEN = 3
   Public Const ERROR_CANTREAD = 4
   Public Const ERROR_CANTWRITE = 5
   Public Const ERROR_OUTOFMEMORY = 6
   Public Const ERROR_ARENA_TRASHED = 7
   Public Const ERROR_ACCESS_DENIED = 8
   Public Const ERROR_INVALID_PARAMETERS = 87
   Public Const ERROR_NO_MORE_ITEMS = 259

   Public Const KEY_QUERY_VALUE = &H1
   Public Const KEY_SET_VALUE = &H2
   Public Const KEY_ALL_ACCESS = &H3F

   Public Const REG_OPTION_NON_VOLATILE = 0

   Declare Function RegCloseKey Lib "advapi32.dll" _
   (ByVal hKey As Long) As Long
   Declare Function RegCreateKeyEx Lib "advapi32.dll" Alias _
   "RegCreateKeyExA" (ByVal hKey As Long, ByVal lpSubKey As String, _
   ByVal Reserved As Long, ByVal lpClass As String, ByVal dwOptions _
   As Long, ByVal samDesired As Long, ByVal lpSecurityAttributes _
   As Long, phkResult As Long, lpdwDisposition As Long) As Long
   Declare Function RegOpenKeyEx Lib "advapi32.dll" Alias _
   "RegOpenKeyExA" (ByVal hKey As Long, ByVal lpSubKey As String, _
   ByVal ulOptions As Long, ByVal samDesired As Long, phkResult As _
   Long) As Long
   Declare Function RegQueryValueExString Lib "advapi32.dll" Alias _
   "RegQueryValueExA" (ByVal hKey As Long, ByVal lpValueName As _
   String, ByVal lpReserved As Long, lpType As Long, ByVal lpData _
   As String, lpcbData As Long) As Long
   Declare Function RegQueryValueExLong Lib "advapi32.dll" Alias _
   "RegQueryValueExA" (ByVal hKey As Long, ByVal lpValueName As _
   String, ByVal lpReserved As Long, lpType As Long, lpData As _
   Long, lpcbData As Long) As Long
   Declare Function RegQueryValueExNULL Lib "advapi32.dll" Alias _
   "RegQueryValueExA" (ByVal hKey As Long, ByVal lpValueName As _
   String, ByVal lpReserved As Long, lpType As Long, ByVal lpData _
   As Long, lpcbData As Long) As Long
   Declare Function RegSetValueExString Lib "advapi32.dll" Alias _
   "RegSetValueExA" (ByVal hKey As Long, ByVal lpValueName As String, _
   ByVal Reserved As Long, ByVal dwType As Long, ByVal lpValue As _
   String, ByVal cbData As Long) As Long
   Declare Function RegSetValueExLong Lib "advapi32.dll" Alias _
   "RegSetValueExA" (ByVal hKey As Long, ByVal lpValueName As String, _
   ByVal Reserved As Long, ByVal dwType As Long, lpValue As Long, _
   ByVal cbData As Long) As Long 

SetValueEx- und QueryValueEx-Wrapperfunktionen:
 
   Public Function SetValueEx(ByVal hKey As Long, sValueName As String, _
   lType As Long, vValue As Variant) As Long
       Dim lValue As Long
       Dim sValue As String
       Select Case lType
           Case REG_SZ
               sValue = vValue & Chr$(0)
               SetValueEx = RegSetValueExString(hKey, sValueName, 0&, _
                                              lType, sValue, Len(sValue))
           Case REG_DWORD
               lValue = vValue
               SetValueEx = RegSetValueExLong(hKey, sValueName, 0&, _
   lType, lValue, 4)
           End Select
   End Function

   Function QueryValueEx(ByVal lhKey As Long, ByVal szValueName As _
   String, vValue As Variant) As Long
       Dim cch As Long
       Dim lrc As Long
       Dim lType As Long
       Dim lValue As Long
       Dim sValue As String

       On Error GoTo QueryValueExError

       ' Determine the size and type of data to be read
       lrc = RegQueryValueExNULL(lhKey, szValueName, 0&, lType, 0&, cch)
       If lrc <> ERROR_NONE Then Error 5

       Select Case lType
           ' For strings
           Case REG_SZ:
               sValue = String(cch, 0)

   lrc = RegQueryValueExString(lhKey, szValueName, 0&, lType, _
   sValue, cch)
               If lrc = ERROR_NONE Then
                   vValue = Left$(sValue, cch-1)
               Else
                   vValue = Empty
               End If
           ' For DWORDS
           Case REG_DWORD:
   lrc = RegQueryValueExLong(lhKey, szValueName, 0&, lType, _
   lValue, cch)
               If lrc = ERROR_NONE Then vValue = lValue
           Case Else
               'all other data types not supported
               lrc = -1
       End Select

   QueryValueExExit:
       QueryValueEx = lrc
       Exit Function

   QueryValueExError:
       Resume QueryValueExExit
   End Function 

Verweise

Programming the Windows 95 User Interface, Kapitel 10 - "Using the Registry"

Informationsquellen zu Funktionen: Handbücher zur Win16- oder Win32-API.

Bitte beachten Sie: Bei diesem Artikel handelt es sich um eine Übersetzung aus dem Englischen. Es ist möglich, dass nachträgliche Änderungen bzw. Ergänzungen im englischen Originalartikel in dieser Übersetzung nicht berücksichtigt sind. Die in diesem Artikel enthaltenen Informationen basieren auf der/den englischsprachigen Produktversion(en). Die Richtigkeit dieser Informationen in Zusammenhang mit anderssprachigen Produktversionen wurde im Rahmen dieser Übersetzung nicht getestet. Microsoft stellt diese Informationen ohne Gewähr für Richtigkeit bzw. Funktionalität zur Verfügung und übernimmt auch keine Gewährleistung bezüglich der Vollständigkeit oder Richtigkeit der Übersetzung.

Eigenschaften

Artikel-ID: 145679 - Geändert am: Dienstag, 19. August 2003 - Version: 1.1
Die Informationen in diesem Artikel beziehen sich auf:
  • Microsoft Visual Basic 5.0 Professional Edition
  • Microsoft Visual Basic 6.0 Professional Edition
  • Microsoft Visual Basic 5.0 Enterprise Edition
  • Microsoft Visual Basic 6.0 Enterprise Edition
  • Microsoft Visual Basic 4.0 Standard Edition
  • Microsoft Visual Basic 4.0 Professional Edition
  • Microsoft Visual Basic 4.0 Professional Edition
  • Microsoft Visual Basic 4.0 16-Bit Enterprise Edition
  • Microsoft Visual Basic 4.0 32-Bit Enterprise Edition
  • Microsoft Visual Basic for Applications 5.0
  • Microsoft Visual Basic for Applications 6.0
Keywords: 
kbhowto kbvb500 kbvbp kbtophit kbvbp400 kbvbp500 kbgrpdsvbdb kbvbp600 kbcode kbnokeyword kbvba KB145679
Microsoft stellt Ihnen die in der Knowledge Base angebotenen Artikel und Informationen als Service-Leistung zur Verfügung. Microsoft übernimmt keinerlei Gewährleistung dafür, dass die angebotenen Artikel und Informationen auch in Ihrer Einsatzumgebung die erwünschten Ergebnisse erzielen. Die Entscheidung darüber, ob und in welcher Form Sie die angebotenen Artikel und Informationen nutzen, liegt daher allein bei Ihnen. Mit Ausnahme der gesetzlichen Haftung für Vorsatz ist jede Haftung von Microsoft im Zusammenhang mit Ihrer Nutzung dieser Artikel oder Informationen ausgeschlossen.

Ihr Feedback an uns

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com