Conclusiones

Aunque existen otras opciones para realizar labores similares a ésta, como Hibernate o directamente JDBC, siempre es bueno como he dicho desde un comienzo, conocer más posibilidades sobre todo en el caso de este tipo de tecnologías tan difundidas a día de hoy. No digo que Mono esté tan difundido como algunos querríamos, pero sí es verdad que por suerte o por desgracia, .NET Framework está presente en cada vez más ordenadores, y la compatibilidad de Mono con la plataforma de Microsoft le augura un futuro muy prometedor.

A través de este curso, he intentado mostraros las operaciones básicas y preliminares para comenzar a funcionar con ADO sobre Mono, utilizando además, una base de datos libre, MySQL que a su vez tiene una implementación de ADO propia. Sin lugar a dudas, un cocktail interesante.

Lo dicho, espero que os haya gustado y sobre todo que os haya sido lo suficientemente interesante como para que os animéis a desarrollar aplicaciones algo más complejas utilizando estas tecnologías.

Previamente deberemos incluir la referencia a nuestro proyecto para el ensamblado System.Data que lo encontraréis dentro del menú de referencias en la pestaña “Paquetes”. En el comienzo del fichero también deberéis rellenar su respectivo using System.Data.

Una vez hecho esto, para rellenar el DataSet sólo tendremos que hacer:

public static void Main(string[] args)
{
	MySqlConnection conexion = new MySqlConnection();
	conexion.ConnectionString = "database=linuxhispano;
server=localhost;user id=root; pwd=contraseña";
	conexion.Open();
	// nuevos objetos a utilizar
	DataSet datos = new DataSet();
	MySqlDataAdapter adaptador = new MySqlDataAdapter();
	try
	{
		MySqlCommand comando = new MySqlCommand
("SELECT * FROM ejemplo", conexion);
		adaptador.SelectCommand = comando;
		adaptador.Fill(datos);
	}
	catch(MySqlException exc)
	{
		Console.WriteLine("Ocurrió un error : " + exc.Message);
	}
	finally
	{
		conexion.Close();
	}
}

Dentro de datos, tendremos un DataTable con todos los datos. Pero, ¿cómo acceder a ellos? Espero que con el siguiente bucle que voy a mostrar se quede todo un poco más claro. En este bucle recogeremos la tabla del DataSet y posteriormente la recorreremos primero por filas y luego cada fila por elementos. Imprimiremos el resultado por pantalla. Para no repetir código sólo pondremos la parte nueva y dónde va insertada.

[...]
// nuevos objetos a utilizar
DataSet datos = new DataSet();
MySqlDataAdapter adaptador = new MySqlDataAdapter();
[...]
	adaptador.Fill(datos);
	DataTable tabla = datos.Tables[0];
	int i = 0;
	foreach(DataRow fila in tabla.Rows)
	{
		Console.WriteLine("Fila " + i.ToString()
 + " --> Elementos : ");
		int j = 0;
		foreach(Object celda in fila.ItemArray)
		{
			Console.WriteLine("\tElemento : "
 + j.ToString() + " - " +  celda.ToString());
			j++;
		}
		i++;
	}
}
catch(MySqlException exc)
[...]

La salida sería algo así:

Fila 0 --> Elementos :
	Elemento : 0 - 25
	Elemento : 1 - Gráficos
Fila 1 --> Elementos :
	Elemento : 0 - 26
	Elemento : 1 - Programación
Fila 2 --> Elementos :
	Elemento : 0 - 27
	Elemento : 1 – Sonido

A partir de aquí, podríamos modificar los registros y no almacenarlos luego en la base de datos, convertir la salida en un fichero XML de manera directa, realizar un mapeo de la base de datos y hacer que los cambios sean instantáneos en ella… en definitiva, todo un mundo de opciones a muy pocas líneas de código de distancia que posibilitan, como he dicho desde un comienzo, un desarrollo del código ligero y rápido en el manejo de datos.

1. Creamos la consulta y la asignamos a una cadena
2. Creamos el comando con la consulta que acabamos de crear
3. Asignamos la conexión pertinente al comando
4. Lo ejecutamos

Ampliando nuestro ejemplo, quedaría así:

public static void Main(string[] args)
{
	MySqlConnection conexion = new MySqlConnection();
	conexion.ConnectionString = "database=linuxhispano;
server=localhost;user id=root; pwd=contraseña";
	conexion.Open();
	try
	{
		string consulta = "INSERT INTO ejemplo (numero , tema)
 VALUES ('27', 'Sonido')";
		MySqlCommand comando = new MySqlCommand(consulta);
		comando.Connection = conexion;
		int resultado = comando.ExecuteNonQuery();
		Console.WriteLine("Filas afectadas : "
 + resultado.ToString());
	}
	catch(MySqlException exc)
	{
		Console.WriteLine("Ocurrió un error : " + exc.Message);
	}
	finally
	{
		conexion.Close();
	}
}

Como se puede apreciar, hemos cuidado que se finalice la conexión aunque existan errores, con finally y hemos controlado los posibles errores que aparezcan. En nuestro caso debería decir: “Filas afectadas: 1”, puesto que la inserción sólo realiza una.

A la hora de realizar la inserción podríamos haber utilizado MySqlParameter, que nos provee de un mejor tratamiento de los datos de cara a mejorar la seguridad y ampliar las posibilidades, pero se escapaba del carácter introductorio de este texto.

Como veis hemos ejecutado el comando con el método ExecuteNonQuery que utilizaremos para operaciones de inserción, borrado y actualización. En el caso de consultas como tales con SELECT, utilizaremos ExecuteReader y en el caso que veremos a continuación, cuando trabajamos con escalares ExecuteScalar. No siempre es así y depende de lo que vayamos a hacer varía el método pero para este punto nos vale.

Las consultas que devuelven escalares son aquellas que devuelven un sólo número, por ejemplo, si preguntamos a la base de datos que nos cuente cuántas filas hay en la tabla. Veamos este ejemplo, el proceso es el mismo pero utilizamos ahora el método ExecuteScalar y cambiamos convenientemente la consulta. Utilizaremos el constructor de MySqlCommand para inicializar con la consulta y la conexión el objeto, de forma que nos ahorremos una sentencia:

public static void Main(string[] args)
{
	MySqlConnection conexion = new MySqlConnection();
	conexion.ConnectionString = "database=linuxhispano;
server=localhost;user id=root; pwd=contraseña";
	conexion.Open();
	try
	{
		MySqlCommand comando = new MySqlCommand
("SELECT COUNT(*) FROM ejemplo", conexion);
		string resultado = comando.ExecuteScalar().ToString();
		Console.WriteLine("Filas en la tabla : " + resultado);
	}
	catch(MySqlException exc)
	{
		Console.WriteLine("Ocurrió un error : " + exc.Message);
	}
	finally
	{
		conexion.Close();
	}
}

La salida por consola debe ser “Filas en la tabla: 3”. Finalmente, veamos cómo recorrer hacia adelante la tabla con ExecuteReader(). La metodología a seguir es ejecutar el comando con este método y posteriormente, imprimir por pantalla el resultado que va devolviendo el lector mientras haya filas que recorrer. El código lo tenéis a continuación:

public static void Main(string[] args)
{
	MySqlConnection conexion = new MySqlConnection();
	conexion.ConnectionString = "database=linuxhispano;
server=localhost;user id=root; pwd=contraseña";
	conexion.Open();
	try
	{
		MySqlCommand comando = new MySqlCommand
("SELECT tema FROM ejemplo", conexion);
		MySqlDataReader lector = comando.ExecuteReader();
		while(lector.Read())
		{
			Console.WriteLine(lector.GetString(0));
		}
		lector.Close();
	}
	catch(MySqlException exc)
	{
		Console.WriteLine("Ocurrió un error : " + exc.Message);
	}
	finally
	{
		conexion.Close();
	}
}

El resultado debería ser en tres líneas distintas, los tres temas que hay presentes en estos momentos en la base de datos. Pasadas estas primeras operaciones, en el siguiente punto vamos a rellenar un DataSet con los datos de la base de datos y vamos a recorrerlo a través de las clases: DataTable, DataColumn y DataRow antes de dar por terminado este artículo.

Uno de los aspectos esenciales de ADO, como no podía ser de otra manera, es la interacción directa con los datos provenientes de las bases de datos. Para comenzar a operar con ello os presento estas cuatro clases: DataSet, DataTable, DataColumn y DataRow; conjunto de datos, tabla de datos, columna de datos y fila de datos, respectivamente.

Un conjunto de datos, es un objeto que almacena datos, en forma de tablas por ejemplo, y que pueden provenir de distintos orígenes. Una tabla de datos, es el objeto que almacena los datos de, una consulta, por ejemplo, en forma de tabla en la memoria y a la que podremos acceder, básicamente, a través de sus filas y columnas. Todas estas clases suelen tener una representación física en la base de datos, pero no tiene que ser así siempre, y podemos trabajar de manera asíncrona con la base de datos o directamente con datos provenientes de otras fuentes como por ejemplo ficheros XML.

Una de las ventajas de ADO es lo transparente que hace al desarrollador el origen de los datos así como la interacción con los mismos, pues al hacer a través de objetos, el manejo en la aplicación es muy intuitivo. Llegados a este punto y para seguir progresando vamos a crear una tabla en la base de datos a la que le agregaremos una serie de registros, de manera que posteriormente podamos interactuar con ellos. Se tratará de una base de datos de revistas.

En la tabla almacenaremos sólo dos campos para el ejemplo: uno de tipo entero que representará el número de la revista, “numero”; y otro de tipo cadena donde almacenaremos la temática de ese número de revista, “tema”. El número será la clave primaria y ambos no podrán ser nulos.

Nos dirigimos de nuevo a la shell de MySQL y escribimos:

CREATE TABLE `linuxhispano`.`ejemplo` (
`numero` INT NOT NULL ,
`tema` VARCHAR( 64 ) NOT NULL ,
PRIMARY KEY ( `numero` )
) ENGINE = MYISAM CHARACTER SET utf8 COLLATE utf8_general_ci

Como comprobaréis, además de indicar los campos he añadido a la tabla el motor a utilizar, ISAM y el juego de caracteres UTF-8 para evitar problemas de acentos y eñes, entre otros. Pasemos a agregar un par de registros:

INSERT INTO `lpmagazine`.`ejemplo` (
`numero` ,
`tema`
)
VALUES (
'25', 'Gráficos'
);
INSERT INTO `linuxhispano`.`ejemplo` (
`numero` ,
`tema`
)
VALUES (
'26', 'Programación'
);

Ya tenemos los datos en la base de datos. Nuestra labor ahora es conectarnos para realizar consultas sobre ellos. Veamos cómo.

Aunque esta entrada no forma parte del curso de Mono, sí está muy relacionada con esta entrega dedicada a tipos de datos.

Si tenemos una variable u objeto y no sabemos su tipo con seguridad, disponemos de dos métodos que usaremos para ver cuál es realmente el tipo del mismo. Veamos:

• getType(): obtiene el tipo de la instancia actual
• Type.GetType(“tipo de objeto”): lo usamos para obtener una referencia con la que comparar

Por ejemplo, ¿cómo saber si el objeto “auxiliar” es un entero con signo de 32 bits (el entero más estándar, el que usamos al poner int simplemente)?

if(auxiliar.GetType() == Type.GetType("System.Int32"))
   return true;
else
   return false;

Al igual que con enteros, podemos hacer la comprobación para cualquier tipo:

• Boolean: valor booleano
• Byte: ocho bits sin signo
• Char: carácter UNICODE
• DateTime: fecha con tiempo
• Decimal: número decimal
• Double: pnto flotante de precisión doble
• Int16: entero con signo de 16 bits
• Int32: ídem pero de 32 bits
• Int64: ídem pero de 64 bits
• SByte:  8 bits con signo
• Single: punto flotante de precisión simple
• UInt16: entero sin signo de 16 bits
• UInt32: ídem pero de 32 bits
• UInt64: ídem pero de 64 bits

Antes de seguir sería conveniente que copiarais al directorio del proyecto el fichero “mysql.data.dll” que venía dentro del paquete comprimido del conector. Os dirigís a referencias y haciendo clic sobre el mismo título “Referencias”, elegís “Editar referencias…”. De las tres pestañas que aparecen en el diálogo elegís “Ensamblado .NET” y os dirigís al directorio del proyecto o donde tengáis guardado el fichero. Lo elegís y lo añadís.

Desde este momento tenéis referenciado el conector dentro de vuestro programa. Ahora el siguiente paso es importarlo al fichero Main.cs. Para ello escribís debajo de “using System; ”, “using MySql.Data.MySqlClient;”. El archivo quedaría así:

using System;
using MySql.Data.MySqlClient;
namespace ejemplo_mono_ado
{
	class MainClass
	{
		public static void Main(string[] args)
		{
			Console.WriteLine("¡Hola Mundo!");
// Hola Mundo inicial creado por el IDE
		}
	}
}

Con ésto ya tendríamos el espacio de nombres del conector MySQL disponible en nuestro código por lo que a partir de ahora sí que podríamos tratar con las clases del mismo.

Antes de nada, de forma básica, vamos a revisar qué necesitamos, cómo obtenerlo y en caso necesario, cómo configurarlo. En este momento ,creo conveniente señalar que utilizaremos MonoDevelop,el entorno de desarrollo integrado para Mono más popular, en lugar de utilizar directamente el compilador, mcs; para centrarnos directamente en el desarrollo con ADO y dejar de lado los detalles que no son necesarios.

Mono y MonoDevelop

En función de la distribución que utilicéis, las circunstancias particulares cambiaran, pero básicamente os comento dos alternativas que probablemente os sirvan prácticamente a todos. La primera es dirigiros a vuestro gestor de paquetes y buscar los paquetes correspondientes. Como monodevelop, que será más o menos así el nombre del paquete, depende de Mono, si elegís éste se os seleccionaran los demás paquetes necesarios para desarrollar y ejecutar programas con Mono. Es decir, básicamente instalando MonoDevelop a través del paquete homónimo, tendréis todo preparado. Además, es más que probable que tengáis instalado Mono en vuestro equipo por defecto. Por ejemplo, el entorno de escritorio Gnome utiliza esta tecnología ampliamente.

La segunda solución, la más larga y menos recomendable es instalar Mono compilando el código fuente. Necesitaremos tener instalados: cmpilador de C (gcc), Bison y las librerías de desarrollo para glib. Descargaremos el código fuente desde la sección de descargas del Proyecto Mono (pondrá algo así como Mono el número de la versión seguido de “sources”). Utilizaremos el directorio “/opt” para evitar problemas. Más o menos el proceso de instalación sería:

1. Descomprimimos y desempaquetamos el código fuente, gráficamente o mediante la consola: $ tar zxvf mono-X.XX.tar.gz
2. Configuramos los archivos para realizar el make: $ ./configure –prefix=/opt/mono
3. Ejecutamos make para ejecutar el código fuente: $ make
4. Finalmente instalamos: $ sudo make install

Tras la instalación deberemos configurar debidamente las variables de entorno. Para ello ejecutamos desde la terminal:

$ export PATH=$PATH:/opt/mono/bin
$ export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/mono/lib
$ export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:/opt/mono/lib/pkgconfig
$ export MONO_PATH=/opt/mono/lib

Una vez ya tenemos instalado Mono, pasamos a instalar MonoDevelop de una forma análoga. Accedemos al sitio de MonoDevelop, descargamos el código fuente y:

1. Desempaquetamos el código fuente y lo descomprimimos: $ tar zxvf monodevelop-X.X.tar.bz2
2. Configuramos para crear el make: ./configure –prefix=`pkg-config –variable=prefix mono`
3. Compilamos: $ make
4. Instalamos: $ make install

Ya tendríamos esta parte lista, pero como dije antes, mucho mejor utilizar el sistema gestor de paquetes para evitar problemas derivados de no poder actualizar tan fácilmente o por ejemplo, las dependencias insatisfechas.

MySQL

De igual manera instalaremos el servidor MySQL al que nos conectaremos desde nuestra aplicación con C#. Dado que hay gran cantidad de tutoriales y manuales en la red, voy a ser bastante breve. Básicamente deberéis buscar en vuestro gestor de repositorios el paquete mysql-server y ya tendréis el servidor de base de datos instalado.

Conector

Finalmente, descargaremos el fichero con el conector de MySQL para .NET y Mono. Es un fichero con extensión .dll, que es la extensión con que suelen ser almacenados los ensamblados, como es el caso de .NET/Mono. Si queréis saber más sobre ensamblados, el CLI, o cualquier otro detalle más técnico propio de .NET/Mono, podéis visitar la Wikipedia (preferiblemente en inglés) o la MSDN (antes también Mono-Hispano pero ahora mismo parece que no está accesible). Aunque no sea el objetivo de este artículo definiré brevemente dichos conceptos para que quede algo más claro. Podríamos decir que un ensamblado en Mono es un conjunto de clases implementadas junto con sus metadatos correspondientes para ser utilizados, recogidos en un fichero que puede ser llamado desde un proyecto Mono.

En el caso que nos ocupa utilizaremos una implementación de la arquitectura ADO.NET creada por el propio proyecto MySQL para posibilitar una comunicación lo más nativa e integrada posible entre aplicaciones desarrolladas con .NET/Mono y MySQL. El conector, que así se llama, podéis encontrarlo en la web de MySQL (http://dev.mysql.com/downloads/connector/net/).

Una vez nos encontremos en el sitio, descargamos los ficheros para Windows sin instalador (un fichero .zip con varios ensamblados), lo descomprimimos y ya tendremos todo preparado para comenzar el proyecto.

Antes de continuar un detalle importante. Microsoft Windows no es case sensitive, sensible a mayúsculas/minúsculas, en cuanto a rutas, pero GNU/Linux sí lo es, por lo que deberéis renombrar los ficheros dll que utilicemos conforme se llaman en el programa que será: “MySql.Data” en lugar de “mysql.data” como vienen nombrados por defectos (los demás también de manera análoga).

Las facilidades que provee una tecnología multiplataforma de alto nivel como Mono, unido a la integración en el mismo de MySQL a través de un conector nativo para ADO.NET, hacen que tengamos al alcance de nuestra mano un binomio de software libre con una potencia envidiable. Siempre tenemos otras opciones también libres, como Java en el caso de tecnología de desarrollo multiplataforma; y otras bases de datos como PostgreSQL para arquitecturas cliente-servidor, o SQLite para máquinas locales, que gozan de muy buena salud.

A lo largo de este curso explicaremos de una manera introductoria el uso de ADO.NET; y lo utilizaremos a través de un interfaz en modo texto. Sin lugar a dudas, las personas que hayan programado anteriormente para la .NET Framework de Microsoft en Windows, conocerán bastantes de los detalles que aquí relatamos y es que como ya muchos sabréis, Mono es una implementación libre de esta plataforma.

Mono, MySQL y ADO.NET

Vamos a ser breves en la presentación de las herramientas con las que vamos a tratar, pero siempre considero útil situar al lector, para que en caso de que no conozca las herramientas sepa situarse en un contexto apropiado.

Mono es un proyecto libre, creado por Ximian en su día y actualmente impulsado por Novell tras la compra de la primera por parte de la segunda, que ofrece una serie de herramientas libres que cumplen las especificaciones de .NET. La figura más destacada del Proyecto Mono es Miguel de Icaza, cofundador de Gnome, hombre fuerte en Novell y una persona un tanto polémica dentro del software libre por sus aportaciones a la vez que sus acercamientos a Microsoft.

MySQL como sabréis, es el sistema gestor de base de datos creado por una empresa del mismo nombre y que posteriormente ha sido adquirido por Sun Microsystems, y recientemente por Oracle. Su popularidad en la red gracias al binomio que forma con PHP la han llevado a convertirse en la base de datos más conocidas del mundo web y una de las alternativas libres más eficaces en este tema.

Finalmente, ADO.NET, es un conjunto de componentes que permiten acceder a datos y a servicios de datos, a través de un arquitectura completa que facilita enormemente ciertas labores al desarrollador. Está integrado dentro de Mono y existe un conector creado ex profeso para ligar a MySQL con Mono/.NET a través de esta arquitectura. Existen otras alternativas similares como Hibernate que nunca está de más conocer.

public static void Main (string[] args)
{
	MailAddress para = new MailAddress("para@direccion.com");
	MailAddress desde = new MailAddress("desde@direccion");
	MailMessage mensaje = new MailMessage(desde, para);
	mensaje.Subject = "Asunto";
	mensaje.Body = @"Cuerpo del correo";
	SmtpClient cliente = new SmtpClient("direccion_servidor", puerto);
	cliente.Credentials = new System.Net.NetworkCredential
("nombre_usuario", "contraseña_usuario");
	Console.WriteLine("Enviando mensaje de correo para: " + para.User
 + " en " + para.Host + " usando el servidor=" + cliente.Host + ".");
      	try {
	  cliente.Send(mensaje);
	  Console.WriteLine("Mensaje enviado");
	}
	catch (Exception ex) {
	  Console.WriteLine("Problemas enviando mensaje: " + ex.ToString());
	 }
}

Tened en cuenta que estamos trabajando con el espacio de nombres del ensamblado: System.Net.Mail.

Como veis el procedimiento es simple:

1. Se crean dos objetos para las direcciones de correo
2. Se crea el mensaje en sí
3. Se instancia el cliente SMTP, inicializando las credenciales
4. Para finalmente llamar al método de envío

Respondemos las dudas y sugerencias en los comentarios.

Interfaces en lenguajes de programación orientados a objetos

Todos conoceréis las interfaces gráficas de usuario. Son el mecanismo software que nos permite interactuar de manera más o menos intuitiva con unas funcionalidades que nos provee el programa. Es decir, es un mecanismo de comunicar distintos niveles, ocultando los detalles de la implementación.

Eso mismo son las interfaces en lenguajes de programación orientados a objetos como son C# o Java. Se trata de un conjunto de métodos, delegados o eventos, que no tienen implementación. El desarrollo de la funcionalidad de los mismos, se hace en la clase que implementa la interfaz. Es un concepto similar a los prototipos de funciones en lenguajes como C.

Declaración

Siguiendo con el ejemplo de los motores, comentado en la entrega anterior dedicada a la herencia, vamos a crear un interfaz IMotor, a la que luego haremos referencia desde la implementación de la clase. He incluido un método más para que se vean más claras las posibilidades.

interface IMotor
{
	// declaración de propiedades
	int Potencia
	{
      		get;
      		set;
 	}
	decimal Par
  	{
      		get;
      		set;
   	}
	// declaración de métodos
	void printInfo();
	// declaración de eventos
}
public class Motor : IMotor
{
	int potencia;
	decimal par;
	public int Potencia {
		get { return this.potencia; }
		set { potencia = value;	}
	}
	public decimal Par {
		get { return this.par; }
		set { par = value; }
	}
	public void printInfo()
	{
		Console.WriteLine("La potencia es " + Potencia.ToString() + "
                y el par: " + Par.ToString());
	}
}

Como podéis apreciar, la declaración de los interfaces es muy similar a la de una clase, incluyendo la palabra clave Interface. La llamada al interfaz desde la clase que lo implementa se realiza como si de una herencia se tratara.

Los interfaces también soportan herencia por si mismos. El único detalle a recordar, es que en caso de conflicto por duplicidad de nombres (un interfaz hereda de otros interfaces en los que hay un método con el mismo nombre en los dos), hay que hacer referencia explícita a cuál se está llamando:

• interfazA.método()
• interfazB.método()

¿Para qué sirven?

Más que para qué sirven voy a comentar para qué los uso en mis desarrollos. Aunque para clases pequeñas no tenga mucho sentido hacerlo, cuando los objetos cogen cierto tamaño, las interfaces facilitan enormemente la comprobación de errores. Por ejemplo, si se nos ha olvidado definir un método o si hay conflictos de tipos de datos, el compilador nos avisa. Recordad lo cómodo e inmediato que es declarar interfaces, en lugar de las clases directamente, con todo el desarrollo que conlleva.

Al fin y al cabo, es otra forma más de crear un mayor grado de abstracción y poder explotar mejor las posibilidades que nos ofrecen la orientación a objetos.

Entregas anteriores

• Curso C# con Mono – Tratamiento de excepciones
• Curso C# con Mono – Conversión de tipos e información cultural
• Curso C# con Mono – Declaración de clases y estructuras
• Curso C# con Mono – Espacio de nombres y regiones
• Curso C# con Mono – Ensamblados
• Curso C# con Mono – Variables y constantes
• Curso C# con Mono – Tipos de datos y uso de referencias
• Curso C# con Mono – ¡Hola Mundo!
• Curso C# con Mono – Interfaces

¿Qué es la herencia?

En programación orientada a objetos, la herencia es el mecanismo básico para crear nuevas clases (hijas o derivadas), basándonos en clases anteriores (a la que llamaremos padre, base o superclase). La relación es similar a la que se produce en muchas situaciones de la vida cotidiana, por ejemplo en el campo de la biología en las relaciones padre-hijo.

Gracias a este mecanismo, podemos basarnos en clases anteriores, para crear nuevas clases sobre trabajo ya hecho, de forma que extendemos la funcionalidad de la clase padre hacia un campo nuevo, sin tener que volver a reescribir todo el contenido de la misma.

Ejemplos

Hay multitud de casos de este tipo. Por ejemplo, la clase padre excepción, provee unos métodos y atributos generales para todas las excepciones posibles. De ella derivan excepciones concretas, por ejemplo de división entre cero, que además de los métodos y atributos ya existentes, añaden funcionalidad extra, pero reutilizando toda la funcionalidad de la clase padre.

Otro ejemplo clásico es el de los controles de una interfaz gráfica. La clase control es la padre de todo un abanico de clases hijo. La clase control tiene por ejemplo la situación (todos los controles tienen situación) pero cada clase hijo aporta nuevas funcionalidades (por ejemplo, sus propios eventos).

Implementación

Veremos la implementación en C# con un ejemplo concreto. Ya que están tan de moda los vehículos eléctricos, vamos a implementar una serie de clases, con herencia, que reflejen la siguiente realidad:

• Clase padre: motor, tendrá las características propias de toda clase de motores, gestionaremos potencia (entero en kW) y par (decimal en Nm)
• Clase hijo: eléctrico, contendrá información exclusiva de los motores eléctricos, intensidad (entero en amperios), potencial (entero en voltios)
• Clase hijo: de combustión interna, gestionará información de este tipo de motores. Cilindrada (entero en cc.), número de cilindros (entero) y emisiones de CO2 (decimal en gr/km)

public class Motor{
	int potencia;
	decimal par;
	public int Potencia {
		get { return this.potencia; }
		set { potencia = value;	}
	}
	public decimal Par {
		get { return this.par; }
		set { par = value; }
	}
}
public class Electrico : Motor{
	int intensidad;
	int potencial;
	public int Intensidad {
		get { return this.intensidad; }
		set { intensidad = value; }
	}
	public int Potencial {
		get { return this.potencial; }
		set { potencial = value; }
	}
}
public class CombustionInterna : Motor{
	int cilindrada;
	int cilindros;
	public int Cilindrada {
		get { return this.cilindrada; }
		set { cilindrada = value; }
	}
	public int Cilindros {
		get { return this.cilindros; }
		set { cilindros = value; }
	}
}

Como veis la implementación es como la de cualquier otra clase, pero añadiendo los dos puntos y el nombre de la clase padre al declarar a la clase hija. Luego podremos hacer llamadas del tipo:

Electrico a = new Electrico();
a.Potencia = 100;

Clases abstractas

Si incluimos la palabra reservada abstract al declarar la clase padre: abstract class Motor; estamos indicándole a Mono que esa clase no podrá instanciarse. Es decir, podremos crear clases derivadas e instanciarlas, pero nunca crear objetos de la clase padre (en este caso, podríamos crear objetos de Electrico o CombustionInterna, pero no podríamos instanciar Motor).

Métodos virtuales

Si declaramos un método en la clase padre, en la clase hijo no podremos volver a declararlo a no ser que en la clase padre sea del tipo virtual. Para ello, en la declaración del método en el padre utilizaríamos la siguiente estructura:

public virtual void mostrarDatos()

Y en el hijo, al declarar el método haríamos uso de la palabra clave override:

public override void mostrarDatos()

Entregas anteriores

• Curso C# con Mono – Tratamiento de excepciones
• Curso C# con Mono – Conversión de tipos e información cultural
• Curso C# con Mono – Declaración de clases y estructuras
• Curso C# con Mono – Espacio de nombres y regiones
• Curso C# con Mono – Ensamblados
• Curso C# con Mono – Variables y constantes
• Curso C# con Mono – Tipos de datos y uso de referencias
• Curso C# con Mono – ¡Hola Mundo!

¿Qué es una excepción?

Una excepción es una situación anormal que se da a lo largo de la ejecución del programa. El manejador de la excepción, es una estructura de control que permite ejecutar un código de acuerdo a esa situación anormal de forma controlada.

¿Qué tipo de acciones se suelen realizar?

Por un lado tenemos acciones de tipo terminación. En lugar de aparecer un mensaje de error del sistema operativo, el programa mismo lo emite informando de qué va a terminar su ejecución.

Por otro lado, tenemos manejadores que modifican el comportamiento del programa en cierto momento. Para este tipo de acciones, podríamos decir que las excepciones representan más una forma de control del flujo que un recurso de emergencia.

¿Qué otros mecanismos existen para esta misma problemática?

Ejemplos típicos de excepciones son:

• Cuando tratamos de dividir entre cero
• Cuando tratamos de llamar a un método de una instancia que es nula
• Cuando tratamos de convertir una cadena en número y la cadena no tiene formato numérico

Y así podríamos seguir un largo etcétera de posibles excepciones. Como comprobaréis todas estas excepciones, podrían comprobarse como se hace en lenguajes que no tienen este mecanismo: mediante condicionales cada vez que hay una operación que pueda sufrir error. ¿Por qué es mejor usar excepciones?

Ventajas de las excepciones

¿Para qué complicarnos la vida con un nuevo concepto si podemos usar directamente comprobaciones?

1. Separar el código principal del programa, del tratamiento de errores
2. Propagar el error en la pila de ejecución, de forma
3. Agrupar y clasificar los errores

¿Cómo detectar y tratar una excepción con Mono y C#?

Para detectar una excepción en C# usamos la siguiente estructura (veámoslo con un ejemplo):

int a = 1;
int b = 0;
try{
	int c = a / b; // zona protegida
}catch(DivideByZeroException exc){
	Console.Write("Ha intentado dividir desde cero"); // código a ejecutar
}

Como véis, estamos hablando directamente de la excepción de división entre cero. Si queremos controlar cualquier tipo de excepción, sólo tendremos que usar en lugar de DivideByZeroException, la clase de excepciones de la que heredan todas las demás, Exception. También podremos combinarlas, de forma que podamos atender a cierto tipo de excepciones y a cualquier otra que no hayamos controlado.

Veamos un caso de control para un tipo de excepción concreta (la de formato incorrecto) y el control para cualquier otro caso:

string cadena = "2a";
try{
	int valor = int.Parse(cadena);
}catch(FormatException exc){
	Console.Write("Ha ocurrido una excepción por el formato del fichero. Detalles:\n" + exc.Message);
}catch(Exception exc){
	Console.Write("Ha ocurrido otro tipo de error. Detalles:\n" + exc.Message);
}

Entregas anteriores

• Curso C# con Mono – Conversión de tipos e información cultural
• Curso C# con Mono – Declaración de clases y estructuras
• Curso C# con Mono – Espacio de nombres y regiones
• Curso C# con Mono – Ensamblados
• Curso C# con Mono – Variables y constantes
• Curso C# con Mono – Tipos de datos y uso de referencias
• Curso C# con Mono – ¡Hola Mundo!

Esto es lo que se llama la información cultural, que se sitúa dentro del ensamblado: System.Globalization, y que aparte de en este tema es conveniente conocer para otras tareas.

Casting

Es la forma más simple de hacer una conversión de datos. Está directamente heredada de C y puede ser implícita (si no se especifica) o explícita (cuando sí lo hacemos). Tiene grandes limitaciones porque básicamente sólo permite no convertir, sino camuflar, para una instrucción en concreto el tipo de dato.

Veamos un ejemplo:

int i = 10;
float f = 0;
f = i;  // conversión implícita
f = 0.5F;
i = (int)f;  // conversión explícita. Existe pérdida de información, los decimales

Métodos ToString

Al igual que en otros muchos lenguajes de programación, a este nivel de abstracción, existe un método ToString, definido en cada clase, que convierte cualquier objeto en una cadena. Si tenemos un entero que tiene dentro el valor 1, devolverá una cadena “1″; igualmente pasará  con un decimal, pero aquí es donde entra la información cultural en juego. Si tenemos la cultura predefinida como la española, mostrará comas y punto de acuerdo a nuestra forma de hacerlo, si definimos otra cultura predefinida, el comportamiento cambiará conforme a eso. También podemos cambiar de forma puntual la cultura predefinida para un punto en concreto.

Veamos ejemplos de uso avanzado de ToString usando especificadores, para mostrar el mismo número por pantalla con decimales, sin ellos, en formato moneda, con porcentaje…

decimal valor = 16325.62m;
string especificador;
// Sin especificador
Console.WriteLine("Sin el especificador tenemos el valor: " + valor.ToString());
// Especificador numérico estándar
especificador = "G";
Console.WriteLine("Con el especificador: " + especificador + " tenemos el valor: " + valor.ToString(especificador));
// Muestra: 16325,62
especificador = "C";
Console.WriteLine("Con el especificador: " + especificador + " tenemos el valor: " + valor.ToString(especificador));
// Muestra: 16.325,62€
especificador = "E04";
Console.WriteLine("Con el especificador: " + especificador + " tenemos el valor: " + valor.ToString(especificador));
// Muestra: 1,6326E+004
especificador = "F";
Console.WriteLine("Con el especificador: " + especificador + " tenemos el valor: " + valor.ToString(especificador));
// Muestra: 16325,62
especificador = "N";
Console.WriteLine("Con el especificador: " + especificador + " tenemos el valor: " + valor.ToString(especificador));
// Muestra: 16.325,62
especificador = "P";
Console.WriteLine("Con el especificador: " + especificador + " tenemos el valor: " + valor.ToString(especificador));
// Muestra: 1.632.562,00%

Veamos un ejemplo de uso con información cultural (CultureInfo):

System.Globalization.CultureInfo culture  = new System.Globalization.CultureInfo("EN-us");
Console.WriteLine("Cambiando a cultura de inglés de Estados Unidos tenemos: " + valor.ToString(culture.NumberFormat));
// Muestra: 16325.62

Existen objetos, que a pesar de tener un método de este tipo, la cadena que devuelven no contiene prácticamente nada de la información del objeto. Por ejemplo, si tenemos un DataTable y le invocamos el método ToString, probablemente la salida sea sólo que es una instancia del tipo de objeto DataTable.

Métodos Parse

Podríamos decir que las funciones Parse, son la funciones inversas a los métodos ToString. A diferencia de los primeros, de una cadena, son capaces de leer su contenido y plasmarlo en un tipo de dato concreto, por ejemplo, de cadena a entero.

En C existían unas cuantas funciones que hacían esa misma labor: atoi, atol…. Además de ser verdaderamente útiles en interfaces gráficos y web, recordad que los datos que introducen los usuarios suelen venir en formato cadena, por la propia constitución de este tipo de interfaces.

Además son verdaderamente útiles cuando tratamos con tipos de datos a los que no podemos hacer casting directamente, ya que la solución más práctica es hacer un ToString seguido de un Parse.

Veamos ejemplos:

string valor = "1";
int a = int.Parse(a);
Console.WriteLine("El valor de a es: " a.ToString());

Como podréis imaginar, si queremos pasar datos decimales con comas y puntos de tal manera o de tal otra, también deberemos usar en este punto la información cultural.

Nos vemos en la próxima entrega.

Entregas anteriores

• Curso C# con Mono – Declaración de clases y estructuras
• Curso C# con Mono – Espacio de nombres y regiones
• Curso C# con Mono – Ensamblados
• Curso C# con Mono – Variables y constantes
• Curso C# con Mono – Tipos de datos y uso de referencias
• Curso C# con Mono – ¡Hola Mundo!

Podríamos decir a muy grosso modo que:

• Las clases son la unidad básica de estructuramiento en un programa de C#
• Las estructuras son una herencia de lenguajes más antiguos, como C, donde creamos un grupo común para varias variables, sin atribuirles posibilidades de ejecución (métodos)

En C#, las estructuras pueden tener métodos básicos para la lectura o modificación de las variables.

¿Cómo crear una clase?

Digo cómo crear y no cómo declarar una clase, porque el curso está basado en MonoDevelop y tras crear una clase con el interfaz, veremos cómo se declara en el código.

Dentro del espacio de nombres, a la izquierda de la interfaz, hacemos: clic derecho, “Añadir”, “Nuevo archivo”, “Clase vacía” e indicamos el nombre. Se nos creará un esqueleto básico de clase como el que sigue:

using System;
namespace holaMundo
{
	public class persona
	{
		public persona ()
		{
		}
	}
}

Veamos ahora la clase un poco más rellena. Como veréis, estoy dentro del mismo espacio de nombres en el que hemos hecho los ejemplos anteriores, “holaMundo”. Incluimos: atributos, métodos para manejar los atributos, el constructor y un método de ejemplo.

using System;
namespace holaMundo
{
	public class persona
	{
		// atributos
		string nombre;
		int edad;
		// propiedades: métodos para manejar los atributos
		public string Nombre {
			get { return nombre; }
			set { nombre = value; }
		}
		public int Edad {
			get { return edad; }
			set { edad = value; }
		}
		// constructor
		public persona (string _nombre, int _edad)
		{
			// usamos los métodos para manejar atributos en lugar de this.nombre
			Nombre = _nombre;
			Edad = _edad;
		}
		// método para imprimir datos de la instancia
		public void print()
		{
			System.Console.WriteLine("Nombre: " + nombre + " - Edad: " + edad.ToString());
		}
	}
}

Aunque la sintaxis os resultará bastante familiar si habéis trabajado con lenguajes como Java o C++, hay alguna curiosidad que querría comentar:

Los getter y setter, también llamadas propiedades, son unos métodos que se encargan de interactuar con los atributos, sin necesidad de usar los típicos y molestos: getVariable() y setVariable(valor). Se integran muy bien en el código y al hacer llamadas del estilo Edad = algo o algo = Edad, se llamarán de forma automática.

MonoDevelop crea las cases automáticamente como public, de esta forma puede tenerse acceso desde fuera de su ensamblado.

Los atributos de las clases también pueden tener diferentes niveles de acceso. Por defecto, si no se indica es private. Veamos las diferencias entre ellos:

• public: Accesible desde otras clases. No recomendable, mejor private y con propiedad para tener acceso desde fuera.
• protected: Hace que el atributo sea accesible directamente desde otras clases derivadas de aquella en la que está declarado, pero no desde el resto.
• private: Opción por defecto. La variable sólo será accesible desde su propia clase.
• internal: Sólo accesible desde el propio ensamblado.

Como he dicho, hay muchas más opciones y mucho más que comentar en este apartado, pero si conocéis orientación a objetos, con esto tendréis suficiente.

De todas formas, vía comentarios, responderé posibles dudas que puedan surgir .

Estructuras

Antes de terminar, haremos una breve introducción a este tipo de mecanismo, que usamos para agrupar distintas variables en torno a una unión común, sin aportar ningún tipo de método para su manejo (esto las distingue directamente de las clases), pero a diferencia de lenguajes más antiguos, permitiendo que tengan variables privadas y propiedades para su manejo.

Veamos cómo se declaran y cómo se hacen llamadas a sus miembros:

public struct direccion{
	string calle;
	int numero;
	char letra;
	public string Calle{
		get { return calle; }
		set { calle = value; }
	}
	public int Numero{
		get { return numero; }
		set { numero = value; }
	}
	public char Letra{
		get { return letra; }
		set { letra = value; }
	}
}

Las llamadas las haremos a las propiedad, que podemos cambiarlas si nos interesan en el código anterior con funciones más complejas, llamadas a BB.DD., etc.; en definitiva, con lo que necesitemos.

direccion personal;
personal.Calle = "Avenida sin nombre";
personal.Numero = 6;
personal.Letra = 'C'

Entregas anteriores

• Curso C# con Mono – Espacio de nombres y regiones
• Curso C# con Mono – Ensamblados
• Curso C# con Mono – Variables y constantes
• Curso C# con Mono – Tipos de datos y uso de referencias
• Curso C# con Mono – ¡Hola Mundo!

Espacios de nombres

Los espacios de nombres o namespaces, son la forma de organizar dentro del código, las clases y funciones de cara a una funcionalidad. Están directamente relacionados con los ensamblados, ya que los ensamblados definen en sí mismos, un espacio de nombres y a su vez pueden contener una serie de ellos.

Cada vez que creamos un proyecto con Mono Develop, se nos crea de forma automática un espacio de nombres para el proyecto, del que colgarán secciones de forma jerárquica cuando el proyecto vaya creciendo.

Para ver qué funciones, clases o qué otros espacios de nombres, podemos directamente hacer lo siguiente. Escribimos el nombre de espacio de nombres (por ejemplo System) y justo tras él, un punto, automáticamente el IDE nos mostrará una lista de posibilidades.

A continuación podéis ver el desplegable. Perdonad por las transparencias pero los efectos gráficos de Compiz al hacer tomas de pantalla con desplegables, juegan estas malas pasadas.

Regiones

Otra forma de organizar el código, aunque no de manera formal, sino de cara al desarrollador es mediante regiones. Hace unos meses ya escribí una entrada sobre eso, así que os dejo la referencia directamente.

Entregas anteriores

• Curso C# con Mono – Ensamblados
• Curso C# con Mono – Variables y constantes
• Curso C# con Mono – Tipos de datos y uso de referencias
• Curso C# con Mono – ¡Hola Mundo!