<\/p>\n
Windows stellt einige API-Prozeduren zum Zugriff auf die Registry zur Verfügung. Die Registry verwaltet viele der für das System wichtigen Informationen. Hierzu gehören Informationen über das System, über die verschiedenen Anwendungen und Dateitypen und wie sie verknüpft werden und vieles mehr. Dieser Beitrag zeigt, wie Sie per VBA über die Funktionen der Windows-API auf die Registry zugreifen.<\/b><\/p>\n
Neben den Informationen über das System finden Sie auch Informationen zu den Anwendungen selbst in der Registry. Wenn Sie zum Beispiel in den Optionen von Access den Standarddatenbankpfad ändern, wird der neue Pfad in die Registry eingetragen.<\/p>\n
Auch wenn Sie der Datenbank einen neuen Assistenten oder ein Add-In hinzufügen, schreibt der Add-In-Manager die benötigten Informationen in die Registry. Für den Entwickler wird die Registry interessant, wenn er bestimmte Daten speichern will, die nicht in einer Tabelle untergebracht werden können oder sollen.<\/p>\n
Die Registry ist im Prinzip wie das Dateisystem von Windows aufgebaut. Die Verzeichnisstruktur ist nahezu identisch. Statt der Dateien enthält die Registry Variablen. Wie die Dateien haben auch die Variablen einen bestimmten Inhalt.<\/p>\n
Die Windows-API stellt einige Befehle zur Bearbeitung der Registry zur Verfügung. Im Folgenden lernen Sie Befehle, die Sie zum Hinzufügen, Bearbeiten und Entfernen von Schlüsseln benötigen, anhand eines Beispiels kennen. <\/p>\n
Die Einträge in die Registry, die Sie über den Befehl RegEdit <\/b>öffnen (beispielsweise über das Suchen-Feld von Windows 10), sind nach einem bestimmten Schema aufgebaut. Auf der obersten Ebene befinden sich die Hauptpfade. Es gibt insgesamt fünf Hauptpfade, die Sie auch in Bild 1 sehen können:<\/p>\n
![\"Die](\"..\/fileadmin\/_temp_\/2016_03\/pic_1040_001.png\")
<\/p>\n
Bild 1: Die Registry mit den fünf Hauptzweigen<\/span><\/b><\/p>\n Jeder dieser Hauptpfade enthält weitere, aus unterschiedlich vielen Ebenen bestehende Unterpfade. Der unterste Pfad jeder der Ebenen enthält schließlich die eigentlichen Schlüssel. Die Schlüssel bestehen aus einem Namen und einem Wert. Mit dem Registrierungseditor, mit dem Sie die Einträge der Registry bequem einsehen, editieren und löschen sowie neue Einträge hinzufügen können, greifen Sie über die Benutzeroberfläche auf diese Schlüssel zu.<\/p>\n Der in Bild 2 markierte Pfad lautet beispielsweise HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Office\\16.0\\Access\\Menu Add-Ins\\RibbonAdmin2016<\/b>.<\/p>\n Bild 2: Die Access-Add-Ins und ihre Registrierung in der Windows-Registry<\/span><\/b><\/p>\n In dem Pfad finden Sie vier Schlüssel, die einige Informationen zu einem Access-Add-In beinhalten – unter anderem die Funktion, die beim Aufruf des Add-Ins gestartet werden soll, sowie der Ort der Bibliothek, in der die benötigte Funktion enthalten ist.<\/p>\n Wenn Sie eine Datenbankanwendung als Shareware vertreiben, möchten Sie die Benutzung der Anwendung möglicherweise auf eine Testphase von beispielsweise 30 Tagen beschränken. Die Anwendung muss also bei jedem Start zunächst überprüfen, ob der angegebene Zeitraum schon beendet ist oder nicht. Dazu müssen Sie zunächst eine Information über das Installationsdatum oder das Datum der ersten Anwendung speichern.<\/p>\n Das Speichern der Daten innerhalb der Datenbank ist deshalb nicht zu empfehlen, weil der Anwender die Datenbank nach Ablauf der 30 Tage einfach neu installieren könnte. Eine weitere Möglichkeit ist das Speichern des Datums in der Registry. Wenn der Benutzer die Anwendung startet, vergleicht die Anwendung das in die Registry eingetragene Datum mit dem aktuellen Datum und soll den Benutzer gegebenenfalls auf das Ablaufen der Testphase hinweisen. Wenn der Benutzer dann die Datenbank neu installiert, findet die Datenbank den noch vorhandenen Registry-Eintrag und erkennt, dass die Testphase bereits einmal abgelaufen ist.<\/p>\n Zunächst einmal überlegt man sich, wo in der Registry ein solcher Wert am besten abgelegt wird. Da die Anwendung vermutlich unabhängig vom Benutzer auf dem Rechner installiert, wählt man den Hauptpfad HKEY_CURRENT_USER <\/b>aus. Der Name des Pfades soll \\AMVShop\\Beispiele\\Registry <\/b>lauten. Den Schlüssel nennen Sie Installationsdatum und der Wert soll das aktuelle Datum sein.<\/p>\n Selbstverständlich sollten Sie die Informationen etwas besser verstecken und gegebenenfalls auch verschlüsseln, wenn Sie eine Anwendung wirksam schützen wollen. Da der vorliegende Anwendungsfall jedoch nur als Beispiel dienen soll, wird hier mit offenen Karten gespielt.<\/p>\n Im Rahmen der nachfolgend beschriebenen API-Funktionen definieren Sie einige Konstanten. Die Konstanten benötigen Sie, um innerhalb des VBA-Code statt nichtssagender Werte für den Entwickler verständliche Begriffe verwenden zu können. So definiert man beispielsweise die folgende Konstante HKEY_CLASSES_ROOT<\/b>, um sie bei der Angabe eines Registryschlüssels statt des Ausdrucks &H80000003 <\/b>zu verwenden:<\/p>\n Damit Sie nicht zwischendurch immer wieder neue Kon-stanten definieren müssen, geben Sie direkt alle in Zusammenhang mit den Registryzugriffen benötigten Konstanten ein:<\/p>\n Noch praktischer ist es, wenn Sie für die fünf Konstanten für die Hauptpfade der Registry gleich eine Enumeration anlegen. Dann können Sie später, wenn Sie in Funktionen eine dieser Konstanten als Parameter übergeben wollen, ganz einfach per Intellisense auf diese Konstanten zugreifen. Dies sieht dann so aus:<\/p>\n Sie müssen die entsprechenden Konstanten dann allerdings löschen oder umbenennen, da sonst mehrere Elemente gleichen Namens im Code vorkommen, was zu Kompilierfehlern führt.<\/p>\n Achtung: Sie werden im Folgenden neben den Konstanten auch noch API-Funktionen deklarieren sowie VBA-Funktionen und -Prozeduren eingeben. Am besten legen Sie für die Konstanten und die API-Funktionen ein eigenes Modul an (zum Beispiel mdlAPIRegistry<\/b>). Die VBA-Funktionen und -Prozeduren zum Thema Registry sollten Sie ebenso in einem eigenen Modul zusammenfassen – beispielsweise mdlRegistry<\/b>.<\/p>\n Die API-Funktion RegCreateKeyEx <\/b>dient zum Anlegen eines Registrierungsschlüssels. Falls der anzulegende Schlüssel bereits vorhanden ist, öffnet die Funktion den Schlüssel. Die Deklaration der Funktion lautet:<\/p>\n Interessant sind vor allem die Parameter hKey <\/b>und lpSubKey<\/b>. Für den Parameter hKey <\/b>geben Sie entweder das Handle an, das auf den entsprechenden Eintrag in der Registry zeigt, oder Sie geben einen der Hauptpfade aus der obigen Liste ein. Für den Parameter lpSubKey<\/b> geben Sie den Pfad des Registry-Wertes an, den Sie öffnen möchten.<\/p>\n Für den Parameter lpSecurityAttributes <\/b>müssen Sie noch einen Type <\/b>definieren, und zwar im Modul mdlAPIRegistry<\/b>:<\/p>\n Um den Aufruf der API-Funktion ein wenig komfortabler zu gestalten, erstellen Sie eine Funktion, an die Sie einfach nur den Hauptpfad und den Pfad des Registry-Eintrages übergeben müssen:<\/p>\n Als Hauptpfad würden Sie nun eine der Konstanten wie etwa HKEY_LOCAL_MACHINE <\/b>eingeben. Da wir dafür aber eine Enumeration angelegt haben, können Sie diese auch als Datentyp für lngHauptpfad <\/b>angeben, sodass die Funktion nun wie in Listing 1 aussieht.<\/p>\n Listing 1: Hilfsfunktion zum Erstellen eines Schlüssels in der Registry<\/span><\/b><\/p>\n Sie können die Funktion zum Beispiel über das Testfenster aufrufen.<\/p>\n Geben Sie dort den folgenden Befehl ein, erhalten Sie Unterstützung bei der Auswahl des Hauptpfades (s. Bild 3):<\/p>\n Bild 3: Aufruf der Funktion SchluesselErstellen mit IntelliSense-Unterstützung<\/span><\/b><\/p>\n Das Meldungsfenster zeigt daraufhin die Nummer des Handles an, mit dem Sie auf den Eintrag in die Registry zugreifen können, ohne den kompletten Pfad eingeben zu müssen – zum Beispiel 4576<\/b>.<\/p>\n Außerdem erstellt die Funktion den angegebenen Pfad in der Registry, wenn er nicht bereits vorhanden ist. Wenn der Pfad bereits erstellt wurde, bereitet die Funktion den Pfad auf den Zugriff vor. Mit dem Registrierungseditor können Sie schnell überprüfen, ob die Funktion den Registrierungsschlüssel wie gewünscht angelegt hat. öffnen Sie den Editor und navigieren Sie zu dem entsprechenden Pfad (s. Bild 4).<\/p>\n Bild 4: Der neue Eintrag in der Windows-Registry<\/span><\/b><\/p>\n Wenn Sie nur auf einen Schlüssel zugreifen möchten, verwenden Sie den API-Befehl RegOpenKey<\/b>. Die Funktion hat die folgende Syntax:<\/p>\n Auch den Aufruf dieser API-Funktion können Sie ein wenig komfortabler gestalten, indem Sie eine Funktion erstellen, die nur die wichtigsten Werte als Parameter erfordert:<\/p>\n Die Funktion SchluesselOeffnen <\/b>aus Listing 2 hat nur einen Unterschied im Vergleich zu der vorherigen Funktion: Sie erstellt keinen neuen Schlüssel, falls der angegebene Schlüssel nicht vorhanden ist. Beachten Sie, dass die API-Funktion keinen Fehler auslöst, wenn der zu öffnende Schlüssel nicht vorhanden ist. Sie gibt lediglich für das Handle den Wert 0 <\/b>zurück.<\/p>\n Listing 2: Hilfsfunktion zum Ermitteln des Handles eines Registry-Eintrags<\/span><\/b><\/p>\n Ein Beispielaufruf sieht wie folgt aus:<\/p>\n Bevor Sie beginnen, den neuen Schlüssel mit Werten zu füllen, erfahren Sie noch, wie Sie einen Schlüssel per API-Aufruf wieder entfernen können. Auch das ist wichtig, denn wenn Sie mit der Installation der Software in die Registry eingreifen, sollten Sie die änderung bei einer Deinstallation auch wieder rückgängig machen. Zum Löschen eines Pfades in der Registry verwendet man den API-Befehl RegDeleteKey<\/b>, den Sie wie folgt deklarieren:<\/p>\n Die Funktion erwartet nur den Hauptpfad und den Pfad des zu löschenden Schlüssels. Die Funktion gibt den Wert 0 <\/b>zurück – es sei denn, die Operation schlägt fehl, zum Beispiel, weil der angegebene Pfad nicht vorhanden ist. Wichtig ist, dass Sie den kompletten zu entfernenden Pfad bis in die unterste Ebene angeben.<\/p>\n Auch für diese API-Funktion haben wir wieder eine Wrapper-Funktion programmiert, die Sie in Listing 3 finden.<\/p>\n <\/p>\n Listing 3: Hilfsfunktion zum Löschen eines Eintrags<\/span><\/b><\/p>\n Wenn Sie nun den gleichen Pfad wieder löschen wollen, den Sie soeben angelegt haben, gelingt dies nicht mit dem folgenden Aufruf der Funktion:<\/p>\n Dies liefert mit dem Wert 0 <\/b>zwar eine Erfolgsmeldung, allerdings wird hier logischerweise nur genau das angegebene Element gelöscht, nämlich das Verzeichnis Test<\/b>.<\/p>\n Wenn Sie alle Verzeichnisse löschen wollen, die Sie zuvor angelegt haben, sind noch zwei weitere Aufrufe nötig – Sie müssen nämlich jedes Verzeichnis vom hintersten an einzeln löschen:<\/p>\n Wenn Sie direkt versuchen, den Pfad SOFTWARE\\AMVShop <\/b>zu löschen, lösen Sie einen Fehler aus beziehungsweise erhalten einen anderen Wert als 0 <\/b>zurück, in diesem Fall den Wert 5<\/b>. Wenn Sie einen Pfad löschen wollen, der nicht mehr vorhanden ist, liefert die Funktion den Wert 2<\/b>.<\/p>\n Mit der API-Anweisung RegCloseKey<\/b> schließen Sie einen geöffneten Schlüssel wieder und geben die dabei gebundenen Ressourcen wieder frei.<\/p>\n Der einzige Parameter der Funktion ist das Handle des zu schließenden Schlüssels, das Sie beim öffnen mit Reg-OpenKey <\/b>ermittelt haben. Die Deklaration lautet folgendermaßen:<\/p>\n Wenn auch eigentlich nicht nötig, da ohnehin nur ein Parameter übergeben wird, haben wir dennoch auch hier eine Wrapper-Funktion erstellt. Sie liefert den Wert 0 <\/b>zurück, wenn das Schließen gelungen ist, sonst den Wert 6<\/b>:<\/p>\n Nachdem Sie nun wissen, wie Sie Registrypfade anlegen, öffnen, schließen und wieder entfernen, lernen Sie jetzt, wie Sie mit der Funktion RegSetValueEx <\/b>einen Schlüssel hinzufügen und einen Wert dafür angeben. Deklarieren Sie die Funktion RegSetValueEx <\/b>folgendermaßen:<\/p>\n Wenn Sie die Deklaration aufmerksam betrachten, dass der Parameter lpData<\/b> als einziger nicht ByVal<\/b>, sondern ByRef <\/b>übergeben wird und dass als Datentyp Any <\/b>angegeben ist. Dahinter verbergen sich einige Besonderheiten.<\/p>\n Wie bereits weiter oben erwähnt, gibt es in C im Gegensatz zu Visual Basic Parameter, die unterschiedlichen Datentyps sein können. Hier tritt dieser Fall zu Tage: Auch die Schlüsselwerte in der Registry können unterschiedlichen Datentyps sein, zum Beispiel String <\/b>oder Long<\/b>. Unmittelbar vor dem Parameter lpData <\/b>finden Sie aber den Parameter dwType<\/b>. Mit ihm können Sie der API-Funktion mitteilen, welchen Datentyps der Parameter ist. Im Falle der Registry können Sie beispielsweise Zeichenketten (String<\/b>) oder Variablen des Typs Long <\/b>verwenden.<\/p>\n Falls Sie eine Zeichenkette verwenden, heißt die entsprechende Konstante REG_SZ<\/b>. Für Variablen des Datentyps Long <\/b>verwenden Sie die Konstante REG_DWORD<\/b>. Die Konstanten dienen der besseren Handhabung für den menschlichen Benutzer, der mit ihnen sicher mehr anfangen kann als mit den Zahlenwerten, die sich hinter den Konstanten verbergen. Natürlich müssen Sie diese und andere Konstanten deklarieren:<\/p>\n Die API-Funktion verwendet einige Parameter, die von vornherein festgelegt beziehungsweise bei der Ausführung ermittelt werden. Die Funktion aus Listing 4 vereinfacht den Aufruf der Funktion RegSetValueEx<\/b>.<\/p>\n Listing 4: Hilfsfunktion zum Eintragen eines Wertes in die Registry<\/span><\/b><\/p>\n Leider gelingt das Eintragen des Wertes noch nicht wie gewünscht, denn dieser erscheint in einem falschen Zeichensatz (s. Bild 5). Dies korrigieren wir, indem wir die speziell für Zeichenketten geeignete API-Funktion RegSetValueEx_Str <\/b>verwenden:<\/p>\n Bild 5: Neuer Wert mit falscher Codierung<\/span><\/b><\/p>\n Den Aufruf aus der Funktion WertSetzenString <\/b>passen Sie entsprechend an:<\/p>\n Die Funktion erwartet als Eingabeparameter den Hauptpfad, den Pfad, den Namen und den Wert des Schlüssels. Die Funktion hängt zunächst den Wert Chr$(0) <\/b>an den Schlüsselwert an. Das ist erforderlich, damit die API-Funktion das Ende der Zeichenkette erkennen kann.<\/p>\n Der anschließende Aufruf der API-Funktion verwendet die Funktion SchluesselOeffnen<\/b>, um aus dem Hauptpfad und dem Pfad das Handle auf den gewünschten Schlüssel zu ermitteln.<\/p>\n Nach dieser änderung trägt die Funktion den Wert im richtigen Zeichensatz in die Registry ein. Ein Beispielaufruf für das Direktfenster sieht wie folgt aus:<\/p>\n In der Regel kommen Sie mit den folgenden verschiedenen Datentypen aus:<\/p>\n Nachfolgend finden Sie eine Liste der Deklarationen der entsprechenden Konstanten für die Datentypen inklusive Zahlenwerte:<\/p>\n Wie Sie weiter oben gesehen haben, gibt es für das Speichern einer Zahl eine etwas andere Konstante als für das Speichern einer Zeichenkette. Also bauen wir uns eine weitere Wrapper-Funktion, mit der wir zuverlässig Zahlenwerte in der Registry speichern können. Diese heißt WertSetzenLong <\/b>und sieht wie in Listing 5 aus.<\/p>\n Listing 5: Hilfsfunktion zum Eintragen eines Long-Wertes in die Registry<\/span><\/b><\/p>\n Wenn Sie so einen Datumswert speichern wollen, müssen Sie nur dafür Sorge tragen, dass dieser Datumswert im Format des Datentyps \n
![\"Die](\"..\/fileadmin\/_temp_\/2016_03\/pic_1040_002.png\")
<\/p>\nPraxisbeispiel: Shareware mit zeitlicher Begrenzung<\/h2>\n
Konstanten<\/h2>\n
Public <\/span>Const HKEY_CLASSES_ROOT As Long<\/span> = &H80000000<\/pre>\nPublic <\/span>Const HKEY_CURRENT_USER As Long<\/span> = &H80000001\r\nPublic <\/span>Const HKEY_LOCAL_MACHINE As Long<\/span> = &H80000002\r\nPublic <\/span>Const HKEY_USERS As Long<\/span> = &H80000003\r\nPublic <\/span>Const HKEY_CURRENT_CONFIG As Long<\/span> = &H80000005\r\nPublic <\/span>Const REG_STR As Long<\/span> = 1\r\nPublic <\/span>Const REG_OPTION_NON_VOLATILE As Long<\/span> = 0\r\nPublic <\/span>Const REG_SZ As Long<\/span> = 1\r\nPublic <\/span>Const KEY_ALL_ACCESS As Long<\/span> = &H3F\r\nPublic <\/span>Const StringlängeMax As Long<\/span> = 200\r\nPublic <\/span>Const ERROR_SUCCESS As Long<\/span> = 0&\r\nPublic <\/span>Const ERROR_NO_MORE_ITEMS As Long<\/span> = 259&<\/pre>\nPublic <\/span>Enum eRegistryPfade\r\n HKEY_CLASSES_ROOT = &H80000000\r\n HKEY_CURRENT_USER = &H80000001\r\n HKEY_LOCAL_MACHINE = &H80000002\r\n HKEY_USERS = &H80000003\r\n HKEY_CURRENT_CONFIG = &H80000005\r\nEnd Enum<\/pre>\nAnlegen eines Schlüssels<\/h2>\n
Declare Function RegCreateKeyEx _\r\n Lib \"advapi32.dll\" _\r\n Alias \"RegCreateKeyExA\" (_\r\n ByVal hKey As Long<\/span>, _\r\n ByVal lpSubKey As String<\/span>, _\r\n ByVal Reserved As Long<\/span>, _\r\n ByVal lpClass As String<\/span>, _\r\n ByVal dwOptions As Long<\/span>, _\r\n ByVal samDesired As Long<\/span>, _\r\n lpSecurityAttributes As <\/span>SECURITY_ATTRIBUTES, _\r\n phkResult As Long<\/span>, _\r\n lpdwDisposition As Long<\/span>\r\n) As Long<\/span><\/pre>\nPrivate <\/span>Type SECURITY_ATTRIBUTES\r\n nLength As Long<\/span>\r\n lpSecurityDescriptor As Long<\/span>\r\n bInheritHandle As Boolean<\/span>\r\nEnd Type<\/pre>\nPublic Function <\/span>SchluesselErstellen(lngHauptpfad As Long<\/span>, _\r\n Pfad As String<\/span>) As Long<\/span>\r\n...<\/pre>\nPublic Function <\/span>SchluesselErstellen(strHauptpfad As <\/span>eRegistryPfade, strPfad As String<\/span>) As Long<\/span>\r\n Dim <\/span>lngHandle As Long<\/span>\r\n Dim <\/span>secAttrib As <\/span>SECURITY_ATTRIBUTES\r\n RegCreateKeyEx strHauptpfad, strPfad, 0&, \"\", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, secAttrib, lngHandle, 0&\r\n SchluesselErstellen = lngHandle\r\nEnd Function<\/span><\/pre>\n![\"Aufruf](\"..\/fileadmin\/_temp_\/2016_03\/pic_1040_003.png\")
<\/p>\nMsgBox<\/span> SchlüsselErstellen(HKEY_CURRENT_USER, \"SOFTWARE\\Haufe\\Beispiele\\Test\")<\/pre>\n![\"Der](\"..\/fileadmin\/_temp_\/2016_03\/pic_1040_004.png\")
<\/p>\nöffnen eines Schlüssels<\/h2>\n
Declare Function RegOpenKeyEx _\r\n Lib \"advapi32.dll\" _\r\n Alias \"RegOpenKeyExA\" ( _\r\n ByVal hKey As Long<\/span>, _\r\n ByVal lpSubKey As String<\/span>, _\r\n ByVal ulOptions As Long<\/span>, _\r\n ByVal samDesired As Long<\/span>, _\r\n phkResult As Long<\/span>) _\r\nAs Long<\/pre>\nPublic Function <\/span>SchluesselOeffnen(lngHauptpfad As <\/span>eRegistryPfade, strPfad As String<\/span>) As Long<\/span>\r\n Dim <\/span>lngHandle As Long<\/span>\r\n RegOpenKeyEx lngHauptpfad, strPfad, 0, KEY_ALL_ACCESS, lngHandle\r\n SchluesselOeffnen = lngHandle\r\nEnd Function<\/span><\/pre>\n SchluesselOeffnen(HKEY_CURRENT_USER, \"SOFTWARE\\AMVShop\\Beispiele\\Test\")\r\n 3816 <\/pre>\n
Entfernen eines Schlüssels<\/h2>\n
Declare Function RegDeleteKey _\r\n Lib \"advapi32.dll\" _\r\n Alias \"RegDeleteKeyA\" ( _\r\n ByVal hKey As Long<\/span>, _\r\n ByVal lpSubKey As String<\/span> _\r\n) As Long<\/span><\/pre>\nPublic Function <\/span>SchluesselLoeschen(lngHauptpfad As <\/span>eRegistryPfade, strPfad As String<\/span>) As Long<\/span>\r\n Dim <\/span>lngHandle As Long<\/span>\r\n lngHandle = RegDeleteKey(lngHauptpfad, strPfad)\r\n SchluesselLoeschen = lngHandle\r\nEnd Function<\/span><\/pre>\n SchluesselLoeschen(HKEY_CURRENT_USER, \"SOFTWARE\\AMVShop\\Beispiele\\Test\")\r\n0<\/pre>\n
SchluesselLoeschen(HKEY_CURRENT_USER, \"SOFTWARE\\AMVShop\\Beispiele\")\r\n0\r\n SchluesselLoeschen(HKEY_CURRENT_USER, \"SOFTWARE\\AMVShop\")\r\n0<\/pre>\n
Schließen eines Schlüssels<\/h2>\n
Declare Function RegCloseKey _\r\n Lib \"advapi32.dll\" ( _\r\n ByVal hKey As Long<\/span> _\r\n) As Long<\/span><\/pre>\nPublic Function <\/span>SchluesselSchliessen(lngHandle As Long<\/span>) As Long<\/span>\r\n SchluesselSchliessen = RegCloseKey(lngHandle)\r\nEnd Function<\/span><\/pre>\nSetzen eines Schlüsselwertes<\/h2>\n
Declare Function RegSetValueEx _\r\n Lib \"advapi32.dll\" _\r\n Alias \"RegSetValueExA\" ( _\r\n ByVal hKey As Long<\/span>, _\r\n ByVal lpValueName As String<\/span>, _\r\n ByVal Reserved As Long<\/span>, _\r\n ByVal dwType As Long<\/span>, _\r\n lpData As <\/span>Any, _\r\n ByVal cbData As Long<\/span> _\r\n) As Long<\/span><\/pre>\nPublic <\/span>Const REG_OPTION_NON_VOLATILE As Long<\/span> = 0\r\nPublic <\/span>Const REG_SZ As Long<\/span> = 1\r\nPublic <\/span>Const\r\nPublic <\/span>Const KEY_ALL_ACCESS As Long<\/span> = &H3F\r\nPublic <\/span>Const StringlaengeMax As Long<\/span> = 200\r\nPublic <\/span>Const ERROR_SUCCESS As Long<\/span> = 0&\r\nPublic <\/span>Const ERROR_NO_MORE_ITEMS As Long<\/span> = 259&<\/pre>\nPublic Function <\/span>WertSetzenString(lngHauptpfad As <\/span>eRegistryPfade, strPfad As String<\/span>, strSchluesselname As String<\/span>, _\r\n strSchluesselwert As String<\/span>) As Long<\/span>\r\n Dim <\/span>lngHandle As Long<\/span>\r\n Dim <\/span>lngLaenge As Long<\/span>\r\n lngLaenge = Len<\/span>(strSchluesselwert)\r\n strSchluesselwert = strSchluesselwert & Chr$(0)\r\n lngHandle = SchluesselOeffnen(lngHauptpfad, strPfad)\r\n WertSetzenString = RegSetValueEx(lngHandle, strSchluesselname, 0&, REG_SZ, strSchluesselwert, lngLaenge)\r\nEnd Function<\/span><\/pre>\n![\"Neuer](\"..\/fileadmin\/_temp_\/2016_03\/pic_1040_005.png\")
<\/p>\nDeclare Function RegSetValueEx_Str _ Lib \"advapi32.dll\" _ Alias \"RegSetValueExA\" ( _ ByVal hKey As Long<\/span>, _\r\n ByVal lpValueName As String<\/span>, _\r\n ByVal Reserved As Long<\/span>, _\r\n ByVal dwType As Long<\/span>, _\r\n ByVal lpData As String<\/span>, _\r\n ByVal cbData As Long<\/span> _\r\n) As Long<\/span><\/pre>\nWertSetzenString = RegSetValueEx_Str(lngHandle, strSchluesselname, 0&, REG_SZ, strSchluesselwert, lngLaenge)<\/pre>\n
WertSetzenString(HKEY_CURRENT_USER, \"SOFTWARE\\AMVShop\\ Beispiele\", \"Beispieltext\", \"Dies ist ein Beispieltext.\")\r\n 0 <\/pre>\n
Die Registrierungsdatentypen<\/h2>\n
\n
Public <\/span>Const REG_SZ As Long<\/span> = 1\r\nPublic <\/span>Const REG_EXPAND_SZ As Long<\/span> = 2\r\nPublic <\/span>Const REG_BINARY As Long<\/span> = 3\r\nPublic <\/span>Const REG_DWORD As Long<\/span> = 4\r\nPublic <\/span>Const REG_MULTI_SZ As Long<\/span> = 5<\/pre>\nDatumsangaben eintragen<\/h2>\n
Public Function <\/span>WertSetzenLong(lngHauptpfad As <\/span>eRegistryPfade, strPfad As String<\/span>, strSchluesselname As String<\/span>, _\r\n lngSchluesselwert As Long<\/span>) As Long<\/span>\r\n Dim <\/span>lngHandle As Long<\/span>\r\n Dim <\/span>lngLaenge As Long<\/span>\r\n lngLaenge = Len<\/span>(lngSchluesselwert)\r\n lngHandle = SchluesselOeffnen(lngHauptpfad, strPfad)\r\n WertSetzenLong = RegSetValueExA(lngHandle, strSchluesselname, 0&, REG_DWORD, lngSchluesselwert, lngLaenge)\r\nEnd Function<\/span><\/pre>\n