PDF de programación - Los genéricos en Delphi 2009

Los genéricos en Delphi 2009



Los genéricos en Delphi 2009
Con propina sobre rutinas anónimas y las referencias de rutina

por Sébastien Doeraene (sjrd.developpez.com)



traducción por Juan Badell
Fecha de Publicación: 13 noviembre 2008

Última puesta al día:


¡ Hace tiempo que los esperábamos ! Finalmente están aquí: los genéricos en Delphi Win32. Estas
pequeñas maravillas llegan con Delphi 2009. Este tutorial te da opción a comprenderlos,
aprender a utilizarlos y, a continuación, diseñar tus propias clases genéricas.

Vuestros comentarios, críticas, sugerencias, etc. serán bienvenidos en el blog.

I. Introducción

I-A. Requisitos

Este tutorial no es para el principiante en Delphi que nunca ha practicado la programación
orientada a objetos. Requiere conocer el lenguaje de Delphi antes, y un importante conocimiento
de la POO.
En cuanto a los genéricos, no es necesario el conocimiento previo para la correcta comprensión y
asimilación de este tutorial. Sin embargo, dado el número de artículos sobre los genéricos
existentes en otros idiomas, no cubriré en detalles las preguntas como "¿Cómo usar los genéricos
correctamente?". La siguiente sección introduce rápidamente al lector en el concepto de los
genéricos, pero si usted no sabe aún lo que es, la mejor comprensión se hará siguiendo este
tutorial a través de ejemplos. Aquí hay algunos artículos que tratan los genéricos en otros
lenguajes / plataformas. Los conceptos son siempre los mismo, y gran parte de su puesta en
escena también.

•
•
•

Les génériques sous Delphi .NET por Laurent Dardenne ;
Generics avec Java Tiger 1.5.0 por Lionel Roux ;
Cours de C/C++ - Les template por Christian Casteyde.

I-B. ¿Qué son los genéricos?

Los genéricos, a veces llamados parámetros genéricos, un nombre que permite presentarlos
mucho mejor. A diferencia del parámetro de una función (argumento), que tiene un valor, el
parámetro genérico es un tipo. Y un parámetro genérico parametrizado una clase, un interfaz, un
record, o, con menor frecuencia, un método.

Para dar inmediatamente una idea más clara, este es un extracto de la clase TList<T>, usted
puede encontrarlo en la unidad Generics.Collections.pas.



¡Sí!, es posible tener puntos en el nombre de una unidad (sin contar el del .pas). No tiene
nada que nada que ver con la noción de espacio de nombres de .NET ni paquete de Java.
Es sólo que ‘.’ tiene el mismo valor que ‘_’ a este nivel, simplemente es parte del
nombre.


type
TList<T> = class(TEnumerable<T>)
// ...
public

Copyright © 2008 - Sébastien Doeraene – traducción por Juan Badell. No está permitida la reproducción, incluso parcial, que puedan hacer de esta
página web y todo su contenido: textos, documentos, imágenes, etc, sin el permiso expreso del autor. De lo contrario incurre la ley hasta 3 años de
prisión y hasta 300.000 € por daños y perjuicios.

http://sjrd.developpez.com/delphi/tutoriel/generiques/

Pág. 1 de 29

Los genéricos en Delphi 2009



// ...

function Add(const Value: T): Integer;
procedure Insert(Index: Integer; const Value: T);

function Remove(const Value: T): Integer;
procedure Delete(Index: Integer);
procedure DeleteRange(AIndex, ACount: Integer);
function Extract(const Value: T): T;

procedure Clear;

property Count: Integer read FCount write SetCount;
property Items[Index: Integer]: T read GetItem write SetItem; default;
end;



Puede observar directamente lo extraordinario del tipo T. Pero, ¿es esto realmente un tipo? No, es
un parámetro genérico. Con esta clase, si necesito una lista de números enteros, utilizo
TList<Integer>, ¡en lugar de un "simple" TList con muchos operadores necesarios en el código!

Los genéricos nos permiten, por tanto, de alguna manera, declarar una serie de clases
(potenciales) de una sola vez, o más exactamente declarar un modelo de clase, pero con uno (o
varios) tipos como parámetro, que se pueden cambiar a voluntad. A cada nueva instancia con un
nuevo tipo real, es como si estuviera escribiendo una nueva clase real, desde el modelo y, por
tanto, otorgarle un verdadero potencial a estas clases.

Como ya he dicho, no voy a detenerme en el por-qué de la forma genérica. Voy a entablar de
inmediato su uso sobre una utilidad diaria. Si todavía no entienden, no importa: todo se irá
aclarando gradualmente poco a poco.

También puede consultar el tutorial

Les génériques sous Delphi .NET de Laurent Dardenne.

II – Uso cotidiano de Tlist<T>

Paradójicamente, vamos a ver primero cómo utilizar una clase genérica – es un abuso del
lenguaje, deberíamos decir: modelo genérico de clase - a diario, no cómo escribir una nueva. Hay
varias buenas razones para ello.

En primer lugar, porque es mucho más fácil diseñar y escribir una clase una vez que tenemos una
idea de cómo debemos utilizarla. Y es aún más cierto en cuando descubrimos un nuevo
paradigma de programación.

Por otro lado, la mayoría de las presentaciones a la orientación a objetos comienzan en general
cómo utilizar una clase creada de antemano.

II –A– Un código simple de base

Para empezar sin problemas, vamos a escribir un pequeño programa que muestra los cuadrados
de números enteros de 0 X, dónde X está definida por el usuario.

Tradicionalmente, se utiliza una matriz dinámica (y sería mucho mejor, recuerde que se trata aquí
un caso docente), pero vamos a utilizar una lista de números enteros.

Vamos directamente al código:

Copyright © 2008 - Sébastien Doeraene – traducción por Juan Badell. No está permitida la reproducción, incluso parcial, que puedan hacer de esta
página web y todo su contenido: textos, documentos, imágenes, etc, sin el permiso expreso del autor. De lo contrario incurre la ley hasta 3 años de
prisión y hasta 300.000 € por daños y perjuicios.

http://sjrd.developpez.com/delphi/tutoriel/generiques/

Pág. 2 de 29



Los genéricos en Delphi 2009



program TutoGeneriques;

{$APPTYPE CONSOLE}

uses
SysUtils, Classes, Generics.Collections;

procedure WriteSquares(Max: Integer);
var
List: TList<Integer>;
I: Integer;
begin
List := TList<Integer>.Create;
try
for I := 0 to Max do
List.Add(I*I);

for I := 0 to List.Count-1 do
WriteLn(Format('%d*%0:d = %d', [I, List[I]]));
finally
List.Free;
end;
end;

var
Max: Integer;
begin
try
WriteLn('Introduzca un número entero :');
ReadLn(Max);
WriteSquares(Max);
except
on E:Exception do
Writeln(E.Classname, ': ', E.Message);
end;

ReadLn;
end.



¿Qué diferencia aprecia usted en este código?

En primer lugar, por supuesto, la declaración de la variable List y la creación de la instancia. Al
nombre del tipo TList, hemos adjuntado en un parámetro real (o su equivalente: es un tipo, no un
valor) entre los signos < y >. (En Inglés, se les llama angle brackets, lo que significa literalmente:
paréntesis en forma de ángulos.)

Usted podrá apreciar pues, que para utilizar una clase genérica, es necesario, asignarle un nombre
e indicar un tipo de parámetro. Por ahora, vamos a utilizar aquí siempre un tipo real.

Algunos idiomas permiten un genérico, lo que se conoce el tipo de inferencia, que es para que el
compilador adivine el tipo (que se llama parámetro de tipo). Este no es el caso Delphi para Win32.
Esa es la razón por la que no se puede escribir:



var
List: TList<Integer>;
begin

Copyright © 2008 - Sébastien Doeraene – traducción por Juan Badell. No está permitida la reproducción, incluso parcial, que puedan hacer de esta
página web y todo su contenido: textos, documentos, imágenes, etc, sin el permiso expreso del autor. De lo contrario incurre la ley hasta 3 años de
prisión y hasta 300.000 € por daños y perjuicios.

http://sjrd.developpez.com/delphi/tutoriel/generiques/

Pág. 3 de 29

Los genéricos en Delphi 2009



List := TList.Create; // falta <Integer> aquí
...
end;



Éste segundo asunto es más importante y menos visible, ya que se trata de una ausencia. De
hecho, no es necesaria la conversión de enteros en punteros, ¡y viceversa! ¿Práctico, no? Y, sobre
todo, mucho más legible.

Además, la seguridad del tipo está mejor gestionada. Con las conversiones, siempre se corre el
riesgo de equivocarse, y añadir un puntero a una lista destinada a contener enteros, o viceversa.
Si utiliza correctamente los genéricos, usted probablemente casi nunca necesitará las
conversiones y, por tanto, cometerá menos errores. Además, si intenta añadir un tipo Pointer a una
clase de objeto TList<Integer>, es el compilador quien le mande de paseo. Antes de los genéricos, ¡un error
de este estilo podría no haber sido revelado más que por un valor aberrante, ¡después de su explotación!

Tenga en cuenta que he elegido el tipo Integer para limitar el código que no esté directamente
vinculado a la noción de genéricos, pero podríamos haber utilizado cualquier tipo en su lugar.

II –B– Asignaciones entre clases genéricas

Como usted sabe, cuando hablamos de herencia, podemos asignar una instancia de una subclase
a una variable de una clase madre, pero no a la inversa. ¿Qué pasa en los genéricos con esto?

¡Parta del principio de que usted no puede hacer nada! Todos estos ejemplos son falsos, y no
compilan:


var
NormalList: TList;
IntList: TList<Integer>;
ObjectList: TList<TObject>;
ComponentList: TList<TComponent>;
begin
ObjectList := IntList;
ObjectList := NormalList;
NormalList := ObjectList;
ComponentList := ObjectList;
ObjectList := ComponentList; // sí, hasta esto es falso
end;



Como el comentario señala, esto no es porque un TComponent puede ser asignados a una
TObject que un TList<TComponent> pueda ser asignados a un TList<TObject>. Para
entender por qué, piense que