¿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> //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 < 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<T> where T: IComparable<T>;
{
    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<Figura>
{
    //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>f.Area)
            return 1;
        else if(this.Area<f.Area)
            return -1;
        else
            return 0;
    }
}

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.

Veamos como invertir un string de tres formas distintas. Por ejemplo, si tenemos el string “puntopeek”, el método devolvería “keepotnup”.

Veamos el primer ejemplo, es el que casi todos conocemos, y es muy fácil de implementar, vamos recorriendo la palabra desde el ultimo caracter hasta el primero y vamos guardando cada letra en un nuevo string, que es el que devolverá el método. El código sería algo así:

public string Invertir(string s)
{
string aux = "";
 
//Recorremos el string en orden inverso
for (int i = s.Length - 1; i >= 0; i--)
aux += s[i];
 
//retornamos la nueva cadena
return aux;
}

Otra opción (pero hay que conocer que es una pila), es ir guardando cada letra en una pila (stack), y luego cuando esten todas las letras las sacamos de la pila. Noten que en esta estructura, el primer elemento que entra, es el último en salir, por eso nos sirve también para invertir un string. El código sería este:

public string Invertir2(string s)
{
//Declaramos una pila usando genericidad.
//Esto se puede hacer con el framework 2.0
Stack stack = new Stack();
 
//Recorremos el string y vamos metiendo en la pila
//cada caracter
for (int i = 0; i < s.Length; i++)
stack.Push(s[i]);
 
string aux = "";
 
//Vamos sacando de la pila los caracteres y los
//ponemos uno a uno en un nuevo string
for (int i = 0; i < s.Length; i++)
aux += stack.Pop();
 
return aux;
}

Ahora veremos la versión recursiva del problema. Si lo analizan paso a paso, verán que hace practicamente lo mismo que Invertir2. Como verán, este método no necesita almacenar ningun caracter, ni copiar, la recursividad se encarga de todo. En realidad la recursividad funciona como una pila (Invertir2) pero no hay que declarar variables ni nada de eso. A veces algunos métodos recursivos parecen mágicos, pero una vez dominemos esta técnica dominaremos el arte de programar. Al menos lo esencial. Veamos el código:

public string Invertir3 (string s, int lenght)
//El parametro lenght es el tamaño del string s
{
//Condicion de parada
if (lenght == 1)
return s;
else
//Llamado recursivo
return Invertir3 (s.Substring(1, s.Length - 1), lenght - 1)
+ s[0].ToString();
}

Para que se den cuenta de lo que hace el método, es necesario que le hagan un debug paso a paso, y vayan viendo como se transforman las variables locales. Si tienen alguna otra solución de como Invertir un string pueden ponerla en los comentarios. Y hasta aquí este post, espero escribir un poco más seguido, pero estoy con muchos proyectos en la universidad y mucho trabajo. Han oido hablar del WinZip o el WinRar? Proximamente estaremos hablando del Algoritmo de Huffman, que se utiliza mucho en el compactación de texto y archivos.

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

Un string es una cadena de caracteres, y hay que saber dominar todos estos caracteres y hacer con ellos lo que nosvenga en gana. La clase String, nos da bastante ayuda, ya que trae algunos métodos que nos hacen la vida mucho más fácil a todos. Ahora explicaré los más importantes:

Métodos fundamentales

public char this[int index] {get;}
Devuelve el caracter de la posición especificada de la cadena.
 
public int Length {get;}
Devuelve la longitud de la cadena(cantidad de caracteres
que contiene) empezando a contar desde 1.
 
public string Insert(int startIndex,string value);
Inserta la cadena especificada a partir de la posición dada.
 
public string Remove(int startIndex,int count);
Elimina el número especificado de caracteres a partir de la
posición dada.
 
public string[] Split(params char[] separator);
Busca las subcadenas contenidas dentro de la cadena,
delimitándolas por los separadores que se le especifiquen,
y las copia a un arreglo de cadenas.
 
public string Substring(int startIndex);
Devuelve la subcadena contenida a partir de la posición
especificada.
 
public string Substring(int index, int length);
devuelve la subcadena que empieza a partir del índice
específico, y tiene la longitud indicada).

Ahora veamos un ejemplo donde se usan algunos de estos métodos.

Invertir una cadena. O sea si invocamos al método Invierte (“puntopeek”), imprimiría en pantalla la palabra al reves, keepotnup.

Veamos ahora el código de este primer ejemplo:

public static void Invierte(string s)
 {
 Stack pila = new Stack();
//Guardamos cada caracter en la pila
 foreach(char ch in s)
    pila.Push(ch);
//Declaramos una nueva cadena
 string aux = "";
//ahora vamos poniendo en aux, cada caracter, como
//usamos una pila, nos quedaría la palabra invertida
 while(pila.Count>0
    aux += pila.Pop().ToString();
//Imprimimos en consola la palabra invertida
 Console.WriteLine(aux);
 }

Y hasta aquí este pequeño manual sobre la clase string y sus métodos, si quieren compartir algún otro ejemplo o les quedó alguna duda, usen los comentarios

Entradas relacionadas

Random r = new Random
// Creamos el objeto Random, que tiene un constructor por defecto
// O para los más exigentes, añadimos un plus de
// aleatoriedad, algo así:
Random r = new Random(DateTime.Now.Millisecond);

Y una vez tenemos el objeto, utilizaremos uno de esos tres métodos.

1.- El método Next Tiene tres sobrecargas:

int aleatorio1 = r.Next();
 
// Le imponemos un máximo
int aleatorio2 = r.Next(100);
 
// Le imponemos un rango, por ejemplo queremos
// un número de 3 cifras
int aleatorio3 = r.Next(100, 999);
 
// Queremos un número entre el 3 y el 12,
int aleatorio4 = r.Next(3, 12);

2.- El método NextDouble

// Devuelve un double entre 0 y 1
int aleatorio5 = r.NextDouble();

3.- El método NextBytes

byte[] buffer = new byte[100];
r.NextBytes(buffer);

¡¡Como ven, es super sencillo trabajar con esta clase, ahora veamos un ejemplo de como trabajar con esta clase.

1 – Crear un array de tamaño aleatorio con números aleatorios. Esto nos puede servir para probar varios métodos que usan arrays (ordenación, búsqueda, etc).

//Inicializamos la clase Random
Random r = new Random();
 
//Creamos un array que va a contener cantidad
//aleatoria de elementos menor que 50.
int [] numeros = new int [r.Next(0,50)];
 
//Recorremos el array y vamos asignando a cada
//posición un número aleatorio
for(int i=0; i<numeros.Lenght; i++)
   numeros[i] = r.Next(0,50);

Y hasta aquí, ya veremos después como es por dentro esta clase…

Entradas relacionadas