viernes, 29 de mayo de 2015

Attributos de la Rtti

Desde la versión 2010 de Delphi, se agregó a la Rtti los attributos, que corresponden con las anotaciones de otros lenguajes como Java o .Net.
Con esta nueva característica de la Rtti podemos añadir a clases, méodos o propiedades, atributos en tiempo de diseño y desarrollo que después podremos recuperar en tiempo de ejecución a través de la Rtti.
Para nosotros será útil para el desarrollo del framework que tenemos en marcha, ya que las utilizaremos para automatizar muchas cosas.
Como sabemos la Rtti lleva mucho tiempo con nosotros y como característica más importante (por lo menos para nuestro framework) es la de poder recuperar las propiedades de una clase, que se hace de forma sencilla
function GoGetProperties(const AClass: TClass): TStrings;
var
  cxt: TRttiContext;
  t : TRttiType;
  p : TRttiProperty;
begin
  Result := TStringList.Create;
  cxt := TRttiContext.Create;
  try
    t := cxt.GetType(AClass);
    for p in t.GetProperties do
    begin
      Result.Add(p.Name);
    end;
  finally
    cxt.Free;
  end;
end;

Si lanzamos la función sobre la clase TMyClass del articulo Serialización sencilla JSON (II) el resultado sería:

IntegerValue
DoubleValue
StringValue


Respecto a los atributos, descienden de la clase TCustomAttribute alojada en System.Rtti y para asociar el atributo a un tipo, método, campo o propiedad simplemente hay que ponerlo entre [] antes de su definición.
type
  TMyAttribute = class(TCustomAttribute)
  end;
  TMyAttribute2 = class(TCustomAttribute)
  end;
  TMyAttribute3 = class(TCustomAttribute)
  end;

  [TMyAttribute]
  TMyClass = class
    ...
    [TMyAttribute2]
    property IntegerValue: Integer read FIntegerValue write FIntegerValue;
    property DoubleValue: Double read FDoubleValue write FDoubleValue;
    [TMyAttribute3]
    property StringValue: string read FStringValue write FStringValue;
    ...
  end;
  ...

Para acceder en tiempo de ejecución a estos atributos, accederemos a la lista de atributos adjunta al tipo, método, campo o propiedad reflejados en la Rtti.
function GoGetProperties2(const AClass: TClass): TStrings;
var
  cxt: TRttiContext;
  t : TRttiType;
  p  : TRttiProperty;
  Attr: TCustomAttribute;
  s: string;
begin
  Result := TStringList.Create;
  cxt := TRttiContext.Create;
  try
    t := cxt.GetType(AClass);
    s := '';
    for Attr in t.GetAttributes do
    begin
      s := ',' + Attr.ClassName;
      if Attr is TMyAttribute then
      begin
        // Este clase tiene asociado el atributo TMyAttribute
      end;
    end;
    if s'' then
      s := '('+s.Substring(2)+')';
    Result.Add('Type: '+t.Name+' '+s);
    for p in t.GetProperties do
    begin
      s := '';
      for Attr in p.GetAttributes do
      begin
        s := ',' + Attr.ClassName;
        if Attr is TMyAttribute2 then
        begin
          // Este propiedad tiene asociado el atributo TMyAttribute2
        end;
      end;
      if s'' then
        s := '('+s.Substring(2)+')';
      Result.Add('  Property: '+ p.Name+' '+s);
    end;
  finally
    cxt.Free;
  end;
end;

Si pasamos esta función sobre la calse TMyClass

Type: TMyclass (MyAttribute)
  Property: IntegerValue (MyAttribute2)
  Property: DoubleValue
  Property: StringValue (MyAttribute3)


Además podemos crear propiedades a los atributos que después podremos recuperar, para ello los crearemos en la clase del atributo:
   ...
  TMyAttribute2 = class(TCustomAttribute)
  private
    FValue: string;
  public
    property Value: string read FValue write FValue;
    constructor Create(const AValue: string = '');
  end;
  ...
constructor TMyAttribute2.Create(const AValue: string);
begin
  FValue := AValue;
end;
  ...

Si ponemos una pequeña modificación cuando recuperamos los atributos de las propiedades podemos recuperar estos valores
        ...
        if Attr is TMyAttribute2 then
        begin
          // Este propiedad tiene asociado el atributo TMyAttribute2
          s := s + '{' + TMyAttribute2(Attr).Value + '}'; 
        end;
       ...

Si añadimos un valor a este atributo en la propiedad del ejemplo
    ...
    [TMyAttribute2('Esto es SPARTA')]
    property IntegerValue: Integer read FIntegerValue write FIntegerValue;
    ...

Ahora el resultado de pasar la función sobre la clase

Type: TMyclass (MyAttribute)
  Property: IntegerValue (MyAttribute2{Esto es SPARTA})
  Property: DoubleValue
  Property: StringValue (MyAttribute3)


Hemos visto como usar los atributos de la Rtti así de como recuperarlos de un tipo, método, campo o propiedad. Esta utilización de la Rtti será muy útil para nuestros propósitos.

viernes, 15 de mayo de 2015

Serialización sencilla JSON (II)

Vamos a ver de manera sencilla como crear la el objeto JSON personalizado de nuestra clase,
para eso veamos la clase creada:
unit Unit1;

interface

uses
  Data.DBXJSON;

type
  TMyclass = class(TObject)
  private
    FIntegerValue: Integer;
    FDoubleValue: Double;
    FStringValue: string;
  public
    class function FromJsonObject(const AJsonObject: TJSONObject): TMyClass;
    class function FromJsonString(const AJsonString: string): TMyClass;
    function ToJsonObject: TJSONObject;
    function ToJsonString: string;
  published
    property IntegerValue: Integer read FIntegerValue write FIntegerValue;
    property DoubleValue: Double read FDoubleValue write FDoubleValue;
    property StringValue: string read FStringValue write FStringValue;
  end;

implementation

uses
  System.SysUtils;

{ TMyclass }

class function TMyclass.FromJsonObject(
  const AJsonObject: TJSONObject): TMyClass;
begin
  Result := TMyclass.Create;
  if Assigned(AJsonObject) then
  begin
    Result.FIntegerValue := TJSONNumber(AJsonObject.Get('I').JsonValue).AsInt;
    Result.FDoubleValue := TJSONNumber(AJsonObject.Get('D').JsonValue).AsDouble;
    Result.FStringValue := TJSONString(AJsonObject.Get('S').JsonValue).Value;
  end;
end;

class function TMyclass.FromJsonString(const AJsonString: string): TMyClass;
var
  AJson: TJSONValue;
begin
  AJson := TJSONObject.ParseJSONValue(AJsonString);
  try
    Result := FromJsonObject(TJSONObject(AJson));
  finally
    if Assigned(AJson) then
      AJson.Free;
  end;
end;

function TMyclass.ToJsonObject: TJSONObject;
begin
  Result := TJSONObject.Create;
  Result.AddPair('I',TJSONNumber.Create(FIntegerValue));
  Result.AddPair('D',TJSONNumber.Create(FDoubleValue));
  Result.AddPair('S',TJSONString.Create(FStringValue));
end;

function TMyclass.ToJsonString: string;
begin
  with ToJsonObject do
  try
    Result := ToString;
  finally
    Free;
  end;
end;

end.

TMyClass es una ampliación de lo que vimos en el post anterior (Serialización sencilla en JSON), aquí el cotarro está en ToJsonObject y FormJsonObject, donde usamos el método AddPair de TJSONObject para ir añadiendo los campos que queremos serializar. que posteriormente recuperaremos con la función Get.

Como ejemplo:
function Test: string;
begin
  with TMyclass.Create do
    try
      IntegerValue := MaxInt;
      DoubleValue := 100728.897;
      StringValue := 'Hola Mundo';
      Result := ToJsonString;
    finally
      Free;
    end;
end;
Result = {"I":2147483647,"D":100728.897,"S":"Hola Mundo"}

Ahora vamos a ver como funcionan los arrays, para verlo podemos crear una lista de objetos, como
...
type
  TMyClassList = class(TObjectList<TMyclass>)
  public
    class function FromJsonObject(const AJsonObject: TJSONObject): TMyClassList;
    class function FromJsonString(const AJsonString: string): TMyClassList;
    function ToJsonObject: TJSONObject;
    function ToJsonString: string;
  end;
...
class function TMyClassList.FromJsonObject(const AJsonObject: TJSONObject): TMyClassList;
var
  AJsonArray: TJSONArray;
  i: Integer;
begin
  Result := TMyClassList.Create;
  if Assigned(AJsonObject) then
  begin
    AJsonArray := TJSONArray(AJsonObject);
    for i := 0 to AJsonArray.Size - 1 do
      Result.Add(TMyclass.FromJsonObject(TJSONObject(AJsonArray.Get(i))));
  end;
end;

class function TMyClassList.FromJsonString(const AJsonString: string): TMyClassList;
var
  AJson: TJSONValue;
begin
  AJson := TJSONObject.ParseJSONValue(AJsonString);
  try
    Result := FromJsonObject(TJSONObject(AJson));
  finally
    if Assigned(AJson) then
      AJson.Free;
  end;
end;

function TMyClassList.ToJsonObject: TJSONObject;
var
  AJsonArray: TJSONArray;
  i: Integer;
begin
  AJsonArray := TJSONArray.Create;
  for i := 0 to Count - 1 do
    AJsonArray.AddElement(Items[i].ToJsonObject);
  Result := TJSONObject(AJsonArray);
end;

function TMyClassList.ToJsonString: string;
begin
  with TJSONArray(ToJsonObject) do
    try
      Result := ToString;
    finally
      Free;
    end;
end;
...
He usado las mismas pautas que en TMyClass para ver de forma sencilla podemos generarlo. Usamos TJSONArray.AddElement para crear los elementos y Get para recuperarlos.

Como ejemplo
function TForm2.Test: string;
var
  a: TMyclass;
  b: TMyClassList;
begin
  b := TMyClassList.Create;
  try
    a := TMyclass.Create;
    with a do
    begin
      IntegerValue := MaxInt;
      DoubleValue := 100728.897;
      StringValue := 'Antonio';
    end;
    b.Add(a);
    a := TMyclass.Create;
    with a do
    begin
      IntegerValue := 0;
      DoubleValue := 827.09;
      StringValue := 'Pedro';
    end;
    b.Add(a);
    a := TMyclass.Create;
    with a do
    begin
      IntegerValue := -MaxInt;
      DoubleValue := -3.141596;
      StringValue := 'Jose';
    end;
    b.Add(a);
    Result := b.ToJsonString;
  finally
    b.Free;
  end;
end;
Result = [{"I":2147483647,"D":100728.897,"S":"Antonio"},{"I":0,"D":827.09,"S":"Pedro"},{"I":-2147483647,"D":-3.141596,"S":"Jose"}]

De una forma sencilla podemos crear nuestra propia serialización.


sábado, 9 de mayo de 2015

Serialización sencilla en JSON

El desarrollo de DataSnap Rest en Delphi (desde XE si no me equivoco)implica que disponemos de unas librerías que nos permiten la serialización de los objetos en JSON. Además se nos ofrecen varios tipos de clases y utilidades que nos permitirá tener estructuras complejas en JSON y poder serializar manualmente cualquier objeto (dentro de la capacidad de la Rtti).
 TJson = class(TObject)
  public
    class function ObjectToJsonObject(AObject: TObject; AOptions: TJsonOptions = []): TJSOnObject;
    class function ObjectToJsonString(AObject: TObject; AOptions: TJsonOptions = []): string;
    class function JsonToObject<T: class, constructor>(AJsonObject: TJSOnObject): T; overload;
    class function JsonToObject<T: class, constructor>(AJson: string): T; overload;
    class function Format(AJsonValue: TJsonValue): string;
  end;
Si no queremos complicarnos la vida, existen funciones que directamente nos hacen el trabajo, se encuentran en la unidad REST.Json, a través de su clase TJson:

Estas funciones nos permiten convertir cualquier objeto en un objeto o cadena JSON y viceversa, su uso es muy sencillo, sólo debemos indicar el objeto, clase y/o cadena a convertir.

Como ejemplo de su simplicidad:
...
type
  TMyClass = class(TObject)
  ...
  public
    function ToJsonString: string;
    class function CreateFromJsonString(const AJsonString: string): TMyClass;
  end;
...
function TMayClass.ToJsonString: string
begin
  Result := REST.Json.TJson.ObjectToJsonString(Self);
end;

class function TMyClass.CreateFromJsonString(const AJsonString: string): TMyClass;
begin
  Result := REST.Json.TJson.JsonToObject<TMyClass>(AJsonString);
end;
...

En muchas ocasiones, estas funciones nos serán de utilidad, en otras ya tendremos que adentrarnos más en el funcionamiento de los objetos json de Delphi y generar nosotros mismos la conversión .



viernes, 1 de mayo de 2015

Desarrollo de Framework

Para aprender un poco más sobre Delphi, voy ha realizar una serie de posts a través de los cuales se desarrollará un Framework de trabajo.

El objetivo que me planteo es aprender, en la medida de lo posible, sobre:
  • Rtti (Run-Time Type Information)
  • Interfaces
  • Json
  • Persistencia 
  • Integración en el IDE de Delphi
  • Ingeniería inversa
  • Bases de Datos
Intentaremos implementar un framework para el desarrollo de soluciones de negocio orientadas a objetos. Ya sé que existen soluciones buenas, pero la función es la del aprendizaje.

Se desarrollará sobre Delphi XE5, aunque se intentará dejar la puerta abierta para implementaciones en versiones más antiguas de Delphi.

Usando clases e interfaces crearemos unas estructuras básicas que nos permitan automatizar los procesos como la creación de clases y objetos, la serialización en Json, el almacenamiento en bases de datos, etc. Todos estos procesos automáticos serán parte fundamental de este framework que basaremos en la utilización de las funcionalidades que nos aporta la Rtti.

Según avancemos en el desarrollo generaremos herramientas de desarrollo que integraremos en el IDE de Delphi, como la generación del código de nuevas clases usando este framework.

También tengo en mente centralizar el uso del framework utilizando DataSnap o un servicio web.

Además intentaremos flexibilizar al máximo el framework (lo que nos implicará más complejidad y por tanto aprenderemos más) para poder utilizarlo de manera inversa usando las estructuras de Bases de Datos de las que ya dispongamos. Ya que en el desarrollo de aplicaciones, se usa mucho crear primero la estructura en la base de datos y después la integración en la aplicación software.

Como he dicho, la primordial misión es la de aprender y no la de obtener un rendimiento óptimo ni de abarcar una casuística muy amplia.

Antes de empezar, e incluso, durante el desarrollo del framework, iré publicando posts que nos sirvan para el desarrollo del framework.

miércoles, 12 de noviembre de 2014

Object Pascal Style Guide

Antes de empezar a con los posts de programación vamos a establecer unos estilos de trabajo.

Aunque cada uno puede usar los estilos que quiera para programar, yo voy a intentar seguir los estilos indicados en Object Pascal Style Guide, con alguna adición o modificación, a continuación presento un esbozo.

Atención: Aunque en este documento los nombres los pongo en castellano (MiVariable, MiCampo,...), en los desarrollo generalmente usaré el inglés (MyVariable, MyField,...), se ha dejado este documento en castellano para su mejor comprensión. 

Convenciones de nomenclatura

A excepción de las palabras reservadas y directivas, que están en minúsculas, todos los identificadores Pascal deben usar UpperCamelCase, lo que significa que la primera letra debe ser mayúscula, y las palabras incrustadas en un identificador debe ser en mayúsculas, así como cualquier sigla que está incrustada. Además no se debe usar el carácter de subrayado o guión bajo  "_" para unir palabras.

// Mal formadas
patata
miVariable
Lanzar_Actualizacion
MiClaseFtp

// Bien formadas
Patata
MiVariable
LanzarActualizacion
MiClaseFTP

Tipos

Cualquier definición de tipo (excepto Interfaces) siempre comenzará con la letra T y a continuación el nombre.

type
  TMiTipo = class(TObject)...

Interfaces

Los interfaces comenzarán con la letra I y a continuación el nombre.

  IMiBuenPastor = interface 
  ...

En algunos casos he comenzando con la palabra Interface aunque ya no lo estoy utilizando mucho

  InterfaceMiBuenPastor = interface 
  ...

Tipos enumerados

En este caso, los componentes del tipo utilizarán la notación húngara (más o menos)

type
  TFormatoCuadrado = (fcNormal, fcRedondeado, fcEstrellado);

Dónde fc significa formato de cuadrado.

Clases

Los nombres de las clases siguen la nomenclatura de los tipos (TMiClase)

Campos

Los campos de las clases comenzarán por la F y el nombre del campo y generalmente irá en la sección privada. En general deben ser sustantivos. Para hacer uso publico de estos campos usaremos las propiedades o  setters y getters

  FMyCampo: string;

Métodos

Los nombres de los métodos deben ser verbos o frases imperativas.

  LanzarRestauracion
  Cargar
  Salvar
  AgregaBoton

Propiedades

Generalmente las propiedades accederán directamente a los campos o a través de getters y setters

  property MiCampo: string read FMiCampo write FMiCampo;
  property MiCampo: string read GetMiCampo write SetMiCampo;
  property MiCampo: string read FMiCampo write SetMiCampo;


Variables locales

Las variables locales nunca deben empezar por la letra F para diferenciarlas de los campos. Deben ser en general sustantivos o nombres que no definan ninguna acción, para no confundirlas con los métodos o procedimientos.

Se permite el uso de variables de una sólo letra en minúscula para variables temporales y de bucle:

  for i := 0 to 9 do
    HacerAlgo;


Procedimientos y funciones

Igual que los métodos.

  procedure HacerAlgo;
  function CalculaAlgo: double;

Formateo de código

Mención especial tiene el formateo de código ya que como actualmente el mismo Delphi ya tiene un herramienta de formateo integrada, por lo que es recomendable usarla. Para versiones más antiguas se puede usar el DelForExp (podeis verlo en Delphi al Límite) o el JEDI Code Format


viernes, 7 de noviembre de 2014

Embarcadero y su política de versiones

Hace un año, en la empresa donde trabajo, pudimos adquirir el Delphi XE5, y aún estamos trabajando en pasar de Delphi 2007 al XE5, y a estas alturas ya han aparecido dos nuevas versiones de Delphi, XE6 y XE7.

A este paso cuando consiga olvidarme del Delphi 2007 (ya me costó hacerlo de mi querido Delphi5) y empezar a profundizar en el XE5 (que ya tengo ganas de programar para Android y IOS desde Delphi), ya estaremos con el XE12 o vayas tú a saber...

Las compañías que desarrollan componentes para Delphi, que para mí son muy importantes porque te dan un valor añadido muy interesante, cada vez que se saca una nueva versión de Delphi tienen que, como mínimo, recompilar todos sus componentes para que sean compatibles con la nueva versión, amén de que no tengan que realizar algún cambio adicional.

Para nosotros que los trabajamos como desarrolladores, ya sea en una empresa que fabrique pañuelos o una empresa que realice complejos programas de análisis científico, la actualización de una versión a otra siempre llega a ser un dolor de cabeza (cambia todos los componentes de terceros que uses y ten por seguro te va a costar más dinero y después adecua todos tus proyectos al nuevo sistema y más si usas bpl que no son compatibles entre versiones!!). Y sobre todo cuando la dirección de la empresa o incluso del departamento de informática/sistemas, nunca tiene previsto hacer una actualización y tienes que convencerles de que ya es hora de hacerlo, ¡imagina si tienes que hacerlo cada año  y no digamos si hay más de una!.

Esta claro que pasar de una versión a la siguiente siempre es más sencillo que saltarse dos o tres, y todos estaríamos mejor preparados si actualizáramos siempre que saliera una nueva versión, pero tal como está la situación económico, no creo que las pequeñas y medianas empresas puedan permitirse el lujo de esta actualizaciones.

No hace mucho, Danysoft abrió un nuevo sistema de actualizaciones llamado Plan de recarga con el que puedes ahorrar un 50% del precio de la actualización, puede ser una alternativa razonable, pero hay que tener en cuenta dos cosas: primero convence a tu dirección para que se acoja a este plan, que conlleva al menos una actualización al año (y este año han habido dos) y segunda ten previsto que el cambio también te supondrá actualizar tus componentes de terceros y en menor medida algo de tu código.

Todos sabemos que el mundo tecnológico va a mil por hora y está claro que la mejor forma de ser competitivos es poder utilizar cuanto antes las nuevas tecnologías, ¿Embarcadero con su política de versiones intenta que estemos siembre de la mano de estas tecnologías ó lo que simplemente quiere es tenernos amarrados como fuente continua de ingresos?

Como he comentado antes ahora mismo trabajo con la XE5 (y 2007), y he estado en las presentaciones de las nuevas versiones de XE6 y XE7  y creo que los cambio con respecto la versión XE5 no son tan relevantes como para hacer dos versiones en el mismo año.

Personalmente creo que es importantes estar actualizado para acceder a las nuevas tecnologías que van apareciendo, y para ello debemos confiar que Embarcadero las integre progresivamente, pero creo que con una actualización al año sería suficiente. Aún con sólo una actualización al año, tal como está la situación económica creo que muchas pymes no podrán soportar este gasto de tiempo y dinero. Cómo último y referente a la situación económica, si alguien me dice "No tienes que preocuparte porque lo paga la empresa y no es problema tuyo", yo contesto  "¿Cuantos de nosotros estamos pendientes de si vamos a cobrar este mes?, cómo para no preocuparse, yo formo parte de la empresa".


PD: Como curiosidad el  roadmap de 2014 que nos informa de las nuevas tecnologías desarrolladas (y por desarrollar) y lo que se tiene previsto para el año que viene, aunque no parece indicar nada de Linux..


jueves, 6 de noviembre de 2014

Iniciamos el trayecto...

Al fin me he decidido a crear mi primer blog, y como no un blog de programación, centrándome en el lenguaje que más he usado y uso actualmente: Delphi.

Realizaré ejemplos prácticos para el uso de Delphi en desarrollo empresariales y mostrar el potencial que puede llegar a tener.

Compartiré experiencias que me surgan en mi día a día laboral, ya que como a mí, a cualquier desarrollador le pueden surgir los mismos problemas.

¡ Yo ya estoy listo paara empezar esta aventura !