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
    }

En este articulo, veremos que cosa es la “Programación Genérica” y lo mas importante: ¿para qué nos sirve?

Definición

Segun la wikipedia:

La programación genérica es un tipo de programación que está mucho más centrada en los algoritmos que en los datos. La idea de esta forma de programar pretende generalizar las funciones utilizadas para que puedan usarse en más de una ocasión.

Esto se consigue parametrizando lo máximo posible el desarrollo del programa y expresados o devueltos de la forma más simple posible, evitando detalles concretos.

Como el nombre de la palabra compuesta lo dice: Programación Genérica, signifíca una programación que no dependa de datos fijos, cuyo algoritmo funcione de manera “genérica” para todo tipo de ocaciones.

Si hacemos una analogía: es como tener una máquina de hacer helados:
Con la programación No-Genérica (la clásica) tendriamos una máquina por cada sabor.
Con la programación Genérica, podriamos utilizar la misma máquina para crear diferentes sabores. Y las posibilidades son infinitas!

Para explicar esta idea, veamos unos ejemplos bien concretos:

function saludar_eduardo() {
  return "Hola Eduardo";
}

function saludar_pedro() {
  return "Hola Pedro!";
}

function despedir_eduardo() {
  return "Chau Eduardo! que la pases bien.";
}

Aplicando el principio de la programación genérica, lograriamos algo asi:

function saludar(nombre, despedir) {
  if(despedir) {
    return "Hola"+nombre;
  }else{
    return "Chau"+nombre+"! que la pases bien.";
  }
}

El ejemplo es bien concreto.

¿Que ventajas ofrece este tipo de programación?

• Reutilización del código
• Mejorar el mantenimiento del código
• Facilidad para encontrar errores y debuguear
• Concentrarse más en la lógica que en los datos

Otra ventaja?

La reutilización del código tanto dentro del mismo proyecto, como para otros proyectos!
Esto es extremadamente útil ya que, solo necesitarias programar un algoritmo una vez en tu vida, y lo reutilizarias (Sí, haciendo copy paste) en otros proyectos.

¿Que pasa si el algoritmo es muy grande y complejo… se puede hacer genérico?
Divide y vencerás: La idea es dividir el algoritmo en partes más simples tantas veces como sea necesario, para volverlo fácil de comprender y de generalizar.

Como palabras finales, cabe destacar que los “Templates” en C++ siguen este principio de generalización, al permitirnos crear estructuras de datos que no dependen de tipos de datos específicos. Pero sobre este tema se hablará en otra ocación.

Y tu… ¿estas familiarizado con este tipo de programación?

¿Programar un arte?

Últimamente he estado leyendo y encontrando una y otra vez esta discusión, ¿Programar es un arte?, Yo pienso que sí y es por el mero hecho de plasmar mis ideas y conocimiento en algo casi “tangible” como el código escrito.

La mayoría de los “profesionistas” como siempre abogan por que programar es más que teclear código mientras que los fanáticos y apasionados (mayormente autodidactas) gritan desesperadamente “Programar es un arte!”.

Por eso a continuación trataré de llegar a la conclusión de una vez por todas ya que si no mi cabeza seguirá procesando código y el bucle infinito no parará de ejecutarse.

¿Qué es el arte?

Empecemos definiendo primero que nada qué es el arte, según la wikipedia: “es una forma de expresar información y dicha información puede transmitir ideas, sentimientos o emociones, limitarse a producir o expresar excepciones y sensaciones que no sean explicables de otro modo”.

Y llegados a este punto.

¿Qué es programar?

Es plasmar un algoritmo en un lenguaje de programación. (ojo que no sólo “picar teclas” como alguien dijo por ahí).

¿Entonces es un arte o no?

Dado que la ingeniería del software no era aplicada cuando los primeros programadores provenientes de las Ciencias Matemáticas y Fisica puedo decir que ellos eran como “Artesanos” lo mismo para los programadores de la Old School que desarrollaban en assembly, c y otros lenguajes antiguos; para ellos el mero hecho de programar no era por “trabajo” era por una expresión de su conocimiento e ideas plasmadas en código, por el goce y el disfrute, por lo tanto Programar ERA un arte.

Con la llegada de la profesionalización de carreras de Informática y el desarrollo poco a poco de la Ingeniería de Software, la programación pasó de ser “Artesanal” a “Ingeniería”.

Actualmente se considera “técnicos” o “programadores” (pica código) a aquellos que programan sin definir detalles de un proyecto, sin planificación ni nada. El problema de esto es que muchos de estos “pica códigos” ya tienen definido y especificado su algoritmo sea en su cabeza o por papel.

Para finalizar y como analogía, diré que “Hacer hamburguesas de McDonalds ES UN ARTE” más que un proceso de producción bien definido.

Quién me diga que no y siga pensando que todo es Ciencia e Ingeniería entonces debería leerse la biografía de Ray kroc y darse cuenta de como habla del pan para hamburguesa y las papas fritas.

Y tú, ¿ sigues pensando que programar NO es un arte? Te invito a expresar tu opinión.

A la hora de resolver problemas es importante elegir el “paradigma” de programación correcto.
Pero ¿qué es un paradigma de programación?

Entiendase por ello en la forma en como el programador “ve” y piensa sobre la ejecución del programa.

No sería lo mismo entonces pensar en una ejecución secuencial a una ejecución de un algoritmo escrito en POO.

¿Qué paradigmas existen?

Bueno antes que nada un poco de historia, remontémonos a los tiempos de la Old school, las polillas en los enormes computadores y antes de que Bill Gates fuera rico.

En esos tiempos existía (y existe aún) la Programación Imperativa, “Assembly” y “El lenguaje binario” eran las únicas formas de programar…

Mucho después empezaron a surgir los HLL (lenguajes de alto nivel) estructuras de control de flujo, variables, bifurcación y todo el resto que ya conocemos; fue entonces que la programación imperativa fue poco a poco evolucionando y de ahí derivó en la programación estructurada, procedural y Orientado a Objetos.

Por lo tanto tenemos:

Programación Imperativa.

Describe la programación en términos de estado del programa y un conjunto de instrucciones que cambian de estado por lo tanto este conjunto le indica a la computadora como realizar una tarea.

Este paradigma podemos subdividirlo en los siguientes:

1. Programación procedural
2. Programación estructurada
3. Programación Orientada a objetos

    

Programación declarativa.

Se declaran un conjunto de condiciones, proposiciones, afirmaciones que describen el problema y detallan su solución.

En la programación declarativa podemos incluír:

1. Programación funcional
2. Programación Lógica.

Por último y sin dejarlo atrás, se cuenta con la Programación Concurrente, pero este paradigma lo dejamos para otra ocasión.

¿Y tú, en qué paradigma te gusta programar más?

Referencias:

http://es.wikipedia.org/wiki/Paradigma_de_programación