C# día 13: indexadores, delegados, eventos

Hoy vamos a ver unos objetos y métodos algo especiales. Todo esta explicado en el código. Por un lado, los indexadores

/**
* Indexadores.cs
* Los indexadores sirven para acceder a un array que puede haber dentro
* de la clase de forma directa. Supongamos que tenemos un atributo que es un
* array de nombres: protected string[] nombres;
* Con el indexador o indexer accederiamos a ese array así:
*   MiClase clase = new MiClase();
*   clase[0] = "Nuevo valor";
* Y para eso hay que definir un indexer.
*/

// Vamos a definir un equipo de fútbol
public class Equipo
{
	// Definimos un atributo que contiene los jugadores del equipo
	private string[] jugadores = new string[5];
	// Un atributo para guardar el nombre del equipo
	private string nombreEquipo;
	
	// Constructor
	public Equipo(string nombre)
	{
		nombreEquipo = nombre;
	}
	
	// método que devuelve tamaño
	public int getSize()
	{
		return jugadores.Length;	
	}
	
	// Indexador
	public string this[int indice]
	{
		get // Mediante el get podemos sacar un valor del array de jugadores
		{
			string temp;
			// Comprobamos indices no nos vayamos a salir
			if( indice >= 0 && indice <= 4 )
			{
 				temp = jugadores[indice];
			}
 			else
 			{
 				temp = "";
			}
			return temp;
		}
		
	  set // Mediante el set podemos establecer un valor en el array de jugadores
 	  {
	 	  // Comprobamos los límites
		  if( indice >= 0 && indice <= 4 )
		  {
			jugadores[indice] = value;
	  	  }
	  }
	}
	
	// Método principal
	public static void Main ()
	{
		// Vamos a crear un gran equipo
		Equipo osasuna = new Equipo("C.A. Osasuna");
		
		// Y ahora ya podemos establecer los nombre
		// de jugadores de forma directa
		osasuna[0] = "Ricardo";
		osasuna[1] = "Krutxi";
		osasuna[2] = "Josetxo";
		osasuna[3] = "Iñaki Muñoz";
		osasuna[4] = "Raúl García";
		
		// Y ahora ya podemos recorrer el array
		for(int i = 0; i < osasuna.getSize(); i++)
		{
			System.Console.WriteLine("Jugador {0}", osasuna[i]);
		}
	}
	
}
Por otro los métodos delegados, similares a los de las interfaces
/**
* Delegados.cs
* Los métodos delegados son similares a los interfaces: definen
* una forma de método (con su nombre, su return y sus parámetros)
* pero sin implementación.
*/

using System;

// Definimos la clase Aritmetica
// que sirve para hacer operaciones simples
public class Aritmetica
{
	
	// Aquí definimos el método delegado
	// Que deberán implementar otras clases
	public delegate int Operacion(int a, int b);
	
	// Fijate en el parámetro
	public int HacerOperacion (Operacion op, int x, int y)
	{
		return (op(x, y));
	}
}

public class UsarAritmetica
{
	// Un método que implementa Operación
	public static int OperacionSumar(int a, int b)
	{
		return (a+b);	
	}

	// Un método que implementa Operación
	public static int OperacionRestar(int a, int b)
	{
		return (a-b);	
	}

	// Método principal
	public static void Main()
	{
		// ATENCION. Se crea una instancia del MÉTODO DELEGADO
		Aritmetica.Operacion sumar = new Aritmetica.Operacion(OperacionSumar);
		Aritmetica.Operacion restar = new Aritmetica.Operacion(OperacionRestar);
		
		// Y ahora creamos una instancia de la clase que contiene el delegado
		Aritmetica aritmetica = new Aritmetica();
		
		// Y ahora usamos los métodos delegados
		int resultado = aritmetica.HacerOperacion(sumar, 665, 1);
		
		System.Console.WriteLine("Que fuerte, ha salido {0}", resultado);
		
		System.Console.WriteLine("Y ahora {0}",  aritmetica.HacerOperacion(restar, 700, 34));

	}
	
}
Vamos a ver, como implementar nuestros propios eventos. Es algo complejo, y hay que ir paso a paso
/**
* Eventos.cs
* Programas que muestran la definición y uso de Eventos.
* Los eventos som situaciones en la ejecución de un programa
* que pueden ser controlados para cambiar el comportamiento del mismo.
* El ejemplo más claro es el entorno de ventanas: el evento de pinchar en un botón
* puede provocar el cierre de una ventana.
*/

using System;

// En esta caso vamos a crear un evento para controlar que el usuario
// ha escrito la palabra viagra en la consola. El evento se va a disparar
// cuando se asigne lo que se ha metido por pantalla a una variable: en ese
// momento se comprobará si esa palabra es "viagra" y de ser así, avisará

// Definimos el método delegado 
// Los parametros son:
// 1. un objeto: el que genera el evento
// 2. argumento del evento: una clase especifica para ese evento
public delegate void capturaPalabraSpam(Object objeto, ArgumentoEvento e);

// Definimos una clase para los argumentos del evento
// que DEBE heredar de la clase: EventArgs
public class ArgumentoEvento : EventArgs
{
	public string palabra;
	
	// Constructor
	public ArgumentoEvento(string palabra)
	{
		this.palabra = palabra;
	}
}

// Ahora una clase para comprobar el evento
public class CompruebaSpam
{
	string palabraspam;
	public event capturaPalabraSpam EventoSpam;
	
	// Atencion cuando hagamos el set (la asignación) se disparará el evento!
	public string PalabraSpam
	{
		get { return palabraspam; }
		set
		{
			if ( EventoSpam != null)
			{
				ArgumentoEvento argumentos = new ArgumentoEvento(value);
				EventoSpam(this, argumentos);
				palabraspam = argumentos.palabra;
			}
		}
	}
}

public class PruebaEvento
{
	// Handler: IMPLEMENTACION DEL MÉTODO DELEGADO
	// Definimos el handler para el evento
	static void detectaSpam(Object source, ArgumentoEvento e )
	{
		if (e.palabra.ToLower() == "viagra")
		{
			System.Console.WriteLine("SPAM!!");
			System.Console.WriteLine("Detectada palabra basura {0}",e.palabra);
		}
	}

	// Método principal
	public static void Main ()
	{
		
		// creamos una instancia del comprobador
		CompruebaSpam comprueba = new CompruebaSpam();
		
		// Le asignamos el handler de eventos que hemos implementado
		comprueba.EventoSpam += new capturaPalabraSpam(detectaSpam);
		
		System.Console.WriteLine("Vamos a ver si generamos un evento");
		System.Console.WriteLine("Escribe algo, distinto de viagra, o no.");
		
		comprueba.PalabraSpam = System.Console.ReadLine();
		
	}
	
}

by Pello Altadill 06/29/2006 08:00:35 - 7004 hits

C# día 12: interfaces

En C# también se pueden crear interfaces como en Java, aunque el manejo de atributos se hace a través de las properties y es algo engorroso. Veamos un ejemplo básico: Definimos el interfaz bebida y una clase que lo implementa, el café. /** * Interfaces.cs * Programa que muestra el uso de interfaces. Al igual que en Java los interfaces son * como clases abstractas pero sin implementación alguna. Su objetivo es servir como * plantilla a las clases que lo implementan ...

by Pello Altadill 06/28/2006 18:55:19 - 2192 hits

More »

C# dí­a 11: E/S standar

Vamos a ver que se puede hacer con la entrada y salida standar de consola. Hay opciones muy interesantes con los formatos numéricos, el manejo de fechas y las conversiones. Vamos que se puede hacer con el WriteLine /** * Formato.cs * Esta clase muestra los distintos formatos que se pueden aplicar * a la hora de mostrar datos por pantalla o por un flujo de salida. */ using System; // Clase Formato // contiene métodos en los que se muestran técnicas de formato public class Formato...

by Pello Altadill 06/27/2006 17:19:44 - 2774 hits

More »

C# día 10: herencia

En un solo ejemplo de código vamos a ver como crear herencia de una clase a otra, en este caso de la clase Dispositivo a la clase Movil. Aquí entrará en juego el polimorfismo, es decir, un mismo método en la clase hija y clase padre con distinto efecto. Merece la pena comentar que disponemos de clases abstractas y también de clases que NO se puede heredar (sealed). Vamos a ver: /** * Dispositivo.cs * Superclase o clase padre para definir los dispositivos, * de esta h...

by Pello Altadill 06/26/2006 10:54:45 - 2324 hits

More »

C# día 09: excepciones

C# también dispone de control de excepciones, y al igual que C++ o Java podemos crear y lanzar nuestras propias excepciones. Primero veamos como se capturan: /** * Excepciones.cs * Clase que muestra el uso de excepciones * no muy distinta de otros lenguajes */ using System; public class Excepcion { // Método principal public static void Main() { int valor; string entrada; int[] vector = new int[4]{4,7,1,0}; System.Console.WriteLine("Introduce un número"); /...

by Pello Altadill 06/24/2006 22:26:06 - 1948 hits

More »

C# día 08: métodos avanzados

Vamos a ver algunas opciones interesantes que tienen los métodos en C#. Para empezar, no podía faltar la sobrecarga: /** * Sobrecarga.cs * Clase que muestra como aplicar sobrecarga en métodos * de una clase. La sobrecarga consiste en crear varios métodos con el mismo * nombre pero con distintos parámetros. */ using System; // Vamos a declarar esto dentro del un espacio de nombres namespace Calculadoras { public class Calculadora { string nombre; // MÃ...

by Pello Altadill 06/24/2006 17:25:05 - 1958 hits

More »

C# dí­a 07: estructuras

Vamos a ver algunas estructuras básicas de c#. Hay alguna cosa curiosa en la forma de definir los arrays y las propiedades de las estructuras. Veamos la struct: /** * Estructuras.cs * */ using System; /** * Las estructuras de C# se comportan practicamente como clases, * salvo que no es imprescindible instanciarlas y que se guardan * en memoria de otra forma. Veamo un ejemplo. */ public struct Casa { // Para que sean accesibles, hay que declararlos public // y no se pueden inicializar. pu...

by Pello Altadill 06/23/2006 11:52:05 - 2349 hits

More »

C# día 06: métodos

Este día a merecido la pena y a los que no conozcan este lenguaje les sugiero echar un ojo al código ya que en los tipos de métodos ya se ve alguna peculiaridad de c# (respecto a java o c). Veamos algunos ejemplos de metodo a través de la clase Pajaro: using System; // Definimos la clase pajaro, esa cosa con pluma public class Pajaro { // ATENCION: SI NO SE ESPECIFICA NADA, // los atributos y metodos NO SON accesibles public string nombre; public int peso; // Variab...

by Pello Altadill 06/21/2006 09:09:31 - 2010 hits

More »

C# día 05: clases!

Veamos como se definen las clases. La cosa no cambia salvo alguna cosa curiosa; si no se especifica otra cosa, los atributos y métodos NO son accesibles, vamos que NO son public por defecto. Veamos la clase Punto, y luego una clase que le crea un instancia y lo usa. using System; // Definimos la clase punto, // que se refiere a un punto en una coordenadas public class Punto { // ATENCION: SI NO SE ESPECIFICA NADA, // los atributos y metodos NO SON accesibles public int x; public int y; ...

by Pello Altadill 06/20/2006 10:17:49 - 1863 hits

More »