Delphi работа с реестром windows 10

Поскольку в прошлом посте про загрузку / парсинг HTML страницы с помощью библиотеки MSHTML мне пришлось бороться со всплывающим окном методом замены значений в реестре Windows, отвечающего за настройки IE, то в данном посте решил освежить минимальные навыки работы с реестром, а именно – чтение / запись.

Итак, подключаем модули в uses

Если заглянуть в него, то можно обнаружить несколько полезных классов

Наша задача

Прочитать из реестра

значение переменной 1A10 и записать какое-то свое значение.

Первым делом посмотрим в редакторе реестра (regedit) какого типа наша переменная?

Переменная типа DWORD!!!

В сети увидел такую информацию на одном из форумов.

An integer type represents a subset of the whole numbers. The generic integer types are Integer and Cardinal; use these whenever possible, since they result in the best performance for the underlying CPU and operating system. The table below gives their ranges and storage formats for the current 32-bit Delphi compiler.Generic integer types for 32-bit implementations of Delphi
Type Range Format
Integer -2147483648..2147483647 signed 32-bit
Cardinal 0..4294967295 unsigned 32-bit
Fundamental integer types include Shortint, Smallint, Longint, Int64, Byte, Word, and Longword.Fundamental integer types
Type Range Format
Shortint -128..127 signed 8-bit
Smallint -32768..32767 signed 16-bit
Longint -2147483648..2147483647 signed 32-bit
Int64 -2^63..2^63-1 signed 64-bit
Byte 0..255 unsigned 8-bit
Word 0..65535 unsigned 16-bit
Longword 0..4294967295 unsigned 32-bit

К чему я озаботился типом переменной? А все просто, чтобы корректно прочитать её в Delphi – нам нужно знать каким методом читать из реестра. Если внимательно изучить модуль Registry, то в нем можно увидеть несколько различных методов чтения…

С учетом всего этого многообразия, нам нужно выбрать какой-то метод. Нам подходит Readinteger, так как наша переменная не превосходит 2147483647. Согласно описанию EricLaw, она меняется в диапазоне т 0 до 3!

Как прочитать из реестра?

Как записать в реестр?

//Запишем, например, число 2

Результат

This entry was posted in Delphi, Без рубрики and tagged Реестр Windows. Bookmark the permalink.

26.09.2009 в 18:23 | Опубликовано в Программирование, Статьи | Оставьте комментарий

TRegistry. Работа с реестром Windows в Delphi.

Что такое реестр Windows?

Реестр Windows – это иерархически построенная база настроек и параметров операционной системы Windows. Реестр содержит в себе настройки программ, информацию об аппаратном обеспечении компьютера, индивидуальные настройки профилей пользователей Windows. Почти все данные реестра находятся в основном на винчестере компьютера.

Реестр состоит из следующих разделов:

HKEY_CURRENT_USER
HKEY_USERS
HKEY_LOCAL_MACHINE
HKEY_CLASSES_ROOT
HKEY_CURRENT_CONFIG
HKEY_DYN_DATA(этот раздел имеется только в Windows 9X/Me, поэтому мы его рассматривать не будем).
HKEY_PERFORMANCE_DATA

Теперь более подробно рассмотрим каждый раздел, и что он в себе хранит.

HKEY_CURRENT_USER

В этом разделе реестра хранятся настройки текущего пользователя Windows. Является подразделом HKEY_USERS.

HKEY_USERS

В данном разделе хранятся настройки всех активных пользователей системы.

HKEY_LOCAL_MACHINE

В этом разделе хранятся настойки конфигурации компьютера, относящиеся ко всем пользователям.

HKEY_CLASSES_ROOT

Этот раздел является подразделом HKEY_LOCAL_MACHINE\Software\Classes. В нем хранится информация о зарегистрированных типах файлов, а также об объектах COM и ActiveX.

HKEY_CURRENT_CONFIG

В этом разделе содержится информация о профиле оборудования, используемом локальным компьютером при запуске системы.

HKEY_PERFORMANCE_DATA

В этом разделе реестра хранятся счетчики производительности системы, и еще довольно большое количество подобной информации. В редакторе реестра (regedit) этот раздел не отображается. Данные этого раздела реестра хранятся не на винчестере, а в памяти компьютера.

Более подробную информацию о разделах реестра можно найти на сайте Microsoft:

Реестр состоит из так называемых ульев(hive, иногда переводят на русский как «куст»), которые являются множеством разделов и параметров(ключей) реестра.

В Delphi работа с реестром Windows осуществляется с помощью класса TRegistry, находящегося в модуле Registry. Класс TRegistry является прямым наследником от класса TObject.

Теперь рассмотрим свойства и методы класса TRegistry.

Методы Create.

1.

Объявлен как:

constructor Create; overload;

Создаёт объект класса TRegistry для работы с реестром Windows. Свойству Access присваивается значение KEY_ALL_ACCESS.

Пример:

uses Registry;

procedure RegistryProc;
var
  Reg: TRegistry;
begin
  Reg := TRegistry.Create;
  try 
    { Производим действия с реестром }
  finally
    Reg.Free;
  end;
end;

2.

Объявлен как:

constructor Create(AAccess: LongWord); overload;

Создает объект класса TRegistry, устанавливает свойство Access в значение параметра AAccess.

Пример:

uses Registry;

procedure RegistryProc;
var
  Reg: TRegistry;
begin
  { Только чтение }
  Reg := TRegistry.Create(KEY_READ); 
  try 
    { Производим действия с реестром }
  finally
    Reg.Free;
  end;
end;

Свойство Access.

Объявлено как:

property Access: LongWord;

Свойство Access используется для указания уровня безопасности при открытии ключей реестра.

Возможны следующие значения:

KEY_QUERY_VALUE

Это значение свойства Access разрешает чтение данных из ключей реестра.

KEY_ENUMERATE_SUB_KEYS

Разрешает нумерацию ключей реестра.

KEY_NOTIFY

Данное значение предоставляет возможность получать уведомления об изменениях в реестре.

KEY_SET_VALUE

Разрешает запись данных в реестр.

KEY_CREATE_SUB_KEY

Разрешает создание подключей.

KEY_CREATE_LINK

Разрешает создание символической ссылки.

KEY_READ

Комбинация значений: KEY_QUERY_VALUE, KEY_ENUMERATE_SUB_KEYS, KEY_NOTIFY.

KEY_WRITE

Комбинация двух значений: KEY_SET_VALUE и KEY_CREATE_SUB_KEY.

KEY_EXECUTE

Разрешает доступ только для чтения. Равняется KEY_READ.

KEY_ALL_ACCESS

Комбинация следующих значений: KEY_READ, KEY_WRITE, KEY_CREATE_LINK.

Свойство RootKey.

Объявлено как:

property RootKey: HKEY;

Используется для указания корневого раздела реестра. При создании объекта класса TRegistry этому свойству присваивается значение HKEY_CURRENT_USER.
Пример:

uses Registry;

procedure RegistryProc;
var
  Reg: TRegistry;
begin
  Reg := TRegistry.Create;
  try 
    Reg.RootKey := HKEY_LOCAL_MACHINE;
    { производим еще какие-то действия с реестром }
  finally
    Reg.Free;
  end;
end;

Метод CreateKey.

Объявлен как:

function CreateKey(const Key: string): Boolean;

Функция CreateKey создает в реестре ключ Key. Если создание ключа прошло успешно функция вернет true, иначе будет поднято исключение ERegistryException, поэтому настоятельно рекомендую все вызовы CreateKey заключать в блоки try..except(finally).

Пример:

uses Registry;

procedure RegistryProc;
var
  Reg: TRegistry;
begin
  Reg := TRegistry.Create;
  try 
    Reg.RootKey := HKEY_LOCAL_MACHINE;
    Reg.CreateKey('Software\MyProg');
    { производим еще какие-то действия с реестром }
  finally
    Reg.Free;
  end;
end;

Метод OpenKey.

Объявлен как:

function OpenKey(const Key: string; CanCreate: Boolean): Boolean;

Функция OpenKey открывает ключ Key. Если CanCreate равно true, то если ключ, указанный в Key не найден, то он будет создан. Функция вернет true, если открытие ключа прошло успешно.

Пример:

uses Registry;

procedure RegistryProc;
var
  Reg : TRegistry;
begin
  Reg := TRegistry.Create;
  try 
    Reg.RootKey := HKEY_LOCAL_MACHINE;
    Reg.OpenKey('Software\MyProg', true); 
	{ если ключ Software/MyProg не будет найден, то он в свою очередь будет создан
      производим еще какие-то действия с реестром }
  finally
    Reg.Free;
  end;
end;

Метод OpenKeyReadOnly.

Объявлен как:

function OpenKeyReadOnly(const Key: String): Boolean;

Открывает ключ Key только для чтения, со значением свойства Access равному KEY_READ. Функция возвращает true, если ключ удалось открыть.

Пример:

uses Registry;

procedure RegistryProc;
var
  Reg : TRegistry;
begin
  Reg := TRegistry.Create;
  try 
    Reg.RootKey := HKEY_LOCAL_MACHINE;
    Reg.OpenKeyReadOnly('Software\MyProg'); 
	{ если ключ Software/MyProg не будет найден, то функция вернет false
      производим еще какие-то действия с реестром }
  finally
    Reg.Free;
  end;
end;

Свойства CurrentKey и CurrentPath.

Объявлены как:

    property CurrentKey: HKEY read FCurrentKey;

    property CurrentPath: string read FCurrentPath;

Свойство CurrentKey содержит в себе дескриптор ключа реестра, который в данный момент открыт. Изменяется при вызове методов OpenKey и OpenKeyReadOnly. Данное свойство записи не подлежит, то есть, является read-only свойством. Если Вы не выходите за рамки действия созданного экземпляра TRegistry, то это свойство Вам вряд ли понадобится.

Свойство CurrentPath содержит путь к ключу реестра, который в данный момент открыт. Аналогично CurrentKey это read-only свойство. CurrentPath автоматически изменяется при открытии другого ключа.

Пример:

По нажатию кнопки появляется сообщение с информацией о текущем открытом ключе реестра.

uses Registry;

procedure TForm1.Button1Click(Sender: TObject);
var
  Reg: TRegistry;
begin
  Reg := TRegistry.Create;
  try 
    Reg.RootKey := HKEY_LOCAL_MACHINE;
    Reg.OpenKeyReadOnly('Software\MyProg'); 
    ShowMessage(Reg.CurretPath);
  finally
    Reg.Free;
  end;
end;

Методы WriteString, ReadString.

Объявлены как:

procedure WriteString(const Name, Value: string);

function ReadString(const Name: string): string;

Процедура WriteString пишет в открытый ключ реестра(CurrentPath) параметр с именем Name и строковым значением Value.

Функция ReadString читает из открытого ключа параметр с именем Name. Если ключ не найден, то функция вернет пустую строку, иначе, прочитанное из реестра строчное значение.

Пример:

По нажатию первой кнопки пишем в реестр строковый параметр, а при нажатии на вторую кнопку его читаем и показываем в сообщении.

uses Registry;

procedure TForm1.Button1Click(Sender: TObject);
var
  reg: TRegistry;
begin
  reg := TRegistry.Create;
  try
    reg.RootKey := HKEY_LOCAL_MACHINE;
    reg.OpenKey('Software\MyProgram', true);
    reg.WriteString('Str1', 'Реестр, превед:)');
  finally
    reg.Free;
  end;
end;

procedure TForm1.Button2Click(Sender: TObject);
var
  reg: TRegistry;
begin
  reg := TRegistry.Create;
  try
    reg.RootKey := HKEY_LOCAL_MACHINE;
    reg.OpenKey('Software\MyProgram', true);
    ShowMessage(reg.ReadString('Str1'));
  finally
    reg.Free;
  end;
end;

Метод WriteExpandString.

Объявлен как:

procedure WriteExpandString(const Name, Value: string);

Процедура аналогична WriteString, только пишет в реестр так называемые «широкие»(не путать с Unicode!) строки, которые чаще всего описывают переменные окружения Windows, например «%PATH%».

Пример:
См. Пример к методам WriteString/ReadString.

Методы WriteInteger, ReadInteger.

Объявлены как:

    procedure WriteInteger(const Name: string; Value: Integer);

    function ReadInteger(const Name: string): Integer;

Процедура WriteInteger пишет в открытый ключ реестра параметр с именем Name и целочисленным значением Value.

Функция ReadInteger читает из открытого ключа параметр с именем Name. Если ключ не найден, то будет поднято исключение типа ERegistryException, иначе, прочитанное из реестра целочисленное значение.

Пример:
См. Пример к методам WriteString/ReadString.

Методы WriteFloat, ReadFloat.

Объявлены как:

procedure WriteFloat(const Name: string; Value: Double);

function ReadFloat(const Name: string): Double;

Процедура WriteFloat пишет в открытый ключ реестра параметр с именем Name и значением в виде натурального числа Value.

Функция ReadFloat читает из открытого ключа параметр с именем Name. Если ключ не найден, то будет поднято исключение типа ERegistryException, иначе, прочитанное из реестра натуральное число.

Пример:
См. Пример к методам WriteString/ReadString.

Методы WriteBool, ReadBool.

Объявлены как:

    procedure WriteBool(const Name: string; Value: Boolean);

    function ReadBool(const Name: string): Boolean;

Процедура WriteBool пишет в открытый ключ реестра параметр с именем Name и булевым значением Value.

Функция ReadBool читает из открытого ключа параметр с именем Name. Если ключ не найден, то будет поднято исключение типа ERegistryException, иначе, прочитанное из реестра булево значение.

Пример:
См. Пример к методам WriteString/ReadString.

Методы WriteCurrency, ReadCurrency.

Объявлены как:

procedure WriteCurrency(const Name: string; Value: Currency);

function ReadCurrency(const Name: string): Currency;

Процедура WriteCurrency пишет в открытый ключ реестра параметр с именем Name и денежным значением Value.

Функция ReadCurrency читает из открытого ключа параметр с именем Name. Если ключ не найден, то будет поднято исключение типа ERegistryException, иначе, прочитанное из реестра денежное значение.

Пример:
См. Пример к методам WriteString/ReadString.

Методы WriteDate, ReadDate.

Объявлены как:

    procedure WriteDate(const Name: string; Value: TDateTime);
 
    function ReadDate(const Name: string): TDateTime;

Процедура WriteDate пишет в открытый ключ реестра дату с именем Name.

Функция ReadDate читает из открытого ключа параметр с именем Name. Если ключ не найден, то будет поднято исключение типа ERegistryException, иначе, функция вернет прочитанную дату.

Пример:
См. Пример к методам WriteString/ReadString.

Методы WriteTime, ReadTime.

Объявлены как:

procedure WriteTime(const Name: string; Value: TDateTime);

function ReadTime(const Name: string): TDateTime;

Процедура WriteTime пишет в открытый ключ реестра параметр со значением типа время и с именем Name.

Функция ReadTime читает из открытого ключа параметр с именем Name. Если ключ не найден, то будет поднято исключение типа ERegistryException, иначе, функция вернет прочитанное время.

Пример:
См. Пример к методам WriteString/ReadString.

Методы WriteDateTime, ReadDateTime.

Объявлены как:

procedure WriteDateTime(const Name: string; Value: TDateTime);
    
function ReadDateTime(const Name: string): TDateTime;

Процедура WriteDateTime пишет в открытый ключ реестра параметр с именем Name и значением в виде дата + время.

Функция ReadDateTime читает из открытого ключа параметр с именем Name. Если ключ не найден, то будет поднято исключение типа ERegistryException, иначе, функция вернет прочитанную дату и время.

Примечание: На самом деле методы WriteDate, ReadDate, WriteTime, ReadTime просто вызывают в своём теле Write(Read)DateTime с соответствующими параметрами.

Пример:
См. Пример к методам WriteString/ReadString.

Методы WriteBinaryData, ReadBinaryData.

Объявлены как:

procedure WriteBinaryData(const Name: string; var Buffer; BufSize: Integer);

function ReadBinaryData(const Name: string; var Buffer; BufSize: Integer): Integer;

Процедура WriteBinaryData записывает в открытый на данный момент ключ реестра в параметр с именем Name данные в HEX виде из буфера Buffer, размером BufSize. При ошибке записи будет поднято исключение ERegistryException.

Функция ReadBinaryData читает из открытого в данный момент ключа шестнадцатеричные данные размером BufSize из параметра с именем Name в буфер Buffer. Размер буфера должен быть больше или равен размеру читаемых данных, иначе будет возбуждено исключение типа ERegistryException. Результатом работы функции является размер прочитанных данных.

Пример:

По нажатию первой кнопки в реестр пишется массив байт, а по нажатию второй – читается оттуда.

uses Registry;

{ Объявим тип нашего буфера }
type
  TBuff = array [1..256] of Byte;

{ пишем данные в реестр }
procedure TForm1.Button1Click(Sender: TObject);
var
  reg: tregistry;
  buf: TBuff;
  i: Integer;
begin
  reg := TRegistry.Create;
  try
    reg.RootKey := HKEY_LOCAL_MACHINE;
    reg.OpenKey('Software\MyProgram', true);
    for i := 1 to length(buf) do
      buf[i] := random(256); 
	  { заполняем наш буфер случайными значениями }
    reg.WriteBinaryData('bin', buf, SizeOf(TBuff));
  finally
    reg.Free;
  end;
end;

//читаем
procedure TForm1.Button6Click(Sender: TObject);
var
  reg: tregistry;
  buf: TBuff;
begin
  reg := TRegistry.Create;
  try
    reg.RootKey := HKEY_LOCAL_MACHINE;
    reg.OpenKey('Software\MyProgram', true);
    reg.ReadBinaryData('bin', buf, SizeOf(TBuff));
  finally
    reg.Free;
  end;
end;

Метод DeleteKey.

Объявлен как:

function DeleteKey(const Key: string): Boolean;

Удаляет ключ, указанный в Key, а также все подключи и параметры из него. Если всё прошло успешно функция вернет true, иначе false.

Пример:

uses Registry;

procedure RegistryProc;
var
 reg: TRegistry;
begin
  reg := TRegistry.Create;
  try
    reg.RootKey := HKEY_LOCAL_MACHINE;
    reg.DeleteKey('Software\MyProgram');
  finally
    reg.Free;
  end;
end;

Метод DeleteValue.

Объявлен как:

function DeleteValue(const Name: string): Boolean;

Удаляет из текущего открытого ключа параметр Name. Если всё прошло успешно то функция вернет true, иначе false.

Пример:

uses Registry;

var
 reg: TRegistry;
begin
  reg := TRegistry.Create;
  try
    reg.RootKey := HKEY_LOCAL_MACHINE;
    reg.DeleteValue ('Value1');
  finally
    reg.Free;
  end;
end;

Метод GetKeyInfo.

Объявлен как:

function GetKeyInfo(var Value: TRegKeyInfo): Boolean;

С помощью этой функции можно получить информацию о текущем ключе. Единственный параметр функции Value представляет собой следующую структуру:

  TRegKeyInfo = record
    NumSubKeys: Integer;
    MaxSubKeyLen: Integer;
    NumValues: Integer;
    MaxValueLen: Integer;
    MaxDataLen: Integer;
    FileTime: TFileTime;
  end;

После вызова функция вернет true в случае успеха и занесет всю нужную информацию в переданную в параметре Value структуру, иначе вернет false.

Теперь разберем, что представляет из себя структура TRegKeyInfo, и для чего нужны её поля:

NumSubKeys

Количество подключей.

MaxSubKeyLen

Максимальная длина имени подключа.

NumValues

Количество параметров.

MaxValueLen

Максимальная длина имени параметра.

MaxDataLen

Максимальный размер записанных данных.

FileTime

Время последнего обновления ключа.

Пример:

uses registry;

procedure RegistryProc;
var
  reg: TRegistry;
  info: TRegKeyInfo;
begin
  reg := TRegistry.Create;
  try
    reg.RootKey := HKEY_LOCAL_MACHINE;
    reg.OpenKey('Software\MyProgram', true);
    reg.GetKeyInfo(info);
  finally
    reg.Free;
  end;
end;

Метод GetDataInfo.

Объявлен как:

    function GetDataInfo(const ValueName: string; var Value: TRegDataInfo): Boolean;

Получает информацию о параметре с именем ValueName. Заносит её в структуру Value типа TRegDataInfo.

  TRegDataInfo = record
    RegData: TRegDataType;
    DataSize: Integer;
  end;

Поле структуры RegData представляет из себя следующий тип:

TRegDataType = (rdUnknown, rdString, rdExpandString, rdInteger, rdBinary);

Теперь о возможных значениях типа TRegDataType.

rdUnknown

Неизвестный тип.

rdString

Строка.

rdExpandString

«Широкая» строка (см. метод WriteExpandString).

rdInteger

Целое число.

rdBinary

Любые двоичные данные(записываемые например процедурой WriteBinaryData).

Нужен этот тип для определения типа записанных в параметре данных. Второе поле структуры TRegDataInfo – DataSize. Это размер значения параметров в байтах.

Пример:

uses Registry;

procedure RegistryProc;
var
  reg: TRegistry;
  info: TRegDataInfo;
begin
  reg := TRegistry.Create;
  try
    reg.RootKey := HKEY_LOCAL_MACHINE;
    reg.OpenKey('Software\MyProgram', true);
    reg.WriteString('str1', 'String'); 
	{ пишем какую-то строку. }
    reg.GetDataInfo('str1', info); 
	{ получаем о ней информацию }
  finally
    reg.Free;
  end;
end;

Метод GetDataSize.

Объявлен как:

function GetDataSize(const ValueName: string): Integer;

Узнает размер значения параметра реестра с именем ValueName. Возвращает размер в байтах.
На самом деле эта функция просто вызывает в своем теле GetDataInfo и возвращает параметр DataSize структуры TRegDataInfo.

Пример:
См. пример к методу GetDataInfo.

Метод GetDataType.

Объявлен как:

function GetDataType(const ValueName: string): TRegDataType;

Вызывает функцию GetDataInfo, для параметра ValueName, и возвращает поле RegData структуры TRegDataInfo.

Пример:
См. пример к методу GetDataInfo.

Метод RenameValue.

Объявлен как:

procedure RenameValue(const OldName, NewName: string);

Переименовывает ключ OldName в NewName. Значение параметра остается прежним.
Примечание: на самом деле просто создается новый ключ, и в него копируется значение из старого, после чего последний удаляется. Для выполнения функции необходимо наличие ключа OldName.

Пример:

uses Registry;

procedure RegistryProc;
var
  reg: TRegistry;
begin
  reg := TRegistry.Create;
  try
    reg.RootKey := HKEY_LOCAL_MACHINE;
    reg.OpenKey('Software\MyProgram', true);
    reg.WriteString('str1', 'String'); 
	{ пишем какую-то строку. }
    Reg.RenameValue('str1', 'str2');
	{ переименовываем в str2 }
  finally
    reg.Free;
  end;
end;

Метод GetKeyNames.

Объявлен как:

procedure GetKeyNames(Strings: TStrings);

Записывает в параметр Strings имена всех подключей текущего открытого ключа.

Пример:

Положите на форму кнопку и TMemo.

OnClick кнопки:

procedure TForm1.Button1Click(Sender: TObject);
var
  reg: tregistry;
  i: integer;
begin
  reg := TRegistry.Create;
  try
    reg.RootKey := HKEY_LOCAL_MACHINE;
    reg.OpenKey('Software\MyProgram', true);
    for i := 0 to 9 do
      reg.CreateKey('SubKey' + IntToStr(i)); 
	  { создаем подключи }
    reg.GetKeyNames(Memo1.Lines);
  finally
    reg.Free;
  end;
end;

В результате в Memo1 получим следующий список:

SubKey0
SubKey1
SubKey2
SubKey3
SubKey4
SubKey5
SubKey6
SubKey7
SubKey8
SubKey9

Метод GetValueNames.

Объявлен как:

procedure GetValueNames(Strings: TStrings);

Получает список всех параметров текущего ключа и заносит их в Strings. Параметры подключей в список не включаются.

Пример:
См. Пример к методы GetKeyNames.

Метод HasSubKeys.

Объявлен как:

function HasSubKeys: Boolean;

Эта функция проверяет наличие подключей в текущем открытом ключе. Если хоть один подключ существует, то функция вернет true, иначе false.
Примечание: на самом деле функция HasSubKey вызывает в своем теле метод GetKeyInfo, и если она в структуре TRegKeyInfo возвращает поле NumSubKeys, которое больше 0, то тогда HasSubKey и возвращает true.

Метод KeyExists.

Объявлен как:

function KeyExists(const Key: string): Boolean;

Проверяет наличие ключа по указанному в Key пути. Если ключ существует, то вернет true, иначе вернет false.

Пример:

procedure TForm1.Button1Click(Sender: TObject);
var
  reg: TRegistry;
begin
  reg := TRegistry.Create;
  try
    reg.RootKey := HKEY_LOCAL_MACHINE;
    reg.OpenKey('Software\MyProgram', true);
    reg.CreateKey('SubKey');
    if reg.KeyExists('SubKey') then
      ShowMessage('Ключ SubKey найден')
    else
      ShowMessage('Ключ SubKey не найден');
  finally
    reg.Free;
  end;
end;

Примечание к примеру: в нашем случае всегда будет показано сообщение о том, что ключ найден, так как перед вызовом KeyExists мы его создаем.

Метод ValueExists.

Объявлен как:

function ValueExists(const Name: string): Boolean;

Проверяет наличие параметра с именем Name в текущем открытом ключе. Если параметр существует, то функция вернет true, иначе вернет false.

Пример:
См. Пример к методу KeyExists.

Метод CloseKey.

Объявлен как:

procedure CloseKey;

CloseKey записывает измененные данные, после чего закрывает текущий ключ. Некоторые методы чтения / записи вызывают в себе CloseKey сразу после произведенных действий.

Примечание: Ключ реестра следует закрывать сразу же как с ним проведены все необходимые действия. Не держите ключ подолгу открытым. Лучше закройте его, а когда он потребуется, вновь откройте.

Свойство LazyWrite.

Объявлено как:

property LazyWrite: Boolean read FLazyWrite write FLazyWrite;

LazyWrite используется для указания того, как ключи должны быть записаны в реестр.
При создании объекта TRegistry это свойство равно true.
Если LazyWrite истинно(true), то система сама решает, когда лучше записать данные на диск. Сначала все данные помещаются в оперативную память.
Когда LazyWrite равняется false, ключи записываются на диск немедленно, что может достаточно сильно нагрузить систему, поэтому я советую вам использовать LazyWrite(false) только в самых крайних случаях.

Метод MoveKey.

Объявлен как:

procedure MoveKey(const OldName, NewName: string; Delete: Boolean);

Переносит ключ OldName, все его подключи и параметры в ключ NewName. Процедура сойдает новый ключ(NewName) и рекурсивно переносит в него все подключи и параметры из OldName. Если Delete равняется true, то старый ключ будет удален, иначе он останется на своём месте.

Пример:

procedure TForm1.Button10Click(Sender: TObject);
var
  reg: TRegistry;
  i: Integer;
begin
  reg := TRegistry.Create;
  try
    reg.RootKey := HKEY_LOCAL_MACHINE;
    reg.OpenKey('Software\MyProgram', true);
    for i := 0 to 9 do
      reg.CreateKey('SubKey' + IntToStr(i));//создадим пару-тройку подключей
    reg.CloseKey;
    reg.MoveKey('Software\MyProgram', 'Software\NewMyProgram', false);
  finally
    reg.Free;
  end;
end;

Примечание: в данном случае будет произведено просто копирование ключа, так как параметр Delete указан как false.

Метод SaveKey.

Объявлен как:

function SaveKey(const Key, FileName: string): Boolean;

Сохраняет все подключи и параметры ключа Key в файл FileName в виде улья.
Файл FileName не должен существовать.

Метод LoadKey.

Объявлен как:

function LoadKey(const Key, FileName: string): Boolean;

Создает ключ Key в корне(свойство RootKey) реестра, и записывает в него улей из файла FileName. В качестве RootKey можно указывать только HKEY_USERS и HKEY_LOCAL_MACHINE, так как остальные разделы реестра являются лишь их частями. В случае удачи функция вернет true, иначе false. При перезагрузке системы ключ теряется, но до этого может быть удален только функцией UnLoadKey.

Метод UnLoadKey.

Объявлен как:

function UnLoadKey(const Key: string): Boolean;

Удаляет из реестра ключ Key, ранее созданный методом LoadKey.

Метод ReplaceKey.

Объявлен как:

    function ReplaceKey(const Key, FileName, BackUpFileName: string): Boolean;

Заменяет указанный в Key ключ, все его подключи и параметры содержимым файла FileName. Ключ Key сохраняется в файл с именем BackUpFileName. Замена происходит только после перезагрузки системы. Функция возвращает true, если всё прошло удачно и false, если что-то не получилось.

Метод RestoreKey.

Объявлен как:

function RestoreKey(const Key, FileName: string): Boolean;

Загружает в указанный ключ Key содержимое файла FileName. Все подключи и параметры ключа Key буду заменены прочитанными из файла данными. При удачной загрузке функция вернет true, иначе false.

Метод RegistryConnect.

Объявлен как:

function RegistryConnect(const UNCName: string): Boolean;

Используется для соединения с реестром другого компьютера. Параметр UNCName – имя удаленного компьютера. Должно иметь следующий вид:

\\computername

Перед тем как вызвать RegistryConnect, необходимо установить свойство RootKey в одно из двух значений:

HKEY_USERS
HKEY_LOCAL_MACHINE

Если удалось подключится, то функция установит свойство RootKey в значение этого же свойства на удаленном компьютере и вернет true, иначе свойство RootKey останется в том же виде в котором вы его оставили, и функция вернет false.

Хочу выразить благодарность Rrader‘у, за полезные замечания по поводу статьи.

How to Read or Write data in Windows Registry by using Delphi ?

What is Windows Registry? a small introduction.

Registry is a simple hierarchical database that can be used to store Application or User related data in Tree structure. Windows Operating System already uses Registry to store different settings and User related data. It stores data in Root, Key and Value pattern.

Root — There are seven predefined root keys, traditionally named according to their constant handles defined in the Win32 API, or by synonymous abbreviations (depending on applications):
• HKEY_LOCAL_MACHINE
• HKEY_CLASSES_ROOT
• HKEY_CURRENT_USER 
• HKEY_USERS 
Key – Variable name
Value – Variable value

The Registry «database» is stored as a binary file. To find it, run regedit.exe (Windows registry editor utility) in your Windows directory. 

For more about Windows Registry please visit following link…

https://support.microsoft.com/en-us/kb/256986

How to access Windows Registry from Delphi?

In Delphi we generally access Windows Registry to store Application and User related data like storing form position, User settings etc. Delphi provides TRegistry or TRegistryIniFile class that can be used to read/write Registry data.

TRegistry — TRegistry class provides generic encapsulation of Registry API to read/write data in Window Registry.

TRegistryIniFile — TRegistryInifile provides interface of the TInifile class to read/write data in Windows Registry. In case to make portability our Application with INI based and Registry based version we use TRegistryIniFile.
TRegIniFile — Same as like TRegistryIniFile. This only acts as helper class of TRegistryIniFile class. 
For more about Delphi class helper visit…
http://docwiki.embarcadero.com/RADStudio/XE8/en/Class_and_Record_Helpers_(Delphi)


Using TRegistry
The reading of data from the registry is illustrated with an example. We will create a new form which will remember its previous location on the screen. The location is determined by the Top and Left properties of the form. In addition to these, we will read and store the Height and Width properties of the form


const
  cKey = ‘SOFTWARE\Test_Company\Test_Application’;
  // key where item values will be stored and read
procedure TRememberForm.FormCreate(Sender:
  TObject);
var
  lReg: TRegistry;
  getInt: integer;
begin
  inherited;
  // general purpose:
  // read latest Left, Top, Width and Height
  lReg := TRegistry.Create;
  // create registry object
  lReg.RootKey := HKEY_CURRENT_USER;
  // set root to current user root,
  // to ensure different users on this
  // machine have their own setting
  lReg.OpenKey(cKey, True);
  // Open key where we will read items
  if lReg.ValueExists(self.name +
    ‘.Left’) then // check if
    value for item formname.left exists
    begin
      getint := lReg.ReadInteger(self.name
        + ‘.Left’); // Read left position of actual form
      if getint > 0 then
        self.Left := getint;
    end;
  if lReg.ValueExists(self.name +
    ‘.Top’) then
  begin
    getint := lReg.ReadInteger(self.name + ‘.Top’);
    if getint > 0 then
      self.Top := getint;
  end;
  if lReg.ValueExists(self.name + ‘.Width’) then
  begin
    getint := lReg.ReadInteger(self.name + ‘.Width’);
    if getint > 0 then
      self.Width := getint;
  end;
  if lReg.ValueExists(self.name + ‘.Height’) then
  begin
    getint := lReg.ReadInteger(self.name + ‘.Height’);
    if getint > 0 then
      self.Height := getint;
  end;
  // Close and free
  lReg.CloseKey;
  lReg.Free;

end;


The FormDestroy event is a good moment to write the data to the registry. The code is a lot shorter:  
procedure TRememberForm.FormDestroy(Sender: TObject);
var
  lReg: TRegistry;
begin
  // open registry, set root and key
  lReg := TRegistry.Create;
  lReg.RootKey := HKEY_CURRENT_USER;
  lReg.OpenKey(cKey, True);
  // write last Left, Top, Width and Height
  lReg.WriteInteger(self.name + ‘.Left’, self.Left);
  lReg.WriteInteger(self.name + ‘.Top’, self.Top);
  lReg.WriteInteger(self.name + ‘.Width’, self.Width);
  lReg.WriteInteger(self.name + ‘.Height’, self.Height);
  // close all
  lReg.CloseKey;
  lReg.Free;
  inherited;
end;
As with reading data, the same applies with writing data. You can easily write boolean, datetimes, floats, strings and binary data.


If an Application runs under 32 bit OS then it works fine but if runs on 64bit only the 32bit apps are recorded because of the Wow6432 node redirection. So in this case we have to create TRegistry object like follow..
//to access 64bit OS registry data create Tregistry object as follow//
Registry := TRegistry.Create(KEY_WRITE OR KEY_WOW64_64KEY);

Using TRegistryIniFile


Read form data from Registry on load
procedure TForm1.FormCreate(Sender: TObject); 
var Reg: TRegistryIniFile; 
begin 
Reg := TRegistryIniFile.Create(‘Software\’ + Application.Title’); 
try 
Top     := Reg.ReadInteger(Name, ‘Top’, Top );
Left    := Reg.ReadInteger(Name, ‘Left’, Left );
Width   := Reg.ReadInteger(Name, ‘Width’, Width );
Height  := Reg.ReadInteger(Name, ‘Height’, Height );
Caption := Reg.ReadString (Name, ‘Caption’, Caption);
finally 
Reg.Free; 
end; 
end;


Write form data to Registry on destroy
procedure TForm1.FormDestroy(Sender: TObject); 
var Reg: TRegistryIniFile; 
begin 
Reg := TRegistryIniFile.Create(‘Software\’ + Application.Title’); 
try 
Reg.WriteInteger (Name, ‘Top’, Top);
Reg.WriteInteger (Name, ‘Left’, Left);
Reg.WriteInteger (Name, ‘Width’, Width);
Reg.WriteInteger (Name, ‘Height’, Height);
Reg.WriteString  (Name, ‘Caption’, Caption);
finally 
Reg.Free; 
end; 
inherited;

end;

Limitations and points need to care when using registry to store data.

There are a few limitations which we haven’t discussed. First, The registry is not meant a database for storing vast quantities of data. It is meant for storing initialization and configuration data. Anything over 2Kb had better be stored in a separate file. If you wish, you can mention the corresponding file location in the registry. Then WriteBinary is especially useful for storing recordtypes. Using a record type saves you typing code, and it can be written to and read from the registry with 1 statement, saving both time and storage. And a large registry might slow down all applications.

Go Up to Working with ini Files and the System Registry

If you are writing a Windows-only application and are comfortable with the structure of the system Registry, you can use System.Win.Registry.TRegistry. Unlike TRegistryIniFile, which uses the same properties and methods of other ini file components, the properties and methods of TRegistry correspond more directly to the structure of the system Registry. You can specify both the root key and subkey using TRegistry, while TRegistryIniFile uses HKEY_CURRENT_USER as the root key.

In addition to methods for opening, closing, saving, moving, copying, and deleting keys, TRegistry lets you specify the access level you want to use.

Note: TRegistry is not available for cross-platform (non Windows) programming.

The following example retrieves a value from a registry entry:

 
 function GetRegistryValue(KeyName: string): string;
 var
   Registry: TRegistry;
 begin
   Registry := TRegistry.Create(KEY_READ);
   try
     Registry.RootKey := HKEY_LOCAL_MACHINE;
 
     // False because we do not want to create it if it doesn't exist
     Registry.OpenKey(KeyName, False);
 
     Result := Registry.ReadString('VALUE1');
   finally
     Registry.Free;
   end;
 end;

#include <Registry.hpp>

AnsiString GetRegistryValue(AnsiString KeyName) {
	AnsiString S;
	TRegistry *Registry = new TRegistry(KEY_READ);
	try {
		Registry->RootKey = HKEY_LOCAL_MACHINE;
		// False because we do not want to create it if it doesn’t exist
		Registry->OpenKey(KeyName, false);
		S = Registry->ReadString("VALUE1");
	}
	__finally {
		delete Registry;
	}
	return S;
}

See Also

• Using TRegistryIniFile
• Using TIniFile and TMemIniFile

Code Examples

• TRregistry (C++)
• TRegistry (Delphi)