ECO está en su 3ª versión junto con Delphi 2006, trayendo nuevos recursos para aquellos que desean iniciar el desarrollo orientado a modelos. Esta nueva forma de desarrollo es un rompimiento de paradigma que vale la pena, pues la productividad del desarrollo aumenta 5 veces, en otras palabras, viene a resolver las necesidades de los desarrolladores que requieren desarrollar mas rápido, con mayor calidad, a menor costo.

Delphi viene extendiendo el desarrollo más allá de los componentes del Framework, orientación a objetos, componentes y desarrollo RAD pues nada de esto es una novedad para los desarrolladores Delphi.

La nueva versión de BDP tiene drivers actualizados para Oracle 10g, Sybase 12.5, SQL Server 2005, InterBase 2007, además el nuevo soporte a MySQL 4, lo que ayuda a los desarrolladores en la migración de sus aplicaciones soportando nuevas versiones de base de datos

La VCL extendió sus capacidades para a soportar .NET y evoluciono también a través de nuevos componentes y actualizaciones en su infraestructura. Posteriormente vamos abordar estos nuevos componentes y hablaremos sobre la VCL Win32. Vale la pena mencionar que la migración de Win32 para .NET esta garantizada.

Se trata de una nueva directiva que va aumentar el desempeño del compilador con solo agregar la palabra reservada “inline”. En este caso, el método es expandido, evitando su lectura a todo momento. Esta forma de acceso presenta mejores resultados para métodos pequeños, fuera del alcance de la unit o para rutinas con muchos parámetros. Para el caso de rutinas mas grandes, se recomienda hacer una análisis de costo-benefició en cuanto a su utilización

A continuación se muestra el código una aplicación de consola, utilizando “inline” en la función Max.

program InlineDemo;
{$APPTYPE CONSOLE}

uses
  MMSystem;

  function Max(const X,Y,Z: Integer): Integer;inline
  begin
    if X > Y then
      if X > Z then Result := X
               else Result := Z
    else
      if Y > Z then Result := Y
               else Result := Z
  end;

const
  Times = 10000000; // 10 millón
var
  A,B,C,D: Integer;
  Start: LongInt;
  i: Integer;

begin
  Random; // 0
  A := Random(4242);
  B := Random(4242);
  C := Random(4242);
  Start := TimeGetTime;
  for i:=1 to Times do
    D := Max(A,B,C);
  Start := TimeGetTime-Start;
  writeln(A,', ',B,', ',C,': ',D);
  writeln('Calling Max ',Times,' times took ',Start,' milliseconds.');
  readln

end.

Al ejecutar esté código y comparar los resultados se ecuentra una reducción importante en el tiempo de respuesta. Los siguientes resultados se obtuvieron despues de que se invoco la función Max 10 millones de veces en una computadora Pentium M 1.8GHz con 2GB RAM. . Aunque estos valores pueden cambiar una computadora a otra, las proporciones son similares.

De acuerdo con lo visto en la tabla anterior, se observa que al utilizar la capacidad “inline”, el código compilado puede aumentar, su rendimiento más de un 50%.

Este recurso se tiene disponible tanto para Delphi Win32 como parA .NET para clases y registros (records). A través de algunas funciones implícitas, el compilador genera automáticamente la llamada más apropiada durante la ejecución. A continuación, un ejemplo de su utilización.

type
   TMyClass = class
     class operator Sumar(a, b: TMyClass): TMyClass;      // Sumar las clases de tipo TMyClass
     class operator Restar(a, b: TMyClass): TMyclass; // Restar las clases de tipo TMyClass
     class operator Implicit(a: Integer): TMyClass;     // Conversión implícita  para la clase de tipo TMyClass
     class operator Implicit(a: TMyClass): Integer;     // Conversión implícita de la clase TmyClass para Integers.
     class operator Explicit(a: Double): TMyClass;      // Conversión explicita de un Double para la clase TMyClass
   end;

// Ejemplo de implementación del método Sumar
class operator TMyClass.Add(a, b: TMyClass): TMyClass;
begin
   // ...
end;

var
x, y: TMyClass;
begin
   x := 12;      // Conversión implícita de un Integer, ejecuta el método Implicit
   y := x + x;   // Ejecuta TMyClass.Add(a, b: TMyClass): TMyClass
   b := b + 100; // Ejecuta TMyClass.Add(b, TMyClass.Implicit(100))
end;
   

Los Class Helpers permiten extender clases sin utilizar herencia. Este recurso es importante, pues algunas clases, llamadas clases Selead, no pueden ser heredadas. La utilización de este nuevo recurso es muy apreciada. A continuación se muestra un ejemplo.

type
   TMyClass = class
      procedure MyProc;
      function  MyFunc: Integer;
   end;

   ...

   procedure TMyClass.MyProc;
   var X: Integer;
   begin
      X := MyFunc;
   end;

   function TMyClass.MyFunc: Integer;
   begin
       ...
   end;

...

type 
   TMyClassHelper = class helper for TMyClass
     procedure HelloWorld;
     function MyFunc: Integer;
   end;

   ...

   procedure TMyClassHelper.HelloWorld;
   begin
      writeln(Self.ClassName); // Self hace referencia al tipo TMyClass y no TMyClassHelper
   end;

   function TMyClassHelper.MyFunc: Integer;
   begin
     ... 
   end;
 
...
   
var 
  X: TMyClass;
begin
  X := TMyClass.Create;
  X.MyProc;    // Ejecuta TMyClass.MyProc
  X.HelloWorld; // Ejecuta TMyClassHelper.HelloWorld
  X.MyFunc;    // Ejecuta TMyClassHelper.MyFunc

Vale la pena observar que la referencia es siempre a la clase TMyClass. El compilador sabe cuando ejecutar la llamada a TMyClassHelper.

Ahora en Delphi Win32 y .NET se tienen dos formas adicionales de determinar la visibilidad de los atributos de una clase: strict private y strict protected.

Strict private: todos los atributos de la clase son visibles únicamente en la clase que fueron declarados. Estos atributos no estarán visibles para métodos declarados en la misma unit y para aquellos que no forman parte de la clase.

Strict protected: Específica que los atributos da clase son visibles para la propia clase y sus descendentes.

En Delphi 2006, las capacidades de los registros (records) han sido incrementadas, pasando a ser casi lo mismo que una clase (Class), con soporte ha:

• Constructores.
• Sobre posición de operadores.
• Declaración de métodos no-virtuales.
• Métodos y propiedades estáticos.

Veamos un ejemplo de la implementación de un registro con estas nuevas características:

Type
    TMiRegistro = Record
    Type
         TTipoColor = Integer;
    Var
         Rojo : Integer;
         Class Var
         Azul : Integer;
         Procedure imprimirRojo();
Constructor Create(Val : Integer);
         Property pRojo : TTipoColor Read Rojo Write Rojo;
         Class Property  pAzul : TTipoColor Read Azul Write Azul;
    End;

    Constructor TMiRegistro.Create(Val: Integer);
Begin
  Rojo := Val;
End;

Procedure TMiRegistro.imprimirRojo;

Begin

WriteLn('Rojo: ', Rojo);

End;

De acuerdo a lo visto anteriormente los registros pueden utilizar muchas de las funcionalidades que hasta entonces eran exclusivas de las clases, sin embargo los registros no son clases y tienen muchas diferencias:

• Los Registros no tienen soporte a herencia;
• Los Registros pueden tener partes variable, las clases no;
• Los Registros son tipos de datos y pueden, entre otras cosas, ser copiados, clases no;
• Los Registros no tienen destructores;
• Los Registros no tienen soporte a métodos virtuales;

Diversas nuevas formas de declaración de clases, tipos, variables y propiedades.

• Class abstract: Especifica una clase abstracta.
• Class sealed: Especifica que la clase no puede ser heredada.
• Class const: Especifica una constante para la clase, que puede ser accedida sin necesidad de crear instancias de la clase.
• Class type: define uno tipo para la clase que puede ser accedida sin necesidad de crear instancias de la clase.
• Class var: Define una variable en el scope de la clase que puede ser accedida sin necesidad de crear instancias de la clase.
• Class property: Define propiedad que puede ser accedida sin la necesidad de crear instancias de la clase.

De una forma más didáctica, las clases Nested (o anidadas) serian como subclases, que pueden ser accedidas a partir de una clase y su tipo declarado dentro de un scope. Ejemplo de clase:

type
      TOuterClass = class
       strict private
          myField: Integer;
 
       public
          type
             TInnerClass = class
              public
                myInnerField: Integer;
                procedure innerProc;
             end;

         procedure outerProc;
       end;

El método de la clase interna se implementa de la siguiente manera:

procedure TOuterClass.TInnerClass.innerProc;
begin
   ...
end;

Finalmente el siguiente código muestra como acceder al método que está en la clase anidada:

var
   x: TOuterClass;
   y: TOuterClass.TInnerClass;

begin
   x := TOuterClass.Create;
   x.outerProc;
   ...
   y := TOuterClass.TInnerClass.Create;

Los Métodos declarados con final especifican que el mismo método no pode ser sobrepuesto (override) en clases descendentes, sin embargo se puede declarar uno método con el mismo nombre siendo virtual.

Son clases que cuando son declaradas como Static no necesitan ser instanciadas para ser accedidas.

Ahora es posible hacer un for directo en objetos que contengan collections, arrays, expresiones string y expresiones de tipo set, tanto para Delphi Win32 como para .NET. Ejemplos:

Ejemplo: Iteración en un Array

var
  IArray1: array[0..9] of Integer   = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
  I: Integer;

begin
  
  for I in IArray1 do 
  begin 
      // Hacer algo aquí...
  end;

Ejemplo: iteración en un String:

var
  C: Char;
  S1, S2: String;

  OS1, OS2: ShortString;
  AC: AnsiChar;
  
begin

  S1 := ‘Nuevos recursos de Delphi 2006';
  S2 := '';

  for C in S1 do
    S2 := S2 + C;

  if S1 = S2 then
    WriteLn('SUCESSO #1');
  else
    WriteLn('FALHOU #1');

  OS1 := 'Migrando de Delphi 7 para Delphi 2006...';
  OS2 := '';

  for AC in OS1 do
    OS2 := OS2 + AC;

  if OS1 = OS2 then
    WriteLn('SUCESSO #2');
  else
    WriteLn('FALHOU #2');

end.

Los nuevos recursos de live template extienden la capacidad de crear templates de código en Delphi. Estés templates creados en un archivo XML y ayudan a programar escribiendo menos código.

Figura 2. Creando un try..finally utilizando la capacidad de LiveTemplates.

La capacidad de block completion es uno de los recursos que habilitan el begin y end automático. ¿Quién nunca se perdió con begin y end?

En la figura 2, tenemos una marcación amarilla y otra verde, la amarilla representa las líneas que fueron cambiadas, mientras las verdes son líneas que no cambiaran.

Independiente de una herramienta de control de versiones, las alteraciones en fuentes son versionadas localmente, permitiendo la comparación entre las versiones.

Figura 3. Versionamento local y comparación entre 2 fuentes

El nuevo depurador trae diversas mejoras en variables locales, call stack y otros, sin embargo una de las principales novedades es la visualización en árboles. Véase un ejemplo:

Figura 4. Depurando una aplicación y visualizando las variables en TreeView

Esta es una de las capacidades que más les gustan a los usuarios de Delphi 7, ya que a través de los refactorings se pueden renombrar clases, variables y métodos de manera que al hacer un cambio de nombre se cambien automáticamente todas las líneas de código en los que se hacía referencia al nombre anterior. Mediante esta capacidad de refactoring es posible también cambiar los parámetros de clases, seleccionar parte del código y generar un método a partir del bloque seleccionado, también es posible mover métodos de una clase a otra, entre muchas otras cosas.

La integración con unidades de pruebas a través de NUnit y DUnit facilitan la creación de métodos y en general código de pruebas que se usa para probar el código de la propia aplicación. Esto facilita la notablemente la prueba de las aplicaciones, pues es como si se tuviese un “programa que prueba al programa”.

Una de las nuevas capacidades de Delphi 2006 es la creación de proyectos UML, utilizando UML 1.5 o UML 2.0, que también son conocidos como proyectos de diseño. Podemos considerar estos proyectos como proyectos de análisis y, como tal, no poseen ninguna interacción con el código fuente. La ventaja de estos proyectos es permitir que se utilice Delphi 2006 en la fase de refinamiento del alcance, en dónde todavía no tienen definido si el proyecto va ser implementado en la plataforma Win32 o en la plataforma .Net. Cuando posteriormente se defina la plataforma, Delphi 2006 puede transformar el proyecto de análisis en un proyecto de implementación en Delphi Win32 o en Delphi .Net o incluso C# (.Net).

Adicionalmente, se puede hacer la ingeniería reversa del código actual y crear un diagrama de clase, como el que se muestra en la siguiente figura:

Figura 5. Diagrama de clase de la unit Buttons.pas

Con la capacidad de Métricas de Delphi 2006 es posible que los desarrolladores mejoren la calidad de sus aplicaciones con una productividad que no existe en ninguna otra herramienta. A través de las Métricas, es posible seleccionar cualquier indicador para medir (cohesión, complejidad, acoplamiento etc...) al mismo tiempo que se definen sus criterios de aceptación como: líneas de código por clase, nivel de if, while, for y otros ciclos, así como límites de herencia entre otros.

¿Cuantas veces usted ya definió un guía de mejores prácticas de codificación que evitan que su equipo de desarrolladores cometa errores de codificación de modo que conviertan el código en algo muy ineficiente o incluso incomprensible?

¿Supongamos que su equipo tiene un guía de mejores prácticas, la siguiente pregunta sería: Como podemos garantizar que esta guía de mores prácticas realmente se esta siguiendo?

La respuesta nuevamente seria: revisión de código (code review) y si realizamos tal plática en un contexto de un proyecto con miles de líneas de código, sabemos que el resultado puede ser catastrófico en relación a tiempo.

A través de Lola capacidad de auditorias de código (QA Audits) de Delphi 2006, usted podrá finalmente definir un conjunto de buenas prácticas de codificación y garantizar que estas prácticas están sendo seguidas en su proyectos. Traduciendo al día-a-día, usted podrá detectar errores que pueden ocurrir en su aplicación antes de incluso de que está se ejecute.

Figura 6. Resultado das métricas a través do Grafico de Kiviat: los puntos fuera del círculo rojo representan violación de las métricas

Todo esto puede ejecutarse en el código desarrollado en Delphi 7 al migrar a Delphi 2006.

¿Cuantos proyectos usted tiene en Delphi que no tienen ningún tipo de documentación? Con Delphi 2006 usted podrá hacer una ingeniería reversa de todas las units de un proyecto, generar los diagramas de clase y los de secuencia, en seguida, generar un sitio web conteniendo estés diagramas de una forma bastante estructurada.

Figura 7. Documentación generada a partir do código

Nuevo componente que permite el posicionamiento automático de los componentes en un panel.

Nuevo componente, que funciona como una tabla donde son definidas las líneas y columnas, de modo que diversos componentes pueden ser insertados y automáticamente posicionados.

Este componente nos permite crear botones y agruparlos en categorías como si fuesen una barra de Outlook y lo que ayuda a realzar el diseño de sus aplicaciones.

Figura 10.Ejemplo de una aplicación usando lo TCategoryButtons

Este componente permite el agrupamiento de diversos botones en un panel.

El famoso icono da barra de Windows para representar la aplicación es ahora soportado nativamente, permitiendo colocar iconos animados y enviar mensajes a través de balones, de acuerdo con el siguiente ejemplo:

Figura 11. TryIcon en acción

IntelliMouse es el suporte al desplazamiento de la ventana en la aplicación. En Delphi 2006, la VCL tiene soporte a esta tecnología, basta declarar la unit IMOUSE en su aplicación.

Diversas funciones da RTL fueron actualizadas aumentando el rendimiento de sus aplicaciones. La más importante de ellas, es FASTMM, nuevo motor que maneja la memoria de aplicaciones Win32, ganando mas rendimiento con la compilación en Delphi 2006 y al asignar True a la variable ReportMemoryLikeonShutdown.

Nuevamente, con solo hacer la compilación sus aplicaciones en Delphi 2006, se gana rendimiento y al mismo tiempo que se pueden detectar las fugas de memoria.

Los componentes da VCL ahora tienen dos nuevas propiedades que permiten definir los márgenes internos e externos de cada componente lo que nos ayuda cuando alineamos componentes alClient y no queremos que queden junto a componentes externos. Así, podemos definir las márgenes superiores, inferiores, derechos e izquierdos.

Nueva versión de Rave Reports que le permite generar diversos tipos de reportes en PDF, RTF, HTML y texto.

Blogs.codegear.com/andreanolanusse

Mi blog, donde pongo diversas informaciones.

www.borlandopenuniversity.com.br

Capacitación web sobre los productos CodeGear como Delphi están disponibles.

dn.codegear.com/es

Sitio de artículos CodeGear y conexión entre CodeGear e los desarrolladores

www.codegear.com

Sitio oficial da CodeGear, contén todas las informaciones sobre los productos CodeGear.