Diccionario serializable

Desde hace un tiempo vengo disfrutando de las ventajas ofrecidas por el tipo de datos Dictionary, más tarde descubrí el SortedDictionary, pero los diccionarios en C# siempre han tenido un punto débil: La serialización.

Navegando por Internet he encontrado un código muy útil para solucionar esto: el XML Generic Serializable Dictionary

A disfrutarlo!!

Publicada la Parallel.FX CTP (Junio 2008)

Ya está disponible para descarga la última versión de Parallel.FX (Community Technology Preview junio 2008). Como suele ser costumbre, incluye bastantes mejoras sobre su predecesora, así como incluir nuevos fallos y problemas.

Algunas Nuevas Características de C# 3 (Visual Studio 2008)

Como algunos ya sabeis, Visual Studio 2008 viene con el .NET Framework 3.5, que incluye una buena cantidad de mejoras y novedades con respecto al framework 2.0 que viene con Visual Studio 2005. Algunas de esas características forman parte del trabajo realizado para Windows Vista, pero hay muchas otras de igual o mayor interés para los desarrolladores.

Variables sin tipo, tipos anónimos e inicializadores de objeto:

¿Qué pasa si necesitas un sitio donde guardar información pero no sabes a priori de qué tipo? Fácil, declaras la variable sin especificar su tipo y permites que sea C# quien determine el tipo real de los datos que vas a almacenar.
Por ejemplo, si queremos tener un diccionario que indexa una lista de enteros en base a una cadena (de forma similar a los arrays asociativos que existen en PHP) podríamos hacerlo así:

// Framework 2.0:
Dictionary <string , List<int>> ejemplo = new Dictionary </string><string , List<int>>();
// Framework 3.0:
var ejemplo = new Dictionary </string><string , List<int>>();

Por supuesto, tenemos que inicializar la variable sin tipo en cuanto la declaremos, para que el compilador pueda decidir en tiempo de compilación qué tipo tendrá la variable, ya sea un tipo predefinido como int, una clase creada por el usuario, o un tipo anónimo (hablo sobre ellos un poco más adelante).

De la misma forma se pueden declarar arrays sin tipo, como en el siguiente ejemplo:

// En este caso se crea un array de tipo Int32 con los elementos indicados.
var potenciasDeDos = new [] {2, 4, 8, 16, 31, 64, 128, 256, 512};

Los tipos o clases anónimas, por definición, no tienen nombre. Eso significa que se pueden considerar como definiciones de clase de usar y tirar. La verdadera importancia de estos “tipos anónimos” aparece cuando consideramos LINQ, Language INtegrated Queries, ya que dependiendo de la consulta que realicemos, obtendremos unos datos u otros, de forma que C# lo que hace es crear una clase anónima con los campos devueltos por la consulta LINQ para que se pueda acceder a ellos fácil y rápidamente.

Un tipo anónimo se define así:

var cosa = new {
    Name = "Botellín de Guiness",
    Price = 1.57,
    Description = "Un mal sustituto de una auténtica Guiness, servida de barril en varias tiradas."
};

Como se puede ver, hemos usado una declaración sin tipo para inicializar un conjunto de datos con aspecto de objeto de forma que el compilador entiende que es un objeto, pero al no pertenecer a una clase definida, el compilador lo define automáticamente como objeto de tipo anónimo.

Además, se presenta otra característica interesante: hemos inicializado los valores de los atributos de clase sin necesitar un constructor. Esto es lo que se conoce como inicializadores de objeto, y básicamente permiten asignar el valor que queramos a un objeto de cualquier tipo que haya sido creado usando el constructor por defecto. A continuación veremos un par de ejemplos de cómo usar los inicializadores de objeto para simplificar la escritura del código:

//Inicialización de un objeto con C#2
Cerveza botellin = new Cerveza();
botellin.marca = "Guiness";botellin.temperatura = 5;
botellin.caducidad = Datetime.Now.AddYears(2);
CajaCerveza.Add(botellin);

//Inicialización de un objeto con los inicializadores en C#3
Cerveza botellin = new Cerveza() {
    marca = "Guiness",
    temperatura = 5,
    caducidad = Datetime.Now.AddYears(2)
};
CajaCerveza.Add(botellin);

//O también podemos hacer esto:
CajaCerveza.Add(new Cerveza() {
    marca = "Guiness",
    temperatura = 5,
    caducidad = Datetime.Now.AddYears(2)
});

Expresiones Lambda:

Expresión Lambda suena a forma terrorífica de arte abstracto, pero en realidad es una forma de decir “función anónima”. En C#3 las funciones anónimas se escriben con el operador “=>” , de forma que lo que queda a la izquierda del operador son los parámetros, y lo que queda a la derecha es el cuerpo de la función anónima. Por ejemplo:

x => x+1;
() => return new SalirATomarGuiness();
(x, y) => {
    var suma = x + y;
    return suma;
}

Las ventajas proporcionadas por esta sintaxis pueden no ser evidentes, a no ser que comparemos lo que pasa entre C#2 y C#3:

//Tenemos una lista de palabras
var palabras = new List</string><string> { "mola", "Guiness", "tomar", "me" };
//Ordenar por longitud de palabra, al estilo C#2
Words.Sort(delegate(string a, string b)
{
    return a.Length.CompareTo(b.Length);
});
//Ordenar por longitud de palabra, al estilo C#3
palabras.Sort((a, b) => a.Length.CompareTo(b.Length));

// Show results.
foreach (string palabreja in palabras)
    Console.Write(palabreja + " ");

La salida es “me mola tomar Guiness” en ambos casos. Como podemos ver, el uso de estas funciones anónimas es mucho más sencillo que el tradicional uso de delegados, y además, dependiendo de la situación, ¡nos podemos ahorrar el tener que declarar un delegado como atributo de clase! Además, nos fijamos en que no declaramos tipo al crear el método anónimo, ¿adivinamos por qué? (pista: mirar sección anterior 😛 )

Bueno, este post está siendo más largo de lo que me gustaría, así que dejaré el tema de LINQ (y cómo explota los tipos anónimos, expresiones Lambda y etc) para otro día.

Revelado RAW

Las inmensa mayoría de las cámaras DSLR (Digital Single Lens Reflex) ofrecen guardar las imágenes en un formato especial, genéricamente denomidado RAW. Este formato guarda toda la información sobre la luz que captura el sensor en el momento de la captura, lo que permite realizar posteriormente un proceso de revelado digital.

Las imágenes RAW normalmente no se pueden manipular directamente, sino que deben ser transformadas en un formato reconocible por el pc (generalmente JPEG). Es en este proceso de exportación donde entra en juego la potencia del formato RAW. Algunas de las características más básicas ofrecidas por el mismo es un completo control del balance de blancos después de tomar la foto, o modificar la exposición de la misma para ajustar zonas infraexpuestas o sobreexpuestas.

Otra utilidad interesante del formate es la generación de imágenes HDR a partir de una única fotografía (en realidad es un pseudoHDR) gracias a la capacidad de modificar la exposición de la imagen, lo que permite revelar con múltiples exposiciones a partir de una única imagen.

El archiconocido Photoshop puede abrir y manejar imágenes RAW, pero para los aficionados al software libre, existe un programita llamado UfRAW que funciona de forma independiente (únicamente revelado) tanto como importador de imágenes RAW para GIMP. Hay que tener cuidado, porque este programa puede alterar la información de la imagen RAW original de forma que no se pueda visualizar desde la cámara (al menos es lo que me pasa con el formato raw NEF que usa mi Nikon D40).

Publicado en Fotografía. Etiquetas: , , , , . 2 Comments »

5555

Otro hito superado 🙂 5555 visitas a poco más de medianoche (hora local), ya a día 25 de abril de 2008, esta importante fecha en la que me toca defender el DEA.

Como suele ser habitual en mí, aunque los nervios hacen gala de su ausencia, una extraña inseguridad y desasosiego se arraigan en mi pecho. Sé que he realizado un buen trabajo, avalado por dos publicaciones en revistas internacionales así como tres congresos (uno nacional, dos internacionales), he escrito una buena memoria, he preparado unas buenas transparencias, he ensayado algunas veces (la mayoría de ellas mentalmente)… y aun así el fantasma del fracaso sigue planeando sobre mí.

Únicamente cuando haya superado este trámite seré capaz de decir ¡Sí, puedo ser doctor! Hasta entonces sólo me queda… esperar.

Publicado en Opinión, Personal. Etiquetas: , , . 2 Comments »

Nikon D40

Todo el mundo tiene un hobby, algunos lo encuentran antes, otros después, y otros cambian de idea a lo largo del tiempo.

En cualquier caso, la fotografía se ha convertido en uno de mis hobbies más interesantes. Aún me hallo en el nivel principiante, pero ya comprendo algunas de las utilidades de la apertura, enfoque, zoom, tiempo de exposición, sensibilidad ISO, y algún otro término que haya olvidado.

Ya sólo me falta poner en práctica mis nuevos conocimientos con mi flamante Nikon D40 (Análisis por Ken Rockwell, un angloparlante que goza de bastante respeto entre la gente que busca información sobre cámaras), una de las cámaras más usadas en Flickr, y al parecer favorita del público (por ejemplo, está sobreviviendo a la que debería haber sido su sucesora, la Nikon D40X).

He comprado el kit de Cuerpo Nikon D40 con el objetivo de 18-55 mm estándard, y que además incluye como “obsequio” la funda semirrígida de transporte, una tarjeta SD de 2 gigas y un trípode (de aspecto bastante endeble) de 87 cm de alto.

Como características principales de la misma destacar un tiempo de apertura entre 30 segundos y 1/4000 segundos, con un tiempo de sincronización mínimo del flash de 1/500 (esta cifra es bastante impresionante y ayuda a conseguir mejores fotos), captura en ráfaga a 2.5 fotos por segundo (depende también del tiempo de exposición elegido), un modo manual alucinante, y sobre todo, es una cámara réflex.

Poco a poco aparecerán más fotos en mi cuenta de flickr, pero mientras tanto, aquí hay un par de las que he tomado con la D40:

A small world In the name of the rose

¿Se nota mucho que me gusta disparar las fotos en macro con ajuste manual para luego revelar el archivo RAW con la exposición y balance de blancos más adecuado?

Publicado en Fotografía. Etiquetas: . 6 Comments »

Cómo enviar un email con C#

mailer
Algunas veces hemos necesitado que una aplicación nos mande un correo, ya sea porque hemos hecho un servidor y necesitamos que se nos notifique de algún evento con urgencia, o porque tenemos un programa ejecutándose un servidor (o supercomputador) en algún otro país realizando cómputos que puedan tardar horas o días y un simpático email diciendo “trabajo terminado” es una buena forma de saber que los datos procesados están listos. O porque tenemos un programita vigilando quién se sienta al pc, y en cuanto la webcam detecte movimiento se captura una foto y hace falta mandarla por correo.
Sea lo que sea, enviar un correo electrónico con .NET es una labor realmente sencilla. Simplemente hay que hacer una ventanita similar a la de la imagen que acompaña este artículo.
Y el código fuente que la alimenta es el siguiente:
using System;
using System.Windows.Forms;
using System.Net;
using System.Net.Mail;

namespace mailExample
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        //Evento para cuando pulsamos el botón "enviar"
        private void button1_Click(object sender, EventArgs e)
        {
            //La cadena "servidor" es el servidor de correo que enviará tu mensaje
            string servidor = "un.servidor.smtp.válido";
            // Crea el mensaje estableciendo quién lo manda y quién lo recibe
            MailMessage mensaje = new MailMessage(
               emisor.Text,
               receptor.Text,
               asunto.Text,
               mensaje.Text);

            //Envía el mensaje.
            SmtpClient cliente = new SmtpClient(servidor);
            //Añade credenciales si el servidor lo requiere.
            cliente.Credentials = CredentialCache.DefaultNetworkCredentials;
            cliente.Send(mensaje);
        }
    }
}