Bis Visual Basic 6.0 war ein Zugriff auf die Registry nur in privaten Teilbereichen möglich. Weiterreichender Zugriff machte den Einsatz des eher unhandlichen Registry-APIs erforderlich. Das .NET Framework macht's einfacher.

Auf dieser Seite

 Registry-Zugriff à la VB
 Registry-Zugriff à la .NET

Registry-Zugriff à la VB

Auch Visual Basic .NET bietet nach wie vor die spracheigenen Funktionen GetSetting, SaveSetting, GetAllSettings und DeleteSetting, die aus klassischen VB-Versionen bekannt sind. Sie erhalten damit lediglich Zugriff auf den Registryzweig HKEY_CURRENT_USER\Software\VB and VBA Program Settings\, wo Sie rein benutzerspezifische Einstellungen Ihrer Anwendungen in der Registry speichern können.

' SCHREIBOPERATIONEN 
' ------------------ 
' Unter HKEY_CURRENT_USER\Software\VB and VBA Program Settings  
' einen Registryschlüssel im Zweig "\Testanwendung\Einstellungen" 
' anlegen: 
SaveSetting("Testanwendung", "Einstellungen", _ 
   "Hintergrund", "Blau") 
' Einen zweiten Schlüssel anlegen: 
SaveSetting("Testanwendung", "Einstellungen", _ 
   "Vordergrund", "Weiss") 
' LESEOPERATIONEN 
' ------------------ 
' Den ersten Schlüssel auslesen 
Debug.WriteLine(GetSetting("Testanwendung", "Einstellungen", _ 
   "Hintergrund")) 
' Die Namen und Werte der Schlüssel im Zweig 
' "\Testanwendung\Einstellungen" ausgeben: 
Dim MySettings(,) As String ' zweidimensionales Array 
Dim i As Integer 
MySettings = GetAllSettings("Testanwendung", "Einstellungen") 
For i = LBound(MySettings, 1) To UBound(MySettings, 1) 
  Debug.WriteLine(MySettings(i, 0) & "=" & MySettings(i, 1)) 
Next 
' LÖSCHOPERATIONEN 
' ------------------ 
'Löschen eines einzelnen Schlüssels: 
DeleteSetting("Testanwendung", "Einstellungen", "Hintergrund") 
' Löschen des Unterzweigs "Einstellungen" 
DeleteSetting("Testanwendung", "Einstellungen") 
' Löschen des gesamten Zweigs "Testanwendung" 
DeleteSetting("Testanwendung")

Registry-Zugriff à la .NET

Die Common Language Runtime (CLR) des .NET Frameworks stellt Ihnen mehrere Klassen zur Verfügung, die im Zusammenspiel den Zugriff auf die sehr viel größere Welt der gesamten Registry deutlich einfacher macht als das Registry-API, das Sie für diesen Zweck unter Visual Basic 6 verwenden mussten (sofern Sie nicht auf Fremdhersteller-Tools zurückgegriffen haben).

In den beiden Klassen Microsoft.Win32.Registry und Microsoft.Win32.RegistryKey finden Sie alle Instrumente, die Sie zum Durchstöbern, Lesen und Schreiben von Registryzweigen und -schlüsseln benötigen. Importieren Sie den Namespace Microsoft.Win32, um sich beim Umgang mit der Registry Tipparbeit zu ersparen:

' Für alle weiteren Beispiele: 
' Namespace "Microsoft.Win32" zur abkürzenden 
' Schreibweise importieren: 
Imports Microsoft.Win32

Die Klasse Registry ist sehr simpel aufgebaut: Sie bietet direkten Zugang zu den Hauptzweigen der Registry. Ihre hierfür angebotenen Objekte ClassesRoot, CurrentConfig, CurrentUser, DynData, LocalMachine, PerformanceData und Users sind bereits alles, was die Klasse anbietet. Jedes dieser Objekte ist vom Typ RegistryKey. In der Klasse RegistryKey ist die Funktionalität für den Registry-Zugriff über das .NET Framework gekapselt. Zugriffsrechte für Registryzweige lassen sich über die Klasse RegistryPermission ermitteln und setzen.

Einen Registryzweig öffnen
Ausgehend von einer Instanz der Klasse RegistryKey werden sie einen Registryzweig üblicherweise zunächst öffnen wollen, um ihn auslesen oder bearbeiten zu können. Hierfür steht die Funktion OpenSubKey zur Verfügung, die wiederum ein Objekt des Typs RegistryKey zurückgibt. Somit können Sie verschachtelte Pfade in der Registry folgendermaßen öffnen:

Dim MeinKey As RegistryKey 
MeinKey = Registry.CurrentUser.OpenSubKey("Software" _ 
  ).OpenSubKey("Schlüssel")

Diesen Weg können Sie sich aber auch einfacher machen: OpenSubKey nimmt auch direkt komplette Pfade an, so dass Sie sich nicht mithilfe verschachtelter OpenSubKey-Anweisungen bis zum letzten Element eines Zweiges durchhangeln müssen:

Dim MeinKey As RegistryKey 
MeinKey = Registry.CurrentUser.OpenSubKey( _ 
 "Software\Schlüssel")

Möchten Sie in den geöffneten Zweig Daten schreiben können, fügen Sie als optionalen zweiten Parameter der Funktion ein True hinzu. Fehlt der Parameter oder ist er zu False gesetzt, erhalten Sie nur Lesezugriff auf den geöffneten Zweig.

Werte auslesen
Möchten Sie einen Wert aus einem Registryschlüssel auslesen, wenden Sie die GetValue-Funktion auf das beim erhaltenen RegistryKey-Objekt an. Als Parameter verwenden Sie dabei den Namen des Schlüssels, dessen Wert Sie auslesen möchten. Als zweiten Parameter können Sie optional einen Wert angeben, den Sie automatisch als Rückgabewert erhalten möchten, falls der Wert des gewünschten Schlüssels nicht ausgelesen werden kann:

Dim MeinKey As RegistryKey 
Dim MeinName As String 
MeinKey = Registry.CurrentUser.OpenSubKey( _ 
   "Software\Microsoft\Windows\" _ 
   & "CurrentVersion\Explorer") 
MeinName = MeinKey.GetValue("Logon User Name", "Metty") 
MeinKey.Close() 
MessageBox.Show("Hallo " & MeinName & "!")

Im obigen Codebeispiel wurde bereits ein weiteres Element der Klasse RegistryKey vorweggenommen: Die Methode Close schließt einen geöffneten Registryzweig.

Tipp:
Um den Standardwert eines Registryzweigs auszulesen, verwenden Sie für den ersten Parameter der Funktion GetValue einen leeren String ("") oder das Pseudoobjekt Nothing.

Werte schreiben und löschen
Nicht minder einfach bietet die RegistryKey-Klasse die Möglichkeit zum Schreiben von Werten an: Ihre Methode SetValue nimmt den Schlüsselnamen selbst sowie den darunter abzulegenden Wert auf. Dabei wird automatisch entschieden, welche Art der registryeigenen Datenspeicherung für den übergebenen Wertetyp am Besten geeignet ist.

Um in einen Registryzweig einen Schlüssel anlegen, ändern oder löschen zu können, ist es erforderlich, den beherbergenden Zweig mit Schreibzugriff zu öffnen. Dafür geben Sie als zweiten Parameter der OpenSubKey-Funktion den Wert True an.

Um bestehende Schlüssel zu löschen, wenden Sie einfach die Methode DeleteValue auf den Schlüsselnamen an (den Standardschlüssel löschen Sie, indem Sie einen leeren String oder das Pseudoobjekt Nothing als Schlüsselnamen verwenden). Fügen Sie optional als zweiten Parameter True hinzu, so wird eine Exception ausgelöst, sofern der zu löschende Schlüssel nicht existierte.

Dim MeinKey As RegistryKey 
' Einen Registryzweig zum Schreiben öffnen 
MeinKey = Registry.CurrentUser.OpenSubKey( _ 
   "Software\Microsoft\Windows\" _ 
   & "CurrentVersion\Explorer", True) 
' Diverse Testschlüssel anlegen 
MeinKey.SetValue("Stringschlüssel", "Testwert") 
MeinKey.SetValue("Integerschlüssel", 65535I) 
' Die angelegten Testschlüssel wieder löschen 
MeinKey.DeleteValue("Stringschlüssel") 
MeinKey.DeleteValue("Integerschlüssel") 
' Den Registryzweig schließen 
MeinKey.Close()

Denken Sie insbesondere nach der Verwendung eines Registryzweigs zum Schreiben von Werten daran, den Zweig nach Verwendung mithilfe der Close-Methode zu schließen! Geöffnete Schlüssel sollten Sie ohnehin generell wieder schließen, sobald Sie sie nicht mehr benötigen. Spätestens zum Zeitpunkt des Schließens werden auch evtl. bisher nur zwischengespeicherte Änderungen aus dem RAM-Cache auf die Festplatte weggespeichert.

Möchten Sie sicherstellen, dass Ihre Änderungen geschrieben werden, obwohl Sie den zugehörigen Zweig noch nicht schließen möchten, verwenden Sie die parameterlose Methode Flush der Klasse RegistryKey für den entsprechenden Zweig.

Anlegen und Löschen von Registryzweigen
Auch zum Anlegen und Löschen von Registryzweigen müssen Sie den beherbergenden Registryzweig in der Funktion OpenSubKey zum Schreiben geöffnet haben.

Ist diese Voraussetzung erfüllt, ist es ein Einfaches (entsprechende Rechte natürlich - wie bisher schon - vorausgesetzt), einen Unterzweig in der Registry anzulegen, zu ändern oder zu löschen: Sie verwenden hierfür einfach die Methode CreateSubKey und die Methode DeleteSubKey unter Übergabe des Namens des anzulegenden bzw. zu löschenden Zweiges. Wie schon bei DeleteValue können Sie auch bei DeleteSubKey optional als zweiten Parameter True übergeben, um eine Exception zu erhalten, falls der zu löschende Zweig nicht existierte.

Dim MeinKey As RegistryKey 
MeinKey = Registry.CurrentUser.OpenSubKey( _ 
   "Software\Microsoft\Windows\" _ 
   & "CurrentVersion\Explorer", True) 
' Einen Unterzweig anlegen 
MeinKey.CreateSubKey("Unterzweig") 
' Den angelegten Unterzweig wieder löschen 
MeinKey.DeleteSubKey("Unterzweig") 
MeinKey.Close()

Auflisten vorhandener Schlüssel und Unterzweige
Haben Sie einen Registryzweig geöffnet, können Sie auch ohne Kenntnis der Namen seiner Unterzweige und Schlüssel über selbige iterieren (beispielsweise für eine rekursive Registrysuche). Dabei helfen Ihnen die RegistryKey-Funktionen GetSubKeyNames und GetValueNames, die Ihnen jeweils ein String-Array zurückliefern, das die gesuchten Namen enthält.

Dim MeinKey As RegistryKey 
Dim i As Integer 
MeinKey = Registry.CurrentUser.OpenSubKey( _ 
   "Software\Microsoft\Windows\" _ 
   & "CurrentVersion\Explorer") 
' Schlüssel dieses Zweigs ermitteln 
Dim ValueNames() As String 
ValueNames = MeinKey.GetValueNames() 
' Namen der Schlüssel ausgeben 
Debug.WriteLine("SCHLÜSSEL:") 
For i = LBound(ValueNames) To UBound(ValueNames) - 1 
  Debug.WriteLine(ValueNames(i)) 
Next 
' Unterzweige dieses Zweigs ermitteln 
Dim SubKeyNames() As String 
SubKeyNames = MeinKey.GetSubKeyNames() 
' Namen der Unterzweige ausgeben 
Debug.WriteLine("UNTERZWEIGE:") 
For i = LBound(SubKeyNames) To UBound(SubKeyNames) - 1 
  Debug.WriteLine(SubKeyNames(i)) 
Next

Statt die Grenzen der so erhaltenen Arrays wie im Beispiel mittels LBound und UBound abzufragen, können Sie auch gleich die Eigenschaften SubKeyCount und ValueCount verwenden: Diese liefern Ihnen die Anzahl von Unterzweigen bzw. Schlüsseln in einem durch das RegistryKey-Objekt repräsentierten Zweig zurück.

Registry-Zugriff übers Netzwerk
Zuletzt soll noch die Funktion OpenRemoteBaseKey vorgestellt werden: Auch sie liefert im Erfolgsfall ein RegistryKey-Objekt zurück. Als ersten Parameter verlangt sie einen der Werte der RegistryHive-Auflistung ein - diese sind namens- und bedeutungsgleich zu den Objekten der Klasse Registry. Als zweiten Parameter geben Sie einfach den Namen des Computers im Netzwerk an, dessen Registry Sie verwenden möchten. Notwendige Rechte vorausgesetzt, können Sie danach mit der Registry des entfernten Rechners ebenso arbeiten wie oben für den lokalen Registryzugriff aufgezeigt.