Enviar mensajes entre aplicaciones con IdUDPClient

En el último artículo vimos como enviar mensajes entre dos aplicaciones sin utilizar ningún protocolo de comunicación cuando los dos ejecutables se encuentran en el mismo PC. Pero si el mensaje hay que enviarlo entre dos ejecutables que se encuentran en dos PC distintos estamos obligados a utilizar un protocolo de comunicación y el más sencillo es el protocolo UDP.

El protocolo UDP goza de la ventaja de que no se establece una conexión entre la IP origen y la IP destino, sino que envía la información sin saber si va a llegar o no (al contrario de TCP que si establece una conexión segura entre ambos puntos).

El protocolo UDP es utilizado comúnmente en aplicaciones P2P para envío rápido de mensajes entre clientes y servidores así como en juegos online donde es necesario transmitir las coordenadas de cada personaje en tiempo real sin que existan demoras.

CREANDO LA APLICACIÓN QUE ENVÍA EL MENSAJE

Creamos un nuevo proyecto y en el formulario principal insertamos estos componentes:


Va a constar de dos componentes TEdit para guardar la IP del destinatario y su puerto (que por defecto le hemos puesto el 80). También va a tener un componente TMemo llamado Mensaje que va a contener las líneas de texto a enviar. Luego añadimos el componente IdUDPClient que se encuentra dentro de la paleta de componentes Indy Clients y que vamos a llamar Cliente.

En el evento OnClick del botón Enviar escribimos el siguiente código:

procedure TFEnviar.BEnviarClick(Sender: TObject);
begin
 Cliente.Host := IP.Text;
 Cliente.Port := StrToIntDef( Puerto.Text, 0 );
 Cliente.Send( Mensaje.Text );
end;

Es algo tan sencillo como pasarle la IP destino (el Host), el puerto y ejecutamos el método Send que envía la información.

El único inconveniente que tiene este método es que no sabe si el destinatario existe o si le ha llegado el mensaje, pero es muy rápido.

CREANDO LA APLICACIÓN QUE RECIBE EL MENSAJE

Volvemos a crear un nuevo proyecto con este formulario:


Sólo va a contener un componente TMemo llamado Mensaje y el componente IdUPDServer que llamaremos Servidor. Al servidor le vamos a poner en su propiedad Port el valor 80. Después lo activamos poniendo su propiedad Active a True.

Ahora escribimos este código en el evento OnUDPRead:

procedure TFRecibir.ServidorUDPRead(Sender: TObject; AData: TBytes;
ABinding: TIdSocketHandle);
begin
 Mensaje.Lines.Add( 'De: ' + ABinding.PeerIP );
 Mensaje.Lines.Add( 'Mensaje: ' + PChar( AData ) );
end;

Mediante la propiedad ABinding.PeerIP obtenemos la IP del que envía el mensaje y la variable AData contiene el mensaje enviado en bytes.

Al ejecutar ambos programas y pulsar el botón Enviar este sería el resultado:


Si el mensaje se va a enviar entre dos aplicaciones que se encuentran en el mismo PC sólo hay que poner como dirección IP la 127.0.0.1 y funciona perfectamente. Incluso si seguimos escribiendo mensajes se añadirán a los que ya están en el destino.

Con algo tan simple como esto ya tenemos un pequeño cliente de mensajería entre dos equipos de la red local o en Internet. Para que la conversación pudiera ser bidireccional habría que crear un solo programa que tuviera un cliente UDP y un servidor UDP. También habría que dejar a elegir al usuario que IP y puertos va a utilizar para enviar y recibir.

Si la información que vamos a enviar es confidencial también sería interesante que las cadenas de caracteres que se envíen fueran encriptadas de algún modo.

Pruebas realizadas en RAD Studio 2007.

ENVIAR MENSAJES ENTRE APLICACIONES SIN COMUNICACIONES

La forma más usual de copiar información entre dos aplicaciones de Windows es usando algún protocolo de comunicaciones, como TCP o UDP. Pero si la comunicación se va a efectuar entre dos aplicaciones que se encuentran en el mismo PC podemos enviar la información sin utilizar ningún protocolo de comunicación.

Para ello se utiliza un mensaje especial que tiene la API de Windows llamado WM_COPYDATA. Lo que permite este mensaje es copiar cualquier tipo de dato, ya sea texto o binario entre dos aplicaciones Windows tal como si se pasara por el portapapeles. De este modo la comunicación es instantánea y asíncrona.

Una aplicación práctica que se le puede dar a este método es la de dividir nuestro programa en varios ejecutables y se que envíen la información entre sí (siempre que estemos dentro el mismo ordenador).

CREANDO LA APLICACIÓN QUE ENVÍA EL MENSAJE

Lo primero que vamos a hacer es crear un nuevo proyecto y al formulario principal de la aplicación lo vamos a llamar FEnviar:


Este formulario sólo va a contener un objeto de la clase TMemo llamado Mensaje para escribir el texto a enviar y un botón para hacerlo (TButton). El proyecto lo podemos guardar con el nombre Enviar.exe.

Para poder transmitir un mensaje es necesario definir una estructura de datos llamada TCopyDataStruct:

TCopyDataStruct = packed record
 dwData: DWORD;   // de uso libre: para indicar por ejemplo el tipo de información a transmitir
 cbData: DWORD;   // el tamaño en bytes de los datos que se van a enviar
 lpData: Pointer; // puntero a los datos que se van a enviar
end;

Esta estructura ya viene predefinida en la API original de Windows (en C) del siguiente modo:

typedef struct tagCOPYDATASTRUCT {
 DWORD dwData;
 DWORD cbData;
 PVOID lpData;
} COPYDATASTRUCT;

El parámetro dwData se le deja libre al programador para que pueda utilizarlo a su propio criterio. Por ejemplo se podría utilizar para decirle al receptor el tipo de dato que vamos a enviar.

En el parámetro cbData debemos indicar el número de bytes que vamos a enviar y lpData es un puntero a los datos que enviamos.

Por último hacemos el evento OnClick del botón Enviar:

procedure TFPrincipal.BEnviarClick(Sender: TObject);
var
 CopyDataStruct : TCopyDataStruct;
 hReceptor: THandle;
 Respuesta: integer;
begin
 CopyDataStruct.dwData := 0; // use it to identify the message contents
 CopyDataStruct.cbData := Mensaje.Width;
 CopyDataStruct.lpData := PChar( Mensaje.Text );

 // Comprobamos si existe el receptor

 hReceptor := FindWindow( PChar( 'TFRecibir' ), PChar( 'Recibir' ) );

 if hReceptor = 0 then
 begin
   ShowMessage( 'No he encontrado al receptor.' );
   Exit;
 end;

 // Enviamos el mensaje y recogemos la respuesta del receptor

 Respuesta := SendMessage( hReceptor, WM_COPYDATA, Integer( Handle ),
   Integer( @CopyDataStruct ) ) ;

 if Respuesta = 1234 then
   ShowMessage( 'El mensaje ha sido recibido satisfactoriamente.' );
end;

Lo primero que hace es almacenar el mensaje en la estructura de datos y luego trata de buscar una ventana llamada Recibir de la clase TFRecibir (que vamos a crear ahora después) que va a recoger la información que se envía.

El programa comprueba si existe esta ventana antes de enviar la información con SendMessage. Como el receptor puede mandar cualquier número entero como respuesta, he establecido el número 1234 como mensaje de que todo ha ido bien.

CREANDO LA APLICACIÓN QUE RECIBE EL MENSAJE

Creamos un nuevo proyecto llamado Recibir.exe cuya ventana principal se llamara FRecibir (de la clase TFRecibir) y que sólo va a contener un objeto TMemo llamado Mensaje que va a recoger la información:


Aquí también tenemos que definir la estructura de datos TCopyDataStruct definida en el proyecto anterior. Otro registro que también vamos a definir es una estructura encargada de recibir de Windows el mensaje de tipo WM_COPYDATA:

TWMCopyData = packed record
 Msg: Cardinal;
 From: HWND;// Handle de la ventana que envía la información
 CopyDataStruct: PCopyDataStruct; // datos enviados
 Result: Longint; // usado para enviar la respuesta
end;

Ahora viene la parte especial del programa. Debemos definir un procedimiento dentro del formulario principal que recoja el mensaje de tipo WM_COPYDATA:

TFRecibir = class(TForm)
 Mensaje: TMemo;
 procedure WMCopyData( var Msg: TWMCopyData ); message WM_COPYDATA;
private
 { Private declarations }
public
 { Public declarations }
end;

Esta sería su implementación:

procedure TFRecibir.WMCopyData( var Msg: TWMCopyData );
begin
 Mensaje.Text := PChar( Msg.CopyDataStruct.lpData );
 Msg.Result := 1234; // Mensaje de respuesta de que todo ha ido bien
end;

En cuanto la aplicación Enviar.exe pulse el botón Enviar se ejecutará en la aplicación Recibir.exe automáticamente el procedimiento WMCopyData de manera instantánea:


Lo que he hecho en ese procedimiento es mandar al Memo llamado Mensaje el texto que hemos recibido.

Una cosa importante que hay que tener en cuenta es que si hay varios receptores de mensaje ejecutándose a la vez (Recibir.exe) entonces sólo lo recibirá el primero de ellos.

Como he mencionado al principio del artículo, este tipo de mensaje es muy útil si tenemos varios ejecutables dentro del mismo PC que necesitan enviarse mensajes de información rápidamente, ya sea como activación de procesos automáticos y como sincronización entre distintas aplicaciones.

Pruebas realizadas en RAD Studio 2007.

Pasando de Delphi 7 a RAD Studio 2007 (y 9)

Hoy vamos a terminar de ver las características más importantes que incorpora RAD Studio 2007.

Otra ventaja que incorporan las nuevas versiones de Delphi es la posibilidad es generar la documentación online de nuestro proyecto automáticamente utilizando la tecnología de Together.

También veremos el explorador de datos que incorpora que nos permite acceder a las tablas de las bases de datos sin tener que utilizar herramientas externas como IBConsole, IBExpert, etc.

GENERANDO DOCUMENTACIÓN AUTOMÁTICAMENTE

Para generar la documentación de la unidad UFacturacion que vimos en el artículo anterior debemos ir a la ventana del Model View pulsamos la unidad UFacturacion con el botón derecho del ratón y seleccionamos Generate Documentation:


Aparecerá una ventana donde podemos elegir la carpeta donde vamos a generar la documentación:


Si no modificamos nada en esta ventana lo que va a hacer es crear dentro de la carpeta de nuestro proyecto dos carpetas mas: out y dentro de esta doc donde finalmente irá la documentación.

Pulsamos el botón Ok y nos pedirá una última confirmación antes de proceder:


Cuando termine nos creará esta página web automáticamente:


En la parte superior de la página tenemos el diseño UML de nuestras clases. En la parte inferior izquierda está el índice de unidades disponibles y si pulsamos en una de ellas aparecerá a la derecha la documentación.

La documentación también puede generarse desde el menú superior seleccionando Tools -> Generate Documentation. Se puede generar documentación de sólo una unidad o bien de todo el proyecto.

De este modo, podemos distribuir nuestras librerías de código a otros programadores incorporando su documentación en línea siempre actualizada.

Aunque es una auténtica gozada poder generar la documentación de este modo se hecha mucho de menos poder manipular el formato de salida así como añadir comentarios opcionales y descripciones a la clase, los métodos y sus campos (variables).

ACCEDIENDO A LAS BASES DE DATOS CON DATA EXPLORER

Al igual que tenemos la pestaña Model View en la ventana del proyecto (Project Manager) también tenemos la última pestaña llamada Data Explorer. Esta pestaña nos permite acceder a las tablas de bases de datos como pueden ser Internase/Firebird, Oracle, MySQL, etc.


Vamos a ver un ejemplo de cómo conectar con una base de datos Firerid utilizando esta herramienta. Lo primero que tenemos que hacer el pulsar INTERBASE con el botón derecho del ratón y seleccionar Add New Connection:


Se abrirá una nueva ventana en la que tenemos que escribir el nombre que le vamos a dar a la conexión:


Pulsamos el botón Ok y veremos la conexión creada debajo de la rama INTERBASE:


Pulsamos esa conexión con el botón derecho de ratón y seleccionamos Modify Connection:


Se abrirá una ventana de configuración en la que debemos configura una conexión DBExpress para conectar con nuestra base de datos:


Una vez introducidos los parámetros de la conexión pulsamos el botón Test Connection para comprobar si todo ha ido bien. Nos tiene que mostrar este mensaje:


Después pulsamos Ok y si abrimos el apartado Tables del nuestra conexión deben verse todas las tablas de nuestra base de datos:


Al hacer doble clic sobre una tabla nos abrirá una nuestra pestaña en el editor de código con una rejilla preparada para modificar los campos de la tabla:


Si hacemos cualquier modificación sobre un registro podemos actualizarlo definitivamente enviando la transacción al servidor pulsando la tabla con el botón derecho del ratón y seleccionando Update:


Igualmente podemos deshacer los cambio pulsando sobre la opción Rollback.

Si abrimos una tabla no sólo podemos ver los nombres de los campos, sino que además se pueden ver sus índices:


Se pueden alterar los metadatos de una tabla seleccionándola con el botón derecho del ratón y eligiendo la opción Alter table:


Nos abrirá una nueva pestaña en medio del editor para modificar los campos creados:


De esta forma se pueden ampliar los campos String a más caracteres sin tener que realizar ninguna SQL. Cuando terminemos de realizar las modificaciones pulsamos la rejilla con el botón derecho del ratón y seleccionamos Save Changes:


Si antes de guardar los cambios seleccionamos la opción Show DLL nos mostrará la SQL que va a ejecutar para realizar las modificaciones:


No es que sea ninguna maravilla de editor de tablas como pueden ser IBConsole o IBExpert pero por lo menos nos permite ver los resultados de las operaciones de nuestro programa sin tener que salir del IDE.

Si nos interesa hacer alguna consulta avanzada entonces debemos seleccionar la conexión con el botón derecho del ratón y elegir SQL Window:


Esto abrirá una nueva pestaña en el centro de la ventana donde podemos escribir nuestras sentencias SQL:


En la parte inferior de este editor podemos escribir la consulta manualmente y luego pulsamos el botón Execute SQL:


Debajo de la sentencia SQL abrirá un apartado con el resultado de la operación:


Si no tenemos gana de escribir sentencias SQL se pueden realizar automáticamente haciendo doble clic sobre las tablas que hay a la derecha y pasarán al centro:


Además se creará abajo la sentencia SQL automáticamente. Incluso se pueden hacer asociaciones entre campos de varias tablas para hacer sentencias SQL más complejas:


Cuando terminemos de trabajar con la base de datos podemos cerrar la conexión pulsándola con el botón derecho del ratón y seleccionando Close connection:


Con esto doy finalizada esta serie de artículos relacionados sobre las diferencias principales entre Delphi 7 y RAD Studio 2007. Quizás en un futuro haga lo mismo entre Delphi 2007 y el recién nacido Delphi 2009 (Tiburón).

Pruebas realizadas con RAD Studio 2007.

Pasando de Delphi 7 a RAD Studio 2007 (8)

En este artículo vamos a ver como aprovechar las ventajas que incorpora RAD Studio 2007 para un analista/arquitecto de software.

EL DISEÑO DE MODELOS UML

Para cualquier tipo de proyecto tenemos en la ventana del proyecto la pestaña Model View que nos permite realizar modelos UML para crear nuestras clases. Cualquier cambio que se produzca en el diseño de una clase se reflejará inmediatamente en el código fuente.

Así mismo, si modificamos el código fuente de una clase se modificará su diseño UML de manera instantánea. Esto nos permite diseñar nuestros programas de una manera profesional sin tener que recurrir a herramientas externas.

COMO DISEÑAR UN MODELO

Supongamos que tenemos que diseñar e implementar un programa de facturación que va a tener unas cuantas clases relacionadas entre sí. En vez de picar código manualmente como hemos hecho hasta ahora lo vamos a diseñar todo utilizando modelos UML.

Lo primero que hay que hacer es crear una nueva unidad que va a contener nuestro código fuente. Seleccionamos en el menú superior File -> New -> Unit y guardamos la unidad con el nombre UFacturacion.pas.

Esto nos dejará una nueva unidad completamente limpia y lista para trabajar:


Ahora seleccionamos la pestaña Model View en la ventana del proyecto:


Al pulsar esta pestaña nos aparecerá este mensaje:


Nos dice que el proyecto actual no esta configurado para el modelado. Pulsamos el botón Sí y aparecerá el editor de modelos con la jerarquía de nuestro proyecto:


Abrimos la rama del proyecto, seleccionamos la unidad UFacturacion con el botón derecho del ratón y seleccionamos Open Diagram:


En la parte central del IDE aparecerá una nueva pestaña con el editor de modelos listo para comenzar a trabajar:


Si nos fijamos en la carpeta que contiene los archivos de nuestro proyecto aparecerá una nueva carpeta dentro llamada ModelSuport_NombreDelProyecto que contiene todos los archivos gráficos UML que vamos desarrollando:


Estos archivos se van actualizando en tiempo real respecto a nuestro código fuente y viceversa.

Vamos a crear nuestro primer modelo para la clase TArticulo. Pinchamos el fondo del editor de modelos con el botón derecho del ratón y seleccionamos Add -> Class:


Nos aparecerá el diseño de una nueva clase llamada Class1:


que vamos a renombrar por TArticulo:


Ahora vamos a añadir una variables a nuestra clase. Pinchamos la clase TArticulo con el botón derecho del ratón y seleccionamos Add -> Field lo que nos creará una nueva variable – campo (Field) con el nombre Field1:


Debemos escribir el nombre del campo, dos puntos y el tipo de variable, por ejemplo:

ID:Integer

Al pulsar Intro aparecerá el signo + a su izquierda:


Esto significa que hemos creado una variable pública. Si seleccionamos esta variable y nos fijamos en el inspector de objetos podemos modificar todas sus propiedades:


En el campo visibility podemos elegir el ámbito de la variable:


De este modo vamos añadiendo campos a nuestra clase hasta completar su diseño:


Si pulsamos la pestaña UFacturacion podemos ver como se refleja inmediatamente en el código fuente:


Todo esto lo hemos hecho sin teclear ni una línea de código. Lo más sorprendente es que si yo añado una variable a la clase, por ejemplo el descuento:

TArticulo = class
  public
  var
    ID:Integer;
    Nombre:String;
    Existencias:Real;
    Precio:Real;
    Descuento:Real;       // Nuevo campo
end;

Si guardamos los cambios y nos vamos al diagrama veremos el cambio en el gráfico:


Esto da una gran flexibilidad al programador al permitir dar toques aquí y allá sin que quede desincronizado el código fuente ni su diseño UML.

Eso sí, no todo va a ser perfecto. Si cogemos todas nuestras variables en diseño y las ponemos como privadas...



Al irnos al código fuente veremos que nos ha hecho esta pequeña chapuza:


Pero bueno, sólo hay que eliminar las palabras private sobrantes y una vez reagrupemos las variables no pasará nada, el diagrama seguirá igual. Pese a este pequeño defecto hay que reconocer que las ventajas de trabajar son enormes.

Cuando estamos diseñando en el editor de modelos podemos seleccionar una clase o una variable de la misma y guardar información respecto al autor, el alias y la versión:


Así podemos trabajar en equipo con otros programadores y analistas diseñando clases y modificando programas ya realizados apuntando siempre quien ha hecho la última modificación y la versión del mismo.

AÑADIENDO MÉTODOS A LA CLASE

A una clase también se le pueden añadir constructores, procedimientos y funciones de manera tan fácil como hemos creado las variables:


Si por ejemplo creamos un constructor, lo llamará automáticamente Create y lo pondrá como público:


Reflejándolo en el código fuente de manera instantánea:


CREANDO REGISTROS

Al igual que hemos creado clases utilizando el editor de modelos podemos crear registros (record) desde la paleta de herramientas:


Se llama structure porque estamos creando una estructura de datos (record). La estructura tiene un gráfico similar a la clase:


Y su código fuente también se crea automáticamente:


En los diseños de los registros también podemos añadir las nuevas características en el lenguaje que hemos visto en artículos anteriores, como pueden ser constructores, funciones y procedimientos.

CREANDO ASOCIACIONES ENTRE LOS ELEMENTOS

Al tener disponible un completo editor UML podemos establecer relaciones, asociaciones y dependencias entre los elementos gráficos insertados:


Tenemos todo tipo de asociaciones para crear una estructura jerárquica perfecta que relacione nuestras estructuras de datos y clase de una manera concisa:


Sólo es cuestión de cogerse un buen libro de UML y aprender como diseñar un sistema completo.

EXPORTANDO EL DISEÑO

El diseño que hemos generado en el Model View podemos exportarlo pulsando el editor con el botón derecho del ratón y seleccionando Export to Image:


Se abrirá esta ventana:


En esta ventana podemos modificar el ancho y alto de la imagen que va a exportar. Si pulsamos el botón Preview veremos una vista previa de la imagen que vamos a generar:


Sólo hay que pulsar el botón Save y podemos guardarlo como imagen JPG, BMP, GIF, etc.

En el próximo artículo veremos como generar la documentación de nuestro proyecto automáticamente.

Pruebas realizadas en RAD Studio 2007.