 | Phosphoros en Creacionismo vs. Evolucionismo… |
 | pacm en Detección de la inserción de u… |
 | paulina en Nuestros jóvenes de hoy en… |
 | Carlos en Detección de la inserción de u… |
 | Antonius en Nikon D40 |
Club.NET AlmeríaDesde 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!!
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.
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.
¿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)
});
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.
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).
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.
Tempus Fugit 