Registry

dEUs

hi,
weil die Frage nach der Registry ziemlich oft kommt, schreib ich mal nen Beitrag für die FAQ.

Schlüssel-Funktionen:

Registry-Schlüssel ("Ordner") erstellen/öffnen:

HKEY hKey;
RegCreateKeyEx(HKEY_CURRENT_USER,"Test",0,0,REG_OPTION_NON_VOLATILE,KEY_ALL_ACCESS,NULL,&hKey,0);

Dieser Code erstellt den Schlüsssel "HKEY_CURRENT_USER\Test\" in der Registry. Wenn der Schlüssel schon existiert, wird er nicht neu erstellt, sondern nur geöffnet. Wenn ein Schlüssel mit RegCreateKeyEx erstellt wird, darf nur die unterste ebene nciht vorhanden sein. Weil ich nciht richtig erklären kann, hier ein Beispiel:

folgende hierarchie besteht bereits:
HKEY_CURRENT_USER\Software\Microsoft\

somit ist folgender code nicht zulässig,

HKEY hKey;
RegCreateKeyEx(HKEY_CURRENT_USER,"Software\\Microsoft\\Test1\\Test2",0,0,REG_OPTION_NON_VOLATILE,KEY_ALL_ACCESS,NULL,&hKey,0);

weil der Ordner Test1 noch nicht vorhanden ist. Man kann also immer nur einen Ordner pro aufruf erstellen.
Dieser Code ist aber zulässig, weil nur ein Ordner erstellt wird:

HKEY hKey;
RegCreateKeyEx(HKEY_CURRENT_USER,"Software\\Microsoft\\Test1",0,0,REG_OPTION_NON_VOLATILE,KEY_ALL_ACCESS,NULL,&hKey,0);

Die Funktionen RegOpenKey wird nicht mehr verwendet, an ihrer Stelle wird die Funktion RegOpenKeyEx benutzt. Sie öffnet den Schlüssel nur. Sie erstellt ihn nicht, wenn er noch nicht existiert.

Registry-Schlüssel löschen:

RegDeleteKey(HKEY_CURRENT_USER,"Software\\Microsoft\\Test1\\Test2);

dieser Code löscht nur den Schlüssel Test2.
Unter Win9x hätte man statt "Software\\Microsoft\\Test1\\Test2" auch "Software\\Microsoft\" angeben können, dann wäre der Schlüssel "Micrososft" samt Unterschlüssel gelöscht worden. Unter WinNT darf der zu löschende Schlössel keine Unterschlüssel besitzen!

Jeder geöffnete Schlüssel muss wieder geschlossen werden, wenn er nicht mehr benötigt wird:

RegCloseKey(hKey);

Wert-Funktionen

Werte erstellen:

BYTE cString[]="Hallo, das ist der eigentliche Wert, der unter dem Namen EintragsName gespeicehrt wird";
RegSetValueEx(hKey,"EintragsName",0,REG_SZ,cString,strlen(cString)+1);

(BYTE ist als unsigned char definiert)

Dieser Code speichert, in dem Schlüssel auf den hKey zeigt, den Wert "Hallo, das ist der eigentliche Wert, der unter dem Namen EintragsName gespeicehrt wird" unter dem Namen "EintragsName".
Der vierte Parameter gibt an, welchen Typ der zu speichernde Wert hat.
Die wichtigsten Werte sin:

REG_BINARY - Binärdaten in jeder Form.
REG_DWORD - Eine 32-bit Zahl.
REG_SZ - Ein nullterminierter String

Wenn man ein Zahl speichern will, sieht der Code so aus:

DWORD dwNumber=150;
RegSetValueEx(hKey,"EintragsName",0,REG_DWORD,(BYTE*)&dwNumber,sizeof(DWORD));

für Binärdaten kann ich keinen Code liefern, weil ich das noch nie benutzt hab und deswegen nciht weiss, wie man es benutzt

Werte auslesen:

Liest eine Zahl aus:

DWORD dwNumber = 0;
DWORD dwData = sizeof(DWORD);
RegQueryValueEx(hKey,"EintragsName",0,0,(BYTE*)&dwNumber,&dwData);

Liest einen String aus:

DWORD dwData = 256;
BYTE cDaten[256] = "";
RegQueryValueEx(hKey,"EintragsName",0,0,cDaten,&dwData2);

der letzte parameter gibt die grösse des buffers an, in den die daten gelesen werden (vorletzter parameter)

Werte löschen:

RegDeleteValue(hKey,"EintragsName");

löscht den Wert "EintragsName" aus dem Schlüssel, auf den hKey zeigt.

Die Enum-Funktionen:

Sowohl die Funktion RegEnumKeyEx als auch die Funktion RegEnumValue liefern bei jedem aufruf ein Unterelement in beliebiger Reihenfolge (nicht alphabethisch sortiert) zurück und ERROR_NO_MORE_ITEMS, wenn jedes Element bereits einmal zurückgegeben wurde.

ich mach für beide Funktionen einfach ein kleines Beispiel.

RegEnumKeyEx:

Gegeben sei folgende Hierarchie:
HKEY_CURRENT_USER
|-Unterschlüssel1
|-Unterschlüssel2
|-Unterschlüssel3
|-Unterschlüssel4

int i=0;
int iLastError=0;
do
{
   char cName[256] = "";
   iLastError = 0;
   DWORD dwData = 256;
   iLastError = RegEnumKeyEx(hKey,i,cName,&dwData,0,0,0,0);
   ++i;
}while(iLastError!=ERROR_NO_MORE_ITEMS);

bei jedem schleifendurchlauf steht in cName einer der vier Unterschlüsselnamen:
"Unterschlüssel1"
"Unterschlüssel2"
"Unterschlüssel3"
"Unterschlüssel4"

es ist aber nicht festgelegt, welcher wann drinnesteht.

RegEnumValue:

Gegeben sei folgende Hierarchie:
Schlüssel
|-Eintrag1
|-Eintrag2
|-Eintrag3
|-Eintrag4

int i=0;
int iLastError=0;
do
{
   char cValueName[256] = "";
   DWORD dwValueName = 256;
   DWORD ValueType = 0;
   BYTE cValueData[256] = "\0";
   DWORD dwValueData = 256;
   iLastError = RegEnumValue(hKey,i,cValueName,&dwValueName,0,&ValueType,cValueData,&dwValueData);
   ++i;
}while(iLastError!=ERROR_NO_MORE_ITEMS);

bei jedem schleifendurchlauf steht in cValueName einer der vier Eintragsnamen:
"Eintrag1"
"Eintrag2"
"Eintrag3"
"Eintrag4"

Es ist aber nicht festgelegt, welcher wann drinnesteht.
In den restlichen Variablen stehen dem Eintragsnamen entsprechend die einzelnen Daten drinn.

Ich denke, dass waren mal die wichtigsten...
wenn jemand noch eine zusätzliche Funktion erklärt will, bitte fragen.