Software y Aplicaciones Web

Mi Primer Objeto - parte 1

jtentor — Mon, 10 Aug 2009 16:54:00 -0200

Con esta publicación voy a desarrollar lo necesario para que un principiante en programación orientada a objetos pueda ver como se logra un objeto. No voy a seguir ninguna metodología en particular, simplemente vamos guiar nuestra ideas en el proceso de construcción.

Algunos conceptos

Los objetos representan entidades con las que tenemos contacto a diario, estas entidades pueden ser reales como por ejemplo un avion, una persona o pueden ser abstractas como una cuenta de banco que no se puede tocar, sabemos que existe pero no la podemos tocar solamente vemos informes del estado de la cuenta.

Sabemos que un objeto tiene comportamiento, lo que significa que presenta ciertas respuestas a determinadas acciones o mensajes que es la forma con la que dialogamos con los objetos. A un motor de auto no le podemos pedir que nos caliente el cafe, no entiende ese mensaje; el motor puede enter acelerar, frenar, parar y otros mensajes que tengan que ver con la naturaleza del motor mismo.

Para poder realizar ese comportamiento que se observa en la vida real, los objetos necesitan de una "estructura interna" que no es otra cosa más que datos almacenados de alguna manera que le permiten al objeto cumplir con las funciones que debe representar. En programación orientada a objetos, a diferencia de otros modelos de programación, lo más importante es el comportamiento; debemos identificar ese comportamiento logrando poner un nombre a cada mensaje que el objeto puede responder y si hacen falta argumentos o parámetros para que ese mensaje tenga sentido, por ejemplo a un motor se le puede pedir que acelere pero debe indicarse cuantó debe acelerar.

Ejemplos a considerar

Los que tuvieron la oportunidad de jugar al Age Of Empire, saben que en ese juego hay personajes que recorren el campo de juego buscando y recolectando madera, oro, piedra entre otroas cosas. Lo que se observa en este caso es que ese personaje tiene un objeto en el cual guarda los elementos que encuentra.

En el juego Counter Strkie, los personajes comienzan con un arma y a medida que pueden "matar" a otros personajes pueden levantar el arma del que acaban de matar. Nuevamente vemos ese comportamiento, resulta que el personaje tiene un objeto donde puede meter las armas (elementos) que levanta, sin embargo aquí se observa un comportamiento adicional: resulta que el personaje que se muere "tira" o "deja" su arma, lo que podemos enunciar como que el objeto en cuestión debe permitir sacar un elemento que está dentro de él. Es en este juego donde también se oberva que ese objeto, el que contiene las armas, puede mostrar todos los elementos que contiene lo que representa otro comportamiento más, en este caso la posibilidad de obtener por ejemplo una cadena con las representaciones de las armas que tiene.

Cuando vamos de compras a un supermercado, paseamos por el salón de ventas recogiendo lo que nos hace falta (y que obviamente podamos pagar), en algunos casos tomamos una unidad del producto o artículo y en otras oportunidades recogemos dos o tres unidades del mismo artículo. Ahora también se observa el mismo comportamiento, hay un objeto (el carro) donde se puede agregar articulos (del mismo tipo o no); sin embargo aquí se observa un caso particular cuando son varias las personas que están haciendo las compras ocurre que una de ellas necesita saber si un elemento está o no en el carro (puede ser que otra persona ya lo haya recogido) de manera que se espera que el objeto pueda decirnos si un elemento está o no en él.

Resulta que cuando ya no vamos a comprar más artículos y nos acercamos a la caja, miramos el carro para ver cuantos articulos tenemos y ver si podemos pasar por una de las cajas rápidas que normalmente aceptan hasta una cantidad de productos; ese es otro comportamiento que debemos considerar, resulta que el objeto tiene que poder decirnos cuantos elementos contiene. Una véz que estámos en la caja se observa que la persona que nos va a cobrar saca (en la medida que puede) los artículos del mismo tipo para pasarlos una sola véz multiplicando su precio por la cantidad que llevamos; he ahí otro comportamiento, resulta que el objeto también tiene que poder decirnos cuantos elementos hay de un tipo o valor en particular.

Una situación que parece innecesaria de enunciar en el ejemplo del carro en el supermercado es el hecho de hasta cuando sacamos productos del carro cuando estamos en la caja. Pues bien lo hacemos hasta que el carro está vacio, lo que significa que el objeto en cuestión tiene que poder decirnos si esta vacío o no.

Bien, creo que los ejemplos muestran que más allá de las diferencias, existe un objeto que presenta un comportamiento comun el que podemos enunciar en la siguiente lista:

Es posible agregar un elemento al objeto tantas veces como se desee.
Es posible sacar un elemento del objeto (siempre que este ahí).
Es posible determinar si un elemento está o no en el objeto.
Es posible averiguar si el objeto está vacío.
Es posible obtener una cadena con la representación de todos los elementos que están en el objeto.
Es posible averiguar cuantos elementos hay en el objeto.
Es posible averiguar cuantos elementos de un mismo tipo o valor hay en el objeto.

Ahora debemos identificar (dejar en claro) los mensajes que utilizaremos para dialogar con este objeto. Tenemos que ponerle un nombre a cada mensaje y también indicar si requiere o no argumentos y por supuesto si el mensaje debe entrgar "algo" de que tipo es ese "algo" que entrega. Este proceso es importante requiere de un nivel de abstracción porque vamos a concentrarnos en "que hace" el objeto y dejar para más adelante "como lo hace". Si logramos superar esta etapa sin pensar en el "como" vamos a tener lo que se conoce como una "interface" que no es otra cosa más que una especificación de lo que debe hacer un objeto, no se indica "como lo hace" simplemente se dice "que hace" y todo lo necesario para que pueda hacerlo de manera que cada mensaje quede bien definido.

Para el punto 1 vamos bautizar el mensaje como "Agregar" y es obvio que tenemos que indicar mediante un argumento o parámetro el elemento que quermos agregar. De manera que en principio el mensaje queda así:

Agregar(TipoElemento elemento)

Utilizamos TipoElemento porque en este punto (gracias a la abstracción) no nos intersa si se trata de artículos, madera, piedra, armas o lo que sea que estamos metiendo dentro del objeto, simplemente queremos agregara elementos. Este mensaje debería o no devolver algo, es bastante común que se piense que no hace falta devolver nada cuando se trata de este tipo de mensajes; sin embargo es una buena práctia devolver el mismo objeto (por supuesto con el elemento agregado) consecuentemente el mensaje quedaría así:

TipoObjeto Agregar(TipoElemento elemento)

Ahor estamos diciendo que el mensaje devuelve una "referencia" al tipo del objeto en cuestión, nuevamente no nos preocupamos por el tipo del objeto eso lo dejamos para más adelante.

En el punto 2 el mensaje podría ser el siguiente:

TipoObjeto Sacar(TipoElemento elemento)

Es importante destacar que este mensaje también devuelve una "referencia" al tipo delobjeto en cuestión (obviamente sin el elemento que indicamos) porque no hace falta dado que ya conocemos el elemento lo que queremos es que lo saque del objeto.

El mensaje del punto 3 será algo como:

bool Existe(TipoElemento elemento)

Obviamente el resultado debe ser un valor booleano (verdadero o falso) de acuerdo a si el elemento que enviamos como parámetro está o no en el objeto.

Para el punto 4 el mensaje es:

bool Vacio()

Lo que es obvio porque también se espera un valor booleano (verdadero o falso) y en este caso no requiere de parámetros.

En el punto 5 podemos imaginar cualquier nombre para el mensaje, sin embargo es costumbre incluso una buena práctica de programación utilizar lo siguiente:

string ToString()

Con lo que estamos indicando que el mensaje devuelve una cadena que tendrá la representación de todos los elementos que están dentro del objeto. Utilizar "ToString" (si fuese Java sería toString, la primera en minúscula) es una posiblidad que nos brindan los lenguajes de programación orientada a objetos dado que este mensaje particularmente ya existe para todos los objetos, y como nuestro objeto pertenecerá a la jerquía de objetos del programa obviamente heredará el mensaje, de manera que lo correcto es "sobreescrir" o redefinir el mensaje.

El punto 6 es bastante simple y queda de este modo:

int Contar()

Devuelve un entero que representa la cantidad de elementos que hay en el objeto.

Para el punto 7 vamos a utilizar la posiblidad que nos brindan los lenguajes de programación orientada a objetos sobrecargando el mensaje, de modo que sería así:

int Contar(TipoElemento elemento)

A diferencia del mensaje del punto 6, cuando se utiliza el mensaje indicando un parametro lo que se desea es que el objeto nos conteste con la cantidad de elementos iguales al parámetro o argumento que pasa.

Hasta este punto, la lista de comportamiento observado ha sido expresada en términos de mensajes obviamente para programación orientada a objetos; si pretendemos mostrarle esto a mi abuela seguramente no lo va a entender, pero los desarrolladores sabemos que cada uno de los mensajes está asociado con un comportamiento que se observa en la vida real.

Otro punto muy importante a esta altura es que en ningún momento se ha pensado al menos no se escribió nada que vincule los mensajes con la estructura interna del objeto, todavia no sabemos como haremos para guardar los elementos dentro del objeto y así debe ser. Los mensajes deben ser totalmente independientes de la estructura interna, de ese modo cuando llegue el momento de implementar (escribir código) se podrá utilizar las formas, técnicas y metodologías más apropiadas para ello. Con esto quiero decir que la manera en que los elementos se guardan dentro de los objetos puede ser diferente, sin embargo el resto del programa o aplicación no se verá afectado porque los objetos de la aplicación dialogan con este objeto por medio de sus mensajes nunca acceden a la estructura interna y tampo saben como hace el objeto para mantener esa estructura interna.

El siguiente paso, ahora que estamos conformes con la especificación del objeto, es implementar algo del objeto o todo si somos habilidosos y creemos que nos puede salir bien de primera. Como esta publicación está dirigida a aquellos que están comenzando con la programación orientada a objetos, vamos a hacerlo por partes, o sea iterativa e incrementalmente lo que quiere decir que vamos a iterar (dar vueltas) trabajando varias veces sobre lo mismo solo que en cada iteración vamos a agregar (incrementar) un poco más de funcionalidad hasta que logremos todo lo que se nos pide.

Como los ejemplos de partida hablan de armas, madera, oro, articulos de un supercado la cosa está complicada entonces una buena idea es hacer un prototipo del comportamiento. Esto quiere decir que vamos a desarrollar un "artefacto" con el cual vamos a probar si somos capaces de lograr el comportamiento observado, por eso vamos a decir que en nuestro prototipo los elementos son letras (caracteres), y vamos a bautizar el TipoObjeto como "Bolsa" porque es un nombre que parece ser el más apropiado. Si podemos lograr el comportamiento para una "Bolsa de caracteres", seguramente podremos iterar e incrementar hasta lograr los ejemplos con los que arrancamos.

Los desarrolladores que tiene un poco más de experiencia realizan esta tarea directamente especificando lo que se conoce como una interface, nosotros no lo haremos porque mi intención es no complicar el ejemplo con otras cuestiones que son necesarias y que las mostraré al finalizar esta tanda de publicaciones.

El desarrollo

A medida que avancemos enel desarrolla voy a mostrar porciones de la implementación realizada en C#, estas porciones están fuera de contexto luego verán como se las incorpora a todas juntas.

Ahora entendemos que el "Que hace" está definido y por el momento no cambia, de manera que vamos a trabajar con el "Como lo hace". Llego el momento de pensar cómo vamos a guardar los caracteres (elementos) dentro de la bolsa (objeto), una primera idea es utilizar un arreglo donde guardamos los elementos (seguro que despues podemos mejorar o no esta situación pero por algún lado hay que comenzar). Resulta que el arreglo tiene un tamaño o dimensión que se fija en algún momento y la bolsa tiene que permitir que los caracteres se agregen o saquen nos hace falta un número (entero) que indique cuantos caracteres hay en el arreglo. Entonces la estructura interna puede quedar de la siguiente manera:

   1:      /// <summary>

   2:      /// sirve para almacenar o guardar los elementos dentro del objeto

   3:      /// inicialmente tiene una capacidad para 100 caracteres.

   4:      /// </summary>

   5:      private char[] datos = new char[100];

   6:      /// <summary>

   7:      /// Sirve para mantener la cantidad de elementos útiles dentro del

   8:      /// objeto, inicialmente su valor es cero.

   9:      /// </summary>

  10:      private int cantidad = 0;

Es importante destacar que los componentes de la estructura interna se declaran como privados, eso es necesario para lograr que el "mundo exterior" desconozca los pormenores del objeto. Observen que estos componentes el arreglo de caracteres y el entero ya están inicializados lo que es necesario porque un arreglo debe tener una dimensión antes de poder utilizarlo y por supuesto el entero que cuenta cuantos caracteres útiles hay en el arreglo debe comenzar con un valor igual a cero. Otro detalle es la ventaja de poder incorporar documentación que indica y aclara para cualquier persona (que pueda leer código) de que se trato lo que ahí se encuentra.

Bién la implementación del mensaje correspondiente al punto 1 es lo que llamamos un método, que puede ser el siguiente:

   1:      /// <summary>

   2:      /// Agrega un elemento al objeto del tipo bolsa

   3:      /// </summary>

   4:      /// <param name="x">Elemento que se desea agregar</param>

   5:      /// <returns>Referencia al mismo objeto bolsa que ahora continene el nuevo elemento</returns>

   6:      public Bolsa Agregar(char x)

   7:      {

   8:        // Solamente se puede agregar hasta que se "llene" el arreglo

   9:        if (cantidad < 100)

  10:        {

  11:          datos[cantidad] = x;

  12:          ++cantidad;

  13:        }

  14:        return this;

  15:      }

Obviamente es publico porque el "mundo exterior" tiene que poder utilizar este método para dialogar con el objeto, observen que la variable "cantidad" (que indica cuantos caracters útiles hay en el arreglo) puede tener un valor que va desde cero hasta 99 lo que nos sirve como subindice para saber donde debemos poner el nuevo caracter, obviamente despues de ponerlo debemos incrementar el valor de "cantidad".

Por ahora solamente se puede agregar hasta que se llene el arreglo, incluso no hacemos nada cuando esa situación ocurre; ya veremos como solucionar esta cuestión. En este momento estamos construyendo un prototipo consecuentemente debemos lograr algo que funcione y nos permita ver que vamos por buen camino.

Entonces debemos implementar el punto 5, que nos permite ver que hay dentro del objeto; de ese modo podremos probar si el mensaje "Agrear(...)" funciona. Entonces podemos considerar la siguiente porción de código:

   1:      /// <summary>

   2:      /// Genera una cadena con todos los elementos que hay en el objeto

   3:      /// del tipo bolsa.

   4:      /// </summary>

   5:      /// <remarks>

   6:      /// ESTA NO ES LA MEJOR IMPLEMENTACIÓN, PERO SIRVE PARA EL EJEMPLO

   7:      /// DEBERÍA UTILIZARSE UN OBJETO StringBuilder (luego lo veremos)

   8:      /// </remarks>

   9:      /// <returns>Cadena con la representación de cada elemento que hay en el objeto bolsa</returns>

  10:      public override string ToString()

  11:      {

  12:        string s = "";

  13:        for (int i = 0; i < cantidad; ++i)

  14:        {

  15:          s = s + datos[i].ToString() + " ";

  16:        }

  17:        return s;

  18:      }

Este método también debe ser publico (caso contrario el "mundo exterior" no lo podría utilizar) pero también debe indicarse que se está sobreescribiendo el mismo método de la jerarquía de clases, debemos recordar que todos los objetos pertenecen a una enorme jerarquía donde el primero de ellos implementa el método ToString. Este código no es de lo mejor pero sirve para que entendamos el ejemplo, de ninguna manera se permite que el desarrollador realice implementaciones de baja calidad o utilizando elementos que no son eficientes porque despues no hay tiempo o se olvidan de cambiarlas y quedan así; al tratarse de un ejemplo académico esto sirve para no complicarnos la vida con otras cosas, el objetivo es mostrar como se puede hacer.

Con lo que tenemos hasta ahora ya es posible realizar una prueba del prototipo, a continuación voy a detallar los pasos necesarios para que esto se pueda utilizar desde una aplicación de consola o línea de comandos.

En C# recomiendo la siguiente manera de atacar un proyecto de prueba o prototipo. Lo primero es tener una solución de manera que una vez que se arranca el Visual Studio van al menú "Archivo - Nuevo" y buscan la alternativa para una "Solución en blanco" o vacía.

Una vez que tiene la solución es posible agregar un proyecto, para ello lo que tienen que hacer es apuntando en el nombre de la solución se pulsa el boton derecho lo que muestra los siguientes menús contextuales y seleccióna "Nuevo proyecto".

Ahora tienen que elegir el tipo de proyecto, para eso buscan en Visual C# la alternativa que diga "Aplicación de consola" y le dan un nombre (el que quieran)

Con esto ya tienen un proyecto que tiene un elemento Program.cs que es por donde comenzará la ejecución la aplicación. Por ahora no hacemos nada en Programa.cs, vamos a agregar un nuevo elemento en este caso una clase que es donde vamos a codificar todo lo necesario para nuestro ejemplo.

Eso se hace apuntando al nombre del proyecto y pulsando el boton derecho para acceder a los menús contextuales de manera que puedan agregar una clase:

Les aparece el siguiente formulario donde deben indicar el nombre de la clase

El nombre apropiado es "Bolsa" porque de ese modo el Visual Studio escribe lo mínimo como para comenzar a implementar el código.

Bien ahora se puede escribir el código en la clase Bolsa lo que debería quedar de la siguiente forma:

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Linq;

   4:  using System.Text;

5:

   6:  namespace Demo1

   7:  {

   8:    public class Bolsa

   9:    {

  10:      #region Campos de la Estructura Interna de cada objeto

11:

  12:      /// <summary>

  13:      /// sirve para almacenar o guardar los elementos dentro del objeto

  14:      /// inicialmente tiene una capacidad para 100 caracteres.

  15:      /// </summary>

  16:      private char[] datos = new char[100];

  17:      /// <summary>

  18:      /// Sirve para mantener la cantidad de elementos útiles dentro del

  19:      /// objeto, inicialmente su valor es cero.

  20:      /// </summary>

  21:      private int cantidad = 0;

22:

  23:      #endregion

24:

  25:      #region Métodos públicos, implementan los mensajes

26:

  27:      /// <summary>

  28:      /// Agrega un elemento al objeto del tipo bolsa

  29:      /// </summary>

  30:      /// <param name="x">Elemento que se desea agregar</param>

  31:      /// <returns>Referencia al mismo objeto bolsa que ahora continene el nuevo elemento</returns>

  32:      public Bolsa Agregar(char x)

  33:      {

  34:        // Solamente se puede agregar hasta que se "llene" el arreglo

  35:        if (cantidad < 100)

  36:        {

  37:          datos[cantidad] = x;

  38:          ++cantidad;

  39:        }

  40:        return this;

  41:      }

42:

  43:      /// <summary>

  44:      /// Genera una cadena con todos los elementos que hay en el objeto

  45:      /// del tipo bolsa.

  46:      /// </summary>

  47:      /// <remarks>

  48:      /// ESTA NO ES LA MEJOR IMPLEMENTACIÓN, PERO SIRVE PARA EL EJEMPLO

  49:      /// DEBERÍA UTILIZARSE UN OBJETO StringBuilder (luego lo veremos)

  50:      /// </remarks>

  51:      /// <returns>Cadena con la representación de cada elemento que hay en el objeto bolsa</returns>

  52:      public override string ToString()

  53:      {

  54:        string s = "";

  55:        for (int i = 0; i < cantidad; ++i)

  56:        {

  57:          s = s + datos[i].ToString() + " ";

  58:        }

  59:        return s;

  60:      }

61:

  62:      #endregion

  63:    }

  64:  }

Observen que se utilizan directivas del IDE, lo que permite encerrar entre #region y #endregion una porción de código, obviamente para mejorar la legibilidad del mismo. Además es posible hacer click el símbolo menos para "esconder" esa porción de código; de hecho en este ejercicio es innecesario, pero cuando se debe implementar código más complejo y largo esto resulta muy util.

El otro punto que es importante destacar es la posibilidad de documentar (técnicamente) el código que está escribiendo. Esto se hace agregando /// (tres barras) en la línea anterior a la declaración del método, entonces el Visual Studio agrega esa plantilla donde uno puede describir lo que ese metodo hace, como son sus parámetors y que devuelve.

Es el momento de generar la solución para ver que todo está compilando bién; eso se hace en el menú con la opcion "Generar - Generar Solución".

Ahora podemos pasar al código de Program.cs que es donde esta el punto de inicio de la aplicación y poner algo de código que nos permita probrar:

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Linq;

   4:  using System.Text;

5:

   6:  namespace Demo1

   7:  {

   8:    class Program

   9:    {

  10:      static void Main(string[] args)

  11:      {

  12:        Bolsa mibolsa = new Bolsa();

  13:        mibolsa.Agregar('A');

  14:        Console.WriteLine("La bolsa tiene: {0}", mibolsa.ToString());

  15:        mibolsa.Agregar('X');

  16:        Console.WriteLine("La bolsa tiene: {0}", mibolsa.ToString());

  17:        mibolsa.Agregar('R');

  18:        Console.WriteLine("La bolsa tiene: {0}", mibolsa.ToString());

  19:        mibolsa.Agregar('A');

  20:        Console.WriteLine("La bolsa tiene: {0}", mibolsa.ToString());

  21:      }

  22:    }

  23:  }

Compilamos y ejecutamos:

FUNCIONA !!!!

Con esto finalizamos nuestra primer iteración dado que tenemos un producto que cumple con los objetivos propuestos para esa iteración que era probar una bolsa de caracteres. En la segunda iteración debemos considerar que pasa cuando el arreglo se llena e implementar el resto de los mensajes de manera que nuestra Bolsa implemente todo el comportamiento observado.

Una de las ENORMES ventajas de los lenguajes orientados a objetos es que ya no hay mas arreglos. Lo que normalmente denominamos "arreglo" en realidad es una "lista en secuencia" o "lista secuencial" lo que significa que en la memoria los componentes de la lista están uno al lado del otro (como en los viejos arreglos de los otros lenguajes), la diferencia escencial es que es un objeto consecuentemente tiene un referencia que se almacena en el Stack y un área de memoria (para los elementos) que se almacena en el Heap y ahora se tiene el Garbage Collector que busca las porciones de memoria no utilizadas o que dejamos de utilizar y las devuelve al sistema operativo.

Con ello en mente se puede crear un nuevo elemento "arreglo" ahora con un tamño mas grande y copiar todos los elementos de uno al otro, como muestra la siguiente porción de código:

   1:      /// <summary>

   2:      /// Agrega un elemento al objeto del tipo bolsa

   3:      /// </summary>

   4:      /// <param name="x">Elemento que se desea agregar</param>

   5:      /// <returns>Referencia al mismo objeto bolsa que ahora continene el nuevo elemento</returns>

   6:      public Bolsa Agregar(char x)

   7:      {

   8:        if (cantidad < 100)

   9:        {

  10:          datos[cantidad] = x;

  11:          ++cantidad;

  12:        }

  13:        else

  14:        {

  15:          char[] nuevo = new char[150];

  16:          for (int i = 0; i < 100; ++i)

  17:          {

  18:            nuevo[i] = datos[i];

  19:          }

  20:          datos = nuevo;

  21:          datos[cantidad] = x;

  22:          ++cantidad;

  23:        }

  24:        return this;

  25:      }

Despues de copiar todos los elementos se hace un cambio en la referencia "datos = nuevo" (línea 20) y listo, el Garbage Collector liberará la memoria utilizada por el viejo arreglo pero nosotros ya tenemos uno más grande.

Cualquiera que sepa un poquito de programación se da cuenta que esto va a fallar porque al principio (línea 8) estamos controlando contra 100 y el nuevo arreglo ahora puede tener un tamaño o dimensión de 150. Esto se arregla con lo siguiente:

   1:      /// <summary>

   2:      /// Agrega un elemento al objeto del tipo bolsa

   3:      /// </summary>

   4:      /// <param name="x">Elemento que se desea agregar</param>

   5:      /// <returns>Referencia al mismo objeto bolsa que ahora continene el nuevo elemento</returns>

   6:      public Bolsa Agregar(char x)

   7:      {

   8:        if (cantidad < datos.Length)

   9:        {

  10:          datos[cantidad] = x;

  11:          ++cantidad;

  12:        }

  13:        else

  14:        {

  15:          char[] nuevo = new char[datos.Length + 50];

  16:          for (int i = 0; i < datos.Length; ++i)

  17:          {

  18:            nuevo[i] = datos[i];

  19:          }

  20:          datos = nuevo;

  21:          datos[cantidad] = x;

  22:          ++cantidad;

  23:        }

  24:        return this;

  25:      }

El código ahora utiliza la propiedad Length que tiene la lista en secuencia para saber su tamaño o dimensión, lo que se incorpora en las líneas 8 y 16. Es importante observar que también se utiliza esta propiedad para hacer que el tamaño del nuevo arreglo vaya creciendo un poco (en este caso de 50 en 50) a partir del tamaño que en ese momento tiene el viejo arreglo.

Bién este código se puede reorganizar un poco porque se observa la mismas líneas (10,11 con 21,22) pero eso es un tema menor.

La implementación del resto de los mensajes no es complicada de manera que podemos ver el código final:

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Linq;

   4:  using System.Text;

5:

   6:  namespace Demo1

   7:  {

   8:    public class Bolsa

   9:    {

  10:      #region Campos de la Estructura Interna de cada objeto

11:

  12:      /// <summary>

  13:      /// sirve para almacenar o guardar los elementos dentro del objeto

  14:      /// inicialmente tiene una capacidad para 100 caracteres.

  15:      /// </summary>

  16:      private char[] datos = new char[100];

  17:      /// <summary>

  18:      /// Sirve para mantener la cantidad de elementos útiles dentro del

  19:      /// objeto, inicialmente su valor es cero.

  20:      /// </summary>

  21:      private int cantidad = 0;

22:

  23:      #endregion

24:

  25:      #region Métodos públicos, implementan los mensajes

26:

  27:      /// <summary>

  28:      /// Agrega un elemento al objeto del tipo bolsa

  29:      /// </summary>

  30:      /// <param name="x">Elemento que se desea agregar</param>

  31:      /// <returns>Referencia al mismo objeto bolsa que ahora continene el nuevo elemento</returns>

  32:      public Bolsa Agregar(char x)

  33:      {

  34:        if (cantidad < datos.Length)

  35:        {

  36:          datos[cantidad] = x;

  37:          ++cantidad;

  38:        }

  39:        else

  40:        {

  41:          char[] nuevo = new char[datos.Length + 50];

  42:          for (int i = 0; i < datos.Length; ++i)

  43:          {

  44:            nuevo[i] = datos[i];

  45:          }

  46:          datos = nuevo;

  47:          datos[cantidad] = x;

  48:          ++cantidad;

  49:        }

  50:        return this;

  51:      }

52:

  53:      /// <summary>

  54:      /// Cuenta cuántos elementos hay en un objeto del tipo bolsa

  55:      /// </summary>

  56:      /// <returns>Cantidad de elementos que hay en el objeto bolsa</returns>

  57:      public int Contar()

  58:      {

  59:        return cantidad;

  60:      }

61:

  62:      /// <summary>

  63:      /// Cuenta cuántos elemetnos de un determinado valor se encuentran dentro

  64:      /// de un objeto del tipo bolsa

  65:      /// </summary>

  66:      /// <param name="x">Valor que se desea averiguar</param>

  67:      /// <returns>Cantidad de elementos del valor dado que hay en el objeto bolsa</returns>

  68:      public int Contar(char x)

  69:      {

  70:        int cuenta = 0;

  71:        for (int i = 0; i < cantidad; ++i)

  72:        {

  73:          if (datos[i] == x)

  74:          {

  75:            ++cuenta;

  76:          }

  77:        }

  78:        return cuenta;

  79:      }

80:

  81:      /// <summary>

  82:      /// Averigua si un elemento está o no dentro de un objeto del tipo bolsa

  83:      /// </summary>

  84:      /// <param name="x">Elemento que se desea controlar</param>

  85:      /// <returns>Verdadero si el elemento está en la bolsa, caso contrario falso</returns>

  86:      public bool Existe(char x)

  87:      {

  88:        for (int i = 0; i < cantidad; ++i)

  89:        {

  90:          if (datos[i] == x)

  91:          {

  92:            return true;

  93:          }

  94:        }

  95:        return false;

  96:      }

97:

  98:      /// <summary>

  99:      /// Saca o retira el elemento indicado del objeto del tipo bolsa,

 100:      /// </summary>

 101:      /// <param name="x">Elemento a retirar o sacar</param>

 102:      /// <returns>Referencia al miso objeto bolsa sin el elemento indicado</returns>

 103:      public Bolsa Sacar(char x)

 104:      {

 105:        if (Existe(x))

 106:        {

 107:          int i = 0;

 108:          while (datos[i] != x)

 109:          {

 110:            ++i;

 111:          }

 112:          for (; i < cantidad - 1; ++i)

 113:          {

 114:            datos[i] = datos[i + 1];

 115:          }

 116:          --cantidad;

 117:        }

 118:        return this;

 119:      }

 120:

 121:      /// <summary>

 122:      /// Genera una cadena con todos los elementos que hay en el objeto

 123:      /// del tipo bolsa.

 124:      /// </summary>

 125:      /// <remarks>

 126:      /// ESTA NO ES LA MEJOR IMPLEMENTACIÓN, PERO SIRVE PARA EL EJEMPLO

 127:      /// DEBERÍA UTILIZARSE UN OBJETO StringBuilder (luego lo veremos)

 128:      /// </remarks>

 129:      /// <returns>Cadena con la representación de cada elemento que hay en el objeto bolsa</returns>

 130:      public override string ToString()

 131:      {

 132:        string s = "";

 133:        for (int i = 0; i < cantidad; ++i)

 134:        {

 135:          s = s + datos[i].ToString() + " ";

 136:        }

 137:        return s;

 138:      }

 139:

 140:      #endregion

 141:    }

 142:  }

Finalmente podemos cambiar un poco el código de Program.cs para probar otros mensajes del objeto Bolsa.

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Linq;

   4:  using System.Text;

5:

   6:  namespace Demo1

   7:  {

   8:    class Program

   9:    {

  10:      static void Main(string[] args)

  11:      {

  12:        Bolsa b = new Bolsa();

  13:        bool continuar = true;

  14:        string buff;

  15:        char elemento;

16:

  17:        do

  18:        {

  19:          Console.Write("Ingrese el valor que desea agregar (punto para finalizar): ");

  20:          buff = Console.ReadLine();

  21:          if (buff.Length > 0)

  22:          {

  23:            elemento = buff[0];

  24:            continuar = elemento != '.';

  25:            if (continuar)

  26:            {

  27:              b.Agregar(elemento);

  28:              Console.WriteLine("Bolsa: {0} ({1} elementos)\n", b.ToString(), b.Contar());

  29:            }

  30:          }

  31:        } while (continuar);

32:

  33:        continuar = true;

  34:        do

  35:        {

  36:          Console.Write("Ingrese el valor que desea sacar (punto para finalizar): ");

  37:          buff = Console.ReadLine();

  38:          if (buff.Length > 0)

  39:          {

  40:            elemento = buff[0];

  41:            continuar = elemento != '.';

  42:            if (continuar)

  43:            {

  44:              b.Sacar(elemento);

  45:              Console.WriteLine("Bolsa: {0} ({1} elementos)\n", b.ToString(), b.Contar());

  46:            }

  47:          }

  48:        } while (continuar);

49:

  50:      }

  51:    }

  52:  }

Espero que les sirva, en especial a aquellos que están comenzando con la programación orientada a objetos.

En la parte 2 de este ejercicio/ejemplo vamos a desarrollar otros aspectos muy importantes sobre todo cuando de objetos se trata.

Número Perfecto

jtentor — Fri, 31 Jul 2009 11:00:00 -0200

En este post se muestra el código para determinar si un número es o no perfecto.

Otra vez se trata de un ejercicio del cursos Programador .NET en Becas Control+F

   1:      /// <summary>

   2:      /// Un número entero se dice que se trata de un número perfecto si sus factores,

   3:      /// incluyendo a 1 (pero excluyendo en el número mismo), suman igual que el número.

   4:      /// Por ejemplo, 6 es un número perfecto porque 6 = 1+2+3.

   5:      /// Escriba una función perfect que determine si el parámetro number es un número

   6:      /// perfecto. Utilice esta función en un programa que determine e imprima todos los

   7:      /// números perfectos entre 1 y 1000.

   8:      /// Imprima los factores de cada número perfecto para confirmar que el numero de verdad

   9:      /// es perfecto.Ponga en acción la potencia de su computadora para probar números más

  10:      /// grandes que 1000

  11:      /// </summary>

  12:      private static void Ejercicio3()

  13:      {

  14:        Console.Clear();

  15:        Console.WriteLine("Laboratorio 4 - Ejercicio 3");

16:

  17:        for (int i = 1; i <= 10000; ++i)

  18:        {

  19:          if (Perfect(i))

  20:            MostrarDivisores(i);

  21:        }

  22:        Console.ReadKey();

  23:      }

  24:      /// <summary>

  25:      /// Determina si un número es perfecto, un numero es perfecto

  26:      /// si el número es igual a la suma de sus divisores excluyendo

  27:      /// el mismo número. Ejemplo 6 = 1 + 2 + 3

  28:      /// </summary>

  29:      /// <param name="number">Número a controlar</param>

  30:      /// <returns>Verdadero si el número es perfecto</returns>

  31:      private static bool Perfect(int number)

  32:      {

  33:        if (number < 1)

  34:          return false;

  35:        int sum = 0;

  36:        for (int i = 1; i <= (number / 2); ++i)

  37:        {

  38:          if ((number % i) == 0)

  39:            sum += i;

  40:        }

  41:        return number == sum;

  42:      }

43:

  44:      /// <summary>

  45:      /// Muestra los divisores de un número y determina si el número

  46:      /// es perfecto.

  47:      /// </summary>

  48:      /// <param name="number">Número a controlar</param>

  49:      private static void MostrarDivisores(int number)

  50:      {

  51:        if (number < 1)

  52:          return;

  53:        int sum = 0;

  54:        Console.Write("Divisores de {0,8} :", number);

  55:        for (int i = 1; i <= (number / 2); ++i)

  56:        {

  57:          if ((number % i) == 0)

  58:          {

  59:            Console.Write(" {0} ", i);

  60:            sum += i;

  61:          }

  62:        }

  63:        if (number == sum)

  64:          Console.WriteLine("Es perfecto");

  65:        else

  66:          Console.WriteLine("NO ES perfecto");

  67:      }

A ver si alguien tiene otra idea de cómo hacer esto.

Jugar a los Dados - Craps

jtentor — Fri, 31 Jul 2009 10:55:00 -0200

Este post muestra el código para jugar a los dados.

Se trata de un ejercicio del cursos Programador .NET en Becas Control+F

   1:      /// <summary>

   2:      /// Un jugador tira dos dados. Cada dado tiene seis caras. Las caras contienen

   3:      /// 1, 2, 3,4,5 y 6 puntos. Una vez que los dados se hayan detenido, se calcula

   4:      /// la suma de los puntos de los puntos en las dos caras superiores. Si a la

   5:      /// primera tirada, la suma es 7, o bien 11, el jugador gana. Si en la primera

   6:      /// tirada la suma es 2, 3, o 12 (conocido como “craps”), el jugador pierde

   7:      /// (es decir, la casa “gana”). Si en la primera tirada la suma es 4, 5, 6, 8,

   8:      /// 9, ó 10, entonces dicha suma se convierte en el “punto” o en la tirada.

   9:      /// Para ganar, el jugador deberá continuar tirando los dados hasta que haga

  10:      /// su “tirada”. El jugador perderá si antes de hacer su tirada sale una tirada de 7

  11:      /// </summary>

  12:      private static void Ejercicio1()

  13:      {

  14:        Console.Clear();

  15:        Console.WriteLine("Laboratorio 4 - Ejercicio 1");

16:

  17:        int dado1, dado2, suma, punto;

18:

  19:        dado1 = TirarDado();

  20:        dado2 = TirarDado();

  21:        suma = dado1 + dado2;

  22:        Console.Write("\n\nSalida {0} + {1} = ", dado1, dado2);

23:

  24:        if ((suma == 7) || (suma == 11))

  25:          Console.WriteLine("{0} Natural - Gana !!!", suma);

  26:        else

  27:          if ((suma == 2) || (suma == 3) || (suma == 12))

  28:            Console.WriteLine("{0} Craps - PIERDE", suma);

  29:          else

  30:          {

  31:            punto = suma;

  32:            Console.WriteLine("{0}\n\nEl punto es {0}", punto);

  33:            do

  34:            {

  35:              dado1 = TirarDado();

  36:              dado2 = TirarDado();

  37:              suma = dado1 + dado2;

  38:              Console.Write("  Tirada {0} + {1} = {2} ", dado1, dado2, suma);

  39:              if (suma == punto)

  40:                Console.WriteLine(" GANA");

  41:              else

  42:                if ((suma == 7) || (suma == 11))

  43:                  Console.WriteLine(" PIERDE");

  44:                else

  45:                  Console.WriteLine(" continua");

  46:            } while (!((suma == punto) || (suma == 7) || (suma == 11)));

  47:          }

  48:      }

49:

  50:      /// <summary>

  51:      /// Este objeto se utiliza para generar números pseudoaleatorios

  52:      /// </summary>

  53:      private static Random generador = new Random();

54:

  55:      /// <summary>

  56:      /// Simula el hecho de tirar un dado, los posibles valores van del 1 al 6

  57:      /// se utiliza un objeto que genera números pseudoaleatorios

  58:      /// </summary>

  59:      /// <returns>Valor simulado 1,2,3,4,5,6</returns>

  60:      private static int TirarDado()

  61:      {

  62:        return generador.Next(1, 7);

  63:      }

A ver si alguien tiene otra idea de cómo hacer esto.

Abstracción Estructuras y Tipos de Datos

jtentor — Mon, 27 Jul 2009 11:00:00 -0200

Abstracción, Estructuras y Tipos de Datos

(Julio-2009)

Contenido

Introducción.. - 1 -

Abstracción.. - 1 -

Abstracción de procedimientos. - 2 -

Método de abstracción por parametrización. - 2 -

Método de abstracción por especificación. - 3 -

Abstracción de datos. - 4 -

Estructuras. - 4 -

Estructuras en informática. - 5 -

Estructura en los lenguajes de programación. - 5 -

Estructuras en los algoritmos. - 5 -

Estructura de datos. - 5 -

Aspectos generales de las estructuras de datos. - 6 -

Relaciones entre elementos. - 6 -

Funciones básicas para estructuras. - 6 -

Operaciones. - 6 -

Estructura de datos con base en la relación entre los elementos. - 7 -

Tipos de datos. - 7 -

Tipos de datos predefinidos. - 8 -

Tipos de datos estructurados. - 8 -

Tipo de datos abstractos. - 8 -

Tipos de datos abstractos básicos. - 8 -

Tipos de datos abstractos compuestos. - 9 -

Resumen de conceptos. - 9 -

Introducción

Con esta publicación pretendo introducir a los estudiantes de carreras informáticas en los conceptos teóricos y prácticos de las Estructuras de Datos con especial interés en la Programación Orientada a Objetos.

Uno de los aspectos fundamentales para el estudio de cualquier sistema, en particular los sistemas de información, es la comprensión de su estructura; para caracterizar una estructura es indispensable un proceso de abstracción.

Abstracción (en filosofía) es una operación mental destinada a aislar conceptualmente una propiedad concreta de un objeto, y reflexionar sobre esta ignorando (mentalmente) las otras propiedades del objeto en cuestión.

Estructura es la disposición y orden de las partes dentro de un todo, también puede entenderse como un sistema de conceptos coherentes y enlazados, cuyo objetivo es precisar la esencia del objeto de estudio.

Abstracción

La abstracción es uno de los aspectos fundamentales para el estudio de las estructuras, y en general para el desarrollo de los sistemas de información, permite tener en cuenta los aspectos relevantes para la solución de un problema y deja en segundo plano todo aquello que no es trascendente.

También se puede referir a la abstracción como la habilidad de concentrarse en lo general y fundamental pasando por alto el detalle, lo que simplifica el análisis y permite concentrarse en lo relevante.

En informática, la abstracción desempeña un papel importante dado que facilita el análisis y el diseño, permite determinar la estructura de los sistemas que se van a implementar y tener una mejor visión de su funcionamiento.

Los desarrolladores (aún los principiantes) utilizan de manera casi natural los procesos de abstracción. Por ejemplo cuando se desea realizar una operación matemática entre número reales, simplemente se escribe una expresión como la siguiente:

real Cantidad, Importe, Total

...

Leer Cantidad

Leer Importe

Total = Cantidad * Importe

...

En este caso, el desarrollador no se preocupa por las cuestiones de aritmética de punto flotante o la manera en que estos datos se representan en la memoria; su interés está centrado en que se efectúe la operación y obtener el resultado.

Aún cuando los desarrolladores apliquen de manera natural los conceptos y procesos de abstracción, es importante destacar que hay diferentes aspectos entre los cuales debemos mencionar la Abstracción de Procedimientos y la Abstracción de Datos.

Abstracción de procedimientos

Mediante la abstracción se determinan los objetivos y operaciones necesarias para dar solución a un problema, y mediante la modularidad se efectúa la separación en unidades funcionales.

La abstracción de procedimientos se puede considerar como una herramienta que permite extender las posibilidades de un lenguaje de programación, al agregar nuevas operaciones mediante procedimientos, funciones, subrutinas, métodos, etc. se tiene la posibilidad de dividir un programa en unidades funcionales.

Esta clase de extensión es útil especialmente cuando los programas por desarrollar son grandes (en número de líneas) y es conveniente descomponerlos. Este tipo de abstracción actualmente se aplica de forma intensiva cuando se una función o un procedimiento para realizar una tarea.

La abstracción de procedimientos combina los métodos de parametrización y especificación de manera que permite abstraer su acción como si se tratara de una simple operación o evento, y además se tiene el uso de parámetros mediante el cual el procedimiento provee una transformación de unos argumentos de entrada en unos argumentos de salida, sin olvidar otras posibilidades, como que se modifiquen los parámetros de entrada o que no existan estos argumentos.

Método de abstracción por parametrización

Esta abstracción se define en términos de parámetros formales; de esta manera la identidad del dato es irrelevante; pero la presencia, el tipo y el número son indispensables.

Este método se utiliza frecuentemente en el desarrollo de sistemas, permite mediante parámetros representar potencialmente diferentes valores, que pueden llegar a ser infinitos.

Ejemplo: función cuyo objetivo es entregar el mayor valor de dos enteros dados.

entero Maximo(entero Valor1, entero Valor2)

Inicio

Si Valor1 > Valor2 Entonces

regresar Valor1

Sino

regresar Valor2

FinSi

Fin

Esta función se puede utilizar de diferentes maneras:

Leer X

Leer Y

Escribir Maximo(X, Y)

...

O un uso más complejo, en este caso hallar el mayor de tres números

Leer A

Leer B

Leer C

Escribir Máximo(Maximo(A, B), C)

...

Obviamente esto se puede extender a la cantidad de números que se desee.

Método de abstracción por especificación

El objetivo de este tipo de abstracción es centrar la atención sobre "qué hace", y pasar a un segundo plano el "cómo lo hace".

El hecho que la implementación (cómo lo hace) no sea lo relevante sino sus efectos (que hace), requiere que se tenga una descripción o especificación técnica del proceso; además es exigible que las modificaciones a nivel de la implementación sean transparentes a su uso brindando de esa manera una gran flexibilidad.

Para obtener los beneficios de la abstracción es necesario que la especificación sea precisa; estas especificaciones pueden ser formales o informales, algunos lenguajes facilitan esta tarea pues han sido diseñados para soportar la abstracción.

Una manera de hacer esta especificación es por medio de aserciones. La primera de ellas es la precondición, que es el conjunto de condiciones necesarias y suficientes que aseguran la correcta ejecución del proceso; la otra aseveración es la postcondición, donde se debe especificar los resultados que se obtienen después de la ejecución del proceso.

Otra información importante de la especificación es el encabezado del procedimiento, además de dar el nombre al mismo, debe brindar información acerca de su función, tipos de parámetros de entrada y salida, su número y orden.

Ejemplo: subrutina que ordena un vector de números; la ordenación se puede realizar de diferentes maneras lo que no es importante en este caso porque se está especificando lo que hace y no como lo hace.

Caso de un procedimiento:

Descripción: Ordena el contenido de un vector de números

Precondición: Se debe facilitar el vector de números y la cantidad de elementos que este vector contiene, debiendo ser esta un entero mayor o igual a cero.

Postcondición: El vector de números es modificado de manera que se presenten ordenados de manera ascendente.

Encabezado: Ordenar(ref TipoVector Datos, entero Cantidad)

Caso de una función:

Descripción: Ordena el contenido de un vector de números

Precondición: Se debe facilitar el vector de números y la cantidad de elementos que este vector contiene, debiendo ser esta un entero mayor o igual a cero.

Postcondición: Se entrega un nuevo vector cuyo contenido son los números del vector original ordenados de manera ascendente.

Encabezado: TipoVector Ordenar(TipoVector Datos, entero Cantidad)

Abstracción de datos

Así como la abstracción de procedimientos permite ampliar la capacidad de los lenguajes de programación, la abstracción de datos permite extender la base de los tipos predefinidos en estos lenguajes. Esta capacidad permite incluir nuevos tipos de datos con las operaciones correspondientes y generar de esa manera estructuras de datos de mayor complejidad.

La abstracción de datos se puede sintetizar en la determinación de un conjunto de objetos y el conjunto de operaciones que se pueden efectuar sobre esos datos. Cuando se implementa el tipo de dato, simultáneamente se deben implementar dichas operaciones.

Los lenguajes de programación modernos facilitan un tipo de dato que permite manipular fechas, lo que nos permite pensar en el siguiente código:

TipoFecha Fecha1, Fecha2

...

Leer Fecha1

Leer Fecha2

Escribir "Hay ", Fecha2 - Fecha1, " días de diferencia entre ambas fechas"

...

Es importante aclarar que la expresión Fecha2 - Fecha1 se realiza sobre dos variables cuyos contenidos son fechas (día, mes, año) y el resultado es un entero que representa la cantidad de días que hay entre ambas fechas, obviamente este valor será cero cuando las fechas sean iguales, positivo si Fecha2 es mayor que Fecha1 o negativo si Fecha1 es menor que Fecha1; pero lo más importante es que la operación "resta" indicada con el operador "-" (menos) debe tener en cuenta las cantidades de días que cada mes tiene en cada una de las fechas así como las consideraciones necesarias para los años bisiestos.

Estructuras

En un sistema ideal, la única relación que debe existir entre los elementos que lo componen debe ser a través de la estructura; aunque esta condición es difícil que se cumpla, especialmente en los sistemas de información que se tienen en el mundo real.

Para ejemplificar el concepto, se puede considerar la estructura atómica propuesta en el modelo de Bohr. En este modelo los elementos de la estructura son los electrones y el núcleo con sus respectivos componentes (protones, neutrones, mesones, etc.); las leyes que gobiernan esa estructura son las que establecen la interrelación entre sus elementos, a saber: "La distribución de los niveles de energía", "La distribución de los electrones en sus órbitas", "La conservación de la cantidad de movimiento" o "La conservación de la energía" entre otras.

Bajo este concepto, todos los elementos químicos tienen la misma estructura básica, la que corresponde al modelo atómico; sin embargo las características de los elementos son diferentes.

El concepto de estructura no sólo se aplica en la química o los cuerpos físicos, también es aplicable en otras áreas por ejemplo:

· En matemáticas una estructura algebraica es un objeto matemático formado por un conjunto no vacio y una o varias leyes de composición interna.

· En sociología se habla de la estructura social como el concepto que describe la forma que adopta el sistema global de las relaciones entre individuos.

Estructuras en informática

Con el objeto de presentar una visión general de las estructuras en informática, se debe tener en cuenta que este concepto se utiliza con mayor frecuencia para referirse a las estructuras de datos, sin embargo se aplica también a los lenguajes de programación y en general a las diferentes aplicaciones y sistemas informáticos.

Estructura en los lenguajes de programación

Los lenguajes de programación se pueden caracterizar mediante su propia estructura general. A nivel individual se puede determinar la estructura de cada lenguaje de programación, siendo factible agruparlos según una caracterización de acuerdo a los diferentes tipos de lenguajes; por ejemplo, procedimentales, orientados a objetos o funcionales, entre otros.

Cualquier lenguaje está constituido por un conjunto de elementos (componentes léxicos) que están regidos mediante normas de sintaxis y semántica propias, todo esto constituye la estructura del lenguaje. Un análisis completo de esta estructura implica definir cada uno de sus componentes y las reglas que los interrelacionan.

Estructuras en los algoritmos

En este caso el concepto de estructura se aplica teniendo en cuenta el tipo de algoritmo: procedimental, orientado a objeto, recursivo; en general de acuerdo a la técnica de programación que se utilice.

Si se desea profundizar además de la estructura general, entonces se puede analizar las estructuras básicas dentro de cada módulo o método según el caso. Estos elementos están relacionados mediante la lógica del algoritmo, y forman de esta manera su estructura.

Estructura de datos

En general, se puede considerar una estructura de datos como un conjunto de variables, quizá de tipos distintos, que se relacionan entre sí y que se pueden operar como un todo, esto implica un conjunto de "celdas" en las que se puede almacenar los datos.

El componente básico de la estructura de datos es la "celda", las estructuras de datos se implementan a través de los lenguajes y son un modelo que caracteriza y permite almacenar y utilizar una determinada organización de datos.

Nota: En los párrafos anteriores se utiliza el término "celda" para indicar el espacio de memoria que un equipo informático destina para almacenar un dato. No es el objetivo de esta publicación internarse en las cuestiones de arquitectura o estructura de computadoras.

Las estructuras de datos son fundamentales para el manejo de información y el desarrollo de sistemas. Las diferentes maneras como se relacionan los datos originan conformaciones que son estructuras de datos de mayor complejidad.

Aspectos generales de las estructuras de datos

Las estructuras de datos se usan en el manejo de información y en el desarrollo de algoritmos; es el caso de los arreglos, las cadenas de caracteres, los archivos entre otras.

Tradicionalmente el enfoque que se tiene es hacia su aplicación por medio de un lenguaje y rara vez se trata el punto de vista estructural, sin embargo existen aspectos fundamentales para el conocimiento de una estructura de datos, tal es el caso de: las relaciones entre sus elementos, las funciones que permite su creación, la forma de acceso a los elementos y las operaciones que se pueden efectuar sobre la estructura.

Relaciones entre elementos

Las relaciones entre los elementos de una estructura establecen la conexión física o lógica entre los distintos elementos que componen la estructura. Los principales tipos de relación son:

· De precedencia: permite representar la secuencia u orden de los elementos.

· De equivalencia, con esta relación es posible equiparar o igualar elementos.

· De jerarquía: permite indicar "niveles de importancia" entre los elementos.

· De pertenencia: determina que algunos elementos están incluidos en otros elementos, conformando de esta manera estructuras más complejas.

· De adyacencia: permite representar la "igualdad de importancia" entre los elementos de la estructura.

Es importante destacar que una estructura puede estar constituida por un conjunto de estructuras elementales o básicas, consecuentemente estas mismas relaciones son válidas entre estructuras.

Funciones básicas para estructuras

Para disponer de una estructura de datos se necesita una serie de algoritmos que ejecuten las tareas fundamentales, los cuales reciben el nombre de funciones básicas y se enumeran a continuación:

· Funciones constructoras: Se encargan de crear la estructura; es decir definen las características, la delimitación, las relaciones, y asignan el espacio correspondiente, dejando la estructura a disposición del desarrollador para que proceda a colocar la información.

· Funciones para acceso: Facilitan la llegada de un elemento perteneciente a la estructura; la función puede ser simple o compleja, depende del tipo de estructura. En general las formas de acceso se pueden considerar directas cuando a partir de un parámetro o una dirección se trata de encontrar el valor correspondiente, y son inversas en el caso contrario.

· Funciones destructoras: Se encargan de devolver al sistema los recursos asignados a la estructura de datos. En los lenguajes modernos casi nunca es necesario efectuar alguna operación sobre la estructura, pues el espacio que ocupaba queda automáticamente liberado.

Operaciones

Sobre una estructura de datos se puede efectuar diferentes tipos de operaciones, entre las más importantes están:

· Navegar por la estructura, es el término que actualmente se utiliza para referirse al recorrido por los elementos de la estructura. Esta es una operación básica, y garantiza que se puede recuperar la información almacenada.

· Búsqueda, permite determinar si un elemento se encuentra o no en la estructura.

· Consulta de la información, permite obtener información de uno o más elementos de la estructura.

· Copia parcial o total, es aquella operación mediante la cual se puede obtener total o parcialmente una estructura con características similares a la original.

· Prueba, permite determinar si uno o varios elementos cumplen determinadas condiciones.

· Modificación, permite variar parcial o totalmente el contenido de la información de los elementos de la estructura.

· Inserción, es la operación mediante la cual se incluye un nuevo elemento en la estructura.

· Eliminación, es la operación que permite suprimir elementos de la estructura.

Estructura de datos con base en la relación entre los elementos

Para establecer una clasificación básica es necesario tener en cuenta el tipo de relación existente entre los elementos que conforman las estructuras de datos. La primera abstracción consiste en considerar que los elementos son datos de los que no nos interesa su conformación (en realidad pueden ser estructuras de gran complejidad), lo importante es que se pueden considerar como datos simples y en consecuencia tratados como si fueran elementos. De esta manera se puede obtener la siguiente clasificación:

· Estructura de tipo lista: Es la que surge al observar la manera como se relacionan los elementos y se puede concluir que una forma de relación es la secuencia u orden de la cual deriva la estructura de lista.

· Estructura de tipo árbol: La estructura de tipo lista es muy utilizada, sobre todo cuando los elementos tienen la misma categoría; sin embargo cuando entre éstos elementos existen diferentes niveles, surgen relaciones del tipo jerárquico que se plasman en una estructura jerárquica o arborescente.

· Estructura de tipo red: Las relaciones que existen entre los elementos en muchos casos son complejas y las dos estructuras anteriores son insuficientes; por ello se requiere de una estructura más abierta, en la que los elementos puedan relacionarse sin tener las restricciones de secuencia o jerarquía, sino básicamente de adyacencia.

Los tipos de relaciones mencionados no son los únicos que se pueden establecer; existen relaciones entre los elementos que aunque no sean un tipo de estructura se pueden analizar como ellas, tal es el caso del modelo relacional que seguramente se estudia en un curso de base de datos.

Tipos de datos

Los tipos de datos son fundamentales para la implantación de estructuras más complejas. En general, cuando se define una variable como perteneciente a un tipo de datos se efectúa una abstracción que incluye la especificación de las celdas en que se puede almacenar, el conjunto de valores válidos que ésta celda puede tomar y el conjunto de operaciones que se pueden efectuar.

Por ejemplo cuando el desarrollador utiliza variables numéricas, sabe que con estas variables se pueden realizar operaciones matemáticas, de ninguna manera se le ocurre concatenar números lo que sí se puede hacer con variables del tipo carácter.

En esencia, un tipo de datos es una colección de valores; el desarrollador aprende que con distintos tipos de datos puede realizar distintas operaciones, las cuales están implementadas en el lenguaje de programación que utiliza.

Tipos de datos predefinidos

Los lenguajes de programación siempre han tenido, como parte de su estructura, la posibilidad de definir una variable o una constante como perteneciente a un tipo de datos que el lenguaje reconoce. Por ello se denominan TDP - Tipo de Dato Predefinido, es el caso de los enteros, reales, booleanos, caracteres.

Es conveniente aclarar que no todos los lenguajes soportan los mismos tipos de datos, ni el mismo TDP - Tipo de Dato Predefinido define exactamente el conjunto de valores para diferentes lenguajes.

Tipos de datos estructurados

Los lenguajes de programación en general permiten definir lo que se conoce como TDE - Tipo de Dato Estructurados, es decir colecciones de más de un elemento que pueden manipularse como si fuese una sola cosa. Algunos de estos tipos de datos estructurados son:

· Arreglos: Un arreglo es un tipo de dato cuya implantación implica una colección de elementos finita y homogénea. Para hacer referencia a cualquiera de las celdas del arreglo es necesario el nombre del arreglo y el valor de uno o más índices lo que permite tener acceso aleatorio a cada elemento de la colección.

· Registros: El tipo de datos registro permite agrupar diferentes elementos y manejarlos como un todo, además permite establecer relaciones lógicas entre ellos. Para acceder a cada uno de los elementos se utiliza un selector de campo o elemento.

· Enumerados: Es un tipo de dato que permite agrupar diferentes identificadores bajo una denominación y asignar estos valores a las variables definidas para ello.

Tipo de datos abstractos

Uno de los problemas que se presentan en los lenguajes de programación es que muchos de los tipos de datos que requiere el desarrollador no se encuentran predefinidos ni tampoco estructurados, sin embargo se pueden definir y posteriormente implementar, mejorando y ampliando de esta manera las posibilidades que brinda el lenguaje.

Un TDA - Tipo de Dato Abstracto es el resultado de aplicar un proceso de abstracción de datos, reuniendo un Tipo de Dato y las operaciones que se pueden realizar con este tipo de dato.

Un aspecto importante que no debe olvidarse es que los TDA son fundamentalmente un modelo, y las estructuras de datos son la implementación de estos TDA en un lenguaje de programación.

Tipos de datos abstractos básicos

· El TDA Entero tiene como tipo el conjunto de números enteros definido por las matemáticas y como operaciones la suma, la resta, la multiplicación y la división entera.

· El TDA Real tiene como tipo el conjunto de números reales definido por las matemáticas y como operaciones la suma, la resta, la multiplicación la división.

· El TDA Carácter tiene como tipo el conjunto de caracteres definido por un alfabeto dado y como operaciones todos los operadores relacionales (<, >, =, >=, <=,<>)

· El TDA Booleano tiene como tipo el conjunto de valores {verdadero, falso} y como operaciones el AND, OR y NOT definidos en el Álgebra Booleana.

Tipos de datos abstractos compuestos

· El TDA Conjunto es una colección de elementos tratados con las operaciones unión, intersección y diferencia de conjuntos definidas en las matemáticas.

· El TDA Arreglo es una colección de elementos homogénea de longitud fija tal que cada uno de sus elementos puede ser accedido individualmente mediante uno o varios índices, que serán de tipo ordinal y que indican la posición del elemento dentro de la colección.

· El TDA Registro es una colección de elementos heterogénea compuesta por una cantidad fija de elementos denominados campos a las que se accede mediante un selector de campo.

Los lenguajes de programación modernos implementan estos tipos de datos abstractos básicos o compuestos de diferentes maneras por eso es importante destacar que en los lenguajes de programación se encuentran Estructuras de Datos que implementan un concepto o modelo denominado Tipo de Dato Abstracto.

Resumen de conceptos

Abstracción: Habilidad que permite tener en cuenta lo fundamental o relevante, dejando de lado los detalles. Se aplica en la solución de problemas o situaciones.

Abstracción de datos: Facilidad mediante la cual en un lenguaje de programación se pueden definir nuevos tipos de datos.

Abstracción de procedimientos: Facilidad que presentan los lenguajes de programación de manera que se los programas se puedan dividir en unidades funcionales.

Estructura: Conjunto de las partes fundamentales de un sistema, incluidas sus relaciones, distribución y orden, que caracterizan al sistema.

Estructura de datos: Implementación a la que se llega mediante un nivel adecuado de abstracción lo que permite caracterizar, almacenar y utilizar una determinada organización de datos.

Tipos de datos: Permite caracterizar una variable al determinar el conjunto de valores que puede tomar.

Tipo de datos abstractos: Modelo definidos por el desarrollador, que permiten caracterizar un conjunto de datos y las operaciones que se pueden efectuar con éstos.

Para aquellos que les interese aquí esta el documento: Abstracción Estructuras y Tipos de Datos.pdf (186,77 kb)

Esepro que les sirva.

Tirando Dados - Simulación

jtentor — Mon, 29 Jun 2009 20:00:00 -0200

Este post muestra el código para simular la tirada de datos, el objetivo es estudiar la probabilidad que tienen de salir los distintos números.

Se trata de un ejercicio del cursos Programador .NET en Becas Control+F

   1:      /// <summary>

   2:      /// Escriba un programa que simule el tirar dos dados. El programa deberá utilizar

   3:      /// una función que genere numero aleatorios para tirar el primer dado, y despues

   4:      /// volver a utilizarla para tirar el segundo dado. La suma de los dos valores

   5:      /// debera ser calculada. Nota: en vista de que cada dado puede mostrar un valor

   6:      /// entero de 1 a 6 entonces la suma de los dos valores variará desde 2 hasta 12,

   7:      /// siendo 7 la suma más frecuente y 2 y 12 las menos frecuentes. Su programa debera

   8:      /// tirar 36000 veces los dos dados. Utilice un arreglo de una dimensión para llevar

   9:      /// cuenta del número de veces que aparece cada suma posible. Imprima los resultados

  10:      /// en un formato tabular. Tambien determine si los totales son razonables, es decir,

  11:      /// existen seis formas de llegar a un 7, por lo que aproximadamente una sexta parte

  12:      /// de todas las tiradas deberán ser 7

  13:      /// </summary>

  14:      static void Ejercicio4()

  15:      {

  16:        Console.Clear();

  17:        Console.WriteLine("Laboratorio 3 - Ejercicio 4");

18:

  19:        int[] valores = new int[13];  // Necesito el subindice 12

  20:        int suma = 0;

  21:        const int MAX = 360000;  // Cantidad de tiradas a realizar

  22:        // Inicialización del arreglo

  23:        for (int i = 0; i < valores.Length; ++i)

  24:        {

  25:          valores[i] = 0;

  26:        }

  27:        // Simulación de tirar dados y cuenta los valores obtenidos

  28:        for (int i = 0; i < MAX; ++i)

  29:        {

  30:          suma = TirarDado() + TirarDado();

  31:          valores[suma] += 1;

  32:        }

  33:        // Muestra los resultados

  34:        for (int i = 2; i <= 12; ++i)

  35:        {

  36:          Console.WriteLine("{0,3} - {1,8} - {2,8}%", i, valores[i], ((float) valores[i] / MAX * 100).ToString("#0.00"));

  37:        }

38:

  39:        Console.ReadKey();

  40:      }

41:

  42:      /// <summary>

  43:      /// Este objeto se utiliza para generar números pseudoaleatorios

  44:      /// </summary>

  45:      private static Random generador = new Random();

46:

  47:      /// <summary>

  48:      /// Simula el hecho de tirar un dado, los posibles valores van del 1 al 6

  49:      /// se utiliza un objeto que genera números pseudoaleatorios

  50:      /// </summary>

  51:      /// <returns>Valor simulado 1,2,3,4,5,6</returns>

  52:      private static int TirarDado()

  53:      {

  54:        return generador.Next(1, 7);

  55:      }

A ver si alguien tiene otra idea de cómo hacer esto.

Diferencias entre Visual Basic y C# - Arreglos 2

jtentor — Fri, 26 Jun 2009 19:10:00 -0200

Ahora voy a continuar presentando diferencias entre Visual Basic y C# a la hora de manipular arreglos.

Se trata de otro ejercicio del curso Programador .NET de Becas Control+F, y en este caso se utiliza un generador de números pseudoaleatorios para evitarse el trabajo de ingresar los datos.

Para ello el Framework facilita una clase Random que permite generar estos números con un método donde se le indica los límites inferior y superior que se desea generar, en la documentación de este método se indica que el límite superior debe ser uno más que el valor que se desa generar.

Ejemplo en C#

   1:      /// <summary>

   2:      /// A cuarenta alumnos se les preguntó el nivel de calidad de los alimentos

   3:      /// de la cafetería para alumnos en una escala de 1 a 10 (1 significa terrible

   4:      /// y 10 significa excelente). Coloque las cuarenta respuestas en una arreglo

   5:      /// entero y resuma los resultados de la encuesta. Realice el Histograma

   6:      /// (utilice nuevamente asteriscos (*) para realizar el grafico)

   7:      /// </summary>

   8:      static void Ejercicio2()

   9:      {

  10:        Console.Clear();

  11:        Console.WriteLine("Laboratorio 3 - Ejercicio 2");

12:

  13:        int[] valores = new int[40];

  14:        Random generador = new Random();  // Objeto para generar números pseudoaleatorios

15:

  16:        for (int i = 0; i < 40; ++i)

  17:        {

  18:          valores[i] = generador.Next(1, 11);

  19:        }

  20:        // Inicializar el arreglo con la cuenta de valores

  21:        int[] histograma = new int[11];

  22:        for (int i = 0; i < histograma.Length; ++i)

  23:        {

  24:          histograma[i] = 0;

  25:        }

  26:        // Contar cuantas veces aparece cada calificación

  27:        for (int i = 0; i < valores.Length; ++i)

  28:        {

  29:          (histograma[valores[i]])++;

  30:        }

31:

  32:        for (int i = 1; i < histograma.Length; ++i)

  33:        {

  34:          Console.Write("Valor {0,2} - {1,2} veces : ", i, histograma[i]);

  35:          for (int j = 0; j < histograma[i]; ++j)

  36:          {

  37:            Console.Write("*");

  38:          }

  39:          Console.WriteLine();

  40:        }

41:

  42:        Console.ReadKey();

  43:      }

Vean en la línea 29 cómo se utiliza el dato que se encuentra en un arreglo (valor[i]) como subindice para acceder a un elemento del arreglo histograma.

Por esa razón es que la dimensión del arreglo histograma es de 11, para que se pueda acceder a la posicón 10. Por supuesto que se podría utilizar algo como (histograma[valores[i]-1])++ y dejar el arreglo en 10 pero queda más claro de esa manera.

Parecería que hacer esto en Visual Basic resulta más comprensible, veamos el código

Ejemplo en Visual Basic

   1:    ''' <summary>

   2:    ''' A cuarenta alumnos se les preguntó el nivel de calidad de los alimentos

   3:    ''' de la cafetería para alumnos en una escala de 1 a 10 (1 significa terrible

   4:    ''' y 10 significa excelente). Coloque las cuarenta respuestas en una arreglo

   5:    ''' entero y resuma los resultados de la encuesta. Realice el Histograma

   6:    ''' (utilice nuevamente asteriscos (*) para realizar el grafico)

   7:    ''' </summary>

   8:    Sub Ejercicio2()

   9:      Console.Clear()

  10:      Console.WriteLine("Laboratorio 3 - Ejercicio 2")

11:

  12:      Dim valores(40) As Integer

  13:      Dim generador As Random = New Random()  '' Objeto para generar números pseudoaleatorios

  14:      Dim i, j As Integer

15:

  16:      For i = 0 To 39

  17:        valores(i) = generador.Next(1, 11)

  18:      Next

  19:      '' Inicializar el arreglo con la cuenta de valores

  20:      Dim histograma(10) As Integer

  21:      For i = 0 To histograma.Length - 1

  22:        histograma(i) = 0

  23:      Next

  24:      '' Contar cuantas veces aparece cada calificación

  25:      For i = 0 To valores.Length - 1

  26:        histograma(valores(i)) += 1

  27:      Next

28:

  29:      For i = 1 To histograma.Length - 1

  30:        Console.Write("Valor {0,2} - {1,2} veces : ", i, histograma(i))

  31:        For j = 0 To histograma(i)

  32:          Console.Write("*")

  33:        Next

  34:        Console.WriteLine()

  35:      Next

36:

  37:      Console.ReadKey()

  38:    End Sub

Observen que para recorrer el arreglo utilizamos el método Length de este objeto, pero tuvimos que restarle uno porque el For ... Next de Visual Basic va hasta ese valor, que es uno más de lo que se definió.

Conclusión me quedo con la modalidad de C#, seguramente los desarrolladores acostumbrados a Visual Basic opinen distinto.

Finalmente les muestro el mísmo ejercicio pero obviando el arreglo de valores.

   1:      /// <summary>

   2:      /// A cuarenta alumnos se les preguntó el nivel de calidad de los alimentos

   3:      /// de la cafetería para alumnos en una escala de 1 a 10 (1 significa terrible

   4:      /// y 10 significa excelente). Coloque las cuarenta respuestas en una arreglo

   5:      /// entero y resuma los resultados de la encuesta. Realice el Histograma

   6:      /// (utilice nuevamente asteriscos (*) para realizar el grafico)

   7:      /// </summary>

   8:      static void Ejercicio2_bis()

   9:      {

  10:        Console.Clear();

  11:        Console.WriteLine("Laboratorio 3 - Ejercicio 2 bis");

12:

  13:        Random generador = new Random();  // Objeto para generar números pseudoaleatorios

  14:        // Inicializar el arreglo con la cuenta de valores

  15:        int[] histograma = new int[11];

  16:        for (int i = 0; i < histograma.Length; ++i)

  17:        {

  18:          histograma[i] = 0;

  19:        }

  20:        // Contar cuantas veces aparece cada calificación

  21:        for (int i = 0; i < 40; ++i)

  22:        {

  23:          (histograma[generador.Next(1, 11)])++;

  24:        }

25:

  26:        for (int i = 1; i < histograma.Length; ++i)

  27:        {

  28:          Console.Write("Valor {0,2} - {1,2} veces : ", i, histograma[i]);

  29:          for (int j = 0; j < histograma[i]; ++j)

  30:          {

  31:            Console.Write("*");

  32:          }

  33:          Console.WriteLine();

  34:        }

35:

  36:        Console.ReadKey();

  37:      }

Esto sería factible si el arreglo de valores no se desea guardar, lo que en general no ocurre; pero sirve como ejemplo.

Diferencias entre Visual Basic y C# - Arreglos

jtentor — Fri, 26 Jun 2009 19:00:00 -0200

En este post voy a presentar las GRANDES diferencias que presenta Visual Basic y C# a la hora de manipular arreglos.

En primer lugar hay que destacar que en Visual Basic se utiliza parenteis "(" y ")" para encerrar los subíndices de un arreglo, en cambio en C# se utiliza corchetes "[" y "]", lo que realmente me complica la vida porque tengo asumido que los paréntesis se usan en las fuciones para encerrar la lista de parámetros.

Las formas en que se declaran presentan una diferencia importante, en C# es necesario "crear" el arreglo mientras que en Visual Basic es el compilador el que realiza esta tarea.

    Dim numeros(10) As Integer

    int[] numeros = new int[10];

Otra cuestión muy importante es que en la declaración o creación se indica el tamaño o dimensión del arreglo, este valor se supone indica cuantos elementos hay en el arreglo.

Hay que recordar que los subíndices de los arreglos en ambos lenguajes comienzan en 0 (cero), de manera que en C# se puede acceder a las posiciones 0, 1, 2, ..., 9; sin embargo en Visual Basic se puede acceder a las posiciones 0, 1, 2, ..., 9, 10 lo que agrega un elemento más al arreglo.

A continuación tenemos un ejercicio del curso de Programación .NET de Becas Control+F, en ambos lenguajes se utiliza un procediminto para mostrar el arreglo (el código está más adelante)

en C#

    /// <summary>
    /// Utilice la estructura de repetición For Next para inicializar los elementos 
    /// de un array entero de diez elementos, e imprima el arreglo en formato tabular 
    /// Inicialice con números pares 
    /// Inicialice con números impares 
    /// Inicialice con múltiplos de tres
    /// </summary>
    static void Ejercicio1()
    {
      Console.Clear();
      Console.WriteLine("Laboratorio 3 - Ejercicio 1");

      int[] numeros = new int[10];

      for (int i = 0; i < 10; ++i)
      {
        numeros[i] = (i + 1) * 2;
      }
      MostrarArray("Pares            ", numeros);

      for (int i = 0; i < 10; ++i)
      {
        numeros[i] = (i + 1) * 2 - 1;
      }
      MostrarArray("Impares          ", numeros);

      for (int i = 0; i < 10; ++i)
      {
        numeros[i] = (i + 1) * 3;
      }
      MostrarArray("Multiplos de tres", numeros);

      Console.ReadKey();
    }

Es importante destacar que el subindice que recorre el arreglo comienza en 0 (cero) y se mantienen en el bucle mientras sea menor que 10 (diez) que resulta ser la dimensión del arreglo.

en Visual Basic

  ''' <summary>
  ''' Utilice la estructura de repetición For Next para inicializar los elementos 
  ''' de un array entero de diez elementos, e imprima el arreglo en formato tabular 
  ''' Inicialice con números pares 
  ''' Inicialice con números impares 
  ''' Inicialice con múltiplos de tres
  ''' </summary>
  Sub Ejercicio1()
    Console.Clear()
    Console.WriteLine("Laboratorio 3 - Ejercicio 1")

    Dim numeros(10) As Integer
    Dim i As Integer

    For i = 0 To 10
      numeros(i) = (i + 1) * 2
    Next
    MostrarArray("Pares            ", numeros)

    For i = 0 To 10
      numeros(i) = (i + 1) * 2 - 1
    Next
    MostrarArray("Impares          ", numeros)

    For i = 0 To 10
      numeros(i) = (i + 1) * 3
    Next
    MostrarArray("Multiplos de tres", numeros)

    Console.ReadKey()
  End Sub

Más allá de las diferencias en la sentencia de control For ... Next del Visual Basic con el for(...; ...; ...) de C#, el código es bastante parecido.

Pero es importante destacar que el For ... Next de Visual Basic va desde el valor inicial hasta (incluido) el valor final en este caso desde 0 (cero) hasta 10 (diez) lo que resulta en 11 (once) posiciones.

Esto lo podemos solucionar bastante facil; NOS OLVIDAMOS QUE HAY UN ELEMENTO EN LA POSICIÓN 0 (CERO) y entonces manipulamos 10 (diez) elementos desde las posiciones 1 (uno) hasta la 10 (diez) como si fuese Pascal .

El problema lo tenemos ahora en el procedimiento que muestra el arreglo. Resulta que al utilizar una estructura FOR EACH ... NEXT de Visual Basic o foreach( ... ) de C# no se puede indicar a partir de qué elemento procesamos el arreglo, los procesa todos.

en Visual Basic

  ''' <summary>
  ''' Muestra un arreglo de enteros
  ''' </summary>
  ''' <param name="mensaje">Mensaje o rótulo a mostrar</param>
  ''' <param name="arreglo">arreglo de enteros</param>
  Sub MostrarArray(ByVal mensaje As String, ByVal arreglo() As Integer)
    Console.Write("{0}: ", mensaje)
    For Each num As Integer In arreglo
      Console.Write("{0,4}", num)
    Next
    Console.WriteLine()
  End Sub

en C#

    /// <summary>
    /// Muestra un arreglo de enteros
    /// </summary>
    /// <param name="mensaje">Mensaje o rótulo a mostrar</param>
    /// <param name="arreglo">arreglo de enteros</param>
    static void MostrarArray(string mensaje, int[] arreglo)
    {
      Console.Write("{0}: ", mensaje);
      foreach (int num in arreglo)
      {
        Console.Write("{0,4}", num);
      }
      Console.WriteLine();
    }

Como pueden ver el código de MostrarArray (salvo las diferencias del lenguaje) es semánticamente identico, muestra todos los elementos que hay en el arreglo

El inconveniente es que al declarar en Visual Basic y en C# el tamaño del arreglo para 10 (diez) elementos, en Visual Basic nos agrega uno más.

Esto no es un error, es simplemente una cuestión que presenta el Visual Basic para mantener compatibilidad con las versiones anteriores de este lenguaje. De todos modos es muy molesto.

Diferencias entre Visual Basic y C#

jtentor — Sat, 20 Jun 2009 20:41:00 -0200

En este post me interesa mostrar un par de aspectos básicos que me llaman la atención en la programación con Visual Basic y C#

Más allá de mi preferencia por los lenguajes de programación C#, C++ o simplemente C; cuando se desarrolla en la plataforma .NET siempre es posible encontrarse con código escrito en Visual Basic. De manera que debemos conocer algunas pequeñas diferencias que se encuentran. A medida que encuentre estos tips iré comentándolos.

En el siguiente ejercicio lo que me llama la atención es cómo Visual Basic tiene la capacidad de convertir una cadena de texto en un entero directamente desde la consola, lo que en C# debe especificarse con Convert.ToInt32(...)

Otra cosa que es importante destacar es la posibilidad que brinda Visual Basic de realizar divisiones enteras o no, esto lo pueden ver en el resultado de las líneas 19 y 20 del código en Visual Basic, esto tampoco es posible en C# que al dividir enteros presenta un resultado entero. Por supuesto que si deseamos el resultado con decimales hay que hacer una conversión (cast) entonces la división se realizará en ese otro tipo de dato.

Ejercicio 1 en Visual Basic

   1:    ''' <summary>

   2:    ''' Escriba un programa que solicite al usuario que introduzca dos números,

   3:    ''' tome los dos números del usuario, e imprima la suma, el producto,

   4:    ''' la diferencia, el cociente y el módulo del número

   5:    ''' </summary>

   6:    Sub Ejercicio1()

   7:      Console.Clear()

   8:      Console.WriteLine("Laboratorio 1 - Ejercicio 1")

9:

  10:      Dim num1, num2 As Integer

  11:      Console.WriteLine("Ingrese dos números")

  12:      Console.Write("Número 1: ")

  13:      num1 = Console.ReadLine()

  14:      Console.Write("Número 2: ")

  15:      num2 = Console.ReadLine()

  16:      Console.WriteLine("Suma       : {0}", num1 + num2)

  17:      Console.WriteLine("Producto   : {0}", num1 * num2)

  18:      Console.WriteLine("Diferencia : {0}", num1 - num2)

  19:      Console.WriteLine("Cociente   : {0}", num1 / num2)

  20:      Console.WriteLine("Cociente(*): {0}", num1 \ num2)

  21:      Console.WriteLine("Módulo     : {0}", num1 Mod num2)

  22:      Console.ReadKey()

  23:    End Sub

Ejercicio 1 en C#

   1:      /// <summary>

   2:      /// Escriba un programa que solicite al usuario que introduzca dos números,

   3:      /// tome los dos números del usuario, e imprima la suma, el producto,

   4:      /// la diferencia, el cociente y el módulo del número

   5:      /// </summary>

   6:      static void Ejercicio1()

   7:      {

   8:        Console.Clear();

   9:        Console.WriteLine("Laboratorio 1 - Ejercicio 1");

10:

  11:        int num1, num2;

  12:        Console.WriteLine("Ingrese dos números");

  13:        Console.Write("Número 1: ");

  14:        num1 = Convert.ToInt32(Console.ReadLine());

  15:        Console.Write("Número 2: ");

  16:        num2 = Convert.ToInt32(Console.ReadLine());

  17:        Console.WriteLine("Suma       : {0}", num1 + num2);

  18:        Console.WriteLine("Producto   : {0}", num1 * num2);

  19:        Console.WriteLine("Diferencia : {0}", num1 - num2);

  20:        Console.WriteLine("Cociente   : {0}", num1 / num2);

  21:        Console.WriteLine("Módulo     : {0}", num1 % num2);

  22:        Console.ReadKey();

  23:      }

El siguiente ejercicio permite mostrar una alternativa o técnica para validar el ingreso efectivo de un tipo de dato. En este caso se pretende ingresar un número entero y se utiliza un bucle que itera hasta que se produce el ingreso efectivo del número.

He codificado el mismo ejercicio en C# y en Visual Basic, observen que salvo las pequeñas diferencias de sintáxis son iguales. Sin embargo Visual Basic tiene la posibilidad de utilizar el "Do ... Loop Until ..." que no necesita de la negación porque es similar a la estructura que nos enseñan en pseudocódigo "Repetir ... Hasta que ...", mientras que la estructura de C# sería algo como "Repetir ... Mientras ..." lo que la mayoría de las veces confunde a los que no están acostumbrados.

Ejercicio 7 en C#

    /// <summary>

    /// Escriba un programa que entre un número de cinco digitos, separe el número

    /// en sus dígitos individuales e imprima los digitos separados unos de otros

    /// mediante tres espacios.

    /// Por ejemplo, si el usuario escribe 42339 el programa debería imprimir 4 2 3 3 9

    /// </summary>

    static void Ejercicio7()

      Console.Clear();

      Console.WriteLine("Laboratorio 1 - Ejercicio 7");

      int num1, dig1, dig2, dig3, dig4, dig5;

      //num1 = Convert.ToInt32(Console.ReadLine());

do

        Console.Write("Ingrese un Número: ");

      } while (!Int32.TryParse(Console.ReadLine(), out num1));

      dig5 = num1 % 10;

      dig4 = (num1 / 10) % 10;

      dig3 = (num1 / 100) % 10;

      dig2 = (num1 / 1000) % 10;

      dig1 = (num1 / 10000) % 10;

      Console.WriteLine("Digitos: {0}   {1}   {2}   {3}   {4}", dig1, dig2, dig3, dig4, dig5);

      Console.ReadKey();

Ejercicio 7 en Visual Basic

  ''' <summary>

  ''' Escriba un programa que entre un número de cinco digitos, separe el número

  ''' en sus dígitos individuales e imprima los digitos separados unos de otros

  ''' mediante tres espacios.

  ''' Por ejemplo, si el usuario escribe 42339 el programa debería imprimir 4 2 3 3 9

  ''' </summary>

  Sub Ejercicio7()

    Console.Clear()

    Console.WriteLine("Laboratorio 1 - Ejercicio 7")

    Dim num1, dig1, dig2, dig3, dig4, dig5 As Integer

    ''num1 = Convert.ToInt32(Console.ReadLine())

Do

      Console.Write("Ingrese un Número: ")

    Loop While Not Integer.TryParse(Console.ReadLine(), num1)

    dig5 = num1 Mod 10

    dig4 = (num1 \ 10) Mod 10

    dig3 = (num1 \ 100) Mod 10

    dig2 = (num1 \ 1000) Mod 10

    dig1 = (num1 \ 10000) Mod 10

    Console.WriteLine("Digitos: {0}   {1}   {2}   {3}   {4}", dig1, dig2, dig3, dig4, dig5)

    Console.ReadKey()

  End Sub

Para probarlo deben cambiar en el código anterior las siguientes líneas

Do

      Console.Write("Ingrese un Número: ")

    Loop Until Integer.TryParse(Console.ReadLine(), num1)

Becas Control F - Instructor

jtentor — Sat, 20 Jun 2009 10:59:00 -0200

Como ya comenté en el post sobre Becas Control+F, se trata de un programa implementado en la Argentina por el gobierno nacional que otorga "becas" a personas interesadas en aprender ciertas herramientas vinculadas a las tecnologías informáticas.

La cuestión es que soy el instructor de uno de los cursos de Programación .NET, en el que se brinda capacitación en la plataforma de desarrollado de Microsoft desde los conceptos básicos de programación hasta los últimos aspectos que incorpora esta plataforma. Voy a aprovechar esto para publicar ejemplos de programación que le servirán a los becarios y a cualquier otra persona.

En la siguente página Ejemplos de Programación iré incorporando un índice a los ejemplos.

Espero que sirva.

Becas Control F

jtentor — Mon, 23 Feb 2009 20:37:00 -0200

Becas Control+F, es un proyecto del gobierno nacional que intenta capacitar a las personas en tecnologías informáticas de manera que se puedan cubrir los puestos de trabajo que en los últimos años quedaron vacantes.

Si, aunque no lo crean hay puestos de trabajo que nadie ocupa !!!

Podemos no estar de acuerdo con el gobierno actual, pero es lo que tenemos y este proyecto puede ayudar a un sector de la sociedad argentina de manera que voy a opinar sobre el proyecto y no sobre las acciones del gobierno.

Desde hace unos años, la CESSI - Cámara de Empresas de Software y Servicios Informáticos muestra que las empresas de software no pueden realizar sus actividades porque no tiene personal capacitado en las áreas que necesitan. Efectivamente, en julio de 2008 se anunciaba que La industria del software prevee facturar $ 7.100 millones para ese año, pero aún así necesitan de un plan de capacitación de personal que les permita contar con la mano de obra calificada para realizar los trabajos; de ese modo es que surge el proyecto que involucra al gobierno y a grandes empresas proveedoras de software de la argentina.

En el marco del plan estratégico hasta el 2016 el gobierno y las empresas pretenden capacitar e incorporar 6.000 puestos de trabajo nuevos por cada año hasta el 2011 (ver/descargar el plan), y es ahí donde aparece Becas Control+F que como su nombre lo indica es un mecanismo de asignación de becas para las personas que deseen capacitarse en alguna tecnología informática. No te dan el dinero; la beca conciste en asistir al curso que la persona desee, y por supuesto hay una lista de cursos de manera que las personas deben inscribirse en el programa y en cuanto esté disponible el curso deseado, se le notifica por correo electrónico.

Lo más importante es que esto también es una bolsa de trabajo, los datos de los inscriptos (curriculum) así como la evolución en los cursos será monitoreada por las empresas que necesitan recursos humanos calificados y probablemente consigan trabajo .

Parece tan sencillo, sin embargo para los que estamos lejos de los grandes centros urbanos este mecanismo es un problema. Ocurre que el curso que nos interesa se puede dictar en Buenos Aires o en Córdoba y la beca cubre el costo del curso, el viaje y la estadía es por cuenta nuestra . Por esa razón lo que debemos intentar es que seamos muchos los inscriptos de una misma región (por ejemplo NOA), de ese modo el curso se dictará en una ciudad cercana a nuestros domicilios.

Por ahí hay comentarios equivocados sobre lo que se pretende, como por ejemplo decir que "estos cursos son para cualquiera" no es tan así, basta con ver los requisitos de los cursos para darse cuenta que hace falta un base de conocimientos para poder asistir a los mismos. Para los cursos de Microsoft Administrador de Bases de Datos SQL Server 2005 y Programador .NET los requisitos son: Conocimientos básico sobre configuración y utilización de sistemas operativos como Microsoft Windows. Por ejemplo usar la interfaz de navegación, administración y monitoreo. Tener conocimientos básicos de base de datos relacionales. Por ejemplo teoría de bases de datos, diferencias entre base de datos y planilla de cálculos. De manera que no es para todos.

Además hay que ver las espectativas de las empresas de software, por eso me tomo la libertad de mostrar unos gráficos que se encuentran en el informe: Situación y perspectivas de las PyME del Sector del Software y Servicios Informáticos en Argentina,

Como pueden ver de ninguna manera las empresas de software están dejando la formación universitaria, es más pretenden incrementarla. El siguiente gráfico muestra qué tipo de empleado se encuentra en las empresas de software y se compara con las empresas de otras industrias (recordemos que el Software y los Servicios Informáticos se calificán como una industria).

Espero que con esto les quede en claro que todos estos cursos son adicionales a una formación de base, por supuesto que hay personas que son muy eficientes en su tarea diaria y no tienen formación universitaria sin embargo basta con ver el gráfico para darse cuenta que son los menos.

Cuando una persona tiene un dolor de cabeza pasa por la farmacia y se compra algun remedio que se auto-medica o le pregunta a un amigo que puede tomar, cuando esa persona tiene que realizarse una cirugía busca un profesional de la medicina para que lo atienda.

Las Empresas de Software y Servicios Informáticos hacen lo mismo, las pequeñas cosas las manejan como pueden, para los grandes proyectos necesitan recursos humanos calificados.

Mis Vacaciones Enero 2009

jtentor — Mon, 02 Feb 2009 18:59:00 -0200

Gracias a Dios, este año pudimos tomarnos unos días de vacaciones

(no digo descanso porque fue una fiesta casi una juerga ...)

Nuevamente fuimos a Carlos Paz (Cordoba - Argentina)

por supuesto nos instalamos en el Camping, Bahia del Gitano.

La pasamos GENIAL , de tal manera que hizo falta unos días para descansar de las vacaciones

Así quedo mi hijo Demian en cama con un buen resfrío

(el otro cachorro es Pulgoso, un siamés de laboratorio)

Como de costumbre, voy a compartir con Uds. algo de estos hermosos días

Llegamos

Lugar Elegido para el Campamento !!!

Carpa lista
(suite para los padres ...)

Otra carpa lista
(habitación simple para los niños ...)

Hora de tomarse una cerveza

Primer día instalados ...

Descansando

Charlando en espera de la comida

Preparando un pescado

Esto no es pescado precisamente ...

Demian haciendo Palestra !!! ...

Preparandose
(un poco grande el arnes)

Comienza a subir ...

Fuerza !!!

El descenso ...

Diosas del camping, amigas de Demian (zonzo para elegir ...)

Oriana
(delicada princesa)

Rocio
(fresca y natural)

Carla
(dulce belleza)

Lucila y Rocio
(divertidas)

PaintBall (Guerra con bolitas de pintura !!!) - Volvimos a nuestra niñez

Valeria

Valeria, Evelina y Vanesa

Demian
(listo para la batalla)

Evelina gastando a los perdedores

Una de tantas tardes, jugando en la pileta

Valeria

Vanesa

Rocio

Demian

Un poco de música brasileña y show de Salsa en la pileta

Noche de cuarteto, pobre Principe Cordobes no lo dejamos descansar !!!

Evelina (a los gritos...)

Evelina y Marcela

Madre e Hija (tal para cuál)

Amigos de la fiesta

Más amigos ...

Este video no se lo pueden perder ... (el cuarteto se baila mejor en CORDOBA)

Bailando con Gaby, Valeria y el Chino ...

A la tarde en la pileta - por la noche en el show de la cantina (y luego baile !!!)

Arquitectura de N-Capas y N-Niveles

jtentor — Thu, 11 Dec 2008 11:45:00 -0200

Lo que se conoce como arquitectura en capas es en realidad un estilo de programación donde el objetivo principal es separar los diferentes aspectos del desarrollo, tales como las cuestiones de presentación, lógica de negocio, mecanismos de almacenamiento, etc.

Los que aprendieron a programar con Pascal, recuerdan que con ese lenguaje todo estaba en la misma porción de código.

A lo mejor un progrador cuidadose organizaba las cosas en "units", pero al final todo esta amontonado.

Vamos a dejar de lado los servicios que el Sistema Operativo facilita para el manejo de archivos, esto es imprescindible.

Figura 1

Muchos de nosotros debemos recordar que desde la aparición de los motores de base de datos existen dos "niveles" perfectamente definidos. Quiero resaltar el uso del término "nivel" y no el de "capa" porque no significan lo mismo. El término capa se utiliza para referenciar a las distintas "partes" en que una aplicación se dividide desde un punto de vista lógico; mientras que "nivel" corresponde a la forma física en que se organiza una aplicación.

Cuando programaba en COBOL las cosas también se hacian como en Pascal, pero había instalaciones donde se podía utilizar una Base de Datos y codificar la aplicación con COBOL; de este modo ya teníamos una separación en niveles:

Se puede observar con total claridad el nivel de aplicación (seguramente en ella existe código de presentación y lógica de negocio) y el nivel de datos (donde está la o las bases de datos de la organización). El objetivo de este esquema fue y sigue siendo el de lograr un único repositorio de datos para la organización y múltiples aplicaciones que utilizan esos datos.

Figura 2

Ahora consideremos el ejemplo de un componente que permita grabar los programas de televisión emitidos. Este componente tiene un sistema de almacenamiento, dado que hace falta "guardar" las instrucciones sobre el día y hora se desea grabar el programa en particular; obviamente existe una porción de lógica de negocio, la que se refiere a los pasos necesarios para capturar el programa de televisión y grabarlo; finalmente hay una interfáz de usuario que permite a las personas ver y editar las instrucciones de grabación.

Podemos decir desde un punto de vista lógico que existen tres capas, y hasta que no veamos el código que escribió el desarrollador vamos a creer que es así.

Lo que no se puede negar es que hay un único nivel, todo esta empotrado en algún componente de hardware dentro del equipo.

Es importante destacar que hace falta separar el código de presentación del código de lógica de negocio, porque el fabricante puede desarrollar este equipo para que muestre las instrucciones en un display del mismo equipo o utilizar el televisor; la cuestión es que el código de presentación tiene que poder intercambiarse, lo cuál es una de las ventajas del desarrollo en capas.

Figura 3

La necesidad de contar con porciones de la aplicación que se puedan "intercambiar" sin tener que modificar el resto de la aplicación es lo que impulsa el desarrollo en capas; de este modo nos encontramos con el siguiente diagrama:

Figura 4

Ahora tenemos 2 niveles y en el primero de ellos diferenciamos 2 capas, de esta manera estamos diciendo que la capa de presentación interactua con la capa de lógica de negocion; Desde la filosofía de arquitectura en capas, esto significa que la capa de lógica de negocios presenta una "interfaz" para brindar servicios a la capa de presentación.

Del mismo modo, en el diagrama estamos diciendo que existe otro nivel donde se encuentra una capa encargada de los datos. Esta capa no se muestra como un "paquete" o "ensamblado" dado que se trata (generalmente) de un motor de base de datos que puede o no ejecutarse en el mismo equipo. Indudablemente esta capa también presenta una "interfaz" para brindar sus servicios a la capa que está por encima.

Lo importante y que siempre debemos recordar es que las capas inferiores brindan servicios a las capas superiores (independientemente del nivel en que se encuentren).

La clave del desarrollo en capas es que una capa solamente debe utilizar lo que la "interfaz" de la o las capas inferiores le brindan, de este modo se puden intercambiar las capas respetando la "interfaz", que viene a ser como un "contrato entre capas"

Ahora escribiendo nuevo código podemos intercambiar la capa de presentación sin afectar el resto de la aplicación. El problema se presenta cuando queremos intercambiar la Capa / Nivel de Datos, esto significa que necesitamos utilizar otro motor de base de datos y resulta que los fabricantes de motores de bases de datos si bién respetan los estándares, incorporan características valiosas en sus productos. Una aplicación que pretenda utilizar la "potencia" o características particulares de un motor de base de datos, inevitablemetne incorporará en la Capa de Lógica de Negocios algo de código que no es compatible con otros motores de base de datos. En consecuencia, cambiar la capa de datos significa corregir la capa de lógica de negocios.

Las buenas prácticas de diseño y desarrollo indican que se debe trabajar sobre el siguiente diagrama:

Figura 5

Ahora si tenemos las tan famosas 3 capas, pero hay que hacer un par de aclaraciones para que nadie se confunda.

La nueva capa, se denomina Capa de Acceso a Datos (o Capa de Persistencia) que no es lo mismo que Capa de Datos.

La capa de acceso a datos es una porción de código que justamente realiza el acceso a los datos. De esta manera cuando es necesario cambiar el motor de base de datos, solamente tendremos que corregir esa capa.

Mientras que la capa de datos (en el nivel de datos) es donde están los datos y se corresponde directamente con la definición de esquemas, tablas, vistas, procedimientos almacenadaos y todo lo que se pueda o deba poner en un motor de base de datos.

Los arquitectos están felices con este diagrama, sin embargo los desarrolladores tienen un problema. Resulta que los componentes de la capa de lógica de negocios necesitan referenciar a instancias de las "clases del dominio" (las que representan las entidades del negocio) y los componentes de la capa de acceso a datos también tienen que referenciarlas para poder "rellenar" tales instancias con los datos que obtienen de las capas inferiores.

Figura 6 (a) Figura 6 (b)

La porción de diagrama de la Figura 6 (a) muestra algo que no se debe hacer, porque los componentes no pueden caer en un ciclo de referencias recursivo, no podría compilarse la aplicación ¿cuál de los dos ensamblados debe resolverse antes para poder compilar el otro?

Una posible solución se presenta en la Figura 6 (b), donde se muestra que la declaración de las "Entidades" se realiza en la capa de acceso a datos.

Bién esto también tiene un problema, la capa de acceso a datos surge porque no queremos "tocar" la lógica de negocio cuando cambiamos el nivel de datos, y con este esquema estamos incluyendo en la capa de acceso a datos uno de los aspectos más importantes, que es nuestra definición del dominio de la aplicación; los cambios en la capa de acceso a datos pueden impactar en las entidades.

Para pequeñas aplicaciones esto puede funcionar, incluso se puede poner ambas capas en un único ensamblado con diferentes nombres de espacio (namespace) pero a la larga traerá problemas.

La solución que satisface a los arquitectos y a los desarrolladores, es la siguiente:

Figura 7

Ahora tenemos otra capa más, la capa de Entidades que corresponde al dominio de la aplicación.

En esta capa se encuentra la declaración de las entidades de la aplicación, de manera que se pueden referenciar desde otras capas sin entrar en ciclos recursivos de compilación.

Además este esquema permite una total independencia entre la lógica de negocios (Business Model) y las entidades (Domain Model). Por supuesto que ambas partes están relacionadas por los casos de uso y otros requerimientos de la aplicación.

Por otro lado, este esquema facilita la incorporación, en la capa de acceso a datos, de componentes tipo ORM - Objet / Relational Mapping que permiten "mapear" (representar) objetos en un esquema relacional. Esto funciona bién dado que las bases de datos más utilizadas (por su mejor performance) son las bases de datos relacionales y no las orientadas a objetos (al menos por ahora).

El nivel de cooperación que presentan las organizaciones requiere que las aplicaciones de software de las distintas organizaciones interactuen unas con otras. El problema es que algunas de ellas no se ejecutan en la misma plataforma o están desarrolladas con marcos de trabajo diferentes. La solución fue presentada como SOA - Service Oriented Architecture, que brinda entre otras cosas una forma estandard de publicar y utilizar servicios, conocidos comunmente como servicios web (web services).

Figura 8

La Figura 8 muestra como los usuarios finales, mediante la utilización de hardware o software liviano, pueden acceder a lo que se denomina el nivel de clientes o aplicaciones que básicamente se constituyen de la capa de presentación y consumen los servicios publicados por la misma organización. Este tipo de aplicaciones son en general sitios o portales en la web.

Pueden implementarse soluciones del tipo cliente - servidor en donde el usuario final accede de manera directa a una aplicación de escritorio que consume los servicios publicados al igual que las aplicaciones para hardware y/o software liviano.

Aplicaciones de otras organizaciones también pueden utilizar los servicios publicados por una organización en particular, obviamente esto necesita de acuerdos comerciales y credenciales para autenticar y autorizar a quienes consumen los servicios.

La pregunta ahora es: ¿Los servicios publicados forman parte de la capa de lógica de negocio?

En algunos caso, como por ejemplo recuperar la información de un inmueble podemos decir que el servicio en si mismo no presenta lógica alguna.

En otros casos, como por ejemplo pagar la factura de un servicio público desde la cuenta bancaria del usuario final si presenta un nivel de lógica que no tiene que ver con la lógica del negocio (sea de la institución pública o del banco). Se trata de la lógica de la transacción que involucra dos organizaciones diferentes (aplicaciones diferentes), consecuentemente debe existir un mecanismo que permita confirmar la realización de todos los "pasos" que cada una de las organizaciones requiere; esto normalmente se conoce como WorkFlow.

De esta manera surje otra capa más, la capa de Servicios Publicados que pueden o no incluir componentes de WorkFlow pero inevitablemente deben estar por arriba de la capa de lógica de negocios. La Figura 9 muestra el diagrama completo incluso con el componente escencial de la aplicación: el Esquema de Seguridad, así como la línea de vida de las entidades en relación a las distintas capas.

Figura 9

Espero que mis consideraciones les sirvan y por supuesto estoy dispuesto a debatir otras opiniones.

Windows Communication Foundation - 2

jtentor — Mon, 08 Dec 2008 20:24:00 -0200

WCF - Windows Communication Foundation (ejemplo con DataContract)

Continuando con los ejemplos inciados en WCF - Parte 1, ahora vamos a ver cómo se hace para manejar datos no estándares (clases)

Para ver como se hace una solución y proyectos de este tipo vean (WCF - Parte 1), a continuación está el código de que deben poner en el mismo ejemplo de la parte 1. Se trata de operaciones matemáticas con numeros complejos.

Componente: Service1.svc.cs

using System.ServiceModel.Activation;

namespace WcfService1

    // Clase de servicio, implementa el contrato

    /// <summary>

    /// Clase de servicio, es la que implementa el contrato de servicio que se

    /// indica en la interfaz IService1

    /// </summary>

    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]

    public class Service1 : IService1

        public ComplexNumber Add(ComplexNumber n1, ComplexNumber n2)

            return new ComplexNumber(n1.Real + n2.Real, n1.Imaginary + n2.Imaginary);

        public ComplexNumber Subtract(ComplexNumber n1, ComplexNumber n2)

            return new ComplexNumber(n1.Real - n2.Real, n1.Imaginary - n2.Imaginary);

        public ComplexNumber Multiply(ComplexNumber n1, ComplexNumber n2)

            double real1 = n1.Real * n2.Real;

            double imaginary1 = n1.Real * n2.Imaginary;

            double imaginary2 = n2.Real * n1.Imaginary;

            double real2 = n1.Imaginary * n2.Imaginary * -1;

            return new ComplexNumber(real1 + real2, imaginary1 + imaginary2);

        public ComplexNumber Divide(ComplexNumber n1, ComplexNumber n2)

            ComplexNumber conjugate = new ComplexNumber(n2.Real, -1 * n2.Imaginary);

            ComplexNumber numerator = Multiply(n1, conjugate);

            ComplexNumber denominator = Multiply(n2, conjugate);

            return new ComplexNumber(numerator.Real / denominator.Real, numerator.Imaginary);

        public ComplexNumber NewComplexNumber(double real, double imaginary)

            return new ComplexNumber(real, imaginary);

Componente: IService1.cs

using System.Runtime.Serialization;

using System.ServiceModel;

namespace WcfService1

    /// <summary>

    /// Interface para el contrato de servicio.

    /// Define las operaciones que se pueden realizar con este servicio

    /// </summary>

    [ServiceContract]

    public interface IService1

        /// <summary>

        /// Suma numeros complejos

        /// </summary>

        /// <param name="n1">Nro Complejo</param>

        /// <param name="n2">Nro Complejo</param>

        /// <returns>Resultado de sumar n1 y n2</returns>

        [OperationContract]

        ComplexNumber Add(ComplexNumber n1, ComplexNumber n2);

        /// <summary>

        /// Resta numeros complejos

        /// </summary>

        /// <param name="n1">Nro Complejo</param>

        /// <param name="n2">Nro Complejo</param>

        /// <returns>Resultado de restar n2 a n1</returns>

        [OperationContract]

        ComplexNumber Subtract(ComplexNumber n1, ComplexNumber n2);

        /// <summary>

        /// Multiplica numeros complejos

        /// </summary>

        /// <param name="n1">Nro Complejo</param>

        /// <param name="n2">Nro Complejo</param>

        /// <returns>Resultado de multiplicar n1 por n2</returns>

        [OperationContract]

        ComplexNumber Multiply(ComplexNumber n1, ComplexNumber n2);

        /// <summary>

        /// Divide numeros complejos

        /// </summary>

        /// <param name="n1">Nro Complejo</param>

        /// <param name="n2">Nro Complejo</param>

        /// <returns>Resultado de dividir n1 en n2</returns>

        [OperationContract]

        ComplexNumber Divide(ComplexNumber n1, ComplexNumber n2);

        /// <summary>

        /// Crear un numero complejo

        /// </summary>

        /// <remarks>

        /// El problema de esta operacion es que instancia el objeto del lado del servidior

        /// y lo transfiere, es LENTO !!!!!!!!!!!!!!1

        /// pero no hay otra alternativa para objetos que requieren lógica de construccion

        /// En este caso es solo un ejemplo, y de hecho esa caracteristica debe evitarse en

        /// las aplicaciones que consumen servicios web, simplemente tienen que les envía el

        /// el servidor y en caso de mandar algo debe ser plano.

        /// </remarks>

        /// <param name="real">Parte real</param>

        /// <param name="imaginary">Parte imaginaria</param>

        /// <returns>Numero complejo</returns>

        [OperationContract]

        ComplexNumber NewComplexNumber(double real, double imaginary);

    /// <summary>

    /// Clase para definir que es un numero complejo

    /// Define los datos que se transfieren

    /// </summary>

    [DataContract]

    public class ComplexNumber

        [DataMember]

        public double Real;

        [DataMember]

        public double Imaginary;

        /// <summary>

        /// Constructor especializado

        /// <remarks>

        ///    Este constructor solo se visulaiza del lado del servidor, en el lado del cliente

        ///    se pude usar el constructor por defecto y acceder a cada propiedad

        /// </remarks>

        /// </summary>

        /// <param name="real">parte real</param>

        /// <param name="imaginary">parte imaginaria (la que se multiplica por i)</param>

        public ComplexNumber(double real, double imaginary)

            this.Real = real;

            this.Imaginary = imaginary;

Acá tenemos dos puntos interesantes:

DataContrac. Indica que se trata de un contrato de datos, es la especificación de datos que utilizamos en el servicio.
DataMember. Indica que se trata de un dato (campo) que se muestra en el contrato de datos y el cliente lo puede manipular dado que la visibilidad que le damos es public (eso significa que podemos tener campos private ???).

En el otro proyecto recuerden referenciar o actualizar al nuevo servicio (obviamente despues de compilarlo) hay que cambiar el componente Program.cs y copiamos el siguiente código:

Componente: Program.cs

using System;

// IMPORTANTE, esto hace falta para manejar las clases definidas en el servicio !!!

using ConsoleApplication1.ServiceReference1;

namespace ConsoleApplication1

    /// <summary>

    /// Esta clase es la que define por donde comienza la aplicación

    /// </summary>

    class Program

        /// <summary>

        /// Este el metodo inicial de la aplicación

        /// </summary>

        static void Main()

            // Crear el cliente

            ServiceReference1.Service1Client client = new ServiceReference1.Service1Client();

            // Call the Add service operation.

            ComplexNumber value1 = new ComplexNumber(); value1.Real = 1; value1.Imaginary = 2;

            ComplexNumber value2 = new ComplexNumber(); value2.Real = 3; value2.Imaginary = 4;

            ComplexNumber result = client.Add(value1, value2);

            Console.WriteLine("Add({0} + {1}i, {2} + {3}i) = {4} + {5}i",

                    value1.Real, value1.Imaginary, value2.Real, value2.Imaginary, result.Real, result.Imaginary);

            // Call the Subtract service operation.

            value1 = new ComplexNumber(); value1.Real = 1; value1.Imaginary = 2;

            value2 = new ComplexNumber(); value2.Real = 3; value2.Imaginary = 4;

            result = client.Subtract(value1, value2);

            Console.WriteLine("Subtract({0} + {1}i, {2} + {3}i) = {4} + {5}i",

                    value1.Real, value1.Imaginary, value2.Real, value2.Imaginary, result.Real, result.Imaginary);

            // Call the Multiply service operation.

            value1 = new ComplexNumber(); value1.Real = 2; value1.Imaginary = 3;

            value2 = new ComplexNumber(); value2.Real = 4; value2.Imaginary = 7;

            result = client.Multiply(value1, value2);

            Console.WriteLine("Multiply({0} + {1}i, {2} + {3}i) = {4} + {5}i",

                    value1.Real, value1.Imaginary, value2.Real, value2.Imaginary, result.Real, result.Imaginary);

            // Call the Divide service operation.

            value1 = new ComplexNumber(); value1.Real = 3; value1.Imaginary = 7;

            value2 = new ComplexNumber(); value2.Real = 5; value2.Imaginary = -2;

            result = client.Divide(value1, value2);

            Console.WriteLine("Divide({0} + {1}i, {2} + {3}i) = {4} + {5}i",

                    value1.Real, value1.Imaginary, value2.Real, value2.Imaginary, result.Real, result.Imaginary);

            // Cerrar el cliente y liberar los recursos

            client.Close();

            Console.WriteLine();

            Console.WriteLine("Pulse <ENTER> para finalizar.");

            Console.ReadLine();

Listo, ahora se puede probar.

Espero que lo puedan hacer, sino se bajan el código completo WcfDemo2.zip (42,08 kb) y lo prueban.

Windows Communication Foundation - 1

jtentor — Mon, 08 Dec 2008 14:35:00 -0200

WCF - Windows Communication Foundation

Hoy en día afrontamos el desarrollo de aplicaciones que deben interactuar con otras aplicaciones; es imposible que todas las organizaciones utilicen la misma aplicación (no tendríamos trabajo !!!). De manera que los Servicios Web (Web Services) son la mejor alternativa para que las aplicaciones de distintas organizaciones interactuen entre sí. No importan ni la plataforma ni el lenguaje de programación utilizado.

WCF - Windows Communication Foundation es la plataforma para servicios web que ofrece Microsoft.

Se puede obtener más información en MSDN WCF (inglés) y en MSDN WCF (castellano). Incluso hay un set de ejemplos enorme, lamentablemente está para Visual Studio 2005 y fué realizado para el .NET Framework 3.0 y es muy complicado hacerlo funcionar. Con Visual Studio 2008 las cosas mejorarón sustancialmente, hay plantillas para configurar una Aplicación de Servicis WCF (con VS2005 hay que hacerlo como una librería de clases y otros problemitas). CUIDADO: Hasta la consolidación del WCF con Visual Studio 2008, los servicios de web se publicaban mediante componentes .ashx; la ventaja que nos ofrece WCF es su relación con Windows WorkFlow Foundation y Windows CardSpace lo que convierte a esta plataforma en algo muy interesante que además cumple con todos los estándares.

A continuación voy a desarrollar con Visual Studio 2008 un ejemplo que copié de MSDN.

Comenzamos creando una solución en Visual Studio 2008

Les recomiendo crear una solución en blanco, y luego incorporar los proyectos del tipo que se necesite. Observn que se utilizará el .NET Framework 3.5

Ahora agregamos un proyect, para eso hay que selección los del tipo Visual C# - Web - WCF Service Application. Le dan un nombre (utilicen el que propone así pueden copiar el el código de ejemplo)

Debería quedar lo siguiente:

IService1.cs -> es la interfáz que define el servicio

Service1.svc -> es la implementación del servicio, utiliza la técnica de CodeBehind esto significa que en el archivo Service1.svc.cs está el código asociado al archivo .svc. Estos tipos de archivos tienen un comportamiento especial en los servidores web.

Web.Config -> archivo de configuración de la aplicación

Bien vamos a borrar lo que está en Service1.svc.cs y ponemos lo siguiente:

Componente: Service1.svc.cs

using System.ServiceModel.Activation;

namespace WcfService1

    // NOTE: If you change the class name "Service1" here, you must also update the

    // reference to "Service1" in Web.config and in the associated .svc file.

    // Clase de servicio, implementa el contrato

    /// <summary>

    /// Clase de servicio, es la que implementa el contrato de servicio que se

    /// indica en la interfaz IService1

    /// </summary>

    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]

    public class Service1 : IService1

        private double result;

        public void Clear()

            result = 0.0D;

        public double AddTo(double n)

            return result += n;

        public double SubtractFrom(double n)

            return result -= n;

        public double MultiplyBy(double n)

            return result *= n;

        public double DivideBy(double n)

            return result /= n;

        public double Result()

            return result;

Lo novedoso en este punto es que estamos indicando que la compatibilidad con AspNet está permitida (Allowed), pero no es obligatoria

También borramos lo que está en IService1.cs y ponemos lo siguiente:

Componente: IService1.cs

using System.ServiceModel;

namespace WcfService1

    /// <summary>

    /// Interface para el contrato de servicio.

    /// Define las operaciones que se pueden realizar con este servicio

    /// </summary>

    [ServiceContract]

    public interface IService1

        /// <summary>

        /// Borra la memoria de almacenamiento

        /// </summary>

        [OperationContract]

        void Clear();

        /// <summary>

        /// Suma el valor dado a la memoria de almacenamiento

        /// </summary>

        /// <param name="n">valor a sumar</param>

        /// <returns></returns>

        [OperationContract]

        double AddTo(double n);

        /// <summary>

        /// Resta el valor dado a la memoria de almacenamiento

        /// </summary>

        /// <param name="n">valor a restar</param>

        /// <returns></returns>

        [OperationContract]

        double SubtractFrom(double n);

        /// <summary>

        /// Multiplica la memoria de almacenamiento por el valor dado

        /// </summary>

        /// <param name="n">valor a multiplicar</param>

        /// <returns></returns>

        [OperationContract]

        double MultiplyBy(double n);

        /// <summary>

        /// Divide la memoria de almacenamiento en el valor dado

        /// </summary>

        /// <param name="n">valor en el que se divide (denominador)</param>

        /// <returns></returns>

        [OperationContract]

        double DivideBy(double n);

        /// <summary>

        /// Obtiene el valor de la memoria de almacenamiento

        /// </summary>

        /// <returns></returns>

        [OperationContract]

        double Result();

Acá tenemos dos puntos interesantes:

ServiceContrac. Indica que se trata de un contrato de servici.
OperationContract. Indica que se trata de ua operación (método) que se muestra en el contrato de servicio.

Lo interesante de esto es que podemos tener métodos que no formen parte del contrato de servicio, basta con no ponerle el [OperationContract] y listo.

Todo esto sirve para indicar lo que estamos publicando de manera que el resto del mundo pueda "verlo" y utilizarlo. La forma en que se publica es el estándard para servicios web solo que se utiliza un compoente específico para la de serialización que opera en el entorno de Windows Communication Foundation.

Bueno en este punto yá deberían poder compilar y ejecutar el servicio (dentro del visual studio). Van a Build - Build WcfService1 o simplemente pulsan F5. Si todo funciona como se espera, el explorador que tengan habilitado debería mostrar el detalle de archivos que tienen en la carpeta del proyect; esto es así porque no hay un Default.aspx u otro de los documentos que se buscan por defecto.

Seleccionan Service1.svc y le dan al enter o doble click, debería aparecer lo siguiente:

Los felicito si llegaron hasta aquí sin problemas.

Bien ahora vamos a incorporar un proyecto con el cliente, la aplicación que consume los servicios provistos. Esto se puede hacer en otro proyecto (para eso deberán publicar los servicios mediante IIS u otras modalidades que están disponibles, lo que explicaré en otras publicaciones ). Para no complicarnos la vida vamos a utilizar una aplicación de consola (los jovenes desarrolladores no saben lo que es esto, si no hay ventanas y mouse no saben que hacer ...). Aclaro que una a aplicación de consola en Windows XP, Vista, Server 2003 o Server 2008 es mucho más que lo se conoce como una aplicación del viejo DOS; los comandos y posiblidades que ofrecen estos sistemas operativos estan a la altura de Unix - Linux, lo que ocurre es que nadie los usa.

En el nuevo proyecto aparece un componente Program.cs por ahí comienza la ejecución de la aplicación (esto se puede cambiar pero no es parte de esta publicación de manera que lo dejamos así). Borramos el código que está por defecto y copiamos el siguiente:

Componente: Program.cs

using System;

namespace ConsoleApplication1

    /// <summary>

    /// Esta clase es la que define por donde comienza la aplicación

    /// </summary>

    class Program

        /// <summary>

        /// Este el metodo inicial de la aplicación

        /// </summary>

        static void Main()

            // Crear el cliente

            ServiceReference1.Service1Client client = new ServiceReference1.Service1Client();

            client.Clear();

            client.AddTo(100.0D);

            Console.WriteLine("Parcial = {0}", client.Result());

            Console.WriteLine("Parcial = {0}", client.SubtractFrom(50.0D));

            Console.WriteLine("Parcial = {0}", client.MultiplyBy(17.65D));

            Console.WriteLine("Parcial = {0}", client.DivideBy(2.0D));

            double result = client.Result();

            Console.WriteLine("Desde el Servicio: 0, + 100, - 50, * 17.65, / 2 = {0}", result);

            Console.WriteLine("Cálculado a mano.: 0, + 100, - 50, * 17.65, / 2 = {0}", ((100 - 50) * 17.65D) / 2.0D);

            // Cerrar el cliente y liberar los recursos

            client.Close();

            Console.WriteLine();

            Console.WriteLine("Pulse <ENTER> para finalizar.");

            Console.ReadLine();

Si tratan de compilar, les va a dar dos errores. Esto es porque todavía no se hizo la referencia al servicio.

Esto se hace en Refernces - Add Service Reference ...

Hay que seleccionar Discover; esto busca los servicios en la misma solución (en caso de referenciar a otros servicios, se debe introducir el URL correspondiente, En ese momento arracan el servidor web de desarrollo y muestra el servicio que hicieron. Lo eligen y le dan a OK.

Listo, ahora se puede compilar la aplicación de consola, van a Build - Build Solution le dan a F5 que compila y luego ejecuta.

Espero que lo puedan hacer, sino se bajan el código completo WcfDemo1.zip (37,29 kb) y lo prueban.

No solo de Post vive el hombre

jtentor — Wed, 03 Dec 2008 20:07:00 -0200

No puedo creer que pasó tanto tiempo desde mi último post.

Estuve ocupadísimo; entrenándome, aprendiendo y desarrollando prototipos. En breve voy a compartir mis apreciaciones sobre Windows Communication Foundation, Windows Work Flow y otras cosillas que vi últimamente.