Enviar correos con C# usando Mono

Si necesitáis conectaros a un servidor SMTP para hacer envíos de correos desde una aplicación que corre Mono, os dejo el código siguiente que seguro que os es de utilidad. Este ejemplo en concreto envía un mensaje usando un SMTP que requiere autenticación, si necesitáis alguna variantes: varios destinatarios, SMTP sin autenticación o cualquier otra cosa, ¡preguntad en los comentarios!

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()); } } read more

Leer más » 5 Comentarios

Curso C# con Mono – Interfaces

Si la última vez que hablamos de C#, estuvimos comentando la herencia, hoy hablaremos de las interfaces.

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()); } } read more

Leer más » 8 Comentarios

Curso C# con Mono – Herencia

Siguiendo con características propias de los lenguajes de alto nivel con orientación a objetos, llegamos a la herencia.

¿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; } } } read more

Leer más » 8 Comentarios

Curso C# con Mono – Tratamiento de excepciones

Una característica común a este tipo de lenguajes de alto nivel, es la presencia del manejo de excepciones. read more

Leer más » 5 Comentarios

Curso C# con Mono – Conversión de tipos e información cultural

Cuando estamos trabajando con diferentes tipos de datos, siempre conviene conocer los mecanismos para convertir un tipo de datos en otros. Si a eso le sumamos, que podamos hacer aplicaciones en las que se trabaje introduciendo datos siguiente el formalismo español (comas para separar decimales, puntos para separar miles) o viceversa (podéis ver un mapa de dónde se usa cada separador decimal aquí).

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% read more

Leer más » 6 Comentarios

Curso C# con Mono – Declaración de clases y estructuras

Llegados a este punto, podríamos hablar tan profundamente y durante tanto tiempo sobre clases, objetos, métodos, atributos… que desvirtuaría el sentido de este curso. Supongo que tenéis nociones básicas de todo este paradigma de la orientación a objetos y veremos cómo implementar clases en C# con Mono.

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.

Declaración de nueva clase con MonoDevelop

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()); } } } read more

Leer más » 9 Comentarios

Curso C# con Mono – Espacio de nombres y regiones

El otro día hablábamos de cómo se organizaba el código ejecutable dentro de los ensamblados, a los que podíamos referir dentro de nuestro proyecto de forma inmediata con Mono Develop. Imaginemos que acabamos de hacer referencia al conector de MySQL para Mono/.NET y queremos usar su funcionalidad en nuestro código. ¿Cómo se organizan los ensamblados, las clases y las funciones en el código? La herramienta básica para esta labor son los espacios de nombres.

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. read more

Leer más » 7 Comentarios

Curso C# con Mono – Ensamblados

En todas las tecnologías de este tipo, existen mecanismos para proveer al usuario de métodos que permitan incorporar funcionalidades de ficheros externos. Ésto, unido a la orientación a objetos, crea un problema: cómo organizar y referenciar todas las clases (ya hablaremos de clases más profundamente), de una forma sencilla y que no dé lugar a incoherencias.

Ensamblados

Para resolver este problema, la estructura en Mono (y en .NET) los ensamblados. Éstos pueden ser tanto ejecutables (con extensión .exe), como de librería (con extensión .dll). Ambas extensiones son una herencia de las tecnologías Microsoft desde los tiempos del MS-DOS. Los ensamblados son ficheros en donde se encuentran, compiladas en su lenguaje intermedio, una serie de clases. read more

Leer más » 5 Comentarios

Curso C# con Mono – Variables y constantes

En la última entrega, la semana pasada, hablábamos de tipos de datos y cómo hacer referencias a variables, sin embargo, no hemos hablado todavía de ellas. read more

Leer más » 14 Comentarios

Curso C# con Mono – Tipos de datos y uso de referencias

Seguimos el curso de C# con Mono profundizando algo más en el lenguaje. Si la semana pasada hablábamos de cómo poner todo en marcha y ejecutar el típico ¡Hola Mundo! esta semana veremos cómo tratar con condicionales, iteradores y operadores.

La idea de este curso no es hablar de qué es una iteración, ni siquiera profundizar en los aspectos más detallados del uso; sino dar unos conceptos breves pero importantes, para que podáis profundizar vosotros mismos.

Introducción

Al igual que en todos los lenguajes en C# existen los tipos de datos. Se tratan de una forma muy similar a Java y como nota destacable sólo comentaré que:

  • El carácter por defecto, char, es UNICODE. Es decir no ocupa 8 bits, sino 16, y puede manejar todo tipo de símbolos (acentos, eñes, etc) por defecto.
  • Si vienes de C y buscas utilizar enteros: 0 y distinto de 0 (falso o verdadero), el tipo bool es la herramienta para hacerlo.
  • Además de los tipos de datos de C# al completo, siempre podrás almacenar en variables referencias a objetos, vectores, etc. o incluso a tipos de datos básicos.

Para pasar referencias a funciones de tipos de datos básicos usamos las palabra claves out y ref (ahora veremos el uso de ambas). Esta es una diferencia relevante con Java, donde las variables de tipos de datos básicos se pasan siempre por valor.

Dualidad objeto/tipo de dato

Al igual que ocurre en Java, los tipos de datos básicos corresponden en realidad a clases. Por ejemplo, el tipo de dato float es en realidad una abreviatura para instanciar la clase System.Single.

Veamos un ejemplo:

float a;
System.Single b = new System.Single();

Estamos declarando, dos variables para almacenar valores en punto flotante de precisión simple de formas. La variable a la declaramos al estilo C y la variable en realidad representa a una instancia de la clase System.Single.

Si dentro de los using tenemos declarado el espacio de nombres System, se puede hacer directamente: Single b = new Single().

Utilización del parámetro out

Veamos directamente sobre un ejemplo el uso del parámetro out. Inicializaremos dos variables a 0, llamaremos a una función donde variaremos su valor. Tras la asignación volvemos a leer el valor de las variables y comprobamos que han cambiado.

Veamos el código:

public static void Main (string[] args)
{
	int a = 0;
	int b = 0;

	Console.WriteLine("Valor de: a = {0}, b = {1}
        antes de llamar a la función", a, b); 

	probarOut(out a,out b);

	Console.WriteLine("Valor de: a = {0}, b = {1}
        tras llamar a la función", a, b);
}

public static void probarOut(out int a, out int b)
{
	a = 100;
	b = 200;
}

Dentro de la función probarOut no hemos intentado leer las variables porque no sería posible. Si queremos hacerlo, de forma similar a lo que haríamos con & en C, debemos usar ref.

El parámetro out se usa en algunas funciones de conversión de datos, por ejemplo, TryParse.

Utilización del parámetro ref

Para terminar con este artículo, veremos el uso de la palabra reservada ref. Haremos una función que intercambie el valor de dos enteros. Previamente los inicializaremos, los imprimimos por pantalla y tras comprobar la llamada a la función, volvemos a imprimir por pantalla para comprobar que su valor ha cambiado.

Veamos el código:

public static void Main (string[] args) { int a = 1; int b = 2; Console.WriteLine("Valor de: a = {0}, b = {1} antes de llamar a la función", a, b); intercambiar(ref a, ref b); Console.WriteLine("Valor de: a = {0}, b = {1} tras llamar a la función", a, b); } public static void intercambiar(ref int a, ref int b) { int tmp = b; b = a; a = tmp; } read more

Leer más » 9 Comentarios