Работа с ini файлами


Работа с реестром и INI-файлами в Delphi

Реестр

Добавление элементов в контекстное меню «Создать»
1. Создать новый документ, поместить его в папку Windows/ShellNew
2. В редакторе реестра найти расширение этого файла, добавить новый подключ, добавить туда строку: FileName в качестве значения которой указать имя созданного файла.

Путь к файлу который открывает не зарегистрированные файлы
1. Найти ключ HKEY_CLASSES_ROOT\Unknown\Shell
2. Добавить новый ключ Open
3. Под этим ключом еще ключ с именем command в котором изменить значение (По умолчанию) на имя запускаемого файла, к имени нужно добавить %1. (Windows заменит этот символ на имя запускаемого файла)

В проводнике контекстное меню «Открыть в новом окне»
1. Найти ключ HKEY_CLASSES_ROOT\Directory\Shell
2. Создать подключ: opennew в котором изменить значение (По умолчанию) на: «Открыть в новом окне»
3. Под этим ключом создать еще подключ command (По умолчанию) = explorer %1

Использование средней кнопки мыши Logitech в качестве двойного щелчка
Подключ HKEY_LOCAL_MACHINE\SoftWare\Logitech и там найти параметр DoubleClick заменить 000 на 001

Новые звуковые события
Например создает звуки на запуск и закрытие WinWord
HKEY_CURRENT_USER\AppEvents\Shemes\Apps добавить подключ WinWord и к нему подключи Open и Close.
Теперь в настройках звуков видны новые события

Путь в реестре для деинсталяции программ:
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Uninstall

Работа с реестром в Delphi

В Delphi есть объект TRegistry при помощи которого очень просто работать с реестром.
Реестр предназначен для хранения системных переменных и позволяет зарегистрировать файлы программы, что обеспечивает их показ в проводнике с соответствующей иконкой, вызов программы при щелчке на этом файле, добавление ряда команд в меню, вызываемое при нажатии правой кнопки мыши над файлом. Кроме того, в реестр можно внести некую свою информацию (переменные, константы, данные о инсталлированной программы . ). Программу можно добавить в список деинсталляции, что позволит удалить ее из менеджера «Установка/Удаление программ» панели управления.
Для работы с реестром применяется ряд функций API :

RegCreateKey (Key: HKey; SubKey: PChar; var Result: HKey): Longint;
Создать подраздел в реестре. Key указывает на «корневой» раздел реестра, в SubKey — имя раздела — строится по принципу пути к файлу в DOS (пример subkey1\subkey2\ . ). Если такой раздел уже существует, то он открывается (в любом случае при успешном вызове Result содержит Handle на раздел). Об успешности вызова судят по возвращаемому значению, если ERROR_SUCCESS, то успешно, если иное — ошибка.

RegOpenKey(Key: HKey; SubKey: PChar; var Result: HKey): Longint;
Открыть подраздел Key\SubKey и возвращает Handle на него в переменной Result. Если раздела с таким именем нет, то он не создается. Возврат — код ошибки или ERROR_SUCCESS, если успешно.

RegCloseKey(Key: HKey): Longint;
Закрывает раздел, на который ссылается Key. Возврат — код ошибки или ERROR_SUCCESS, если успешно.
RegDeleteKey(Key: HKey; SubKey: PChar): Longint;
Удалить подраздел Key\SubKey. Возврат — код ошибки или ERROR_SUCCESS, если нет ошибок.

RegEnumKey(Key: HKey; index: Longint; Buffer: PChar;cb: Longint): Longint;
Получить имена всех подразделов раздела Key, где Key — Handle на открытый или созданный раздел (см. RegCreateKey и RegOpenKey), Buffer — указатель на буфер, cb — размер буфера, index — индекс, должен быть равен 0 при первом вызове RegEnumKey. Типичное использование — в цикле While, где index увеличивается до тех пор, пока очередной вызов RegEnumKey не завершится ошибкой (см. пример).

RegQueryValue(Key: HKey; SubKey: PChar; Value: PChar; var cb: Longint): Longint;
Возвращает текстовую строку, связанную с ключом Key\SubKey.Value — буфер для строки; cb- размер, на входе — размер буфера, на выходе — длина возвращаемой строки. Возврат — код ошибки.

RegSetValue(Key: HKey; SubKey: PChar; ValType: Longint; Value: PChar; cb: Longint): Longint;
Задать новое значение ключу Key\SubKey, ValType — тип задаваемой переменной, Value — буфер для переменной, cb — размер буфера. В Windows 3.1 допустимо только Value=REG_SZ. Возврат — код ошибки или ERROR_SUCCESS, если нет ошибок.

Объект INIFILES — работа с INI файлами

Почему иногда лучше использовать INI-файлы, а не реестр?
1. INI-файлы можно просмотреть и отредактировать в обычном блокноте.
2. Если INI-файл хранить в папке с программой, то при переносе папки на другой компьютер настройки сохраняются. (Я еще не написал ни одной программы, которая бы не поместилась на одну дискету :)
3. Новичку в реестре можно запросто запутаться или (боже упаси), чего-нибудь не то изменить.
Поэтому для хранения параметров настройки программы удобно использовать стандартные INI файлы Windows. Работа с INI файлами ведется при помощи объекта TIniFiles модуля IniFiles. Краткое описание методов объекта TIniFiles дано ниже.

Constructor Create(‘d:\test.INI’);
Создать экземпляр объекта и связать его с файлом. Если такого файла нет, то он создается, но только тогда, когда произведете в него запись информации.

WriteBool(const Section, Ident: string; Value: Boolean);
Присвоить элементу с именем Ident раздела Section значение типа boolean

WriteInteger(const Section, Ident: string; Value: Longint);
Присвоить элементу с именем Ident раздела Section значение типа Longint

WriteString(const Section, Ident, Value: string);
Присвоить элементу с именем Ident раздела Section значение типа String

ReadSection (const Section: string; Strings: TStrings);
Прочитать имена всех корректно описанных переменных раздела Section (некорректно описанные опускаются)

ReadSectionValues(const Section: string; Strings: TStrings);
Прочитать имена и значения всех корректно описанных переменных раздела Section. Формат :
имя_переменной = значение

EraseSection(const Section: string);
Удалить раздел Section со всем содержимым

ReadBool(const Section, Ident: string; Default: Boolean): Boolean;
Прочитать значение переменной типа Boolean раздела Section с именем Ident, и если его нет, то вместо него подставить значение Default.

ReadInteger(const Section, Ident: string; Default: Longint): Longint;
Прочитать значение переменной типа Longint раздела Section с именем Ident, и если его нет, то вместо него подставить значение Default.


ReadString(const Section, Ident, Default: string): string;
Прочитать значение переменной типа String раздела Section с именем Ident, и если его нет, то вместо него подставить значение Default.

Free;
Закрыть и освободить ресурс. Необходимо вызвать при завершении работы с INI файлом

Property Values[const Name: string]: string;
Доступ к существующему параметру по имени Name

Статья добавлена: 1 июня 2005

Зарегистрируйтесь/авторизируйтесь,
чтобы оценивать статьи.

Статьи, похожие по тематике

Для вставки ссылки на данную статью на другом сайте используйте следующий HTML-код:

Ссылка для форумов (BBCode):

Быстрая вставка ссылки на статью в сообщениях на сайте:
<> (буква a — латинская) — только адрес статьи (URL);
<<статья:7>> — полноценная HTML-ссылка на статью (текст ссылки — название статьи).

Поделитесь ссылкой в социальных сетях:

Комментарии читателей к данной статье

Оставлять комментарии к статьям могут только зарегистрированные пользователи.

Работа с * ini файлами

Вообще, ini -файлы – очень удобная вещь. В ini -файл можно записать практически всё, хотя создан он в основном для хранения настроек программы.

Структура ini -файла очень проста: весь файл поделён на секции. В секциях содержатся ключи и эти ключи хранят значения. Вот пример открытого в блокноте ini -файла:

[Form properties]
Height=320
Left=10
Top=35
[Application properties]
Dir = C :\Мои документы\ Musuc
Date=28.09.02

В этом ини-файле, как мы видим, 2 секции: Form properties и Application properties . В каждой из этих секций есть ключи, содержащие числа, строковые выражения, дату. Запись в файл осуществляется путём указания секции ини-файла, названия ключа и указания самого значения. Ниже я опишу способы использования ини-файла на Borland Delphi .

Для работы с ини-файлами в Delphi существует модуль IniFiles . В нём описан нужный нам класс TIniFile .

1. Включите Delphi и создайте новый проект.

2. Допишите в Uses новый модуль IniFiles .


3. Создайте глобальную переменную класса TIniFile .

Form1: TForm1;
IniFile : TIniFile ;

4. При создании формы надо инициализировать переменную IniFile:

procedure TForm1.FormCreate(Sender: TObject);
begin
IniFile:=TIniFile.Create( ‘C:\Program files\MyApplication\MyIni.ini’ );

Инициализация проходит с участием дополнительного параметра типа string . Это имя файла. Если имя введено не полностью, а, например, так: ‘ MyIni . ini ‘ , то файл создастся при записи в папке Windows . Я же рекомендую создавать файл в папке с программой (её можно узнать так: ExtractFilePath ( Application . ExeName ) ).

5. Как осуществить запись в файл? Для записи в ини-файл есть несколько процедур у класса TIniFile — смотря что надо записать.

Процедура записи строки:

WriteString(const Section, Ident, Value: string);

Процедура записи цифры:

WriteInteger(const Section, Ident: string; Value: Longint);

Процедура записи булевого выражения:

WriteBool(const Section, Ident: string; Value: Boolean);
WriteDate(const Section, Name: string; Value: TDateTime);
WriteTime(const Section, Name: string; Value: TDateTime);

Запись даты и время вместе:

WriteDateTime(const Section, Name: string; Value: TDateTime);

Запись не целого численного значения:

WriteFloat(const Section, Name: string; Value: Double);
WriteBinaryStream(const Section, Name: string;Value: TStream);

Во всех этих функциях обязательно указывать секцию ( Section ), имя ключа ( Name ) и записываемое значение.

Для наглядности вы можете поместить на форму кнопку и по её нажатию можете прописать следующее:

procedure TForm1.Button2Click(Sender: TObject);
begin
IniFile.WriteString( ‘Form info’ , ‘Form caption’ ,Caption);


IniFile.WriteInteger( ‘Form info’ , ‘Left’ ,Left);
IniFile.WriteInteger( ‘Form info’ , ‘Top’ ,Top);
IniFile.WriteInteger( ‘Form info’ , ‘Width’ ,Width);
IniFile.WriteInteger( ‘Form info’ , ‘Height’ ,Height);
IniFile.WriteTime( ‘Other’ , ‘Write time’ ,Time);

По выполнению этого кода программа создаст (если ещё не создан) файл в указанном при процедуре Create месте и запишет в него примерно следующее:

[Form info]
Form caption=Form1
Left=192
Top=107
Height=375
[Other]
Write time=23:13:55

6. Процедура чтения из ини-файла осуществляется похожим способом. Для чтения существуют функции:

ReadString(const Section, Ident, Default: string): string;
ReadInteger(const Section, Ident: string; Default: Longint): Longint;
ReadBool(const Section, Ident: string; Default: Boolean): Boolean;
ReadBinaryStream(const Section, Name: string; Value: TStream): Integer;
ReadDate(const Section, Name: string; Default: TDateTime): TDateTime;
ReadDateTime(const Section, Name: string; Default: TDateTime): TDateTime;
ReadFloat(const Section, Name: string; Default: Double): Double;
ReadTime(const Section, Name: string; Default: TDateTime): TDateTime;

Каждая функция возвращает прочтённое из файла значение. Если по каким-либо причинам прочтение не удалось, то функция возвращает значение, указанное в параметре самой функции как Default .

Например, для прочтения из нашего ини-файла значения Form caption надо написать следующее:

Edit1.Text:=IniFile.ReadString( ‘Form info’ ,
‘ Form caption ‘ , ‘Ошибка при чтении!’ );

В этом примере тексту помещённого на форму Edit -а присваивается прочтённое из файла значение. В нашем случае тексту Edit -а будет присвоено значение « Form 1». Если чтение не удастся, то тексту Edit -а будет присвоено значение «Ошибка при чтении».


Другие процедуры и функции для работы с ини-файлами:

Проверка, существует ли секция:

function SectionExists(const Section: string): Boolean;

Прочтение всей секции:

procedure ReadSection(const Section: string; Strings: TStrings);

Прочтение всего файла (все секции записываются в Strings ):

procedure ReadSections(Strings: TStrings);

Прочтение всех значений в заданной секции:

procedure ReadSectionValues(const Section: string; Strings: TStrings);

Удалить заданную секцию со всеми её значениями:

procedure EraseSection(const Section: string);

Удаление определённого ключа (и его значения) в секции:

procedure DeleteKey(const Section, Ident: String);

Проверка, существует ли заданный ключ в указанной секции:

Добро пожаловать на наш портал

Не доступно

Опрос

Репутация: нет Главная » 2013 » Март » 13 » Учимся подключать .INI файлы в свои Delphi-приложения.

Урок Delphi – Учимся подключать .INI файлы в свои Delphi-приложения.

Сегодня мы рассмотрим, как подключать инициализационные файлы в свои приложения на Delphi . Инициализационные .INI файлы представляют собой, обычные текстовые файлы, которые вы могли наблюдать обычно в папках с программами на вашем компьютере. Они используются для хранения пользовательских настроек и параметров и обычно открываются любыми текстовыми редакторами и имеют такой формат:

Работать с .INI файлами в Delphi очень просто. Основной базовый класс для работы с ними это TIniFile, который позволяет производить над ними все операции записи и считывания, перезаписи пользовательских настроек. Есть еще класс TMemIniFile, который отличается и первого TIniFile, тем, что все данные записываются в оперативную память компьютера, и сохраняются на диске только в момент вызова UpdateFile метода. Оба этих класса содержаться в модуле IniFile и для того, чтобы мы смогли использовать .INI файлы и работать с этими классами в ваших приложениях, вы должны добавить модуль IniFiles в секцию Uses.

Создать объект класса TIniFile или TMemIniFile очень просто, для этого нужно передать конструктору имя .INI файла. В случае, если данного файла не существует, он создается автоматически. Для чтения/записи из/в .INI файл пользовательских значений программно существуют методы

Довольно теории, теперь попробуем попрактиковаться и написать небольшое приложение, наглядно демонстрирующее работу с инициализационными файлами в Delphi и классом TIniFile. Наше приложение после запуска считает из .INI файла информацию о положении и размерах окна, а так же содержимого поля ввода типа Edit, а когда мы закроем приложение оно вновь запишет в .INI файл свои новые( если мы поменяли размер окна или что-то написали в поле ввода) данные, с которыми оно откроется в следующий раз.

Открываем Delphi, помещаем на форму компоненты Edit(поле ввода) и Button(обычная кнопка). Будем обрабатывать события компонента Form, главной формы при создании OnCreate и закрытии OnClose, а также события нажатия на кнопку Button OnClick.

Добавляем в секцию подключаемых модулей Uses модуль IniFile, в котором содержится класс TIniFile, с которым наше приложение будет работать.

В самом начале работы программы (в теле обработчика события создания формы OnCreate) мы попробуем прочитать данные из .INI файла. Чтобы это реализовать, создадим объект класса TIniFile, вызвав его конструктор, с именем нужного файла. Имя файла мы получим из имени исполняемого файла приложения Application.ExeName, изменив его расширение на «ini” с помощью функции ChangeFileExt.

Извлекать из .INI файла отдельные значения мы будем с помощью методов: ReadInteger, ReadString и ReadBool. Эти функции имеют 3 аргумента


  1. Read/Write*(имя типа данных Integer, String или Bool)* ( 1N , 2N, 3N ) ;
  2. 1N – первый аргумент, имя секции, в нашем случае это будет Form
  3. 2N — второй аргумент, имя параметра (Top, Left, Text и т.п.)
  4. 3N – третий аргумент, указывает значение по умолчанию(100, 200, 300 и т.п.) если используется Read* чтение, в случае Write* записи, это будет записываемое значение.

Извлечь значения из .INI файла нам возможно и не удастся не только в аварийном случае, но и по нескольким из причин, например, отсутствие инициализационного файла, или секции. Поэтому, для обработки подобных или еще более серьезных ошибок мы будем использовать защищенный блок tryfinally .

procedure TForm1.FormCreate(Sender: TObject);
var
IniSoub: TIniFile;
begin
Caption := ‘*.INI’;
Button1.Caption := ‘&Сохранить”
Edit1.Text := ”;
//создаем объект класса TIniFile
IniSoub := TIniFile.Create(ChangeFileExt(Application.ExeName, ‘.ini’));
try // пробуем прочитать данные
Edit1.Text := IniSoub.ReadString(‘Edit’, ‘Text’, ”);
Top := IniSoub.ReadInteger(‘Form’, ‘Top’, 100);
Left := IniSoub.ReadInteger(‘Form’, ‘Left’, 100);
Height := IniSoub.ReadInteger(‘Form’, ‘Height’, 100);
W > IF IniSoub.ReadBool(‘Form’, ‘Maximized’, false) then
WindowState := wsMaximized
else
WindowState := wsNormal;
finally
IniSoub.Free; //освобождаем память
end;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
Close;
end;

Когда мы закрываем программу, событие закрытия формы OnClose обработается и запишет текущие значения (высота, размер окна, и т.п.) в инициализационный файл с помощью методов класса TIniFile :

WriteString()
WriteInteger()
WriteBool()

Мы их рассмотрели выше, в Write* все тоже, что и в Read*, кроме последнего 3 аргумента, который записывает .INI файл какое-то числовое значение.

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
var
IniSoub: TIniFile;
begin
//создаем обьект класса TIniFile
IniSoub := TIniFile.Create(ChangeFileExt(Application.ExeName, ‘.ini’));
try // пытаемся записать данные в наш .INI файл
IniSoub.WriteString(‘Edit’, ‘Text’, Edit1.Text);
IniSoub.WriteInteger(‘Form’, ‘Top’, Top);
IniSoub.WriteInteger(‘Form’, ‘Left’, Left);
IniSoub.WriteInteger(‘Form’, ‘Height’, Height);
IniSoub.WriteInteger(‘Form’, ‘Width’, Width);
IniSoub.WriteBool(‘Form’, ‘Maximized’, WindowState = wsMaximized);
finally
IniSoub.Free; // освободим память
end;
end;

Теперь скомпилируйте приложение и сохраните его куда-нибудь в папку или на рабочий стол. Откройте его и попробуйте поменять, например, размер его окна, его расположение на вашем мониторе и нажмите кнопку ”Сохранить”. Теперь откройте его заново и можете убедиться, что размер окна, и остальное что вы меняли, отображается с тем же размером. Все эти данные находятся в .INI файле, вы можете его открыть и отредактировать, поменяв тем самым какие-то значения, с которым приложение отобразиться, как вы его откроете.

Вот его листинг

Не забывайте при редактировании .INI файла вручную указывать имена секций в квадратные скобки [….], а все остальные строки файла, должны иметь формат =

Если хотите предусмотреть возможность редактирования .INI файлов через саму программу, можно использовать компонент ValueListEditor, находящийся на вкладке Additional.

На сегодня урок закончен. Все вопросы можете задавать в комментариях, с удовольствием на них отвечу, и если что-то не понятно, всегда помогу вам разобраться!

Тема: Работаем с ini файлами.

Опции темы
Отображение
  • Линейный вид
  • Комбинированный вид
  • Древовидный вид

Работаем с ini файлами.

Всем привет, в этом так сказать «гайде» — я расскажу как работать с ini-файлами.
И так приступим.

1. Для начала нам следует подключить в uses модуль IniFiles.
Далее нужно объявить глобальную переменную для работы с ини.
*Ini — название переменной.
[code=delphi]var Form1: TForm1;
Ini: TIniFiles;[/code]
Далее самое интересное, но мы пока отойдём от практики и немного теории


Вообще ini-файл удобная весчь. Туда можно записать практически — все. Правда используются ini-файл чаще для настроек самой программы.
Как выглядит ini-файл созданный средствами делфи :

Как видим, файл поделён на секции, ключи и их значения.

2. Ладно, теперь вновь к практике!
Есть несколько процедур записи в ini-файл
Процедура записи строки:
WriteString(const Section, Ident, Value: string);

Процедура записи цифры:
WriteInteger(const Section, Ident: string; Value: Longint);

Процедура записи булевого выражения:
WriteBool(const Section, Ident: string; Value: Boolean);

Запись даты:
WriteDate(const Section, Name: string; Value: TDateTime);

Запись время:
WriteTime(const Section, Name: string; Value: TDateTime);

Запись даты и время вместе:
WriteDateTime(const Section, Name: string; Value: TDateTime);

Запись не целого численного значения:
WriteFloat(const Section, Name: string; Value: Double);

Запись потока:
WriteBinaryStream(const Section, Name: string;Value: TStream);

Во всех функциях обязательно указывать секцию (Section), имя ключа (Name) и значение (Value).
А теперь поместим на форму баттон, щелкним по нему два раза и запишем следующие :
[code=delphi]Ini.WriteString(‘Form info’,’Form Capton’,Caption);[/code]
Теперь если вы скомпилируете программу, сделав все, что в пункте 1, то создаться ini-файл примерно со следующим содержанием :

3. Процедуры чтения ini-файла весьма похожи с записью в файл.
ReadString(const Section, Ident, Default: string): string;

ReadInteger(const Section, Ident: string; Default: Longint): Longint;

ReadBool(const Section, Ident: string; Default: Boolean): Boolean;

ReadBinaryStream(const Section, Name: string; Value: TStream): Integer;

ReadDate(const Section, Name: string; Default: TDateTime): TDateTime;

ReadDateTime(const Section, Name: string; Default: TDateTime): TDateTime;

ReadFloat(const Section, Name: string; Default: Double): Double;

ReadTime(const Section, Name: string; Default: TDateTime): TDateTime;

Каждая функция прочтенное значение из файла. Если чтение не удалось, то функция возвратит значение, указанное в параметре самой функции как дефолт.
Пример :
[code=delphi]Edit1.Text:=ReadString(‘Form info’,’Form Caption’,’Error’);[/code]
Как вы поняли эдиту присвоится ранее записанное значение Form Caption, если чтение не удастся, то эдиту присвоится значение Error.

Ну собственно и все, хотя здесь не совсем все.

Так сказать «статья» моя, специально для fpteam.

Последний раз редактировалось f1ng3r; 01.11.2011 в 08:13 .

Работа с *.INI файлами в VB.NET

Как правило, настраиваемые параметры приложения хранятся во внешних по отношению к программе расположениях. Имеется множество способов вынести настройки программы вне кода самой программы. Распространёнными способами являются: хранение параметров приложения в реестре Windows, в базах данных, в конфигурационных XML файлах, в файлах *.config или *.cfg, в специфических двоичных форматах и, конечно же, в *.ini файлах. Эти файлы мы сейчас и рассмотрим.

1 Что такое INI-файлы

Что такое INI-файлы известно, наверное, каждому более-менее опытному пользователю операционной системы Windows. Зачастую файл с расширением *.INI – это самый быстрый и удобный способ вынести настраиваемые параметры приложения вне кода программы. Эти файлы имеют свою, довольно простую, структуру и, как правило, отличаются малыми размерами. Это обычные текстовые файлы, которые открываются даже в «Блокноте».


Вообще, INI-файл может иметь некоторые отступления от общепринятых норм, каждый разработчик определяет структуру и синтаксис файла для себя. Но есть некоторые общепринятые соглашения. Собственно, вот как выглядит структура INI-файла в общем виде:

Видно, что *.INI файл может содержать:

  • комментарии;
  • заголовки разделов (секций);
  • параметры в виде пары «ключ-значение»;
  • пустые строки.

2 Создание разделов и ключей INI-файлас помощью Visual Basic .NET и kernel32.dll

Можно изобретать велосипед и создать свой разборщик и генератор для INI-файлов. Но мы поступим более рационально и приземлённо и воспользуемся готовым решением из самой ОС Windows.

Дело в том, что в поставку любой операционной системы семейства Windows входит динамическая библиотека kernel32.dll. Эта библиотека расположена в системном каталоге Windows/system32. Она имеет множество функций для доступа к API Windows. В том числе и для работы с INI-файлами. Описывать все его возможности нет смысла, т.к. их великое множество (вот, например, описание kernel32 на 500+ страниц). Посмотреть все методы библиотеки можно с помощью наших старых знакомых DllExportViewer или DependencyWalker.

Нас здесь интересуют всего два метода: GetPrivateProfileString() для чтения ключей и разделов INI-файлов и WritePrivateProfileString() для записи.

Напишем класс-обёртку для упрощённого доступа к функциям работы с файлами *.INI, предоставляемым библиотекой kernel32:

Код класса IniFile.vb для работы с INI-файлами (разворачивается)

Использовать класс IniFile можно, например, так:

ini файлы в c# — давайте проще

Как заядлый (закоренелый) Дельфист, я не мог не попасть в так вот красивый просак, а именно в сохранение определённых настроек программы.
Методы формирования ini файлов отбросил, так как хотелось изящества и нативности, что по русски звучит так: надо проще и понятнее, что бы раз и навсегда сделать и забыть.
Ну и стоит, конечно, отметить, что к ООП я раньше вообще не имел никакого отношения.

И так задача: программа стартует — имеет одно окно (Form1) и одну кнопку (практически бесполезную).
Перемещаем окно по экрану и закрываем программу. Запускаем заново и она, после старта, занимает на экране позицию в которой она была в момент закрытия. Другими словами программа помнит место положение окна.

в Form1.cs добавляем две строки:

using System.IO; // это для работы с файлами
using System.Xml.Serialization; //это для сохранения классов — что и есть серилизация (стрёмное слово)

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

Дальше я привожу всё тело программы, так проще комментировать:

Послесловие.
Иногда очень со скрипом идёт ломка старых стереотипов — я 3 часа бился головой в клавиатуру, выписывая код сохранения в старый добрый ini файл и, увидев во что превращается простенькая задача, бросил это занятие. Да — XML не так красиво читаем как ini файл, но всё равно он правится как вручную, так и сторонними программами.

Данная статья не подлежит комментированию, поскольку её автор ещё не является полноправным участником сообщества. Вы сможете связаться с автором только после того, как он получит приглашение от кого-либо из участников сообщества. До этого момента его username будет скрыт псевдонимом.

Работа с ini файлами в Delphi

Порой требуется записать какую-либо информацию из программы, но использовать реестр нет возможности или просто ненужно. Для таких операций в delphi используют ini файлы. В них легко записать информацию любого характера, а также считать её.

1) Создать новый проект и подключить библиотеку IniFiles в uses.
2) Записать в глобальной переменной новый класс IniFile и объявить как TIniFile.
3) На открытие формы необходимо подключить автоматическую загрузку файла (также ее можно сделать по нажатии определённой кнопки).
4) Начать работать с переменными. Ниже будет предоставлен полный список задач, которые вы могли бы реализовать в своей программе.
Результат, который должен получиться:

Процедуры чтения ini файла:

В заключении хочется сказать, что данный способ не совсем безопасен, так как вы храните свои данные в чистом виде, но для каких-либо логов это идеал. Если вам необходимо защитить все данные, которые у вас есть в этих файлах, рекомендуем использовать хеширование base64, добавляя свой уникальный шифр. Например, слова любимой песни в любой кодировке и тому подобное. В следующей статье разберем, как отправить почту на delphi

Работа с * ini файлами

Здраствуйте мастера. У меня такая проблема: Как мне сохранять, а потом загружать параметры из INI файла.

Я сними работаю, как собычными файлами. Атам всё просто:
AssignFile
Reset / Rewrite
Read / Readln / Write / Writeln
CloseFile

Может, это и не грамотно, но работает



> INCOGNITO © (22.06.03 03:13

и какждый раз парсеришь строку?
мой тебе совет
> Palladin © (22.06.03 01:56)

Часть первая.
Создаем новый проект, в форму Form1 помещаем компоненты Edit, ComboBox, два компонента CheckBox, две кнопки BitBtn.
Для компонента ComboBox1 изменяем свойство Style в csDropDownList и редактируем свойство Items, занося туда несколько произвольных строк. Дальше для BitBtn1 свойство Caption изменяем на Сохранить, а для кнопки BitBtn2 — Восстановить.
В процедуре нажатия на кнопку «Сохранить» аналогично закрытию окна команда WriteParams, для кнопки «Восстановить» — ReadParams.

Часть вторая.
uses
inifiles; // подключение модуля, позволяющего работать с ini файлами

type
procedure ReadParams; // процедура чтения параметров
procedure WriteParams; // процедура записи параметров

Часть третья.
implementation
<$R *.DFM>
procedure TForm1.ReadParams;
Var IniFile:TIniFile; // объявление переменной, через которую будут обрабатываться данные
begin
IniFile:=TIniFile.Create(«project.ini»); // создаем переменную
Edit1.Text:=IniFile.ReadString(«FORM1″,»Edit1Text»,Edit1.Text); // текст в Edit1
ComboBox1.ItemIndex:=IniFile.ReadInteger(«FORM1″,»ComboBox1ItemIndex»,ComboBox1.ItemIndex); // выбранный пункт
CheckBox1.Checked:=IniFile.ReadBool(«FORM1″,»CheckBox1Checked»,CheckBox1.Checked); // состояние CheckBox1
CheckBox2.Checked:=IniFile.ReadBool(«FORM1″,»CheckBox2Checked»,CheckBox2.Checked); // состояние CheckBox2
IniFile.Free; // если сами создаем, то сами уничтожаем.
end;

Часть четвертая.
procedure TForm1.WriteParams;
Var IniFile:TIniFile;
begin
IniFile:=TIniFile.Create(«project.ini»);
IniFile.WriteString(«FORM1″,»Edit1Text»,Edit1.Text);
IniFile.WriteInteger(«FORM1″,»ComboBox1ItemIndex»,ComboBox1.ItemIndex);
IniFile.WriteBool(«FORM1″,»CheckBox1Checked»,CheckBox1.Checked);
IniFile.WriteBool(«FORM1″,»CheckBox2Checked»,CheckBox2.Checked);
IniFile.Free;
end;


> Palladin © (22.06.03 01:56)
> TIniFile+F1

Ты как всегда в своем репертуаре. В справке же нет никакого примера.

Я уже где-то в форуме приводил функции для записи и чтения в ini-файл и как их вызывать. Поищи.

мне не понятно твое высказывание

AbrosimovA (23.06.03 09:39)
Это как нет, я не поленился посмотреть, по TIniFile есть, по крайней мере 4 комплексных примере. Как прикажешь понимать тебя Абдулла?


> Palladin © (23.06.03 09:43)
> мне не понятно твое высказывание

А тем, кто задает вопросы в форуме, будут понятны твои ответы
из разряда «Смотри справку». Людям нужны примеры, а не смотреть справки, в которых заведомо примера по данному вопросу нет.
Нужно уважать не только себя, но и тех, кто только начинает программировать. Всюду, где ты отвечаешь, сквозит презрение к тем, кого ты считаешь «ламерами» и «чайниками».

Посмотри эту статью:
http://code-code.narod.ru/art/ini.html


> AbrosimovA (23.06.03 10:01)

Это естественный отбор.
Лично я не понял его проблемы работы с ini файлами, может у него с головой она, а может и нет, вопрос задан некорректно, значит дам 0.6 что с головой.
После прочтения вопроса такое чувство возникает, что вот он сидел на стуле, сидел, мух ловил, и тут у него вдруг неожиданное возникла проблема «Как мне сохранять, а потом загружать параметры из INI файла.», как же ее решить? ну как, вот знакомый форум посоветовал, спроси там. О точно, спрошу ка я в форуме.

AbrosimovA (23.06.03 10:01)
Опять продолжаешь преднамеренный обман, в справке есть комплексные примеры.
Похоже все таки твоя цель наезд.


> Anatoly Podgoretsky © (23.06.03 10:26)

Вот содержание моей справки и где же в ней примеры. A.

Hierarchy Properties Methods Using TIniFile See also
________________________________________________________________

TIniFile stores and retrieves application-specific information and settings from INI files.

TIniFile enables handling the storage and retrieval of application-specific information and settings in a standard INI file. An INI file stores information in logical groupings, called “sections.” Within each section, actual data values are stored in named keys. Keys take the form:

A FileName is passed to the TIniFile constructor and identifies the INI file that the object accesses.

Note: On Linux, TIniFile is the same as TMemIniFile. This differs from the Windows product, in which TIniFile does not buffer writes in memory the way TMemIniFile does.

Смею предположить, что ты, когда был начинающим, то также сидел на стуле и ловил мух. А сейчас ты «санитар леса».

AbrosimovA (23.06.03 10:38)
>Вот содержание моей справки и где же в ней примеры. A.
>TIniFile
>Hierarchy Properties Methods Using TIniFile See also

Глубже поискать не судьба?

This example reads the Transfer section of the myapp.ini file into a memo and changes one of the strings in the INI file when Button1 is clicked. When Button2 is clicked, the myapp.ini file is restored to its initial state, using the values stored in the memo.
Before you run this example, you must add the IniFiles unit to the uses clause of your unit.

Warning: Do not click button2 before you have clicked button1!


procedure TForm1.Button1Click(Sender: TObject);

var
MyIniFile: TIniFile;
begin
MyIniFile := TIniFile.Create(«myapp.ini»);
Memo1.Clear;
MyIniFile.ReadSectionValues(«Transfer», Memo1.Lines);
if Memo1.Lines.Values[«Title1»] <> «Picture Painter» then
MyIniFile.WriteString(«Transfer», «Title1», «Picture Painter»);
MyIniFile.Free;
end;

procedure TForm1.Button2Click(Sender: TObject);

var
MyIniFile: TIniFile;
begin

< if the entry wasn’t there before, delete it now >
if Memo1.Lines.Values[«Title1»] = «» then
MyIniFile.DeleteKey(«Transfer», «Title1»)
< otherwise, restore the old value >
else
MyIniFile.WriteString(«Transfer», «Title1», Memo1.Lines.Values[«Title1»]);
MyIniFile.Free;
end;

Если это заблуждение, то это не лучше, это будет говорить уже о твоем уровне, который в этом случае говорит об неумении пользоваться скажем для начала такой вещью как справочная система, навигация по ней, например выбор между пунктами меню свойства, методы и события и далее опять Example-
Но твой интеллектуальный и профессиональный уровень это не основание, чтобы на основе его делать наезды на участиников форума и многоуважаемую фирму Борланд.

Когда я был начинающим, у меня не было интернета, у меня был Поиск2 в школе и две книжки GWBasic и Turbo Pascal 3, соотвествоенно и ПО такое же. хотя я конечно не такой «матерый» как Юрий Зотов, но мне этого хватило. учителя у меня не было. у меня был наставник который подсказывал методологию изучения и развития, но не саму информацию, к счастью на практике он мне ничем не помогал. ни пример показать ни синтаксис описать. иначе бы я заразился от него его логикой и был бы ею же и ограничен. мудрый он был, то есть и сейчас есть.

А в этом случае, ну разве не видно, что человеку бы алгоритмы пописать простейшие, решения квадратных уравнений, и пр. а потом уже что то более серьезное писать, но он не будет. зачем? зачем ему это надо?
Кинь я ему сюда пример, как Sorpx, он бы его скопировал, модифицировал и все, но я его в справку отправил, что бы он хоть немного поковырял, там справка, извините меня, и 10 классу понятна.

Работа с * ini файлами

Полную версию библиотеки KOL и MCK можно скачать здесь.

Если вы не являетесь любителем забивать свои и чужие реестры мегабайтами мусора, или просто не надеетесь на сохранность информации в нем (когда нибудь Windows наверняка умрет), то вам надо обратить свои взоры на старые добрые Ini-файлы.

В KOL работа с ini организованна с помощью объекта TIniFile .
Для того чтобы открыть ini-файл (и одновременно создать TIniFile), надо воспользоваться функцией OpenIniFile .
Свойство Mode отвечает за то, что вы будете делать с ini файлом : производить запись или чтение. Для записи вы должны прировнять Mode к ifmWrite, и соответственно для чтения к ifmRead. По умолчанию (при открытии) Mode = ifmRead, т.е. для чтения.

Для чтения/записи данных из ini используют 4 функции. Их описание приведено в таблице :

Чтение/запись данных Value типа integer под именем Key

function ValueInteger( const Key: String; Value: Integer ): Integer;

Чтение/запись данных Value типа string под именем Key

function ValueString( const Key: String; const Value: String ): String;

Чтение/запись данных Value типа boolean под именем Key

function ValueBoolean( const Key: String; Value: Boolean ): Boolean;

Чтение/запись данных на которые указывает Value длинной Count под именем Key

function ValueData( const Key: String; Value: Pointer; Count: Integer ): Boolean;

Еще раз повторюсь и напомню, что чтение или запись происходит в зависимости от того чему равно свойство Mode.

Как известно ini файлы построены по следующему принципу

[Section1]
Key1=Value
Key2=Value
.
[Section2]
Key1=Value
Key1=Value
.
Section — секция (раздел) ini файла.
Key — имя переменной
Value — Переменная которая записывается под именем Key
(Кто этого не знал, может открыть любой ini файл и убедится в этом).
За то из какой секции происходит чтение (или запись) отвечает свойство Section. Для того чтобы получить список секций надо обратится к GetSectionNames . А для получения данных из секции, надо воспользоваться SectionData . И у первой и второй процедуры данные записываются в объект типа pStrList (список строк).
Я про него пока ничего не рассказывал, но он мало чем отличается от от VCL аналога TStringList. Но отличия все-таки есть, и к сожалению не в пользу pStrList. У pStrList нет таких свойств как Name и Value, а они бы не помешали, так как SectionData возвращает список из переменных и их значений в том же виде, в каком они записаны в ini файле (т.е разделенные знаком равно).
Ну это не такая и большая проблема :) В подтверждение этого, маленький примерчик простенького ini-редактора.
Программа внешне состоит из двух списков (List1 и List2). В List1 заносятся имена секторов, а в List2 список переменных и их значения. Сверху два поля (edName и edDan), в которые заносятся имя переменной и ее значение, когда происходит двойной клик по List2. Поле edDan (в него заносятся значение) можно редактировать. Исходный текст : 2,64 Кб ; размер программы: 32,5Кб(без сжатия и замены System).

А теперь таблица подытоживающая все вышесказанное, а также рассказывающая про свойства pIniFile, которые не были затронуты:

Блог о Linux и Windows

Записки по настройке Debian Ubuntu и Microsoft Windows

Работа с ini файлами в Delphi

На разных этапах создания проекта у вас может возникнуть потребность сохранить пользовательские настройки на диск. Лучше всего для этого подойдут INI файлы.

Работать с ними намного удобнее, нежели с обычными текстовыми файлами. Представьте ситуацию, вы написали крупный проект, который имеет огромное число настроек, например 100 штук (причем это не простые чекбоксы). Теперь представьте, что пользователь изменит один из параметров. Вам придется заново переписывать все 100 настроек в файл. Это очень утомительно. Благо есть способ более элегантный. Для хранения настроек и прочих подобных данных лучше всего подходят INI файлы или реестр. С реестром мы разберемся в следующий раз. Изучим работу с INI файлами. Одно из главных преимуществ INI файлов заключается в том, что эти файлы поддерживают переменные разных типов (String, Integer, Boolean). Также несравненным плюсом является возможность доступа к определенной записи, без изменения остальных. Думаю, что пора закончить введение и перейти к практике. Прежде всего нам надо создать новое приложение. Добавьте в секцию uses модуль inifiles. Давайте сохраним какие-нибудь настройки в INI файле.

Илон Маск рекомендует:  grayscale() в CSS
Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL
Функция Выполняемое действие