Los objetos de trasferencia de datos (DTO) pueden ser de mucha utilidad al momento de desarrollar software. Basicamente son un molde para la información, donde el esquema se encuentra fuertemente tipeado
Algunas de las ventajas de utilizar diseños que implementen este tipo de objetos son:

• En cualquier punto del sistema la información puede ser validada, a partir de metadatos establecidos
• Mejora la comunicación entre los programadores, dandoles un mismo esquema de información, evitando conflictos
• Separa fisicamente las capas del sistema, haciendo el codigo mucho mas limpio y reutilizable
• Proporciona mayor seguridad

Aunque estos objetos pueden darnos una gran cantidad de ventajas, tienen una enorme desventaja la cual es la causante de su poco uso, y es el tiempo de desarrollo, ya que obliga al programador a tipear cada una de las entidades logicas del sistema.
Es por esta razón por la cual muchas de las compañias que utilizan este tipo de diseño, o que elaboración frameworks para lo mismo, utilizan herramientas de generación automatica de código.

En lo que respecta a .NET, Microsoft deposito toda su confianza en los famosos objetos denominados Dataset, con los cuales se puede trabajar de una manera muy grafica y sencilla, es muy facil crear un esquma de información a partir de una base de datos de casi cualquier tipo (SQL, OLEDB, XML, etc.).
Pero estos objetos Dataset tienen una desventaja tan grande como sus ventajas… no les importa el diseño del sistema, puedes continuar utilizando los asistentes del VS y ver como terminas juntando el acceso a datos, juntos con las reglas de negocio y la interfaz grafica, tienen tanta funcionalidad que resulta practicamente inutil tratar de heredarlos e incrementar funcionalidad.

Aunque es posible crear objetos DTO usando un Dataset, muchas veces resulta inapropiado, ya que se perdio la razón de ser de estos mismos que es: asegurarse que el transporte de la información se lleve acabo de manera practica y segura, y solo eso.Es por eso que me decidi a crear mi propia estructura para objetos DTO, la cual aunque muy simple tambien es muy concreta y eficaz.
Aún no acabo de hacer todo lo que eh querido (una aplicación de auto-generación de código, y la funcionalidad de serialización en XML), pero por lo pronto ya tiene la funcionalidad que deberia tener para poder trabajar con el.

Les muestro el diagrama de clases, y el código, si alguien tiene alguna de idea de alguna modificación, escribanlo en los comentarios

using System;
using System.Collections.Generic;

    /// <summary>
    /// Domain. Representa la gama de valores en que cierto objeto debe pertenecer
    /// </summary>
    public struct Range<type> where type : struct
    {

        #region Campos
            private System.Nullable<type> minValue;
            private System.Nullable<type> maxValue;
            private bool applyMinValue;
            private bool applyMaxValue;
        #endregion

        #region Constructores

            internal Range(System.Nullable<type> minValue, System.Nullable<type> maxValue) {
                this.minValue = minValue;
                this.maxValue = maxValue;
                this.applyMinValue = true;
                this.applyMaxValue = true;
            }

            internal Range(System.Nullable<type> minValue, System.Nullable<type> maxValue, bool applyMinValue, bool applyMaxValue)
            {
                this.minValue = minValue;
                this.maxValue = maxValue;
                this.applyMinValue = applyMinValue;
                this.applyMaxValue = applyMaxValue;
            }            

        #endregion

        #region Propiedades
            public object MinValue {
                get { return minValue; }
            }
            public object MaxValue {
                get { return maxValue; }
            }
            public bool ApplyMinValue {
                get { return applyMinValue; }
            }
            public bool ApplyMaxValue {
                get { return applyMaxValue; }
            }
        #endregion

    }

    /// <summary>
    /// Metada. Representa un metadato (Información de un campo)
    /// </summary>
    public class MetaData
    {

        #region Campos

            private Type netType; //Default. NETTypes.String
            private int length; //Default. 0
            private int maxLength; //Default. 0

            private bool isNullable; //Default. false
            private bool isReadOnly; //Default. false
            private bool isUnique; //Default. false

            private int numericPrecision; //Default. 0
            private int numericScale; //Default. 0

        #endregion

        #region Constructores

            /// <summary>
            /// MetaData. Constructor Generico
            /// </summary>
            public MetaData() {
                this.netType = Type.GetType("System.String");
                this.length = 0;
                this.isNullable = false;
                this.isReadOnly = false;
                this.isUnique = false;
                this.numericPrecision = 0;
                this.numericScale = 0;
            }
            /// <summary>
            /// Metadata. Constructor por tipo
            /// </summary>
            public MetaData(Type nettype) : this(){
                this.netType = nettype;
            }

        #endregion

        #region Propiedades

            public Type NetType {
                get {
                    return this.netType;
                }
                set {
                    this.netType = value;
                }
            }

            public int Length {
                get {
                    return this.length;
                }
                set {
                    this.length = value;
                }
            }

            public int MaxLength{
                get {
                    return this.maxLength;
                }
                set {
                    this.maxLength = value;
                }
            }

            public bool IsNullable {
                get {
                    return this.isNullable;
                }
                set{
                    this.isNullable = value;
                }
            }

            public bool IsReadOnly {
                get {
                    return this.isReadOnly;
                }
                set {
                    this.isReadOnly = value;
                }
            }

            public bool IsUnique {
                get {
                    return this.isUnique;
                }
                set {
                    this.isUnique = value;
                }
            }

            public int NumericPrecision {
                get {
                    return this.numericPrecision;
                }
                set {
                    this.numericPrecision = value;
                }
            }

            public int NumericScale {
                get {
                    return this.numericScale;
                }
                set {
                    this.numericScale = value;
                }
            }

        #endregion

    }

    /// <summary>
    /// FieldMeta. Clase abstracta basica de Field
    /// </summary>
    public abstract class BaseField : MarshalByRefObject
    {

        #region Campos

            private MetaData meta;
            private string name;

        #endregion

        #region Constructores

            public BaseField(string name, MetaData meta) {;
                this.name = name;
                this.meta = meta;
            }

            public BaseField(string name, MetaData meta, bool isLocked){
                this.name = name;
                this.meta = meta;
            }            

        #endregion

        #region Propiedades

            internal MetaData Meta{
                get { return this.meta; }
                set { this.meta = value; }
            }

            public string Name{
                get { return name; }
                set { name = value; }
            }

        #endregion

        #region Delegados & Eventos

            internal delegate void ValueChange(BaseField field, object value);
            internal event ValueChange valueChange;

            internal void OnValueChange(BaseField field, object value) {
                if (valueChange != null) {
                    valueChange(field, value);
                }
            }
        #endregion
    }

    /// <summary>
    /// Field. Representa un campo
    /// </summary>
    public class Field<type> :  BaseField where type : struct
    {

        #region Campos
            private System.Nullable<type> value;
            private System.Nullable<Range<type>> range;
            private string regEx;
        #endregion

        #region Constructores

            public Field(string name, MetaData meta) : base(name, meta) { }
            public Field(string name, MetaData meta, bool isLocked) : base(name, meta, isLocked) { }

        #endregion

        #region Propiedades

            public type Value{
                get { return this.value.Value; }
                set {  this.value = value; }
            }

            public Range<type> Range {
                get { return this.range.Value; }
                set { this.range = value; }
            }

            public string RegEx {
                get { return this.regEx; }
                set { this.regEx = value; }
            }

            public bool HasValue {
                get { return value.HasValue; }
            }

            public bool HasRange{
                get { return range.HasValue; }
            }

            public bool HasRegEx {
                get { return !string.IsNullOrEmpty(this.regEx); }
            }

        #endregion

        #region Metodos

            #region General

                public override string ToString() {
                    if (value.HasValue){
                        return Value.ToString();
                    }
                    else{
                        return string.Empty;
                    }
                }                

            #endregion

            #region Dominio

                public void SetRange(type minValue, type maxValue)
                {
                    this.range = new Range<type>(minValue, maxValue);
                }

                public void SetRange(type minValue, type maxValue, bool applyMinValue, bool applyMaxValue)
                {
                    this.range = new Range<type>(minValue, maxValue, applyMinValue, applyMaxValue);
                }

            #endregion 

        #endregion

    }

    /// <summary>
    /// DTObject. Representaun objeto tipo DTO
    /// </summary>
    public abstract class DTObject : MarshalByRefObject
    {

        #region Campos
            private Dictionary<string, BaseField> internalCollection;
        #endregion

        #region Propiedades
            public BaseField this[string name]{
                get { return this.internalCollection[name]; }
            }
        #endregion

        #region Constructores
            public DTObject() {
                this.internalCollection = new Dictionary<string,BaseField>();
                SetFields();
            }
        #endregion

        #region Metodos
            protected abstract void SetFields();
            protected void AddField(string name, BaseField field) {
                field.valueChange += new BaseField.ValueChange(OnValueChange);
                this.internalCollection.Add(name, field);
            }
        #endregion

        #region Delegados & Eventos
            public delegate void ValueChange(BaseField field, object value);
            public event ValueChange fieldValueChange;

            protected void OnValueChange(BaseField field, object value){
                if (fieldValueChange != null){
                    fieldValueChange(field, value);
                }
            }
        #endregion
    }

Para comenzar a utilizar el SEH (Structured Exception Handling) primero que nada comenzaremos definiendo que es una “Excepción“.

Excepción:

Es un evento que ocurre durante la ejecución de un programa y require la ejecución de codigo fuera del flujo normal de control.

Hay dos tipos de excepciones:

• Excepciones de Software
  

  Suceden cuando por ejemplo el programa pasa un parámetro invalido

• Excepciones de Hardware
  

  Son iniciadas por el CPU y ocurren cuando son ejecutadas secuencias de código invalidas como una división por zero

Las cuales serán tratadas de la misma forma por nuestro manejador de excepciones.

Bloque de Código SEH

__try
{
    /* Bloque de código  en el cual podría generarse una excepción*/
}
   __except(/*Expresión de filtrado*/)
   {
      /* Bloque de código el cual se ejecutará inmediatamente después de que se produzca la excepción en el bloque anterior */
   }

El bloque de codigo anterior es la estructura la cual nos servirá para manejar las excepciones.
Ahora ¿cómo saber que bloque de código meter en “try”?

Para que nos demos una idea aplicaremos el SEH en estos casos:

• Manipulación de arrays.
• Operaciones matemáticas.
• Al llamar una función que puede generar una excepción a propósito o por que no ha sido bien testeada.
• Errores de sistema que puedan ocurrir y en vez de terminar el programa continuar su ejecución.

Ejemplo de uso de SEH

#include <stdlib.h>
#include <stdio.h>
#include <windows.h>

int main()
{
	__try
	{
			int x,y = 0;
			int z;
			z = x / y;
	}
	__except(EXCEPTION_EXECUTE_HANDLER)
	{
		MessageBoxA(0,"Capturamos la excepcion","SEH Activo",0);
	}

	return 0;
}

Como podemos ver en el anterior ejemplo de código, dentro de try incluimos una división por 0, al ejecutarse ese bloque inmediatamente se salta al bloque de “except” el cual siempre se le pasará un parámetro definido ya en unas constantes:

• EXCEPTION_EXECUTE_HANDLER
  

  Se ejecuta inmediatamente el bloque de código contenido en __except

• EXCEPTION_CONTINUE_SEARCH

  El sistema ignora el manejador de excepciones y busca por un manejador de excepciones dentro del bloque, y continua hasta que encuentra un manejador

• EXCEPTION_CONTINUE_EXECUTION

  El sistema inmediatamente regresa el control al punto en el cual la exepción ocurrió aunque no es posible continuar después de que ocurran “ciertas” excepciones.

Y esto ha sido solamente una introducción al manejo de SEH al menos en C.
Si alguien tiene alguna duda o sugerencia con respecto a este artículo sería bueno que lo comente.

Bueno hoy ante ustedes traigo, para la cartera de la dama o bolsillo del caballero, una guía sobre las ventajas y desventajas de los Entornos de Programación Integrados (IDE en ingles) mas usados en C++ :

VISUAL C++ STUDIO

Empezando por la versión de Microsoft, el Visual C++ es quizás el mas completo de todos los entornos que vamos a encontrar para trabajar en C++. Junto con sus completas librerías (el conjunto SDK) podemos crear casi de todo, y además es la plataforma utilizada por mas del 90% de los desarrolladores de video juegos ya sea en 2D o en 3D.

Su compilador es muy veloz, el depurador es excelente, permite el encarpetamiento de clases para mejorar la organización de los proyectos y tiene una integración sencilla con herramientas externas.

Sus desventajas son, que no es conveniente utilizarlo si vamos a realizar proyectos pequeños ya que requiere demasiadas especificaciones antes de poder empezar a tipear código, además sus diferentes versiones van desde los u$s 600 hasta los u$s 10939, es un producto caro, no es recomendable para personas que quieren comenzar en la programación C++ y sus requerimientos en memoria son mucho mas altos que los de sus competidores.

Recientemente Microsoft a realizado una versión gratuita del Visual C++ la cual podemos descargar de su pagina
http://www.microsoft.com/express/download/, esta versión tiene algunas restricciones.

Para resumir es la mejor herramienta si tienes el dinero suficiente y sabes bastante de C++, por mi parte utilizo la versión gratuita que descargué desde un torrent con la cual estoy aprendiendo desarrollo de video juegos y me es aún difícil de controlar.

BLOODSHED DEV C++

Es un entorno gratuito, aun muy joven, pero totalmente muy recomendable si estamos ingresando a la programación en C++ , además nos va marcando el código en diferentes colores para una mejor comprensión del mismo.

Lo mejor es que sus librerías se van actualizando día a día con versiones nuevas en Internet y sus requerimientos de memoria son bajos, es un entorno prometedor a futuro y podemos descargar la ultima versión de su pagina http://www.bloodshed.net/.

También deberemos descargar la librería MinGW desde la pagina http://sourceforge.net/project/showfiles.php?group_id=2435. Recomiendo descargar la versión MinGW 5.1.3 es la última versión y funciona muy bien.

Otra desventaja que tiene este IDE es que no posee diseñador de formularios pero puede ser complementado con librerías como qt (descargar de: http://www.trolltech.com), muchas veces se puede colgar y el depurador es algo pobre.

BORLAND C++ BUILDER 6.0

Es un entorno excelente y una gran opción ya que permite el desarrollo de proyectos con interfaces de usuario complejas de manera fácil y permite recompilar proyectos de C++ en Linux.

Pero por otra parte su depurador es algo pobre, contiene un compilador mucho mas lento que el de Visual Studio y solo permite importar proyectos de Visual Studio 6 o aquellos cuales tengan código en ANSI C++.

No es gratuito pero su precio es inferior al de Visual aunque difícil de conseguir (legalmente) su precio varia entre los u$s69 y los u$s 100, además creo que han salido nuevas versiones pero no las he revisado aun, en definitiva no deja de ser una buena opción para quienes no estén dispuestos a pagar los terribles precios de Microsoft o crean que el Dev C++ no es una buena herramienta.

ECLIPSE

Este IDE es, a mi entender, una de las mejores opciones para proyectos pequeños, medianos y hasta para algunos grandes proyectos, al igual que DEV C++ colorea el código y es gratuito.

Es un proyecto creado dentro del ámbito universitario y esta en constante actualización. Contiene un buen depurador, utiliza MinGW y contiene muchas opciones para la creación de proyectos con POO.

Pero sus desventajas son, la lentitud tanto para compilar como para depurar, y su instalación es verdaderamente tediosa. Necesitaremos tener motor java instalado o descargarlo desde http://www.java.com/es/download/ ya que originalmente se creo como un IDE para java y contiene algunos bugs, sin embargo no deja de ser una de las mejores opciones a la hora de iniciarnos, algo difícil al principio pero cuando descubramos todas sus opciones lo encontraremos realmente útil.

Para descargarlo debemos elegir alguno de los mirrors en su pagina de descargas y luego deberemos seguir las instrucciones en su tutorial en la parte -> C/C++Developers, y luego en la ventana de ayuda, en el índice de contenidos con la solapa -> “before begin”, instalando el MinGW 5.1.3 si tenemos Windows, o el Cygwin si tenemos Linux. Luego deberemos seguir todos los pasos descriptos instalando todo lo que nos pide desde los links que proporciona el mismo.

Estos no son los únicos entornos existentes pero son los mas utilizados, sobre todo Visual Studio. Antes de elegir uno deberemos detenernos y pensar que es lo que vamos a hacer y que nos conviene más, investigando detenidamente la plataforma que mejor nos parezca.

¿Y tú… que IDE vas a usar?

Este artículo es una continuación de Programación Genérica.

Siguiendo con la introducción que hizo Eduardo y con ayuda de unos amigos, voy a explicar que son y para que se usan los templates, uno de los recursos mas poderosos de C++.

Definición

Según la wikipedia:

Las plantillas son el mecanismo de C++ para implantar el paradigma de la programación genérica. Permiten que una clase o función trabaje con tipos de datos abstractos, especificándose más adelante cuales son los que se quieren usar.

Las templates nos permiten crear estructuras de datos que no dependen de si vamos a ingresarles un entero, una letra, o cualquier otro tipo de dato que se nos ocurra. ¿como es esto? Se nos permite, mediante simples modificaciones, adaptar nuestras estructuras.

Yo usaré una clase con un array (vector) que iré modificando para que reciba enteros, luego char y por ultimo float(reales). Esta es una de las mejores maneras de reutilizar código!

A la antigua, esto requería que se hiciera 3 clases diferentes con 3 arrays diferentes… pero usando templates lo haré en una sola.

El siguiente es el código:

/*********ARCHIVO PRUEBA.H ***********/
#ifndef PRUEBA_H_
#define PRUEBA_H_
#include <iostream>

/**
 * Aqui empiezan las diferencias a una declaración ordinaria.
 * La linea siguiente define que cada vez que aparezca  "t"
 * se modificará el dato por otro que mas adelante definiremos.
 */
template <class t>

class prueba
{
  private:

                      /** como vemos, el array no es ni de enteros **/
    t array[5];       /** ni de char ni de otros datos sino que es
                      /** de datos tipo "t"
                      /**/

    int poscicion;

  public:
    prueba(){}
    virtual ~prueba(){}
    bool ingresar_datos(t & datos)
    {
      if (poscicion<5)
      {
        array[poscicion]=datos;
        poscicion ++;
        return true;
      }
      else
      {
        return false;
      }
    }

    /**
     * nuevamente vemos que esta funcion nos devuelve un dato de tipo "t"
     */
    t mostrar_datos(int & pos)
    {
      if (pos<=4 && pos>=0)
        return array[pos];
      else
        return array[1];
    }
};

#endif /*PRUEBA_H_*/

Bueno, hasta aquí vimos que donde supuestamente debía aparecer un tipo de dato aparecía una “t”, esto le indicará al compilador que se debe tomar a “t” como el tipo de variable que a continuacion definiremos en el main de abajo.

Jugando con templates

A continuación, dejo una posible implementación en un archivo main.cpp:

#include "prueba.h"
#include <iostream>

using namespace std;

int main (){
  int   dato1 = 1;
  char  dato2 = 'a';
  float dato3 = 3.14;
  int   pos = 0;

  prueba<float>prueba3;
  prueba<char>prueba2;
  prueba<int>prueba1;

  prueba1.ingresar_datos(dato1);
  cout << prueba1.mostrar_datos(pos) << endl;

  prueba2.ingresar_datos(dato2);
  cout << prueba2.mostrar_datos(pos) << endl;

  prueba3.ingresar_datos(dato3);
  cout << prueba3.mostrar_datos(pos) << endl;
  return 0;
}

Como vemos, con esta simple declaración cambiamos de una clase común, a una clase que puede admitir tanto enteros como punteros como cualquier otro dato que se nos ocurra; hicimos una infinidad de pasos en pocas líneas ya que con modificar <float> por <char> o por <int> cambiamos nuestra clase para que admita un dato diferente.

Ahora, quizás esta forma de definir nuestras clases y crear objetos se vea un poco complicada, pero yo recomiendo que se familiaricen bien con los templates porque en mas de una ocasión nos ahorrarán muchas pero muchas líneas de código.

Mas adelante explicaré como crear una lista enlazada con templates… y ahí veremos la gran utilidad de los templates.

¿Y tu, utilizas esta potente herramienta?