Pues bien, si ya llevas algún tiempo programando, habrás notado que esto de extraer los datos de la fuente de datos y tratarlos como objetos es algo complicado, sobre todo porque existen buenas diferencias entre las bases de datos relacionales y los lenguajes orientados a objetos como C#.

Se han diseñado unas cuantas herramientas ORM (Object-Relational mapping) para resolver este problema (crear una base de datos orientada a objetos virtual), pero casi siempre dejan algo que desear, y hoy por hoy, a pesar de haber unas cuantas herramientas de uso libre y comercial, muchos programadores prefieren usar sus propias bibliotecas para trabajar con fuentes de datos.

En este contexto es que nace la idea de LINQ (Language INtegrated Query), en principio una herramienta más para dar solución al problema del mapeo objeto-relacional (ORM) y simplificar la interacción entre objetos y fuentes de datos (XML, ADO.Net, RDBMS), quién luego se convirtió en un conjunto de herramientas de consulta integrado en varios lenguajes de la plataforma .Net.

LINQ es un cambio en la forma de manejar y manipular los datos, permite el acceso a cualquier fuente de datos (LINQ to Objects, LINQ to SQL, LINQ to DataSets), mezclar datos de diferentes fuentes con una sintaxis muy sencilla, comprobar en tiempo de compilación las consultas, el uso de IntelliSense de Visual Studio y un enfoque declarativo para escribir códigos más cortos y sencillos. Funciona a partir de C# 3.0 y VB.Net 9.0 ya que requiere de ayuda por parte del compilador.

En realidad LINQ lo que provee es una capa intermedia entre la fuente de dato y el cliente, por decirlo de alguna forma. Gracias a esta abstracción es que podemos trabajar de la misma forma con LINQ sin importar que la fuente de datos sea un archivo XML o una base de datos.

Bueno,  vamos a ver algunos códigos y ejemplos de consultas LINQ y su ventaja frente a las consultas imperativas que se hacen con C# y a otras.

Nota: Para este ejemplo, vamos a suponer que tenemos ya una base de datos llamada Personal mapeada a un conjunto de clases como sigue. Noten que en muchos casos esto se puede hacer de forma automática con Visual Studio.

Esta sería la estructura de la clase que hace referencia a la base de datos:

[Table(Name="Personas")]
class Persona
{
     [Column(IsPrimaryKey=true)]
      public int ID;
 
     [Column(Name="ContactName")]
      public string Nombre;
 
     [Column(Name="ContactAge")]
      public int Edad;
 
     [Column]
      public string Ocupación;
}

Ahora vamos a obtener todas las personas que tengan menos de 30 años y que sean abogados usando LINQ:

var consulta =
            from persona in db.GetTable()
            where persona.Edad<30 && persona.Ocupacion==”abogado”
            select persona;

Y así ya dejamos de tener que hacer las consultas SQL aquellas que nos complicaban la vida, ahora todo es mucho más sencillo, y podemos mantener las mismas consultas sin importar que fuente de dato se esté usando. En el MSDN hay unos cuantos buenos ejemplos de LINQ. Terminaré con una frase que describe en dos líneas la idea esencial de LINQ:

“Before LINQ it was like you had to order your dinner in one language and drinks in another”
Jason McConnel, Product Manager for Visual Studio at Microsoft

Para seguir leyendo sobre LINQ:

Hoja de Trucos de LINQ to SQL
Ejemplo práctico con LINQ y C#
Tutorial de LINQ to SQL *

Entradas relacionadas

Se definen como métodos estáticos pertenecientes a una clase estática y no genérica; pero se llaman de la forma tradicional, como métodos de una instancia de una clase.

Se les pasa como primer parámetro this seguido del tipo de la clase a la cual se va a añadir el método; aquí tenemos un ejemplo de añadirle un método a la clase String de .Net:

public static class MyExtensions
{
     public static int WordCount(this String str)
     {
         //Split separa la cadena en un array de string utiizando los separadores especificados
         return str.Split(new char[] { ' ', '.', '?', ';' , ':' }, StringSplitOptions.RemoveEmptyEntries).Length;
     }
}

Utilizando este ejemplo:

  string s = "hello extension methods!";
  int count = s.WordCount();
  //Este código imprime: 3

Este método podrá ser usado en todas las variables de tipo string, IntelliSense también los reconoce ya que no violan los principios de encapsulación, pues en realidad no modifican a la clase ni acceden a sus variables privadas.

Los métodos extensores se usan para extender una clase o interface; pero no para sobreescribirla. Un método extensor con el mismo nombre y signatura (parámetros) que un método de la clase o la interface, nunca será llamado: en tiempo de compilación, los métodos extensores tienen menor prioridad que los métodos definidos en el propio tipo y están definidos en el ámbito del namespace.

Veamos otro ejemplo un poco más complejo usando interfaces y genericidad:

//Este método devuelve el mayor de una colección que sea 
//IEnumerable(List, array, LinkedList, etc)
public static T Mayor(this IEnumerable items) where T : IComparable
    {
      T max = default(T);
      bool empty = true;
      foreach (T x in items)
      {
        max = x; empty = false;  break;
      }
      if (empty) throw new Exception("The source cannot be empty");
      foreach (T x in items)
      {
        if (x.CompareTo(max) > 0)
          max = x;
      }
      return max;
    }

Como en el caso anterior, ahora en todas las clases que implementen la interfaz IEnumerable donde sus elementos se puedan comparar, tendremos un método Mayor, que devuelve el mayor elemento de la colección de objetos de tipo T genérico. Veamos algunos ejemplos de como usar este método:

int[] numeros = { 10, -60, 20, -50, 30, -40 };
Console.WriteLine(numeros.Mayor()=;
//se va a imprimir 30

Otro ejemplo podría ser:

List colores = new List { "rojo", "verde", "azul", "blanco", "negro"};
Console.WriteLine(colores.Mayor());
//se va a imprimir verde, que es el mayor en orden alfabético

Bueno, si quieren ver más ejemplos aquí les dejo unos cuantos métodos extensores en C# para descargar con sus probadores y todo, para que practiques y le saques el mayor partido a esta nueva característica de C#. Si tienes alguna duda, propuesta o no entiendes algo en los comentarios por favor. Proximamente estaremos hablando de LINQ, otra de las nuevas características de C# y .Net.

No hay entradas relacionadas.

Crear una aplicación de Consola:

Para esto, deberemos ir a File->New->Project si usas Visual Studio, pero con cualquier otro IDE debe ser algo parecido. Entonces se mostrará una nueva ventana como la de la figura, seleccionamos C# en el menu izquierdo y luego como tipo de proyecto marcamos “Console Apliccation”, le ponemos un nombre al proyecto y le damos Ok. Ya estaremos listos para empezar con el código.

Métodos útiles para trabajar con la consola

Para interactuar con el usuario es que existen algunos métodos básicos cuando trabajamos con la Consola. Veamos los más usados:

1- Console.WriteLine();
Escribe una nueva linea en la consola, es como presionar Enter y escribir una linea. Por ejemplo, podemos hacer:
Console.WriteLine(“Lo que quiera q salga en la consola”);
También podremos imprimir las variables de nuestro programa, para esto hay dos formas, pero veamos mejor dos ejemplos que son lo mismo:

//declaramos dos variables
string nombre = "Invitado";
int edad = 22;
//Imprimimos una linea en la consola de dos formas distintas
Console.WriteLine("Tu nombre es: "+nombre+" y tienes " + edad + " años.");
//En C# se usa el operador + para concatenar cadenas
Console.WriteLine("Tu nombre es {0} y tienes {1} años", nombre, edad);

Como ven la segunda vía es mucho más simple, solo debes recordar que el numero que está entre cochetes, es el indice del parámetro que se pasa al final del método.
2- Console.Write()
Hace casi lo mismo que Console.WriteLine() pero sin cambiar de línea, o sea… concatena el texto que le pasemos al método con lo que se haya escrito hasta ese momento en la consola.

3- Console.ReadLine()
Se usa para leer lo que el usuario escribió en la consola, y podemos guardarlo en una variable para despues usarlo en nuestro programa. No hay que pasarle ningún parámetro y el programa solo continuará cuando el usuario teclee alguna línea y presione Enter. Podemos hacer algo como esto:

Console.WriteLine("Escriba su nombre");
string nombre = Console.ReadLine();

Importante: Si lo que queremos es recoger lo que el usuario escriba como un tipo en específico, por ejemplo, un entero, deberemos usar el método estático int.Parse, por ejemplo:

int x = int.Parse(Console.ReadLine();

ya que lo que devuelve Console.ReadLine() es un string.

4-Console.ReadKey()
Este método resulta importante algunas veces, sobre todo cuando queremos darle varias opciones al usuario (a, b, c, d). Aunque se puede utilizar Console.ReadLine(). En este caso, este método lo que devuelve es un objeto de tipo ConsoleKeyInfo, y se puede utilizar de la siguiente forma, por ejemplo:

Console.WriteLine("Presiona una tecla");
ConsoleKeyInfo c = Console.ReadKey();
Console.WriteLine("Presionaste la tecla "+ c.KeyChar);

static void Main(string[] args)

public static int DameEdad(int dia, int mes, int año)
{
     //Usamos la clase DateTime y un método estatico para restar fechas
     DateTime fecha_nacimiento = new DateTime(año, mes, dia);
     TimeSpan edad = DateTime.Now.Subtract(fecha_nacimiento);
     return (edad.Days/365);
}

private static void Main(string[] args)
{
    //Variables que usaremos para la fecha de nacimiento
    int dia_nacimiento, mes_nacimiento, año_nacimiento=0;
 
    Console.WriteLine("Escriba su nombre");
    string nombre = Console.ReadLine();
    Console.WriteLine("Hola {0}, bienvenido a mi aplicacion!",nombre);
    Console.WriteLine("Por favor, introduce tu fecha de nacimiento:");
    //El while solo termina cuando se hace break
    while (true)
    {
        //Pedimos el dia y lo validamos
        Console.Write("Dia de nacimiento: ");
        dia_nacimiento = int.Parse(Console.ReadLine());
        if (dia_nacimiento < 1 || dia_nacimiento > 31)
             Console.WriteLine("Por favor, especifique un dia entre 1 y 31");
        else
             //Si el dia es valido, entonces pasamos a pedir el mes
             break;
    }
 
    while (true)
    {
        //Pedimos el mes y lo validamos
        Console.Write("Mes de nacimiento: ");
        mes_nacimiento = int.Parse(Console.ReadLine());
        if (mes_nacimiento < 1 || mes_nacimiento > 12)
             Console.WriteLine("Por favor, especifique un mes entre 1 y 12");
        else
             break;
    }
    while (true)
    {
        //Pedimos el año y lo validamos
        Console.Write("Año de nacimiento: ");
        año_nacimiento = int.Parse(Console.ReadLine());
        //El año no puede ser posterior a 1900 y anterior al año actual
        if (año_nacimiento < 1900 || año_nacimiento > DateTime.Now.Year)
             Console.WriteLine("Por favor, especifique un año entre 1900 y el {0}", DateTime.Now.Year);
        else
             break;
     }
     //Si llegamos aqui, es porque tenemos una fecha correcta, vamos a calcular la edad con
     //el método DameEdad() que escribimos antes
     int edad = DameEdad(dia_nacimiento, mes_nacimiento,año_nacimiento);
     Console.WriteLine(nombre+", usted tiene " + edad + " años.");
     Console.WriteLine("Presione cualquier tecla para terminar el programa");
     Console.ReadKey();
}

La estructura cola (queue) está basada en el principio que plantea que “el primero en entrar a la cola es el primero en salir (First In First Out), de aquí que a estas estructuras se le llaman (FIFO). En este caso no se va a cumplir este principio, ya que los elementos van a estar ordenados en función de la prioridad. Las operaciones que definiremos sobre una cola con prioridad son:

Insertar – Inserta un elemento en la cola con prioridad. Luego de esta operación, el elemento insertado estará en su posición de acuerdo con su prioridad.

Extrae-Min (Extrae-Max) – Extrae el elemento de mayor prioridad de la cola.

Devuelve-Min (Devuelve-Max) – Retorna el elemento de mayor prioridad, pero no lo elimina.

Esta estructura pudiera ser útil, por ejemplo, en la sala de urgencia de un hospital, donde cada paciente debe ser atendido en función de su gravedad. Luego, con esta estructura podríamos formar un orden entre los pacientes logrando que los pacientes mas graves fueran atendidos primero.

Existen diversas formas de implementar esta estructura, pero en casi todas, alguna de las operaciones principales (ExtraeMin o Insertar) son de orden lineal respecto a la cantidad n de elementos que se almacenan. En este post, veremos cómo lograr una buena implementación de esta estructura usando un tipo de árbol binario que cumple ciertas características, llamado Árbol Parcialmente Ordenado (Heap), donde ambas operaciones serán O(log(n)). Veamos formalmente que es un heap.

Que es un Heap?

Un Heap es un árbol que tiene las siguientes características:

i. Es un árbol binario.
ii. Todos los niveles están llenos, excepto, quizás, el último.
iii. Los niveles se van llenando de izquierda a derecha. Si el árbol no es completo, en el último nivel, las hojas están agrupadas a la izquierda.
iv. Cada nodo tiene una prioridad mayor que la de sus dos hijos.

Heap como árbol parcialmente ordenado

Lo primero que podemos ver es que puede haber varios elementos con una misma prioridad, y lo segundo es que el árbol no está ordenado completamente, es decir, entre sus hijos no hay prioridad. Como vimos en el post anterior con los arboles binarios de búsquedas, donde el hijo izquierdo tenía que ser menor que el padre y este a su vez, menor que el hijo derecho. De aquí que este tipo de árbol binario se conoce como Árbol Parcialmente Ordenado, porque no define un orden total entre sus nodos.

Como hablamos de un árbol binario, podríamos pensar en representar un Heap con un arreglo donde A[0] es la raíz del árbol, el hijo izquierdo del nodo i será A[2*i+1] y el derecho A[2*i+2].

Operaciones con el Heap

Veamos ahora como serían los métodos para garantizar que las operaciones sean O(log(n)):
DEVUELVE-MIN(Heap h)
1 if(count(h)>0)
2  do return A[0]

Claramente este primer método es bastante sencillo, ya que el elemento de mayor prioridad siempre va a ser la raíz

EXTRAE-MIN(Heap H)
1  Intercambiar(0,n);
2  H[n] ←null;
3  n←n+1
4  HEAPIFY( 0);

En Extrae-Min lo que hacemos es eliminar el nodo raíz y poner el ultimo nodo a la derecha del primer nivel como raíz, disminuimos la cantidad de elementos y llamamos a un método llamado recursivo heapify que será el encargado de ubicar al elemento A[0] en su posición de acuerdo a su prioridad. Para esto, lo que hace es en cada paso del algoritmo ver si se viola alguna de las condiciones, y en caso positivo, lo intercambiar con el hijo de menor prioridad, esto es lo que hace que las operaciones sean O(log(n)), veamos un pseudocódigo para ilustrar mejor la idea:

HEAPIFY (Heap H, nodo i)
1  if(i<left(i) and i<right(i))
2  do return;
3  max = Max(left(i), right(i);
4  Intercambiar(i,max);
5  Heapify(H, max);

Luego, el método Insert(Heap H, x) sería agregar el nuevo elemento al final del array que representa el Heap y hacer heapify, pero en este caso en el orden contrario, desde las hojas hacia la raíz. A continuación el pseudocódigo:

INSERT(Heap H, x)
1  n←n+1
2  H[n] ←x;
4  HEAPIFY( n);

Esto es básicamente una buena implementación de Heap con array, que mejora un poco la representación por Arbol, ya que para insertar un nuevo elemento, nos evitamos el trabajo de buscar cual es la hoja más a la derecha, que como sabemos, en la representación por array será el nodo de la posición n.

Código en C# de un Heap

Bueno, aquí les dejo una implementación de Heap en C# que hice el año pasado como parte de una tarea. El código está bien comentado y entendible. De cualquier forma, si ves algún error o tienes alguna duda, en los comentarios. Otra implementación que he usado es proyectos más grandes es la que ofrecen en CodeProjects, que es una clase PriorityQueue mucho más completa, con más métodos y propiedades.

Entradas relacionadas

Informalmente, un árbol es una colección de objetos llamados nodos, de los cuales uno constituye la raíz. Sobre los nodos se define una relación “ser padre” que garantiza la estructura jerárquica entre los nodos. Como se puede apreciar, un hijo de un nodo de un árbol, es también un árbol, por lo que podemos definir un árbol recursivamente como una estructura formada por un nodo raíz r y un conjunto de árboles cuyas raíces son los hijos de r.

Algunas definiciones

Un nodo es hoja si no es padre de ningún nodo.
Un árbol que no tenga ningún nodo es un árbol nulo.
Un árbol es ordenado si existe una relación de orden entre los hijos de un nodo.
Un árbol binario es un árbol donde cada nodo tiene como máximo dos hijos. De igual forma podemos definir un árbol k-ario, donde cada nodo tiene a lo sumo k hijos.
Un árbol binario ordenado es un árbol donde cada nodo tiene un hijo izquierdo y un hijo derecho.
Veamos algunos métodos y propiedades que se pueden tener en un árbol:

public void Add(T x); (agrega un objeto al árbol)
public bool Contains(T x); (dice si el árbol contiene el objeto especificado)
public int Widht(); (devuelve el ancho del árbol, o sea el total de hojas)
public int Height(); (devuelve la altura del árbol, que es la mayor distancia desde la raíz a una de la hojas)
public object Value{get;} (devuelve el valor de la raíz del árbol)

Nota: Si no estás familiarizado con la notación “T x” utilizada para clases genéricas, puedes leer aquí sobre genericidad en C#.

Existen varias formas de recorrer un árbol, en dependencia de cómo estén ordenados, los recorridos más comunes son preorden, entreorden, a lo ancho y postorden.

PreOrden: Este recorrido imprime primero los padres y después los hijos en preorden. El algoritmo sería el siguiente:

public void Preorder(Tree t)
{
   foreach (T key in t.Keys)
     //Imprime la llave i-esima
     Console.WriteLine(key);
   foreach (Tree child in t.Childs)
     //Recorrer en preorden el hijo i-esimo
     Preorder(child);
}

El resultado de este recorrido para el árbol de la figura anterior sería A, B, C, D, E, F.

EntreOrden: Primero se imprime el primer hijo izquierdo con su recorrido EntreOrden, después la raíz, y luego el segundo hijo en EntreOrden, y así sucesivamente los restantes hijos. Si el árbol en cuestión es un árbol binario ordenado (ABB) el recorrido sería exactamente una ordenación de los elementos de dicho árbol, ya que hay un orden establecido entre los hijos, pero luego trataremos un post completo sobre los árboles binarios de búsqueda, que tienen algunas aplicaciones y propiedades importantes.

public static void EntreOrden (Tree t)
{
   if (t.Childs.Length>0)
      // Recorre en simétrico el primer hijo
      EntreOrden(t.Childs[0]);
   for (int i = 1; i < t.Childs.Length; i++)
   {
      // Imprime la llave (i-1)-esima
      Console.WriteLine(t.Keys[i - 1]);
      // Recorre en entreorden el hijo i-esimo
      EntreOrden(t.Childs[i]);
   }
}

Para el ejemplo anterior tendríamos el siguiente recorrido: B, A, D, C, E, F
PostOrden: Se recorren primero los hijos y luego los padres en postorden.

public static void PostOrden(Tree t)
{
   foreach (Tree child in t.Childs)
      // Recorre en postorden el hijo i-esimo
      PostOrden(child);
   foreach (T key in t.Keys)
      // Imprime la llave i-esima
      Console.WriteLine(key);
}

El recorrido postorden para el ejemplo sería B, D, E, F, C, A

Por último, le dejo algunos códigos que hice hace algunos años donde pueden ver otros métodos y funcionalidades de la clase árbol (añadir elementos, eliminar, altura, espejo, ancho, recorridos, dibujar arbol,  etc), también añadí la clase árbol binario, que hereda de la clase árbol, y una aplicación de consola donde se prueban varios métodos de estas clases.

Espero que les sirva de ayuda. Si tienen alguna duda con el código, dejen su comentario.

Descargar Código

Entradas relacionadas

La idea de este algoritmo de ordenación es particionar el arreglo de elementos en dos subarreglos, no necesariamente de igual tamaño, donde cualquier elemento de la primera será menor que todo elemento de la segunda partición. Esto se logra seleccionando un valor aleatorio del arreglo, y una vez realizada esta parte del algoritmo, se aplica el algoritmo recursivamente a cada una de los subarreglos semiordenados.

En la práctica, se usa QuickSort hasta obtener subarreglos de un tamaño fijo mucho menor (una longitud que ha traído buenos resultados es 20). Entonces se aplica Ordenación por Inserción a estos subarreglos, que es bastante eficiente cuando el arreglo está casi ordenado y hay pocas inversiones.

Veamos ahora el pseudocódigo, para entender un poco mejor que hace este maravilloso algoritmo de búsqueda:

void QuickSort(int[] A) {
QuickSort(A, 0, A.Length - 1);
}
 
void QuickSort (int[] A, int p, int r){
   if (p < r)
   {
      int q = Partition(A, p, r);
      //ordena los primeros q elementos
      QuickSort (A, p, q);
      //ordena los restantes n - q elementos
      QuickSort (A, q + 1, r);
   }
}
 
int Partition(int[] A, int p, int r)
{
   //elemento pivote del arreglo
   int x = A[p];
   int i = p - 1;
   int j = r + 1;
 
   while (true)
   {
      do j--; while (x < A[j]);
      do i++; while (A[i] > x);
      if (i > j)
         Swap(A, i, j);
      else
         return j;
   }
}

El método Partition(), lo que hace es intercambiar elementos que estén invertidos, en función del pivote seleccionado. O sea, Pone a un lados, los elementos menores que el pivote, y al otro lado, los mayores.

Les dejo una implementación en C# que hice hace algún tiempo, si ven algún problema me dicen. Si tienen alguna duda o pregunta, en los comentarios.

//Ordenacion rapida (QuickSort)
public static void QuickSort(int[] a)
{
   QuickSort(0,a.Length-1,a);
}
 
private static void QuickSort(int ini,int fin,int[] a)
{
   int left=ini;
   int right=fin;
   int mid=a[(ini+fin)/2];
 
   do
   {
      //Este es el Partition
      while(a[left]<mid)
         left++;
      while(a[right]>mid)
         right--;
      if(left<=right)
      {
        //Intercambio los elementos
        //si estan invertidos
        int t=a[left];
        a[left]=a[right];
        a[right]=t;
        left++;
        right--;
      }
   }
   while(left<=right);
 
   //Ordeno recursivamente los dos subarreglos
   if(left<fin)
      QuickSort(left,fin,a);
   if(right>ini)
      QuickSort(ini,right,a);
}

Entradas relacionadas

¿Qué es la genericidad?

Primero lo primero. La genericidad nos permite pasar un tipo genérico (o más), como parámetro a un método, clase, estructura o interfaz. O sea, este nuevo tipo (que llamaremos <T>), viene a sustituir al tipo object, que es usado sobre todo en estructuras de propósito general, como son los arraylist, pilas (stack), colas (queue) y otras que usamos frecuentemente, en las cuales todos los elementos deben ser de un mismo tipo. Por ejemplo, en una lista de números, en la que no queremos que hayan datos de tipo strings o char, solo de tipo int. Ahora se preguntarán ¿Por qué sustituir el tipo Object?

Recuerden que todos los tipos en C# (int, long, string, char, etc) heredan de la clase Object, lo cual es una ventaja para algunas cosas, pero a la vez es un problema a la hora de chequear el tipo de los elementos que se insertan en estas estructuras, ya que no hay una forma rápida y eficaz de verificar que todos los elementos sean del mismo tipo, para controlar esto, tendríamos que castear* cada vez que queramos obtener un valor de dicha estructura, lo cual puede llevar a errores, por no mencionar que es algo muy pesado, incómodo de programar y hay una gran posibilidad de errores en tiempo de ejecución.

Al usar genericidad también tenemos que tener en cuenta algunos cambios (para bien) en nuestra forma de programar, pero es mejor verlo en la práctica, veamos un ejemplo: Supongamos que queremos crear una clase con un método o función que nos devuelva el menor de dos valores de un mismo tipo. Utilizando la genericidad, tendríamos algo así:

class Ejemplo //T es el tipo de dato genérico
{
    //Método que devuelve un elemento de tipo T que es el mínimo
    //entre el elemento x y el elemento <em>y</em>
    T Minimo(T x, T y)
    {
       if(x &lt; y)
          return x;
       else
          return y;
    }
 
}

Ahora veamos qué pasa cuando invocamos este método:

//Supongamos que tenemos una clase Figura
Figura f1 = new Figura();
Figura f2 = new Figura();
Ejemplo ej = new Ejemplo();
Figura min = ej.Minimo(f1, f2);

Este código ni siquiera se ejecutaría, y dará un error en tiempo de compilación en la línea marcada de la clase Ejemplo<T> donde T es la clase Figura, ya que en ninguna parte especificamos cuando una instancia de Figura es menor, mayor o igual que otra, sin embargo, para el tipo int esto no supondría ningún problema verdad?

¿Qué quiere decir esto?

Cuando usemos genericidad tenemos que ser mucho más cuidadosos y formales cuando programemos, lo cual no es una mala práctica y es bueno ir acostumbrándose. Ahora arreglemos la clase Ejemplo para que el método Minimo(T x, T y) funcione con cualquier tipo de dato en general (que se pueda comparar):

class Ejemplo where T: IComparable;
{
    T Minimo(T x, T y)
    {
        int c = x.CompareTo(y);
        if(c<0)
            return x;
        else
            return y;
    }
}

Ahora ya especificamos que T es un tipo que debe implementar la interfaz IComparable<T>. En otras palabras, obligamos a que los elementos de tipo T se pueden comparar entre ellos, ya que en otro caso, hallar el mínimo pierde el sentido. En estos casos, se utiliza la palabra reservada where: y a continuación todas las restricciones que debe cumplir T, separadas por coma.

Entonces usamos el método CompareTo que debe implementar toda clase T que sea IComparable para saber cuál es el menor elemento. Este método deberá devolver 0 si x=y, 1 si x>y,-1 si x<y. Por tanto, el resultado de ejecutar Minimo, depende completamente de cómo implementemos el método CompareTo(). Por ejemplo, si tenemos la clase Figura:

class Figura: IComparable
{
    //Supongamos que tenemos estos métodos implementados
    public long Area();
    public long Perimetro();
 
    //Ahora implementamos el método <em>CompareTo</em>
    public int CompareTo(Figura f)
    {
        if(this.Area&gt;f.Area)
            return 1;
        else if(this.Area

En este caso, decidimos que una Figura es mayor que otra, en función del área, pero podemos definir que se comparen por el diámetro, por el perímetro, etc. Noten que aquí si podemos usar los operadores binarios dentro del CompareTo, ya que en este caso comparamos implícitamente elementos de tipo long, que son IComparables por defecto. Ya vas notando algunas ventajas de usar genericidad?

Ahora en un mismo método Mínimo, podemos devolver el elemento menor de cualquier tipo de dato que se pueda comparar, noten que este método nos servirá para Int, String, Long, Figuras, Personas y toda clase o tipo que implemente la interfaz IComparable.

Les dejo dos implementación de la clase Queue<T>, que es una cola con algunos métodos genéricos. En una de las implementaciones uso arrays, y en la otra colas enlazables. No lo he probado muy bien, pero funcionaba hace dos años cuando la implementé, jeje.

Veremos algunas otras cosas que podemos hacer con la genericidad en la segunda entrega de este tutorial, la semana próxima. Cualquier duda en los comentarios.

Descarga aquí el archivo en .zip:  Cola en C#

Entradas relacionadas

Cuando creamos un elemento en Windows Form, para seleccionar cual evento queremos disparar y como lo queremos programar, solo hay que seleccionar un objeto (boton, formulario, label) que hayamos creado previamente, y en el menu Propiedades, en la parte superior seleccionamos Events, ahí salen todos los eventos asociados al objeto creado. Solo tenemos que hacer doble click, entonces ya podremos programar lo que queremos que se haga cuando se dispare el evento.

Si se fijan bien, al poner el mouse arriba de un Evento, en la parte inferior del panel de propiedades aparece una pequeña descripción sobre el evento.

Aquí les dejo un programita que hice ya hace algunos años, y les servirá de ejemplo para que vean el manejo del evento MouseMove().

Pueden descargar el código fuente aquí:
http://www.puntopeek.com/wp-content/uploads/2009/11/Broma.zip

Lo unico que hay que saber para hacer un programa de este tipo, bien sencillo, es programar el evento MouseMove() y saber que MouseMove() se activa cuando el mouse pasa por encima del objeto asociado este evento. El programa lo que hace es mover el botón de lugar cuando tratas de posicionar el mouse encima del botón, esto se hace calculando nuevas coordenadas.

Bueno, los dejo con el ejemplo, tengo que seguir trabajando en mi proyecto de Estructura de Datos (Un Módulo de Respuesta Automatizada xD). Practiquen un poco y lean sobre el Grafics en Windows Forms, porque a partir del lunes empezaré a escribir pequeño tutorial sobre como programar algun juego sencillo en C#, y estoy pensando en el Sudoku. Cualquier duda en los comentarios.

No hay entradas relacionadas.

En este post trataré de explicar de la forma más sencilla posible, lo que es la herencia en programación, y pondré algunos ejemplos al final para ver si se llevan la idea, aunque seguro se quedan con algunas dudas, ya que es un concepto fácil de entender, pero difícil de aplicar en programación… después hablaremos entonces de lo que es la encapsulación y el polimorfismo

Por definición, la herencia no es más que la capacidad de un objeto de heredar las características de otro. Bueno, en programación, la herencia es la capacidad de una clase de heredar los métodos, las variables y las propiedades de otra (los constructores no se heredan). Esto permite ahorrar código, ya que varias funcionalidades no tendríamos que implementarlas nuevamente.

Una clase que herede de otra, puede usar los métodos, las propiedades o las variables de la clase padre. También se puede redefinir o modificar los métodos y propiedades, usando algunas palabras reservadas para esto, creando así un nuevo comportamiento del objeto. Una condición necesaria para que una clase herede de otra, es que la clase hija (la que hereda), debe poder usarse donde se use la clase padre (de la cual va a heredar). Si hay al menos un caso donde se puede usar la clase padre, y no se puede usar la clase hija, la herencia no tiene sentido.

En C#, una clase solo puede heredar de otra (por algunas razones difíciles de explicar). O sea, una clase no puede heredar de varias clases a la vez. Para que una clase herede de otra nada más hay que ponerle ‘:‘ después de su declaración, y seguido poner el nombre de la clase de la que se quiere heredar.

Ejemplo:

class Circulo: Figura
{
    // Implementación de la clase
}

Si una clase hija tiene un constructor que recibe los mismos parámetros que un constructor de la clase padre, y este constructor cumple las mismas funciones, que en la clase padre, el de la clase padre puede ser llamado desde la clase hija poniendo después de la declaración del constructor en la clase hija : y después la palabra reservada base. Dentro de los paréntesis van los parámetros del constructor base, (también veremos un ejemplo).

También es importante saber que si una clase hereda de otra, que a su vez hereda de otra, esta clase hereda también de la clase más arriba.

Por ejemplo, si un cuadrilátero es una figura y un paralelogramo es un cuadrilátero, entonces un paralelogramo es una figura…

Para que una clase padre permita que uno de sus métodos sea redefinido por sus clases herederas (las que heredan de ella) este método debe ser declarado usando la palabra reservada virtual, y cuando la clase hija vaya a redefinirlo, debe declararlo usando la palabra reservada override.

Ejemplo:

public <strong>virtual</strong> void Método()
//declaración del método en la clase Padre
{
//aquí va el codigo
}
 
public override void Método()
//declaración del método en la clase Hijo
{
//nuevas instrucciones
}

Si una clase hijo quiere redefinir un método de una clase padre, y este no fue declarado virtual en la clase padre, entonces hay que poner la palabra reservada new en la declaración del método.

Ejemplo:

public void Método()
//declaración del método en la clase Padre
{
   //aquí va el codigo
}
 
public new void Método()
//declaración del método en la clase Hijo
{
   //nuevas instrucciones
}

Ejemplo de herencia:

public class Hijo:Padre
{
 
//la clase Hijo hereda de la clase Padre
public Hijo(int n):base(n){}
}

El constructor de la clase Hijo que recibe como parámetros un entero llama al constructor de la clase Padre que recibe un entero pasándoselo como parámetro.

Ahora veremos un ejemplo real donde se vea la importancia de este importante mecanismo. Imaginen, que queremos tener algunas figuras geométricas, poder calcular el area, perimetro, moverlas en un plano, etc. Pero nos damos cuenta enseguida, que todas las figuras tienen area y perímetro, solo que se calculan de diferentes formas. Todas se pueden ocultar, mostrar y mover de igual forma, no? Veamos ya el código, para que sigan esta idea:

Antes de pasar al código, hay que definir que una jerarquía de clases es un grupo de clases, que heredan unas de otras, donde existe una clase base de la cual heredan todos los integrantes de la jerarquía, en este caso, la clase base es la clase figura.

//Declaramos la clase padre, de la que todas las figuras heredarán
//Es abstracta porque tendrá algunos metodos abstractos
 
public abstract class Figura
{
//Usamos <strong>protected,</strong> para que solo tengan acceso
//a estas variables, las clases que heredan de ella
protected int x,y;
protected Control control;
protected Pen myPen;
protected bool visible;
 
//Un constructor por defecto para todas las figuras
public Figura(int x, int y, Color color, Control control)
{
//Validar parametros
this.x = x;
this.y = y;
this.control = control;
myPen = new Pen(color,4);
 
}
public abstract void Muestra();
public abstract int Area();
public virtual void Oculta()
{
Color temp = myPen.Color;
myPen.Color = control.BackColor;
Muestra();
myPen.Color = temp;
visible = false;
}
public virtual void Traslada(int plusX, int plusY)
{
   if(visible)
   {
      Oculta();
      x += plusX;
      y += plusY;
      Muestra();
   }
   else
   {
      x += plusX;
      y += plusY;
   }

Ahora veremos el código de otras dos figuras en concreto que heredarán de la clase figura, un circulo y un rectángulo.

public class Circulo:Figura
{
//Vemos que en esta clase solo hay que declarar
//una variable
protected int radio;
//Este constructor tendrá todos los parámetros
//por defecto y un radio porque es un circulo
public Circulo(int x, int y, Color miColor, Control miControl,
 int radio)
:base(x,y,miColor,miControl)
{
   //Validacion
   this.radio = radio;
}
//Ahora hay que programar como se mostrará la figura
public override void Muestra()
{
   Graphics g = control.CreateGraphics();
   g.DrawEllipse(myPen,x-radio,y-radio,radio*2,radio*2);
   visible = true;
}
 
//Decimos como se calcula el area en este caso
public override int Area()
{
   return Math.PI * Math.PI * radio;
}
 
//Le podemos añadir otro método independiente
public int Perimetro()
{
    return 2 * Math.PI * radio;
}
}
 
//Esta clase también heredará de figura
public class Rectangulo:Figura
{
   protected int ancho,alto;
 
public Rectangulo(int x, int y, Color miColor, Control miControl,
int ancho, int alto)
:base(x,y,miColor,miControl)
{
   //Validar
   this.ancho = ancho;
   this.alto = alto;
}
//Redefinimos como mostrar la figura
public override void Muestra()
{
   Graphics g = control.CreateGraphics();
   g.DrawRectangle(myPen,x,y,ancho,alto);
   visible = true;
}
//Redefinimos como calcular el area
public override int Area()
{
   return alto * ancho;
}
}

Bueno, hasta aquí este pequeño tutorial sobre herencia en C#, próximamente estaremos hablando sobre polimorfismo, y después de encapsulación. Cualquier duda en los comentarios. Hasta la próxima

Entradas relacionadas

En un constructor, es donde se construye un objeto del tipo de la clase, es donde se inicializan las variables, se verifica que sus valores sean admisibles, y se le asignan valores a estas. Una clase puede contener varios constructores, estos se deben diferenciar en la cantidad de
parámetros, o en el tipo de los parámetros que reciben. Los constructores no se heredan, pero pueden ser llamados desde clases herederas usando la palabra reservada base y pasándole los parámetros que recibe. Esto lo veremos un poco más adelante cuando hablemos de herencia y polimorfismo, que son las bases de la programación orientada a objetos (POO).

Para declarar un constructor de una clase, se usa la siguiente sintaxis:

<modificador de visibilidad> <nombre de la clase a la que pertenece> (parámetros){instrucciones}

Ejemplo:

public class Auto
{
string marca;
int modelo;
Color color;
public Auto(){} //constructor por defecto
 
//Otro constructor
public Auto(string marca)
{
this.marca= marca;
}
//Otro constructor al que le pasamos todos los datos
public Auto(string marca, int modelo, Color color)
{
this.modelo = modelo;
this.color = color
this.marca= marca;
}

Nótese que los constructores se diferencian en la cantidad de parámetros o en el tipo de estos. Pero el constructor es uno solo, pero con varias sobrecargas, de modo que puedes elegir después como quieres crear un auto, dependiendo de los datos que tengas o no… además puedes crear  propiedades y métodos propios de una clase, pero eso lo veremos en el proximo post. Ahora  para crear un nuevo auto, o sea, una instancia de la clase Auto, podemos hacerlo de tres formas:

Auto miAuto = new Auto();
Auto ford = new Auto("Ford Explorer");
Auto audi = new Auto("Audi", 404, Color.Red);

Por ahora practiquen, ya veremos un poco más adelante todo lo que podemos y se nos permite hacer detro de las clases. Si tienen duda, comentarios…

Entradas relacionadas