C# dí­a 15: clases útiles

Vamos a conocer algunas clases útiles de C#, presentes en cualquier otro lenguaje. Veamos el práctico temporizador con Timer

/**
* Temporizador.cs
* Muestra el uso de la clase Timer para crear temporizadores.
* Se puede asociar un evento a un temporizador para que el programa
* reaccione al cabo de x tiempo.
* Info sobre el standar http://msdn.microsoft.com/net/ecma
*/

using System;
using System.Timers;


// Vamos a usar El timer a través de nuestra clase temporizador
public class Temporizador
{
	private Timer miTimer;
	
	public Temporizador (int intervalo)
	{
		miTimer = new Timer();
		
		// Le asociamos un evento
		miTimer.Elapsed += new ElapsedEventHandler( EventoTemporizador );
		
		// Le asignamos un tiempo
		miTimer.Interval = intervalo;
		
		// Lo ponemos en marcha
		miTimer.Start();
	
	 }

	// Este será el evento que se ejecutará al pasar el tiempo
	public static void EventoTemporizador( object objeto, ElapsedEventArgs e )
	{
		System.Console.WriteLine("Salto el temporizador: Campaaana y se acabó");
		//exit(0);
	}
	
	
	// Método principal
	public static void Main ()
	{
		// Un  temporizador que salte cada 3 segundos...
		Temporizador temporizador = new Temporizador(3000);
		System.Console.WriteLine("Que paasa");
		
		// Creamos un bucle infinito y a ver que ocurre
		for(;;);
			// Pues aquí, a verlas venir...

	}
}
Vamos a ver algunas funciones matemáticas con Math
/**
* Mates.cs
* Muestra el uso de la clase Math, para las operaciones matemáticas habituales
*/

using System;
using System.Timers;


// La clase Mates
public class Mates
{
	
	// Método principal
	public static void Main ()
	{
		double valor = 0.0;
		
		// Vamos a coger un número con comas y a jugar con él
		System.Console.WriteLine("Anda resalao mete un numero con comillas");	
		string entrada = System.Console.ReadLine();
		
		try  // Trata de convertirlo Carlos!!
		{
			valor = Convert.ToDouble(entrada);
			
			// Vamos a probar el redondeo, su techo y su suelo
			System.Console.WriteLine("Redondeo con Round produce {0}", Math.Round(valor));
			System.Console.WriteLine("Redondeo con Floor produce {0}", Math.Floor(valor));
			System.Console.WriteLine("Redondeo con Ceiling produce {0}", Math.Ceiling(valor));
			System.Console.WriteLine("Su absoluto {0}", Math.Abs(valor));
			
			// Otras funciones: Log, Max, Min, Pow, Cos, Sin, Tan..
			
			System.Console.WriteLine("Constantes universales {0} y {1}", Math.PI, Math.E);
			
		} catch (Exception)
		{
			System.Console.WriteLine("Es probable que no metieras un número válida. Adios.");
		}

		// Si buscas números aleatorios usa Random, no Math
		Random aleatorio = new Random();
		System.Console.WriteLine("A ver un aleatorio: {0}", aleatorio.Next());

	}
}
Vamos a ver como manejar el entorno con Environment
/**
* Entorno.cs
* Muestra el uso de la clase Enviroment que nos da información sobre el
* entorno en que se ejecuta el programa. Siendo c# multiplataforma, puede
* ser una clase de gran interés
*/

using System;



// Vamos a conocer el entonno...
public class Entorno
{
	
	// Método principal
	public static void Main ()
	{
		int i = 0;
		
		// Vamos a ver..
		System.Console.WriteLine("Vamos a ver que se cuece en el sistema");

		string maquina = "";
		string quienSoy = "";
		string dondeEstoy = "";
		
		// Sacamos los datos de máquina ///////////////////////////////
		maquina += "Sistema operativo: " + Environment.OSVersion + "
";		
		maquina += "Versión: " + Environment.Version + "
";		
		maquina += "Hostname: " + Environment.MachineName + "
";		
		maquina += "RAM: " + Environment.WorkingSet + "
";		

		System.Console.WriteLine("{0}
",maquina);
		
		// Sacamos nuestro nombre de programa y argumentos //////////////
		quienSoy += "Comando ejecutado: " + Environment.CommandLine + "
";
		// Argumentos usados
		string [] argumentos = Environment.GetCommandLineArgs();
		// Mostramos todos, el primero sera el propio programa
		for (i = 0; i < argumentos.Length; i++)
		{
			quienSoy += String.Format("Arg[{0}]: {1}", i, argumentos[i]) + "
";
		}
		
		System.Console.WriteLine("{0}
", quienSoy);
		
		// Sacamos nuestra posicion y las unidades de disco //////////////
	    dondeEstoy += "Directorio actual: " + Environment.CurrentDirectory + "
";		
	    dondeEstoy += "Directorio de sistema: " + Environment.SystemDirectory + "
Unidades:
";
		
		// Sacamos unidades
		string [] unidades = Environment.GetLogicalDrives();
		// Mostramos todos, el primero sera el propio programa
		for (i = 0; i < unidades.Length; i++)
		{
			dondeEstoy += String.Format("Unidad[{0}]: {1}", i, unidades[i]) + "
";
		}
		
		System.Console.WriteLine("{0}
", dondeEstoy);
		
		// Variables de entorno, por ejemplo la mitica PATH, basta con ejecutar
		// el comando set en DOS para sacar las variables
		Console.WriteLine("
Path: {0}", Environment.GetEnvironmentVariable("Path"));
		Console.WriteLine("
Usuario: {0}", Environment.GetEnvironmentVariable("Username"));
		
	}
}
Vamos a ver como manejar los ficheros con System.IO
/**
* Ficheros.cs
* Muestra el acceso a ficheros: sacar sus datos, leer y escribir en ellos
*/

using System;
using System.IO; // Habrá que importar esta claro..


// Clase Ficheros para manipular archivos
public class Ficheros
{
	private string fichero;

	public Ficheros (string nombre)
	{
		fichero = nombre;
	}
	
	// Método para sacar las propiedades de un fichero
	// devuelve true si el fichero existe
	public bool propiedades()
	{
		string prop = "";
		FileInfo info;
		
		try
		{
			info = new FileInfo(fichero);
			
			// Comprobamos si el fichero existe, es lo suyo
			if (info.Exists)
			{
				prop += "Nombre: " + info.Name +"
";
				prop += "Tamaña: " + info.Length +"
";
				prop += "Fecha Creación: " + info.CreationTime +"
";
				prop += "Último acceso: " + info.LastAccessTime +"
";
				prop += "Última escritura: " + info.LastWriteTime +"
";

				System.Console.WriteLine("PROPIEDADES:
{0}
", prop);
			}	
		}
		catch (Exception e)
		// Otra excepción podría ser System.IO.FileNotFoundException
		{
			System.Console.WriteLine("Ocurrió una excepción: {0}", e);
			return false;
		}
		
		return true;
	}
	
	// Método para leer de un fichero
	public void leer()
	{
		// Definimos un StreamReader
		StreamReader lector;
		string linea = "";
		
		try
		{
			lector = File.OpenText(fichero);	
			
			// Lee linea a linea
			while ( (linea = lector.ReadLine()) != null)
			{
				System.Console.WriteLine("{0}", linea);
			}
			
			// Cerramos la conexion
			lector.Close();
			
		}
		catch (Exception e)
		{
			System.Console.WriteLine("Ocurrió una excepción: {0}", e);
		}
		
	}

	// Método para escribir un fichero, al final de él
	// Para escribir desde el inicio, usa WriteText
	public void escribir()
	{
		// Un objeto para
		StreamWriter escribe;
		string linea = "";
		
		try
		{
			escribe = File.AppendText(fichero);
			// podria ser CreateText para crear uno nuevo
			// o también WriteText para machacar el texto
			
			while (linea != "##")
			{
				System.Console.WriteLine("Mete algo en el fichero, ## para terminar ");
				linea = System.Console.ReadLine();
				escribe.WriteLine(linea);
			}		
			
			// Cerramos
			escribe.Close();
				
		}
		catch (Exception e)
		{
			System.Console.WriteLine("Ocurrió una excepción: {0}", e);
		}
	}
		
	// Método principal
	public static void Main (string[] args)
	{
		// Vamos a requerir un parámetro
		if (args.Length != 1)
		{
			System.Console.WriteLine("Pasame un nombre de fichero como parametro");
			return;
		}
		
		// Un  temporizador que salte cada 3 segundos...
		Ficheros miFichero = new Ficheros(args[0]);
		
		if (miFichero.propiedades())
		{
			miFichero.leer();
			
			// Y vamos a escribir
			miFichero.escribir();
			
			// A ver como ha quedado
			miFichero.leer();
			
			// Y las propiedades
			miFichero.propiedades();
		}

	}
}

by Pello Altadill 07/01/2006 22:44:20 - 20681 hits

C# dí­a 14: sobrecarga de operadores

Al igual que en C++ también podemos sobrecargar operadores en C#. Desde los aritmeticos binarios (+, -, *,..), comparativos, unarios(++), hasta Equals. Este ejemplo no muy útil muestra un poco la forma de sobrecargar operadores, no tiene mucho misterio pero hay que fijarse bien en los parámetros y returns para cada caso. /** * SobrecargaOperadores.cs * Este archivo muestra como sobrecargar operadores * en concreto los binarios simples: +,-,*,/.%, etc.. */ using System; // Defin...

by Pello Altadill 06/30/2006 09:05:24 - 3131 hits

More »

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 def...

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

More »

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 - 2465 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 - 3046 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 - 2555 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 - 2176 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 - 2216 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 - 2624 hits

More »