Voy a contar como Delphi gestiona los ficheros ini.

Por fichero ini se entiende todo

fichero que tiene extensión ini, está en formato Ascii, y tiene una estructura interna
dividida en secciones. Un claro ejemplo es el famoso Win.ini, que lo podéis
encontrar en el directorio Windows. Se puede abrir con el Bloc de Notas de
Windows, aunque Windows, incluye un programa visor para ver los ficheros del
sistema, que se llama Sysedit, si ejecutáis este programa podréis ver el contenido
de los ficheros de sistema, entre ellos los de extensión ini.

Los ficheros ini, normalmente, tienen una estructura. Están divididos en bloques o
secciones, y dentro de cada sección hay valores que se usan en la configuración
del programa que gestiona ese fichero o esa sección. Digo esa sección porque el
fichero Win.ini almacena datos sobre Windows, y algunos programas añaden
secciones a él. Aquí hay que hacer una aclaración ya que esto solo ocurre en
Windows 3.x, y Windows 95 tiene este archivo aunque esta en desuso (por
compatibilidad).

Los nombres de las secciones están indicados entre corchetes, e inmediatamente

van los variables que haya puesto el programa con sus valores. Este es un
ejemplo de una entrada de mi fichero Win.ini:

[Ports]
LPT1:=
LPT2:=
LPT3:=
COM1:=9600,n,8,1,x
COM2:=9600,n,8,1,x
COM3:=9600,n,8,1,x
COM4:=9600,n,8,1,x
FILE:=

Como podéis ver es todo Ascii, así que alguien puede pensar que con lo que sabe
de ficheros, se puede sentar delante del ordenador y hacerse unas rutinas para
leerlos, a lo cual yo respondo que tu mismo, pero que Delphi ya tiene un sistema
para leerlos, y muy bueno.

Delphi tiene una unidad donde tiene todos los procedimientos y funciones
definidos. Así que lo único que tienes que hacer para poder empezar a trabajar
con estos ficheros es añadir la palabra IniFiles a la cláusula uses de tu unidad.
Esta es la lista de funciones y procedimientos para leer y escribir en estos
ficheros.

Create(Filename) Para acceder a un fichero

Free Cierra el fichero
ReadSecctionValues(Seccion,TString) Para leer todas la variables

ReadSections(TString) Lee las secciones

ReadSection(Seccion,TString) Lee una Seccion entera

ReadString(Seccion,Variable, Defecto) Lee una variable tipo String

ReadInteger(Seccion,Variable,Defecto) Lee una variable tipo integer

ReadBool(Seccion,Variable,Defecto) Lee una variable tipo boleano

WriteString(Seccion,Variable,Valor) Escribe un valor en una Variable.

WriteInteger(Seccion,Variable,Valor) Escribe un valor tipo Integer

WriteBool(Seccion,Variable,Valor) Escribe un valor boleano

Quizás ante tanto nombre os asustéis, pero en cuanto explique un par de detalles
el resto será coser un cantar. Para acceder a un fichero ini, lo primero es indicar
que fichero es, y eso se hace cuando creamos el objeto. He dicho objeto, y lo he
soltado así de refilón, resulta que como Delphi es un lenguaje orientado al objeto,
y el sistema de lectura/escritura de ficheros ini, es una clase pues hay que
inicializarlo. Seguro que hay alguno de esta pensando que se ha metido en un lió,
pero Delphi no nos abandona en los momentos difíciles, y el sistema es muy fácil.
Un procedimiento genérico (cuando digo genérico es que se puede poner dentro
de cualquier procedimiento) seria como sigue:

Var
MiFicheroIni : TiniFile;
Begin
MiFicheroIni := TIniFile.Create ('pepe.ini');
MiFicheroIni.Free;

En este mini programa lo que he hecho crear una variable tipo IniFile, la cual
inicializo en la primera línea indicando que el fichero con el cual vamos a trabajar
se llama Pepe.ini, después podría hacer lo que me plazca, y al final libero la
variable que he creado, para que no ocupe memoria. Atención porque sino se
indica el nombre del fichero con la ruta completa se asume que este está en el
directorio Windows, y NO donde se esta ejecutando tu programa. Si quieres
acceder al fichero dentro de otro directorio, debes ponerlo así:

MificheroIni := TiniFile.Create ('c:\mi directorio\pepe.ini');

Os comento que los ejemplo que voy a poner trabajarán en el directorio donde se
ejecuta la aplicación. Antes de que se me pase, cuando el fichero no se encuentra
este es creado.

Vamos hacer un ejemplo donde se usen las principales funciones. Para lo cual
construye un formulario como este, con dos botones, dos campos edit, un
CheckBox, y un par de etiquetas. Como os dije, el fichero se creará en el directorio
donde se ejecuta este programa, así que para ello debemos saber donde se
ejecuta, la manera que yo he usado es declarar un variable en la sección privada
de la unidad, la cual contendrá el directorio y el nombre del fichero, y estos datos
le serán asignados en el momento de la creación del formulario, así que este
procedimiento será como sigue:

procedure TForm1.FormCreate(Sender: TObject);

begin
Fichero := ExtractFileDir (ParamStr(0))+'\Fichero.ini';
end;

El truco para saber el directorio donde está ejecutandose el programa, está en

ParamStr, el cual contiene en su elemento 0 (es un array), el nombre con la ruta
completa del programa. Con la función ExtractFileDir obtengo solo la ruta.

El LeerDatos, que se llama Button1, tiene las siguientes líneas de código:

procedure TForm1.Button1Click(Sender: TObject);

Var
MiFichero : TIniFile;
Edad : Integer;
begin
MiFichero := TiniFile.Create (Fichero);
Edit1.Text := MiFichero.ReadString ('Usuario','Nombre','Desconocido');
Edad := MiFichero.ReadInteger ('Usuario','Edad',99);
CheckBox1.Checked := MiFichero.ReadBool ('Usuario','Español',True);
MiFichero.Free;
Edit2.Text := IntToStr (Edad);
end;

Las funciones de lectura de datos devuelven los valores en el formato que los
leen. Así cuando usamos ReadString la variable que recoge los datos debe ser un
String, cae de cajón, pero por si las moscas. Además tienen tres parametros, el
primero es el nombre de la sección, el segundo el nombre de la variable, y el
tercero el valor por defecto, en el caso que no exista tal variable, sección, o incluso
si el fichero no existiese y fuera creado en el momento de su apertura. Como la
edad he decido almacenarla como un valor numérico (integer), para poderla
mostrarla en el campo Edit2 he de convertirla a texto, que es lo que hace la última
línea.

El procedimiento de escritura es similar:

procedure TForm1.Button2Click(Sender: TObject);

Var
MiFichero : TIniFile;
Edad : Integer;
begin
Edad := StrToInt (Edit2.Text);
MiFichero := TiniFile.Create (Fichero);
MiFichero.WriteString ('Usuario','Nombre',Edit1.Text);
MiFichero.WriteInteger ('Usuario','Edad',Edad);
MiFichero.WriteBool ('Usuario','Español',CheckBox1.Checked);
MiFichero.Free;
end;

Fijaros que el procedimiento es casi indentico al anterior, pero esta vez se usan
las ordenes de escritura. Aqui ocurre lo mismo, si el fichero, la seccion, o la
variable no existen son creadas. Como regla general se puede decir que si al leer
o escribir algo no existe, este es creado.

He dejado atrás funciones que son: ReadSectionValues, ReaSections y

ReadSection, las cuales tienen como parametros variables de tipo TStrings, las
cuales más que ser una variable es un objeto, el cual no esta de más que vallas
tratando porque es muy potente. Básicamente es una lista de cadenas, algo así
como un Array o Matriz, pero se pueden hacer muchas cosas con el, añadir
elementos, borrarlos, acceder por el indice, ordenarlos, etc. Y lo mejor es que los
componentes que usan esten objeto lo hacen practicamente todo ellos. Un
componente que usa este objeto son los TListBox, es el séptimo componente
empezando por la derecha en la paleta Standar.

Estas funciones leen partes de un fichero ini. Así ReadSectionValues, lee los
valores de las variables contenidas en una seccion. ReadSections, lee el nombre
de las secciones de un fichero ini, y ReadSection lee el nombre de las variables de
la sección. He hecho un pequeño ejemplo que lee de nuestro fichero ini.

He puesto en un formulario tres botones que invocan a estos tres procedimientos y

un TListBox, el cual su propiedad items, es del tipo TStrings. Esta es la imagen del
formulario que preparé y los tres procedimientos.

procedure TForm1.Button1Click(Sender: TObject);

Var
MiFichero : TiniFile;
begin
MiFichero := TIniFile.Create (Fichero);
MiFichero.ReadSection ('Usuario',ListBox1.Items);
MiFichero.Free;
end;

procedure TForm1.Button2Click(Sender: TObject);

Var
MiFichero : TiniFile;
begin

MiFichero := TIniFile.Create (Fichero);

MiFichero.ReadSections (ListBox1.Items);
MiFichero.Free;

end;

procedure TForm1.Button3Click(Sender: TObject);

Var
MiFichero : TiniFile;
begin
MiFichero := TIniFile.Create (Fichero);
MiFichero.ReadSectionValues ('Usuario',ListBox1.Items);
MiFichero.Free;

end;

Bueno pues los ficheros ini no tienen más secretos, solo comentar que yo
personalmente prefiero trabajar sobre un fichero ini propio que tocar en el win.ini.
El motivo es que así el fichero ini lo creo en el directorio donde esta el programa
ejecutable, con lo que obtengo una ventaja, y es que es que si el usuario borra el
programa, borrando el directorio donde está el programa ya borra el fichero ini, y
no se queda en el directorio Windows y si hubiera añadido entradas al fichero
win.ini este no quedaria engordado inultilmente.
En el primer ejemplo lo que vamos a hacer es aprender a: crear un archivo INI
Para eso vamos a crear un nuevo proyecto y en el form creado, en el evento Oncreate
vamos a poner:
Código DELPHI

1. procedure TForm1.FormCreate(Sender: TObject);

2. Var
 3. MiArchivoINI : TiniFile; // crea una variable de tipo
TIniFile
4. Begin
5. // Crea el archivo INI en la direccion del programa
6. MiArchivoINI :=
TIniFile.Create(ExtractFilePath(Application.ExeName)+'Mi
Archivo.ini');
7. // Escribe dentro del archivo creado
8. MiArchivoINI.WriteString( '1', 'A', '' );
9. end;
10.

Tened en cuenta que hay que colocar en el uses el tipo Tinifile, asi:

Código DELPHI

1. uses
2. Windows, Messages, SysUtils, Variants, Classes,
Graphics, Controls, Forms,
3. Dialogs, IniFiles;

Guardad el proyecto.

En este segundo ejemplo veremos como se escribe dentro de un archivo INI y como podemos
obtener esa información.
Primero creemos un nuevo proyecto:
Flile New Application.
En el form creado vamos a poner:
2 Panel
3 botones
1 Combobox
1 memo
2 edit
3 label

Nos quedara asi:

Como veis se hicieron estos cambios:

Al primer panel cambiadle el caption por: Datos de la persona
Al segundo panel dejad el caption en blanco
Los edits dejadlos en blanco en la propiedad TEXT.
En el combobox en la propiedad string poned:
Nombre
Apellido
DNI

Los Label serian: Código, Tipo, Dato.

Los botones:
Guardar los datos
Ver los datos según el código
Salir
Cambiemos le el caption del form a: Datos en Archivo INI.
Guardemos el proyecto.

Seguimos:
Vamos a escribir el código que nos servirá para este ejemplo:
Primero el mas sencillo:
El boton Salir:
Dadle doble click y poned esto:
Código DELPHI

1. Close;

El botón Guardar los datos:

Aquí vamos a crear algunas variables que nos servirán para almacenar los datos.
Este es el código:
Código DELPHI

1. var
2. B: TIniFile; // contiene el dato de tipo TIniFile
3. Codigo: String;
4. Tipo: String;
5. Dato: String;
6. begin
7. Codigo:= Edit1.Text; //Obtiene el dato del edit1
8. Tipo:= ComboBox1.Text; //Obtiene el dato del
combobox1
9. Dato:= Edit2.Text; //Obtiene el dato del edit2
10. B := TIniFile.Create(ExtractFilePath(ParamStr(0))
+ 'MiArchivo.Ini'); // busca el archivo INI en el
directorio del programa
11. with B do
 12. begin
13. B.WriteString(Codigo,Tipo,Dato); // Escribe los
datos en el archivo ini
14. Showmessage('Dato Guardado'); // muestra un
mensaje
15.

Ahora el botón: Ver los datos Según el código:

Crearemos las variable para almacenar los datos:
Código DELPHI

1. var
2. BF: TIniFile;
3. Codigo: String;
4. A, B, C: String;
5. begin
6. Codigo:= Edit1.Text;
7. BF := TIniFile.Create(ExtractFilePath(ParamStr(0))
+'MiArchivo.Ini');
8. with BF do
9. begin
10. A := BF.ReadString(Codigo,'Nombre','');
11. B := BF.ReadString(Codigo,'Apellido','');
12. C := BF.ReadString(Codigo,'DNI','');
13. Memo1.Clear;
14. Memo1.Lines.Add('Nombre = '+A);
15. Memo1.Lines.Add('Apellido = '+B);
16. Memo1.Lines.Add('DNI = '+C);
17. end;
18.

Como veis en este segundo botón se busca el archivo ini, se leen los datos con la
función ReadString y se muestran en el memo.

Acordaros que hay que declarar en tipo TInifile en el uses:

Código DELPHI

1. uses
2. Windows, Messages, SysUtils, Variants, Classes,
Graphics, Controls, Forms,
3. Dialogs, IniFiles;
Corred el programa y empezad a jugar con datos, veréis que los guarda y los recupera
según el dato que se escriba en el edit1 el cual sera el código de referencia.

Seguimos...

Como visteis anteriormente un archivo INI lee la información en un sector especifico dentro de el.
Esto es lo que usaremos para poder conectar una BD por medio de un archivo INI.
Una cosa a tomar en cuenta es que aunque los datos son del tipo Texto se puede usar con datos
numéricos, eso tal vez lo veamos en otra ocasión por ahora nos enfocaremos al enlace con las BD.
Sabemos, según lo que pudimos ver que el dato de tipo ''control'' se encuentra encerrado dentro
de corchetes [ ] y que los datos contenidos dentro del principal se definen con un signo de igual =.
En el caso de la conexión con una BD se puede desde colocar todos los datos necesarios, los
básicos, las claves etc. etc. etc..
Lo normal es colocar solamente la dirección donde se encuentra la BD.
Aveces se necesita colocar la clave y el usuario, por lo menos yo lo prefiero en el caso de Firebird.
En el siguiente paso os mostrare tanto el código para access como para Firebird, como veréis serán
prácticamente lo mismo con ligeras diferencias.
Seguimos.....

Seguimos....
Conectarnos a una BD access por medio de un archivo INI.
Bien, en este caso usaremos los componentes ADO.
Este código lo podemos colocar en un form o en un datamodule (que es lo mas eficiente),
siempre dentro del evento OnCreate.
Hay que recordar que en el uses del from hay que poner el uses IniFiles, en el caso de un
datamodule:
Código DELPHI

1. uses
2. SysUtils, Classes, DB, ADODB, IniFiles, Forms,
Dialogs;

Colocad este código (en el evento Oncreate):

Código DELPHI

1. Var
2. BaseDeDatos, ConStr : String;
3. IniFile: TIniFile;
4. begin
5. // Obtiene la ruta y el nombre de la base de datos
6. IniFile :=
TIniFile.Create(ExtractFilePath(Application.ExeName)+'Mi
Archivo.ini');
 7. BasedeDatos := IniFile.ReadString('BD','Path','');
8. If BasedeDatos = '' then ShowMessage('Error al
cargar Base de Datos');
9. ConStr := 'Provider=Microsoft.Jet.OLEDB.4.0;'+
10. 'Data Source='+BaseDeDatos+';'+
11. 'Persist Security Info=False;'+
12. 'Jet OLEDB:Database Password=admin';
13. AdoConnection1.ConnectionString := ConStr;
14. AdoConnection1.Open;
15.

Como veis el sector principal se llama BD este estará encerrado entre corchetes y el dato se
sacara del sector Path que es donde se escribirá la dirección de la BD.
Bien, abrid el archivo INI y poned los datos para que sean leídos por el programa, tendrán
que quedar de esta forma:
Cita
[BD]
Path="C:\MICarpeta\Micarpetadebd\MiBD.MDB"
Si colocáis en el sector Path la dirección de la carpeta donde esta la BD y el nombre de la
BD entonces el programa la buscara y enlazara conectándola.