18 julio 2008

Pasando de Delphi 7 a RAD Studio 2007 (2)

Sigamos viendo las novedades de RAD Studio respecto a Delphi 7.

EL EDITOR DE CODIGO FUENTE

Esta es una comparativa entre el editor de código de Delphi 7 y RAD Studio 2007:


La primera característica que puede apreciarse es en la barra lateral situada a la izquierda del código fuente. Mientras que Delphi 7 sólo mostraba la posición de la línea y columna actual en la parte inferior del editor de código, en RAD Studio podemos ver siempre el número de línea donde estamos situados. Además, también muestra el número de línea cada 10 líneas.

Otra novedad que destaca se encuentra en la línea lateral de color verde. Esta línea nos informa en todo momento del código fuente que se ha modificado y si se ha guardado o no.

Por ejemplo, si yo creo una variable privada, me mostrará en amarillo las líneas afectadas por la modificación:


Cuando pulse el botón de guardar volverán a estar todas las líneas en color verde, preparado para más modificaciones:


También otra novedad importante que da más claridad al código fuente es la posibilidad en abrir y cerrar bloque de código. Por ejemplo este bloque código fuente está abierto:


Si pulsamos el botón [-] que se indica en la foto superior contraerá toda la definición de la clase TForm1 dejando menos líneas de código en pantalla:


El botón [-] ha sido sustituido por el botón [+] para poder desplegar el código de nuevo. El funcionamiento es similar a otros entornos de desarrollo como Visual Studio, NetBeans, Eclipse, etc.

Así mismo, podemos contraer o estirar todos los bloques de código de la unidad en la que estamos situados pulsando con el botón derecho del ratón sobre el código fuente y seleccionando la opción Fold:


Podemos contraer métodos, tipos de datos, etc.

Lo mismo para volver a desplegarlo todo:


La barra de estado inferior del editor de código también tiene algunas novedades:


En la parte izquierda de la barra incorpora tres botones para la grabación y la reproducción de macros. Una macro puede ser desde una acción con los menús de Delphi o incluso escribir un código fuente que luego tenemos que repetir. Es decir, graba todas las acciones de teclado o ratón que se realicen en Delphi para su posterior reproducción.

Después tiene las mismas coordenadas de fila y columna que tenía Delphi 7 y el estado al escribir: Insertar o Modificar. Por último, finaliza con tres pestañas:

Code: Muestra el editor de código.

Design: Muestra el formulario.

History: Muestra el histórico de versiones del código fuente de la unidad actual.

EL HISTORIAL DE VERSIONES

La pestaña History es otra de las novedades que incorporan las versiones Delphi para Win32 y superiores:


Para cada unidad de código, RAD Studio realiza automáticamente un control de versiones para poder recuperar el código fuente de modificaciones anteriores.

Cuando hemos pulsado las pestaña History ha dividido el editor de código fuente en dos partes. La parte superior muestra las distintas versiones que almacena de la unidad donde estamos:


La última versión es File y el resto va en orden descendente. En entorno de RAD Studio viene configurado por defecto para guardar hasta 10 versiones de cada unidad. Aunque podemos modificar esto seleccionando Tools -> Options y en la sección Editor Options tenemos el campo File backup limit:


Vamos a verlo con un ejemplo. Supongamos que añado la variable sDireccion a mi clase TForm1:


Si pulsamos la pestaña History podemos ver la última versión pulsando sobre la primera fila del histórico (File):


Pero si seleccionamos la versión 3 (la segunda fila) me mostrará como estaba el código fuente antes de realizar el último cambio:


Como sabemos por la configuración que guarda hasta los 10 últimos cambios, podemos modificar el programa a nuestro antojo sin miedo a rectificar el código actual. Todos estos cambios los va guardando realmente en una carpeta llamada __history que esta situada en el mismo directorio de nuestro proyecto.

Si queremos recuperar una versión anterior sólo hay que seleccionarla con el botón derecho del ratón y seleccionar Revert:


Nos pedirá confirmación por si acaso:


Una vez pulsemos el botón Yes dejará el código fuente exactamente como estaba en esa versión.

REFACTORIZANDO BLOQUES DE CÓDIGO

Esta es otra de las mejores características que incorpora respecto a Delphi 7. Como todos sabéis, refactorizar el código fuente significa crear funciones o procedimientos comunes que simplifiquen y reduzcan el número de líneas de código. Vamos a verlo con un ejemplo.

Supongamos que tengo un procedimiento con dos bucles que hacen casi lo mismo:

procedure TForm1.Facturar;
var
i: Integer;
begin
for i := 1 to iNumeroPedidos do
begin
MarcarDocumento( i );
CrearFactura;
ActualizarMovimientos;
end;

for i := 1 to iNumeroAlbaranes do
begin
MarcarDocumento( i );
CrearFactura;
ActualizarMovimientos;
end;
end;

Para simplificar este procedimiento habría que hacer otro procedimiento común llamado FacturarDocumento que ejecutará cada una de las tres líneas de cada bucle. Hasta ahora lo hemos hecho a mano, pero vamos a ver como se simplifica el proceso con RAD Studio.

Ahora podemos refactorizarlo de la siguiente manera:

1. Seleccionamos las tres líneas del primer bucle:


2. Pinchamos con el botón derecho del ratón sobre las líneas seleccionadas y elegimos Refactoring -> Extract Method:


Aparecerá esta ventana:


2. En el campo New Method Name escribimos FacturarDocumento y pulsamos el botón Ok. El código fuente quedará de este modo:

procedure TForm1.FacturarDocumento(i: Integer);
begin
MarcarDocumento(i);
CrearFactura;
ActualizarMovimientos;
end;

procedure TForm1.Facturar;
var i: Integer;
begin
for i := 1 to iNumeroPedidos do
begin
FacturarDocumento(i);
end;

for i := 1 to iNumeroAlbaranes do
begin
MarcarDocumento( i );
CrearFactura;
ActualizarMovimientos;
end;
end;

Lo que ha hecho es crear el nuevo método llamado FacturarDocumento que se ha llevado las tres líneas del bucle y las ha reemplazado por una llamada a este nuevo método. Ahora sólo queda quitar los begin y end del primer bucle y hacer lo mismo con el segundo:

procedure TForm1.FacturarDocumento(i: Integer);
begin
MarcarDocumento(i);
CrearFactura;
ActualizarMovimientos;
end;

procedure TForm1.Facturar;
var
i: Integer;
begin
for i := 1 to iNumeroPedidos do
FacturarDocumento(i);

for i := 1 to iNumeroAlbaranes do
FacturarDocumento(i);
end;

Como puede apreciarse, la refactorización ha sido un éxito y nos ha llevado poco tiempo. Quizás en programas tan pequeños como este no se note demasiado, pero en unidades de miles de líneas os puedo asegurar que es una bendición.

También se puede hacer más rápido del siguiente modo: seleccionas el bloque de código que quieres sacar a parte y luego pulsas la combinación de teclas Mayúsculas + CTRL + M. Después pulsas Intro y ya esta.

DECLARANDO VARIABLES AUTOMÁTICAMENTE

Otra de las características que incorporan las opciones dedicadas a la refactorización es la posibilidad de declarar automáticamente en la sección var las variables que utilizamos en un bloque de código.

Por ejemplo, supongamos que creo el siguiente bucle:

procedure TForm1.CrearFactura;
begin
for i := 0 to iLineasDetalle do
ActualizarMovimientosLinea( i );
end;

Vamos hacer que la variable i la declare RAD Studio automáticamente. Hay que seguir estos pasos:

1. Seleccionamos la varible i.

2. La pinchamos con el botón derecho del ratón y seleccionamos Refactoring -> Declare Variable:


Aparecerá esta ventana:


Como puede apreciarse, ya ha reconocido que la variable a declarar es de tipo Integer.

3. Pulsamos el botón Ok y este es el resultado:

procedure TForm1.CrearFactura;
var
i: Integer;
begin
for i := 0 to iLineasDetalle do
ActualizarMovimientosLinea( i );
end;

En procedimientos pequeños como este no suele apreciase mucho esta opción, pero en bloques de código de 50 o 60 líneas si que es un autentico coñazo tener que subir al principio del procedimiento a declarar la variable para luego volver a bajar y seguir por donde íbamos.

Este proceso todavía se puede hacer mucho más rápido si seleccionamos la variable i y luego pulsamos la combinación de teclas Mayúsculas + CTRL + V y luego pulsamos Intro. Cuando te aprendes esta combinación es una auténtica gozada y se gana mucha velocidad.

RENOMBRANDO LAS VARIABLES DE UN BLOQUE DE CÓDIGO

Las opciones de refactorización también permiten renombrar las variables de un bloque de código, ya sea de un procedimiento, función, clase o de toda la unidad.

Muchos os preguntaréis, ¿para que quiero esta opción si ya utilizo CTRL + R para reemplazar trozos de código? Pues con variables que tienen un nombre único no hay problema, pero ¿Qué pasa si necesitas renombrar la variable i de un bucle sin estropear la letra i de todo el resto del código?

Por ejemplo en este bloque de código:

procedure TForm1.Facturar;
var
i: Integer;
begin
for i := 1 to iNumeroPedidos do
FacturarDocumento(i);

for i := 1 to iNumeroAlbaranes do
FacturarDocumento(i);
end;

Si yo intento cambiar el nombre de la variable i por j utilizando CTRL + F me haría este desastre:

procedure TForm1.Facturar;
var
j: jnteger;
begjn
for j := 1 to jNumeroPedjdos do
FacturarDocumento(j);

for j := 1 to jNumeroAlbaranes do
FacturarDocumento(j);
end;

No sólo he ha reemplazado la variable i sino que me ha estropeado dos variables más y hasta el comando begin.

Para hacer esto correctamente hay que seguir estos pasos:

1. Seleccionamos cualquier variable i (ya sea la que está dentro de la sección var o la del bucle).

2. Pulsamos esta variable con el botón derecho del ratón y seleccionamos Refactoring -> Rename variable “i”:


Mostrará este cuadro de diálogo:


3. En el campo New Name podemos j y pulsamos Ok.

4. Como RAD Studio es muy precavido, nos mostrará en la parte inferior de la ventana de código como quedaría el bloque de código después de la operación:


Ahora sólo tenemos que pulsar el botón Refactor y luego cerramos la ventana de refactoring:


Lo bueno que tiene esto es que sólo nos reemplaza la variable dentro de ámbito donde estamos. Si estamos dentro de un procedimiento, sólo nos modifica la variable del mismo y no del resto de la unidad. También detecta cuando estamos renombrando la variable de una clase en concreto o de toda la unidad.

CAMBIANDO LOS PARÁMETROS DE FUNCIONES Y PROCEDIMIENTOS

¿Qué pasa cuando tenemos que añadir, modificar o eliminar un nuevo parámetro a una función o procedimiento de una clase? Hasta ahora teníamos que hacer lo siguiente:

1. Nos vamos a la definición de la clase (dentro de type) y añadimos el nuevo parámetro.

2. Nos vamos a la implementación del procedimiento y también añadimos el nuevo parámetro.

3. Buscamos por todas las unidades del proyecto a ver quien llama a este procedimiento y añadimos el nuevo parámetro (esto lo hacemos compilando y según se vaya quejando el compilador vamos reemplazando código).

Pues ahora sólo tenemos que hacerlo en un solo paso. Por ejemplo tenemos este procedimiento:

procedure TForm1.FacturarDocumento( i: Integer );
begin
MarcarDocumento(i);
CrearFactura;
ActualizarMovimientos;
end;

el cual es llamado por este otro:

procedure TForm1.Facturar;
var
j: integer;
begin
for j := 1 to iNumeroPedidos do
FacturarDocumento(j);

for j := 1 to iNumeroAlbaranes do
FacturarDocumento(j);
end;

Pues bien, supongamos que tengo que añadir otro parámetro:

procedure TForm1.FacturarDocumento( i: Integer; bEstado: Boolean );

Hay que hacerlo del siguiente modo:

1. Selecciono el nombre del procedimiento (FacturarDocumento) con el botón derecho del ratón y selecciono Refactoring -> Change params:


Aparecerá esta ventana:


2. Pulsamos el botón Add y aparecerá este cuadro de diálogo:


3. En el campo Parameter Name escribimos bEstado y en Data type el valor Boolean. Después pulsamos Ok.

3. Volverá a la ventana anterior con el nuevo parámetro:


4. Pulsamos Ok y aparecerá la sección de refactoring informándonos de los las líneas de código afectadas por el cambio:


5. Pulsamos el botón Refactor y trabajo terminado tanto en la declaración de la clase:

private
{ Private declarations }
procedure FacturarDocumento(i: Integer; bEstado: Boolean);
...

Como en la implementación:

procedure TForm1.FacturarDocumento( i: Integer; bEstado: Boolean );
begin
MarcarDocumento(i);
CrearFactura;
ActualizarMovimientos;
end;

Además nos deja preparadas las llamadas este procedimiento para añadir el nuevo parámetro:

procedure TForm1.Facturar;
var
j: integer;
begin
for j := 1 to iNumeroPedidos do
FacturarDocumento(, )(j);

for j := 1 to iNumeroAlbaranes do
FacturarDocumento(, )(j);
end;

Aunque hay que reconocer que esto último es algo rarillo. Pero bueno, al fin y al cabo tenemos que modificar las llamadas y darles el nuevo parámetro. El IDE ha realizado un trabajo limpio e impecable que nos ahorra muchas compilaciones y saltos en el código de allá para acá.

En el próximo artículo seguiremos viendo más novedades.

Pruebas realizadas con RAD Studio 2007.

3 comentarios:

Anónimo dijo...

Me parece muy bueno el trabajo que te estas currando. Animo.

Administrador dijo...

Se hace lo que se puede. Gracias.

Talleres dijo...

Estan geniales los 2 articulos. Me gusta leer sobre Delphi todabia. Sigue asi ;)

Publicidad