Die Registry von Windows ist für den einen oder anderen ein Buch mit sieben Siegeln. Tatsache ist: Dort landen manche wichtigen Informationen, die Sie gegebenenfalls einmal mit VBA auslesen wollen, oder Sie wollen dafür sorgen, dass per VBA bestimmte Elemente in der Registry angelegt werden. Wir stellen einige Routinen vor, die Ihnen die Arbeit mit der Registry erleichtern. Gleichzeitig liefern wir den Code in 64-Bit-kompatibler Form.<\/b><\/p>\n
Per VBA mit der Registry arbeiten<\/h2>\n
Wann und wo Sie auf eine Anforderung stoßen, die mit dem Lesen oder Schreiben von Registry-Werten per VBA zu tun hat, lassen wir einmal dahingestellt. Wichtig ist allein, dass Sie nach der Lektüre dieses Beitrags auf den Ernstfall vorbereitet sind!<\/p>\n
Daher schauen wir uns in diesem Beitrag nicht nur einen Satz von Funktionen an, welche wiederum die API von Windows für den lesenden und schreibenden Zugriff auf die Registry nutzen, sondern liefern auch noch eine Reihe von Beispielen für die Anwendung dieser Funktionen.<\/p>\n
Unser konkreter Anlass, uns mit dem Thema VBA-Zugriff auf die Registry auseinanderzusetzen, war der Beitrag Optionen per VBA für Access 2019 <\/b>(www.access-im-unternehmen.de\/1320<\/b>). Hier haben wir untersucht, welche Einstellungen des Dialogs Access-Optionen in der Registry landen. Um schnell prüfen zu können, ob sich nach dem Ändern einer Option unter Access einer der Einträge in der Registry geändert hat, haben wir eine Tabelle erstellt, die alle bereits in der Registry vorhandenen Werte enthält. Diese Werte haben wir initial einmal aus dem entsprechenden Bereich der Registry ausgelesen.<\/p>\n
Anschließend haben wir nach jeder Änderung eine Prozedur durchlaufen lassen, welche alle Werte der Registry mit den bestehenden Werten in der Tabelle abgeglichen und eventuelle Unterschiede oder gar neue Werte im Direktbereich ausgegeben hat.<\/p>\n
Den Bereich der Registry, der die Access-Optionen enthält, findet sich unter HKEY_CURRENT_USER <\/b>im Ordner SOFTWARE\\Microsoft\\Office\\16.0\\Access\\Settings<\/b>. Der Screenshot aus Bild 1 zeigt einige der Einstellungen.<\/p>\n
![\"Dieser](\"..\/fileadmin\/_temp_\/2021_05\/pic_1323_001.jpg\")
<\/p>\n
Bild 1: Dieser Bereich der Registry speichert die meisten der Access-Optionen.<\/span><\/b><\/p>\n Auf diesen Ordner wollen wir uns in diesem Beitrag konzentrieren – wie lesen die Informationen aus, legen neue Werte an, erstellen Unterordner und so weiter. Vorher schauen wir uns allerdings noch die dazu notwendigen Funktionen im Modul mdlRegistry <\/b>an.<\/p>\n Da das Modul die Deklaration von API-Funktion enthält sowie dafür vorgesehene Wrapperfunktionen, benötigen wir auch einige Enum<\/b>– und Const<\/b>-Elemente. Diese sehen wie folgt aus:<\/p>\n Neben diesen Elementen benötigen wir die Deklarationen der eigentlichen API-Funktionen. Dabei handelt es sich um 13 Funktionen, deren Deklaration Sie in Listing 1 finden.<\/p>\n Listing 1: Die benötigten API-Funktionen<\/span><\/b><\/p>\n Die erste Wrapperfunktion soll das Auslesen eines Wertes für einen Eintrag eines Schlüssels\/Unterschlüssels ermöglich. Diese Funktion erwartet drei Parameter:<\/p>\n Die Funktion nutzt die API-Funktion RegOpenKeyEx<\/b>, um den angegebenen Schlüssel zu öffnen. Dann liest sie mit RegQueryValueEx <\/b>das gewünschte Element aus. Der Parameter varValue <\/b>nimmt den gesuchten Wert auf.<\/p>\n Dieser wird in den folgenden Schritten noch untersucht und von nicht erwünschten Zeichen befreit. Schließlich wird dieser Wert zurückgegeben und der Registry-Schlüssel mit der API-Funktion RegCloseKey <\/b>wieder geschlossen (siehe Listing 2)<\/p>\n Listing 2: Die Wrapperfunktion QueryValue<\/span><\/b><\/p>\n Die Wrapperfunktion EnumKeyValues<\/b> ermittelt alle Einträge der mit den Parametern übergebenen Schlüssel\/Unterschlüssel-Kombination.<\/p>\n Die Funktion erwartet diese beiden Parameter:<\/p>\n Die Funktion öffnet wieder mit RegOpenKey <\/b>den Schlüssel. Dann startet sie eine Do…Loop<\/b>-Schleife, die dann endet, wenn die Funktion RegEnumValue <\/b>den Wert 0 <\/b>zurückgibt. Diese erhält in der Schleife wiederum einen Index als zweiten Parameter, der mit jedem Schleifendurchlauf erhöht wird, sowie als dritten Parameter eine mit 255 Leerzeichen vorbelegte Zeichenkette. Diese wird, sofern der aktuelle Index aus lngIndex<\/b> ein gültiges Ergebnis hergibt, mit dem Namen des Eintrags gefüllt. Der Inhalt von strSave <\/b>wird dann mit der Funktion StripTerminator <\/b>von vbNullChar<\/b>-Zeichen befreit und an das Array strKeys <\/b>angehängt. Dieses gibt die Funktion schließlich als Ergebnis zurück:<\/p>\n Die in der vorher vorgestellten Funktion verwendete Hilfsfunktion StripTerminator <\/b>befreit die übergebene Zeichenkette von Vorkommen des Zeichens vbNullChar<\/b>. Die API-Funktion RegEnumValue <\/b>ersetzt in der String<\/b>-Variablen strSave <\/b>die 255 Leerzeichen durch das Ergebnis und füllt die übrigen Zeichen mit dem Zeichen vbNullChar <\/b>auf. Diese wollen wir entfernen und verwenden dazu die Funktion StripTerminator<\/b>. Die Funktion erwartet die zu untersuchende Zeichenkette als Parameter und gibt die überarbeitete Zeichenkette zurück. Sie sucht im ersten Schritt nach dem ersten Vorkommen von vbNullChar <\/b>und geht davon aus, dass hier das eigentliche Ergebnis beendet ist. Die Suche erledigt sie mit der Funktion InStr<\/b>, welche die Position des ersten Vorkommens zurückliefert. Ist das Ergebnis größer als 0<\/b>, wurde ein vbNullChar<\/b>-Zeichen gefunden. Dann schneidet die Funktion alle Zeichen von diesem Zeichen an ab und trägt nur die davor liegenden Zeichen in den Rückgabewert der Funktion ein. Andernfalls erhält dieser einfach die übergebene Zeichenkette als Ergebnis:<\/p>\n Wenn Sie alle Schlüssel unterhalb eines anderen Schlüssels auslesen möchten, können Sie dazu die Wrapperfunktion EnumRegKeys <\/b>nutzen (siehe Listing 3). Diese Funktion erwartet die gleichen Parameter wie die Funktion EnumKeyValues<\/b>.<\/p>\n Listing 3: Die Wrapperfunktion zum Auslesen aller untergeordneten Schlüssel<\/span><\/b><\/p>\n Sie öffnet mit der API-Funktion RegOpenKey <\/b>den zu untersuchenden Schlüssel. Dann durchläuft sie eine Do Loop<\/b>-Schleife solange, bis kein weiterer untergeordneter Schlüssel mehr gefunden werden kann.<\/p>\n Dabei füllt sie die Variable strSave<\/b>, die mit dem jeweiligen Namen des Unterschlüssels gefüllt werden soll, mit 255 Leerzeichen. Dann prüft sie in einer If…Then<\/b>-Bedingung das Ergebnis der API-Funktion RegEnumKeyEx<\/b>.<\/p>\n Ist dieses 0<\/b>, wurde für den Index mit dem Wert aus lngIndex <\/b>ein Unterschlüssel gefunden.<\/p>\n Dann vergrößert die Funktion im If<\/b>-Teil der Bedingung das Array strKeys <\/b>für die Ergebnisse auf den aktuellen Index aus lngIndex <\/b>und fügt den Namen des mit strSave <\/b>ermittelten Unterschlüssels an der neuen Position in das Array ein. Zuvor entfernt die Funktion StripTerminator <\/b>wieder die überzähligen vbNullChar<\/b>-Zeichen aus strSave<\/b>.<\/p>\n Liefert RegEnumKeyEx <\/b>für den aktuellen Index den Wert 0 <\/b>zurück, ist kein weiterer Unterschlüssel mehr vorhanden und der untersuchte Schlüssel wird mit RegCloseKey <\/b>geschlossen.<\/p>\n Einen neuen Schlüssel anzulegen bedeutet in der Sprache der Registry, dass Sie einen neuen Ordner im linken Bereich erstellen wollen. Das gelingt viel einfacher als bei Ordnern im Dateisystem.<\/p>\n Sie brauchen einfach nur den Hauptschlüssel festzulegen und dann den Unterschlüssel zu definieren – egal, ob dieser noch übergeordnete Schlüssel hat. Sie können damit auch in einem Schritt mehrere verschachtelte Schlüssel anlegen, also beispielsweise Test1\\Test2\\Test3<\/b>.<\/p>\n Schauen wir uns die Funktion an, die dies erlaubt – siehe Listing 4. Die Funktion erwartet zwei Parameter:<\/p>\n Listing 4: Die Wrapperfunktion zum Erstellen eines Wertes<\/span><\/b><\/p>\n Die Funktion ruft ohne Umschweife die API-Funktion RegCreateKeyEx <\/b>auf, der sie den ersten und den zweiten Parameter neben einigen anderen Werten als Funktionsparameter übergibt.<\/p>\n Im Gegensatz zu den ersten Wrapperfunktionen taucht hier kein Aufruf der Funktion RegOpenKey <\/b>auf, was nicht nötig ist, da wir ja erst einen Schlüssel erstellen wollen.<\/p>\n Dennoch wird beim Anlegen der Schlüssel „geöffnet“, was dazu führt, dass dieser auch geschlossen werden muss.<\/p>\n Die API-Funktion RegCreateKeyEx <\/b>liefert daher mit dem Parameter hNewKey <\/b>ein Handle auf den neuen Schlüssel zurück, das dann mit RegCloseKey <\/b>zum Schließen verwendet werden kann.<\/p>\n Nun wollen wir einem bestehenden Schlüssel einen neuen Eintrag mit Wert hinzufügen. Dazu nutzen wir eine weitere Wrapperfunktion namens AddKeyAndValue<\/b> (siehe Listing 5). Diese erwartet neben den bereits bekannten Parametern drei weitere Parameter:<\/p>\nDas Modul mdlRegistry und die Registry-Funktionen<\/h2>\n
Public <\/span>Enum Key\r\n HKEY_CLASSES_ROOT = &H80000000\r\n HKEY_CURRENT_USER = &H80000001\r\n HKEY_LOCAL_MACHINE = &H80000002\r\n HKEY_USERS = &H80000003\r\nEnd Enum\r\nPublic <\/span>Enum DataType\r\n dtString = 1\r\n dtNumber = 4\r\nEnd Enum\r\nGlobal Const ERROR_NONE = 0\r\nGlobal Const ERROR_BADDB = 1\r\nGlobal Const ERROR_BADKEY = 2\r\nGlobal Const ERROR_CANTOPEN = 3\r\nGlobal Const ERROR_CANTREAD = 4\r\nGlobal Const ERROR_CANTWRITE = 5\r\nGlobal Const ERROR_OUTOFMEMORY = 6\r\nGlobal Const ERROR_INVALID_PARAMETER = 7\r\nGlobal Const ERROR_ACCESS_DENIED = 8\r\nGlobal Const ERROR_INVALID_PARAMETERS = 87\r\nGlobal Const ERROR_NO_MORE_ITEMS = 259\r\nGlobal Const KEY_ALL_ACCESS = &H3F\r\nGlobal Const REG_OPTION_NON_VOLATILE = 0<\/pre>\nDeclare PtrSafe Function RegCloseKey Lib \"advapi32.dll\" (ByVal hKey As Long<\/span>) As Long<\/span>\r\nDeclare PtrSafe Function RegCreateKeyEx Lib \"advapi32.dll\" Alias \"RegCreateKeyExA\" (ByVal hKey As Long<\/span>, _\r\n ByVal lpSubKey As String<\/span>, ByVal Reserved As Long<\/span>, ByVal lpClass As String<\/span>, ByVal dwOptions As Long<\/span>, _\r\n ByVal samDesired As Long<\/span>, ByVal lpSecurityAttributes As Long<\/span>, phkResult As Long<\/span>, lpdwDisposition As Long<\/span>) As Long<\/span>\r\nDeclare PtrSafe Function RegOpenKeyEx Lib \"advapi32.dll\" Alias \"RegOpenKeyExA\" (ByVal hKey As Long<\/span>, _\r\n ByVal lpSubKey As String<\/span>, ByVal ulOptions As Long<\/span>, ByVal samDesired As Long<\/span>, phkResult As Long<\/span>) As Long<\/span>\r\nDeclare PtrSafe Function RegQueryValueExString Lib \"advapi32.dll\" Alias \"RegQueryValueExA\" (ByVal hKey As Long<\/span>, _\r\n ByVal lpValueName As String<\/span>, ByVal lpReserved As Long<\/span>, lpType As Long<\/span>, ByVal lpData As String<\/span>, lpcbData As Long<\/span>) As Long<\/span>\r\nDeclare PtrSafe Function RegQueryValueExLong Lib \"advapi32.dll\" Alias \"RegQueryValueExA\" (ByVal hKey As Long<\/span>, _\r\n ByVal lpValueName As String<\/span>, ByVal lpReserved As Long<\/span>, lpType As Long<\/span>, lpData As Long<\/span>, lpcbData As Long<\/span>) As Long<\/span>\r\nDeclare PtrSafe Function RegQueryValueExNULL Lib \"advapi32.dll\" Alias \"RegQueryValueExA\" (ByVal hKey As Long<\/span>, _\r\n ByVal lpValueName As String<\/span>, ByVal lpReserved As Long<\/span>, lpType As Long<\/span>, ByVal lpData As Long<\/span>, lpcbData As Long<\/span>) As Long<\/span>\r\nDeclare PtrSafe Function RegSetValueExString Lib \"advapi32.dll\" Alias \"RegSetValueExA\" (ByVal hKey As Long<\/span>, _\r\n ByVal lpValueName As String<\/span>, ByVal Reserved As Long<\/span>, ByVal dwType As Long<\/span>, ByVal lpValue As String<\/span>, _\r\n ByVal cbData As Long<\/span>) As Long<\/span>\r\nDeclare PtrSafe Function RegSetValueExLong Lib \"advapi32.dll\" Alias \"RegSetValueExA\" (ByVal hKey As Long<\/span>, _\r\n ByVal lpValueName As String<\/span>, ByVal Reserved As Long<\/span>, ByVal dwType As Long<\/span>, lpValue As Long<\/span>, ByVal cbData As Long<\/span>) _\r\n As Long<\/span>\r\nDeclare PtrSafe Function RegDeleteKey& Lib \"advapi32.dll\" Alias \"RegDeleteKeyA\" (ByVal hKey As Long<\/span>, _\r\n ByVal lpSubKey As String<\/span>)\r\nDeclare PtrSafe Function RegDeleteValue& Lib \"advapi32.dll\" Alias \"RegDeleteValueA\" (ByVal hKey As Long<\/span>, _\r\n ByVal lpValueName As String<\/span>)\r\nDeclare PtrSafe Function RegOpenKey Lib \"advapi32.dll\" Alias \"RegOpenKeyA\" (ByVal hKey As Long<\/span>, _\r\n ByVal lpSubKey As String<\/span>, phkResult As Long<\/span>) As Long<\/span>\r\nDeclare PtrSafe Function RegEnumKeyEx Lib \"advapi32.dll\" Alias \"RegEnumKeyExA\" (ByVal hKey As Long<\/span>, _\r\n ByVal dwIndex As Long<\/span>, ByVal lpName As String<\/span>, lpcbName As Long<\/span>, ByVal lpReserved As Long<\/span>, _\r\n ByVal lpClass As String<\/span>, lpcbClass As Long<\/span>, lpftLastWriteTime As <\/span>Any) As Long<\/span>\r\nDeclare PtrSafe Function RegEnumValue Lib \"advapi32.dll\" Alias \"RegEnumValueA\" (ByVal hKey As Long<\/span>, _\r\n ByVal dwIndex As Long<\/span>, ByVal lpValueName As String<\/span>, lpcbValueName As Long<\/span>, ByVal lpReserved As Long<\/span>, _\r\n lpType As Long<\/span>, lpData As Byte<\/span>, lpcbData As Long<\/span>) As Long<\/span><\/pre>\nWrapperfunktion zum Auslesen von Werten<\/h2>\n
\n
Public Function <\/span>QueryValue(lngKey As <\/span>Key, strKeyName As String<\/span>, strValueName As String<\/span>)\r\n Dim <\/span>lngRetVal As Long<\/span>\r\n Dim <\/span>hKey As Long<\/span>\r\n Dim <\/span>varValue As Variant<\/span>\r\n lngRetVal = RegOpenKeyEx(lngKey, strKeyName, 0, KEY_ALL_ACCESS, hKey)\r\n lngRetVal = QueryValueEx(hKey, strValueName, varValue)\r\n varValue = Trim<\/span>(varValue)\r\n If <\/span>varValue <> \"\" Then<\/span>\r\n If <\/span>Asc(Right<\/span>(varValue, 1)) > 127 Then<\/span>\r\n varValue = Left<\/span>(varValue, Len<\/span>(varValue) - 1)\r\n End If<\/span>\r\n End If<\/span>\r\n If <\/span>varValue <> \"\" Then<\/span>\r\n If <\/span>Asc(Right<\/span>(varValue, 1)) < 21 Then<\/span>\r\n varValue = Left<\/span>(varValue, Len<\/span>(varValue) - 1)\r\n End If<\/span>\r\n End If<\/span>\r\n QueryValue = varValue\r\n RegCloseKey hKey\r\nEnd Function<\/span><\/pre>\nWrapperfunktion zum Auslesen aller Einträge eines Schlüssels<\/h2>\n
\n
Public Function <\/span>EnumKeyValues(lngKey As <\/span>Key, _\r\n strSubkey As String<\/span>) As String<\/span>()\r\n Dim <\/span>hKey As Long<\/span>\r\n Dim <\/span>lngIndex As Long<\/span>\r\n Dim <\/span>strSave As String<\/span>\r\n Dim <\/span>strKeys() As String<\/span>\r\n RegOpenKey lngKey, strSubkey, hKey\r\n Do\r\n strSave = String(255, 0)\r\n If RegEnumValue(hKey, lngIndex, strSave, 255, _\r\n 0, ByVal 0&, ByVal 0&, ByVal 0&) <> 0 Then\r\n Exit Do<\/span>\r\n Else<\/span>\r\n ReDim Preserve strKeys(lngIndex)\r\n strKeys(lngIndex) = StripTerminator(strSave)\r\n lngIndex = lngIndex + 1\r\n End If<\/span>\r\n Loop<\/span>\r\n RegCloseKey hKey\r\n EnumKeyValues = strKeys\r\nEnd Function<\/span><\/pre>\nDie Hilfsfunktion StripTerminator<\/h2>\n
Private Function <\/span>StripTerminator(strInput As String<\/span>) _\r\n As String<\/span>\r\n Dim <\/span>lngPosNull As Long<\/span>\r\n lngPosNull = InStr<\/span>(1, strInput, vbNullChar)\r\n If <\/span>lngPosNull > 0 Then<\/span>\r\n StripTerminator = Left$(strInput, lngPosNull - 1)\r\n Else<\/span>\r\n StripTerminator = strInput\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nWrapperfunktion zum Auslesen aller Unterschlüssel eines Schlüssels<\/h2>\n
Public Function <\/span>EnumRegKeys(lngKey As <\/span>Key, strKeyName As String<\/span>) As String<\/span>()\r\n Dim <\/span>hKey As Long<\/span>\r\n Dim <\/span>lngIndex As Long<\/span>\r\n Dim <\/span>strSave As String<\/span>\r\n Dim <\/span>strKeys() As String<\/span>\r\n RegOpenKey lngKey, strKeyName, hKey\r\n Do\r\n strSave = String(255, 0)\r\n If <\/span>RegEnumKeyEx(hKey, lngIndex, strSave, 255, 0, vbNullString, ByVal 0&, ByVal 0&) <> 0 Then<\/span>\r\n ReDim Preserve strKeys(lngIndex)\r\n strKeys(lngIndex) = StripTerminator(strSave)\r\n lngIndex = lngIndex + 1\r\n Else<\/span>\r\n Exit Do<\/span>\r\n End If<\/span>\r\n Loop<\/span>\r\n RegCloseKey hKey\r\n EnumRegKeys = strKeys\r\nEnd Function<\/span><\/pre>\nWrapperfunktion zum Erzeugen eines neuen Schlüssels<\/h2>\n
Public Function <\/span>CreateNewKey(lngKey As <\/span>Key, strNewSubkey As String<\/span>)\r\n Dim <\/span>hNewKey As Long<\/span>\r\n Dim <\/span>lngRetVal As Long<\/span>\r\n lngRetVal = RegCreateKeyEx(lngKey, strNewSubkey, 0&, vbNullString, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, _\r\n 0&, hNewKey, lngRetVal)\r\n RegCloseKey hNewKey\r\nEnd Function<\/span><\/pre>\n\n
Wrapperfunktion zum Erzeugen eines neuen Eintrags mit Wert<\/h2>\n
Public Function <\/span>AddKeyAndValue(lngKey As <\/span>Key, strSubkey As String<\/span>, strValueName As String<\/span>, strValue As String<\/span>, _\r\n lngValueType As <\/span>DataType)\r\n Dim <\/span>lngRetVal As Long<\/span>\r\n Dim <\/span>hKey As Long<\/span>\r\n lngRetVal = RegOpenKeyEx(lngKey, strSubkey, 0, KEY_ALL_ACCESS, hKey)\r\n lngRetVal = SetValueEx(hKey, strValueName, lngValueType, strValue)\r\n RegCloseKey hKey\r\n