Rejestr



Wykorzystanie rejestru Windowsa pozwala zapisać i odczytać ustawienia programu. W odróżnieniu do plików INI, nie musimy podawać ścieżki dostępu do rejestru.

OBSŁUGA

Najpierw musimy dodać moduł Registry do sekcji uses. Następnie deklarujemy zmienną np.

var
Reg : TRegistry;

Teraz pora stworzyć obiekt:

Reg := TRegistry.Create;

Zwolnienie zasobów to:

Reg.Free;

Prawidłowy blok kodu, korzystającego z Rejestru powinien wyglądać tak:

Reg := TRegistry.Create; // tworzymy

try
// tu odczytujemy, zapisujemy w rejestrze
finally
Reg.Free; // zwolnij zasoby
end;

Pozwala nam to uniknąć nieciekawych sytuacji, gdyby odczyt/zapis danych nie przebiegł poprawnie nasz kod nie będzie powodował tzw. memory leak'ów.

ODCZYT / ZAPIS

Najpierw trzeba ustawić w którym z 5 [w WinXP, w starszych jest 6] kluczy będziemy operować do wyboru mamy:

HKEY_CLESSES_ROOT
HKEY_CURRENT_USER
HKEY_LOCAL_MACHINE
HKEY_USERS
HKEY_CURRENT_CONFIG
HKEY_DYN_DATA [w Win95, Win98, WinME]

Jeśli ustawienia naszego programu mają być inne dla każdego z użytkowników proponuję operować na HKEY_CURRENT_USER, jeśli nie to HKEY_LOCAL_MACHINE. Ustawienie klucza głównego wygląda tak:

Reg.RootKey := HKEY_LOCAL_MACHINE;

Jeśli niewiecie jak wygląda struktura rejestru to proponuję obejrzeć to programem RegEdit [Start->Uruchom, wpisać regedit i Enter]. Gdy ustawimy już klucz główny, trzeba otworzyć konkretny klucz [czy też gałęź]. Przykładowo :

Reg.OpenKey('SOFTWARE\Microsoft\Windows\CurrentVersion\Run',FALSE);

Pierwszy parametr to gałęź do otwarcia, drugi jeśli na True powoduje utworzenie takiej gałęzi w przypadku gdyby nie było tej, którą podaliśmy. Jeśli boimy się o przypadkowe nadpisanie ważnych informacji w rejetrze możemy skorzystać z Otwarcia-Tylko-Do-Odczytu, czyli:

Reg.OpenKeyReadOnly('SOFTWARE\Microsoft\Windows\CurrentVersion\Run');

W tym kluczu możemy zapisać informację, która spowoduje uruchomienie naszego programu po starcie Windowsa.

Reg.WriteString('NaszProgram','C:\NaszProgram.exe');

W taki sam sposób możemy zapisywać inne dane, zmieniajać nieco procedurę.

Reg.WriteCurrency(Klucz, WartośćCurrency);
Reg.WriteBinaryData(Klucz, Tablica, SizeOf(Tablica));
Reg.WriteBool(Klucz, WartośćBoolean);
Reg.WriteDate(Klucz, WartośćDateTime);
Reg.WriteDateTime(Klucz, WartośćDateTime);
Reg.WriteFloat(Klucz, WartośćFloat);
Reg.WriteInteger(Klucz, WartośćInteger);
Reg.WriteString(Klucz, WartośćString);
Reg.WriteTime(Klucz, WartośćDateTime);

Odczyt informacji odbywa się tak samo, adekwatnie dla każdej zmiennej:

ZmiennaCurrency := Reg.ReadCurrency(Klucz);
ZmiennaInteger := Reg.ReadBinaryData(Klucz, Tablica, SizeOf(Tablica));
ZmiennaBoolean := Reg.ReadBool(Klucz);
ZmiennaDateTime := Reg.ReadDate(Klucz);
ZmiennaDateTime := Reg.ReadDateTime(Klucz);
ZmiennaFloat := Reg.ReadFloat(Klucz);
ZmiennaInteger := Reg.ReadInteger(Klucz);
ZmiennaString := Reg.ReadString(Klucz);
ZmiennaDateTime := Reg.ReadTime(Klucz);

Funkcje te zwracają odczytaną wartość. Najbardziej wyróżnia się tu WriteBinaryData i ReadBinaryData, o ile odczyt/zapis innych wartości jest stosunkowo prosty w BinaryData musimy mieć zadeklarowaną tablicę.

var
Bufor: array[0..127] of Byte;

Teraz możemy przystąpić do odczytu i zapisu BinaryData

Reg.ReadBinaryData(Klucz, Bufor, SizeOf(Bufor));
// zapisze to do Klucza, ciąg binarny o długości 128 bajtów

Reg.WriteBinaryData(Klucz, Bufor, SizeOf(Bufor));
// odczyta to z Klucza, ciąg binarny o max długości 128 bajtów
// funkcja zwaraca zmienną Integer, będąca ilością odczytanych bajtów

Usunięcie jakiejkolwiek wartości w otwartej gałęzi to:

Reg.DeleteValue('NaszProgram');

Usunięcie klucza [nie klucza głównego]:

Reg.DeleteKey(Klucz);

Ale co jeśli chcemy zobaczyć czy dany klucz istnieje?

if Reg.KeyExists(Klucz) then .....

Funkcja zwraca wartość Boolean, True - istnieje, False - nieistnieje. Sprawdzenie czy dany klucz ma pod klucze:

if Reg.HasSubKeys(Klucz) then ....

Jeśli ma możmy sprawdzić jakie. Najpierw jednak

var: Lista: TStringList;

oraz

Lista := TStringList;

odczytujemy wszystkie podklucze wybranego klucza

Reg.GetKeyNames(Lista);

lub odczytujemy wszystkie wartości w kluczu

Reg.GetValueNames(Lista);

teraz przerzucamy to do np. Memo

Memo1.Lines:=Lista;

na koniec zwalniamy

Lista.Free;

Inny sposób utworzenia klucza oprócz

Reg.OpenKey(Klucz, True);

jest

Reg.CreateKey(Klucz);

Gdy wywołamy procedure OpenKey [lub OpenKeyReadOnly] i wykonaliśmy na tym kluczu wybrane przez nas operacje, a chcemy przejść na inny klucz musimy użyć procedure

Reg.CloseKey;

Ponieważ gdy zrobimy coś takiego:

Reg.OpenKey('SOFTWARE\NaszProg', False);
// tu odczytujemy zapisujemy, a potem
Reg.OpenKey('SOFTWARE\InnyProg', False);

spowoduje to w rzeczywistości otwarcie klucza SOFTWARE\NaszProg\SOFTWARE\InnyProg i gdybyśmy użyli zamisat False, True zrobiłby się śmietnik w rejetrze. Więc prawidłowo wygląda to tak:

Reg.OpenKey('SOFTWARE\NaszProg', False);
// tu odczytujemy zapisujemy w SOFTWARE\NaszProg
Reg.CloseKey;
Reg.OpenKey('SOFTWARE\InnyProg', False);
// tu odczytujemy zapisujemy w SOFTWARE\InnyProg
Reg.CloseKey;

Możemy także przenieść jakiś klucz w inne miejsce:

Reg.MoveKey(StaryKlucz, NowyKlucz, CzyUsunąćStary);

gdzie StaryKlucz i NowyKlucz nie muszę chyba tłumaczyć, natomiast gdy ustawimy CzyUsunąćStary na True, po przeniesieniu StaryKlucz zostanie usunięty. Aby zmienić nazwę wartości:

Reg.RenameValue(StaraNazwa, NowaNazwa);

lub podmienić klucz na klucz zapisany w pliku

Reg.ReplaceKey(Klucz, ŚcieżkaPliku, ŚcieżkaPlikuZapasowego);

plik zapasowy zostanie utworzony przed wymianą klucza z niezmienionego jeszcze rejestru, aby można było naprawić to co spsujemy. Przywrócenie klucza z pliku to

Reg.RestoreKey(Klucz, ŚcieżkaPliku);

Zapisanie klucza z rejestru do pliku

Reg.SaveKey(Klucz, ŚcieżkaPliku);

Jeśli zapomnieliśmy jaki mamy aktualny klucz główny to

Reg.CurrentKey - zwraca nam RootKey

Reg.CurrentPath - zwraca nam Klucz, który mamy otwarty

Jak widać rejestr nie jest głupią sprawą i warto znać jego obsługę, która i tak niejest specjalnie skomplikowana.





...powrót