Los bloques Initialization y Finalization

Tanto initialization y finalization son palabras reservas y se utilizan como identificadores de los bloques de inicialización y finalización de una unidad. Si bien estas secciones de la unidad son opcionales y deben ubicarse al final de la misma, el bloque initialization es el primero en ejecutarse y en contraparte, finalization, es el último. Son los bloques olvidados de Pascal, la OOP o PPO han hecho que ya no se utilice casi nunca, pero su utilidad sigue vigente en algunos casos como veremos en unos ejemplos.

Estos bloques pueden utilizarse en conjunto o solo uno de ellos.

No se usa ni begin ni end para definir el comienzo y el fin de estos bloques, aunque puede utilizarse, es opcional. No confundir con en end. (end punto) que marca el final de la unidad.

Estos bloques se usan casi exclusivamente en unidades simples.

En el componente de Lazarus llamado Online Package Manager (OPM) o Gestor de Paquetes en Línea, en la unidad opkman_VTLogger veremos un ejemplo de su uso:

initialization
  Logger:=TLCLLogger.Create;
finalization
  Logger.Free;
end.

En la unidad DCConvertEncoding del populat programa Double Commander:

procedure Initialize;
begin
  //aquí hay código que es irrelevante para el ejemplo
end;

{$ENDIF}

initialization
  {$IF DEFINED(FPC_HAS_CPSTRING)}
  FileSystemCodePage:= WideStringManager.GetStandardCodePageProc(scpFileSystemSingleByte);
  {$ENDIF}
  Initialize;

end.

Declara un procedimiento llamado Initialize y lo llama al final del bloque Initialization.

Recordemos que el end seguido de un punto indica el fin de la unidad y nada tiene que ver con los bloques Initialization y Finalization.

El siguiente ejemplo lo utilizo en bastante en mis programas:

initialization
  ARCHIVO_OPCIONES:=Application.Location+'opciones.bin';
  ARCHIVO_CARPETAS:=Application.Location+'carpetas.txt';
  ARCHIVO_NOBORRAR:=Application.Location+'noborrar.txt';
  CARPETA_COPIAS:=Application.Location+'copias';

finalization; //Esto sobra pero si lo dejamos no pasa nada.

end.

Aunque están en mayúsculas son variables que utilizo como si fueran constantes, por eso las escribo así.

Para más información (en inglés) puede leerse la documentación oficial de Free Pascal de unit.

Ejecutar programas externos con TProcess

Para empezar hay que tener claro algo: TProcess no es un emulador de terminal.

TProcess es una clase utilizada para ejecutar y controlar otros procesos ajenos a nuestro programa.

La mayoría de la veces se usa para ejecutar comandos (que son programas) que se ejecutan desde un emulador de terminal, pero se pueden ejecutar también programas con entorno gráfico, es decir, cualquier clase de programas, incluso aquellos que requieren permiso de administrador, como veremos en el ejemplo.

TProcess es un componente "no visual" que está en la pestaña o lengüeta "System" de la barra de componentes de Lazarus. Esta clase se halla definida en la unidad process y forma parte de la FCL (Free Component Library).

function TFmain.LoadList: Boolean;
var
  proc:TProcess;
begin
  if Assigned(dmiList) then dmiList.Free;
  dmiList:=TStringList.Create;
  proc:=TProcess.Create(nil);
  proc.CommandLine:='pkexec dmidecode';
  proc.Options:=proc.Options+[poWaitOnExit, poUsePipes];
  proc.Execute;
  dmiList.LoadFromStream(proc.Output);
  proc.Free;
  Result:=dmiList.Count>0;
end;

Esta función es del programa LazDMIDecode y carga una lista con el resultado del comando dmidecode, que requiere contraseña de administrador y es solicitada al usuario anteponiendo el comando pkexec al comando dmidecode. De esta manera el programa nunca sabrá la password y el cuadro de diálogo que la solicita es el nativo del sistema operativo.

Las opciones, desde ya, deben definirse antes de llamar al proceso Execute o seleccionarlas desde el inspector de objetos si se utilizó como componente en un formulario o similar.

La opción poWaitOnExit indica que debe esperar a que finalice el proceso antes de pasar a la instrucción siguiente a proc.Execute.

La opción poUsePipes es para capturar el resultado que se almacena en la propiedad Output de TProcess en un stream. La propiedad Output solo debe utilizarse conjuntamente con la opción poUsePipes y solo si el comando invocado devuelve un resultado, caso contrario ocurrirá un error.

Para finalizar se asigna el stream de proc.Output al stringlist y luego se libera la instancia de TProcess si utilizó como en este ejemplo creándola mediante el constructor de la clase.

Documentación de TProcess:

• La clase TProcess
• El conjunto TProcessOptions
• Definiciones y ejemplos en la wiki de Free Pascal.
  

TActionList

Es una clase muy útil para manejar y asociar manejadores de eventos; de hecho, debería utilizarse siempre, aunque no tengamos dos componentes que ejecuten la misma acción y utilizar el famoso evento OnClik solo para referenciar a la acción de la lista e incluso que la acción de la lista sea llamar a un procedimiento o función que pueda ser miembro público o privado del Form o incluso de otra unidad.

Veamos el famoso ejemplo de cuando se tienen un menú, una barra y unos botones para realizar lo mismo.

Ingredientes:

• TMainMenu
• 3 TMenuItem
• TToolBar
• 3 TToolButton
• 3 TButton
• TActionList

Los ítems del menú Archivos serán: Abrir, Guardar y Cerrar, lo mismo para los botones de la barra y los botones del formulario.

Para abrir el editor de la lista de acciones TActionList1 se hace doble click sobre el mismo. Con [Insert] o haciendo click en "+" y en "Nueva acción", no en "Nueva acción estándar" que es otra cosa. Escribimos el nombre "Abrir" y lo mismo para las otras dos acciones: Guardar y Cerrar.

Debe de quedar así:

Ahora desde el inspector de objetos definimos los eventos de cada acción:

Haciendo click en los "..." se define solo.

Recordemos que estamos hablando de eventos, no podemos asignar a OnClick (por ejemplo) un procedimiento regular, debe ser un evento, por eso usamos la lista de acciones.

Además nuestro programa queda bien factorizado, mejor lectura y mantenimiento.

A cada TAction le definimos Caption y Name.

Todavía no escribimos nada de código, sigamos.

Desde el inspector de objetos, asociamos el evento OnClick de cada componente con la acción respectiva.

Otra opción es asignar la TAction justamente en el evento Action, o solo en OnClick o también en ambas. Para el ejemplo con OnClick solamente está bien.

En este caso la acción será solo un showmessage, pero en lugar de incluir el mismo en la acción, creamos un procedimiento privado en el formulario y en la acción llamamos al mismo. Siempre es mejor tener el menor código posible en los manejadores de eventos, además de esta forma podemos utilizar el procedimiento, llegado el caso, desde cualquier lado, incluso tenerlos en otra unidad.

El código:

unit Unit1;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, Forms, Controls, Graphics, Dialogs, Menus, ComCtrls,
  StdCtrls, ActnList;

type

  { TForm1 }

  TForm1 = class(TForm)
    aAbrir: TAction;
    aCerrar: TAction;
    aGaurdar: TAction;
    ActionList1: TActionList;
    bAbrir: TButton;
    bGuardar: TButton;
    bCerrar: TButton;
    mnAbrir: TMenuItem;
    mnGuardar: TMenuItem;
    mnCerrar: TMenuItem;
    mnMenu: TMainMenu;
    mnArchivos: TMenuItem;
    tbBarrar: TToolBar;
    tbAbrir: TToolButton;
    tbGuardar: TToolButton;
    tbCerrar: TToolButton;
    procedure aAbrirExecute(Sender: TObject);
    procedure aCerrarExecute(Sender: TObject);
    procedure aGaurdarExecute(Sender: TObject);
  private
    procedure Abrir;
    procedure Guardar;
    procedure Cerrar;
  public

  end;

var
  Form1: TForm1;

implementation

{$R *.lfm}

{ TForm1 }

procedure TForm1.aAbrirExecute(Sender: TObject);
begin
  Abrir;
end;

procedure TForm1.aCerrarExecute(Sender: TObject);
begin
  Cerrar;
end;

procedure TForm1.aGaurdarExecute(Sender: TObject);
begin
  Guardar;
end;

procedure TForm1.Abrir;
begin
  ShowMessage('Procedimiento Abrir archivo');
end;

procedure TForm1.Guardar;
begin
  ShowMessage('Procedimiento Guardar archivo');
end;

procedure TForm1.Cerrar;
begin
  ShowMessage('Procedimiento Cerrar archivo');
end;

end. 

Este es el uso clásico de la clase TActionList, pero la misma posee muchas más opciones. Además nos ahorramos tener en el código los eventos OnClick de cada componente y nos pudimos ahorrar también los procedimientos colocando ese código en el evento Execute de cada TAction.

Descargar proyecto.

TZQuery.ExecSQL

Actualización 26-12-2020: downgrade de Zeos 7.2.6 (también probé la 7.2.8) a Zeos 7.1.3.a stable del año del jopo.

No hace mucho actualicé tanto el IDE como el compilador, algunos componentes que forman parte de Lazarus se actualizan y otros, como ZeosLib no. Años usando la versión estable 7.1.3 (si no me equivoco) ya que las primeras versiones de la 7.2 me tiraba errores por todos lados. Finalmente decidí ir por la 7.2.6 y al principio iba todo bien, pero un sistema de los primeros que hice, hace ya más de 3 años, y sin las mejores técnicas de programación precisamente, me pidieron una modificación, nada del otro mundo y ahí empezaron los problemas con el querido Zeos. La documentación de los cambios de Zeos no es la mejor del mundo.

En dicho programa, tenía mucho código que actualizaba la base de datos con TZQuery en lugar de TZConnection.ExecuteDirect. Motivo: se pueden utilizar parámetros, me resulta más cómodo. Por ejemplo tenía códigos de este tipo:

ZQTHab.SQL.Text:='DELETE FROM tashaber;';
ZQTHab.Open;
ZQTHab.Close; 

Funcionaba sin problemas.

Ahora arroja un error: "Can not open a Resultset." 

 

Se soluciona con TZQuery.ExecSQL que la verdad no sé si es un método nuevo o si siempre existió.

ZQTHab.SQL.Text:='DELETE FROM tashaber;';
ZQTHab.ExecSQL; 

Lo bueno es que no se necesita ni abrir ni cerrar la consulta, más legible.

También me saltaron errores de base de datos bloqueada y tuve problemas con la edición e inserción de registros. Pues bien, hoy salió una nueva versión de ZeosLib, la 7.2.8 que no corrige esos bugs, pero anuncia que los mismos serán corregidos en la versión 8.0.

"When using Cached Updates, it is not possible to add a row and then edit
that row before posting to the database. This bug cannot be fixed in Zeos 7.2.
It has been fixed in the upcoming Zeos 8.0. Please use database transactions
instead.".

Respecto de la base de datos bloqueada, era cuando usaba una segunda conexión a la base de datos, tuve que eliminar esa segunda conexión. El tema sin solución es que el programa se usa en red y cuando dos o más usuarios se conectan a la base de datos se bloquea. Además era una de las gracias de utilizar el conector de Zeos con la propiedad Autocommit en true y funcionaba de maravilla.

Deberé, otra vez, regresar a la versión 7.1.3 donde todo funcionaba bien.

Guardar y leer un array of integer en un archivo.

Un vector de números enteros lo podemos también guardar en un archivo de texto, al fin y al cabo no hay que complicarse con la separación decimal y con un IntToStr para guardar y un StrToInt para leer, no debería de haber ninguna complicación, en más, dependiendo de lo que se busque, hasta tiene la ventaja de poder leerse y editar con un editor de texto plano, claro que también esto puede se una desventaja.

En Pascal podemos manejar archivos de varias formas, a su vez los archivos pueden ser de texto o binarios. Dentro del tipo de los binario tenemos binario a secas o de algún tipo, como por ejemplo, de enteros, de registros, etc.

En el ejemplo se usa el vector1 del tipo dinámico (también se puede usar uno estático) al cual se le establece un rango de 100 elementos, al ser dinámico se basa en cero, por lo tanto su índice inicial es el 0 y el final el 99; a este array se le cargan número enteros aleatorios hasta el 5.000 (se pude cambiar por cualquier otro valor). Luego se lo guarda en un archivo, se muestra el contenido en Memo1.

El vector2 se usa para leer el archivo de enteros. ¿Era necesario usar 2 vectores? No, se podría usar uno solo, pero pienso que se visualiza mejor el ejemplo. El vector2 se muestra en el Memo2 para comparar el resultado obtenido.

Lo principal:

• Para crear/cargar el archivo usamos: file of Integer.
• Para grabar el array abrimos/creamos el archivo con Rewrite que si el archivo existe lo sobre escribe. Recorremos el vector de la forma clásica y grabamos cada elemento del mismo en el archivo mediante Write.
• Para leer el archivo lógicamente también necesitamos definir una variable del tipo File Of Integer, abrimos el archivo mediante Reset que es de solo lectura y con un ciclo for to lo leemos y cargamos en vector2 mediante Read.
• Siempre debe cerrarse el archivo usando CloseFile.

unit Unit1;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, Forms, Controls, Graphics, Dialogs, Buttons, StdCtrls;

type

  { TForm1 }

  TForm1 = class(TForm)
    BCargarArray: TBitBtn;
    BGuardarArray: TBitBtn;
    BLeerArray: TButton;
    Edit1: TEdit;
    Memo1: TMemo;
    Memo2: TMemo;
    procedure BCargarArrayClick(Sender: TObject);
    procedure BGuardarArrayClick(Sender: TObject);
    procedure BLeerArrayClick(Sender: TObject);
    procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
    procedure FormCreate(Sender: TObject);
  private
    procedure ArrayToFile(aArray:array of integer; aNameFile:String);
    procedure ArrayFromFile(aArray:array of integer; aNameFile:String);
  public

  end;

var
  Form1: TForm1;
  vector1, vector2:array of integer;

implementation

{$R *.lfm}

{ TForm1 }

procedure TForm1.FormCreate(Sender: TObject);
begin
  Randomize;
  SetLength(vector1,100);
  SetLength(vector2,100);
end;

procedure TForm1.BGuardarArrayClick(Sender: TObject);
begin
  ArrayToFile(vector1,Edit1.Text);
end;

procedure TForm1.BLeerArrayClick(Sender: TObject);
begin
  ArrayFromFile(vector2,Edit1.Text);
end;

procedure TForm1.ArrayToFile(aArray: array of integer; aNameFile: String);
var
  i:Integer;
  aFile:file of Integer;
begin
  AssignFile(aFile,aNameFile);
  Rewrite(aFile);
  for i:=Low(aArray) to High(aArray) do
    Write(aFile,aArray[i]);
  CloseFile(aFile);
end;

procedure TForm1.ArrayFromFile(aArray: array of integer; aNameFile: String);
var
  i:Integer;
  aFile:file of Integer;
begin
  Memo2.Clear;
  AssignFile(aFile,aNameFile);
  Reset(aFile);
  for i:=1 to 100 do
    begin
      Read(aFile,aArray[i-1]);
      Memo2.Lines.Add((IntToStr(aArray[i-1])));
    end;
  CloseFile(aFile);
end;

procedure TForm1.BCargarArrayClick(Sender: TObject);
var
  i:Integer;
begin
  Memo1.Clear;
  for i:=Low(vector1) to High(vector1) do
    begin
      vector1[i]:=i+Random(5000);
      Memo1.Lines.Add(IntToStr(vector1[i]));
    end;
end;

procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
begin
  CloseAction:=caFree;
end;

end.

Descargar el proyecto.

TBitButton: cambiar imagen.

Se trata de cambiar la imagen de un botón TBitButton en tiempo de ejecución (o mediante código). En este caso las imágenes las obtenemos de TImageList y, como ejemplo, algo básico como un botón para ocultar o mostrar.

Al ejecutar el programa se tiene que ver algo así, un TMemo, que será el elemento del formulario a mostrar y ocultar, y un TBitButton que cambiará la imagen y el texto cada vez que se presione.

unit Unit1;

{$mode objfpc}{$H+}

interface

uses
Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, Buttons, StdCtrls;

type

{ TForm1 }

TForm1 = class(TForm)
  BitBtn1: TBitBtn;
  ImageList1: TImageList;
  Memo1: TMemo;
  procedure BitBtn1Click(Sender: TObject);
  procedure FormCreate(Sender: TObject);
private
  FOcultar:Boolean;
end;

var
  Form1: TForm1;

implementation

{$R *.lfm}

{ TForm1 }

procedure TForm1.FormCreate(Sender: TObject);
begin
  FOcultar:=True;
  ImageList1.GetBitmap(0,BitBtn1.Glyph);
end;

procedure TForm1.BitBtn1Click(Sender: TObject);
begin
  if FOcultar then
  begin
    ImageList1.GetBitmap(1,BitBtn1.Glyph);
    BitBtn1.Caption:='Mostrar';
    Memo1.Visible:=False;
  end
 else
 begin
   ImageList1.GetBitmap(0,BitBtn1.Glyph);
   BitBtn1.Caption:='Ocultar';
   Memo1.Visible:=True;
  end;
  FOcultar:=not(FOcultar);
end;

end.

En la variable FOcultar almacenamos el estado del botón.
En el evento FormCreate le asignamos el valor True a FOCultar y le asignamos la imagen correspondiente, en este caso la misma es la primera de TImageList que por cierto, también debemos incluir en el Form.
ImageList1.GetBitmap(0,BitBtn1.Glyph);
Para asignar la primera imagen de la lista, utilizamos el procedimiento GetBitmap de TImageList: el primer parámetro corresponde al índice de la imagen, el segundo, a la imagen destino, en este caso BitBtn1.Glyph.
Porque TBitBtn.Glyph:TBitmap = class(TFPImageBitmap).
El método (procedimiento) GetBitmap pertenece a la clase TCustomImageList:

TCustomImageList.GetBitmap(Index: Integer; Image: TCustomBitmap);

En este ejemplo también cambiamos el texto del botón.
Finalmente cambiamos el valor de FOcultar, sino, no pasa nada.

Si bien es algo sencillo, dejo el código fuente del proyecto: descargar.

Crear un formulario en tiempo de ejecución.

Muchas veces cuando programamos queremos ver los datos de las variables, ya sean arrays, stringlist o lo que sea, y nos valemos de uno o más TMemo para mostrar allí los datos. También para mostrar al usuario los logs o alguna otra información. Hay muchas formas de hacer esto, una de ellas creando un TForm con un Tmemo, de esta manera tendremos en la unidad más de un formulario, claro que solo uno será el creado por Lazarus con su correspondiente archivo .lfm.

Para el caso agregar en el Form 3 TButtons, solo eso.

Veamos el código.

unit Unit1;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls;

type

  { TForm1 }

  TForm1 = class(TForm)
  Button1: TButton;
  Button2: TButton;
  Button3: TButton;
  procedure Button1Click(Sender: TObject);
  procedure Button2Click(Sender: TObject);
  procedure Button3Click(Sender: TObject);
  procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
  procedure FormCreate(Sender: TObject);
  private
  sl1:TStringList;
  sl2:TStringList;
  sl3:TStringList;
  procedure VerLista(sl:TStringList);
public

end;

var
  Form1: TForm1;

implementation

{$R *.lfm}

{ TForm1 }

procedure TForm1.FormCreate(Sender: TObject);
var
  i:Integer;
begin
  sl1:=TStringList.Create;
  sl2:=TStringList.Create;
  sl3:=TStringList.Create;
  for i:=0 to 99 do
  begin
    sl1.Add(IntToStr(i));
    sl2.Add(IntToStr(i*10));
    sl3.Add(IntToStr(i*100));
   end;
end;

procedure TForm1.VerLista(sl: TStringList);
var
  F:TForm;
  mm:TMemo;
begin
  F:=TForm.Create(nil);
  F.Height:=380;
  F.Width:=500;
  F.Position:=poMainFormCenter;
  mm:=TMemo.Create(nil);
  mm.Text:=sl.Text;
  mm.Parent:=F;
  mm.Align:=alClient;
  mm.ScrollBars:=ssAutoBoth;
  F.ShowModal;
  FreeAndNil(mm);
  FreeAndNil(F);
end;

procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
begin
  CloseAction:=caFree;
end;

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

procedure TForm1.Button2Click(Sender: TObject);
begin
  VerLista(sl2);
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
  VerLista(sl3);
end;

end.

Lo más importante es esto
mm.Parent:=F;
que establece el parentesco, sitúa el TMemo dentro del formulario F. El resto es simplemente asignar valores a las propiedades tanto del formulario como del memo.

TStringGrid: borrar filas.

¿Por qué no hay un método (procedimiento o función) para eliminar todas la filas de un StringGrid excepto las fijas? Porque con StringGrid1.RowCount:=1; alcanza, dejando la primera fila únicamente, siendo ésta la fija (los títulos de las columnas), si se tratara de una grilla sin fila fija, entonces sería StringGrid1.RowCount:=0; casi siempre se utiliza la primer fila para los títulos de las columnas, la fila 0 (cero), de esta forma se conservan las propiedades de las columnas.

Otras formas de borrar filas:

DeleteRow(nroFila) donde nroFila es un entero, simplemente borra dicha fila.
Clear: Borra todo, no queda nada.

Borrar ciertas filas en base a una condición.

Lo primero a tener en cuenta es saber que utilizando un for to no vamos a ningún lado, por ejemplo:

for i:=0 to StingGrid1.RowCount-1 do
  if condicion then StringGrid.DeleteRow(i);

nos dará un error en timepo de ejecución; veamos por qué:

Supongamos que tenemos una grilla con 3 filas sin filas fijas, de la 0 a la 2 y sin ninguna condición usamos el método anterior. La propiedad RowCount-1 será 3-1=2 entonces el ciclo for será de 0 a 2, hasta ahí vamos bien.

En la primera iteración:
for i:=0 to StingGrid1.RowCount-1 do //i=0 y RowCount=2 es decir de 0 a 2
  StringGrid.DeleteRow(i); //Borra la fila 0

en la segunda iteración:
for i:=0 to StingGrid1.RowCount-1 do //i=1 y RowCount=1 es decir de 1 a 1
  StringGrid.DeleteRow(i); //Borra la fila 1

en la tercera iteración:
for i:=0 to StingGrid1.RowCount-1 do //i=2 y RowCount=1 es decir de 2 a 1 //---->ERROR<----
  StringGrid.DeleteRow(i); //Borra la fila 0

La forma correcta es mediante for downto. Supongamos una grilla de n filas con la primera de ellas fija la cual no borraremos, entonces:

for i:=StringGrid.RowCount-1 downto 1 do //el ciclo no llega a la fila 0.
  StringGrid.DeleteRow(i);

y con un condicional sería lo mismo pero agregando la condición:

for i:=StringGrid.RowCount-1 downto 1 do //el ciclo no llega a la fila 0.
  if condicion then
    StringGrid.DeleteRow(i);

Clase para medir tiempo de ejecución.

Si bien esta entrada que escribí hace exactamente dos años (increíble, juro que es coincidencia) acerca de medir el tiempo de ejecución de un proceso es totalmente válida y funcional, mejor aún es hacer una clase (class) que haga lo mismo. Las ventajas son muchas, desde la legibilidad del código hasta la manera más simple se su reutilización.

La clase es simple:

type
  TMedirTiempo=class(TObject)
private
  FInicio:TTime;
  FFinaliza:TTime;
  FTranscurrido:TTime;
public
  constructor Create (Owner:TComponent);
  function Iniciar:TTime;
  function Finalizar:TTime;
  function Transcurrido:TTime;
end;

Cómo estoy comenzando a implementar clases, luego de leer bastante, voy a explicar un poco algunas cosas que la mayoría de los colegas programadores ya saben, pero los que retomamos la programación luego de muchos años, no.

Por ejemplo, la clase la definimos como class(TObject) porque es una clase que no hereda de ninguna otra clase y la más "primitiva" es TObject. Ahora:
TMedirTiempo=class así sin TObject también es válido, pero no recomendado.
FInicio es un campo (Field) por eso se acostumbra a empezar con la letra F; los campos son variables que pertenecen a una clase. Si se declaran en la "sección" (en realidad no es sección aunque lo aparenta muy bien, private es un identificador) private solo podrá se accedido por otros miembros de la clase y clases heredadas pero no por la instancia de la clase, por ejemplo:

var
  Medidor:TMedirTiempo;
begin
  Medir:=TMedirTiempo.Create(nil);
  Medir.Finicio:= // esto no se puede.

¿Por qué usamos un constructor? Porque en él inicializamos los campos, pero muchas veces no es necesario definirlo, en tal caso se utiliza el heredado de TObject. Y sí, el constructor es público, lo mismo que las funciones, lo que implica que se pueden invocar en la unidad donde instanciamos la clase.

Hasta aquí la interfaz, vamos ahora a la implementación de la clase.

constructor TMedirTiempo.Create(Owner: TComponent);
begin
  FInicio:=StrToTime('0');
  FFinaliza:=StrToTime('0');
  FTranscurrido:=StrToTime('0');
end;

function TMedirTiempo.Iniciar: TTime;
begin
  FInicio:=Now;
end;

function TMedirTiempo.Finalizar: TTime;
begin
  FFinaliza:=Now;
end;

function TMedirTiempo.Transcurrido: TTime;
begin
  FTranscurrido:=FFinaliza-FInicio;
  Result:=FTranscurrido;
end;

Y para utilizarla es muy simple, por ejemplo:

Procedure CargarSList;
var
  MedirTiempo:TMedirTiempo;
  sl:TStringList;
  i:Integer;
begin
  sl:=TStringList.Create;
  MedirTiempo:=TMedirTiempo.Create(nil);
  MedirTiempo.Iniciar;
  for i:=1 to 100000 do
    sl.Add(IntToStr(i));
  MedirTiempo.Finalizar;
  ShowMessage('Tiempo transcurrido: '+TimeToStr(MedirTiempo.Transcurrido));
  sl.Free;
  MedirTiempo.Free;
end;


También podríamos mostrar la hora de inicio y fin de la medición, porque ambas son funciones que devuelven el tiempo.

Puede pasar (y pasa) que el tiempo es menor a un segundo, entonces se muestra 0 (cero). Una opción para agregar los milisegundos es utilizar la misma función TimeToStr (que se ubica en la unidad DateUtils) con la opción FormatSettings.
Sería algo así:

Procedure CargarSList;
var
  MedirTiempo:TMedirTiempo;
  sl:TStringList;
  i:Integer;
  fs:TFormatSettings;
begin
  fs:=DefaultFormatSettings;
  fs.LongTimeFormat:='hh:nn:ss.zzz';
  sl:=TStringList.Create;
  MedirTiempo:=TMedirTiempo.Create(nil);
  MedirTiempo.Iniciar;
  for i:=1 to 100000 do
    sl.Add(IntToStr(i));
  MedirTiempo.Finalizar;
  ShowMessage('Tiempo transcurrido: '+TimeToStr(MedirTiempo.Transcurrido,fs));
  sl.Free;
  MedirTiempo.Free;
end;


TFormatSettings es un registro (record) por lo tanto ni se crea ni se libera.