Bueno, ante una triste noticia, nuevamente me cambio de blog , WordPress ha sido bueno hasta ahora, pero buscando un poco más de flexibilidad he decidido levantar un nuevo espacio usando BlogEngine.Net (yep, si en su mayoría escribo de .Net porqué no usar una plataforma en .Net?). Seguiré blogeando de lo que me gusta, de lo que me interesa y de lo que quiero seguir anotando para acordarme más tarde.

Los espero en mi nuevo espacio (http://www.cristianprieto.com), no se si seguiré haciendo crossposting a este espacio así que mejor hagan un update a sus marcadores y a sus RSS feeds.

The blog is dead… Long life the blog!!!

No suelo publicar sobre esto, pero hace unas horas jugando Quake 4 en el level en que peleas con el boss del Network Security Installation (creo que es el level 29) me topé con esto algo extraño después de aniquilarlo:

Alguien tiene idea de que rayos es eso? (ojo, las llamas supongo que son las de los propulsores que usaba el Boss y luego de eliminado siguen funcionando!)

Aunque esta un poco fuera de lo habitual y se que tengo que continuar con mi serie sobre estructuras bien formadas, esto es algo que anoto para que no se me vuelva a olvidar. Como muchos saben suelo usar Subversion para el control de código fuente (o sea como SCM), aunque no es del todo mi agrado usar Subersion no me queda mucho por escoger en mi oficina, bueno, de eso no se trata el post.

Algunos quizás sepan que hay webapps para poder ver los repositorios de Subversion en el browser y así revisar nuestro repositorio, algunos de ellos son Trac (que es más que un simple repo browser), ViewCV y WebSVN (este último en PHP y usado por su simpleza para ver repositorios en SVN), aquí en la oficina usamos WebSVN para la colección de repositorios, pero si hay algo que irrita de WebSVN es su total incapacidad para resaltar texto en C# o VB.net.

WebSVN no resalta el código en estos lenguajes debido a que depende de Enscript para el resaltado de texto; enscript no posee archivos de sintaxis para C# o VB.net (realmente si tiene para C# pero es realmente malo, nisiquiera resalta palabras claves como namespace o partial). Recuerdo que en la oficina un día aburridos hicimos un paster en Python usando Pylons y para resaltar texto empleamos Pygments, una excelente framework de resaltado de código fuente. Pygments puede usar la línea de comandos para resaltar texto mediante pygmentize así que decidí reemplazar el segmento de código en WebSVN que resalta el código y que en vez de enscript usara pygmentize.

Revisando el código de WebSVN fue algo dificil, el código es algo enmarañado, algo así al estilo de programadores de PHP a quienes les encanta ver acumulaciones de if en el código fuente, bueno, por lo menos no mezclaban HTML con PHP, algo es algo. Luego de revisar el código di como cambiar el resaltado a pygments y resaltar código en VB.net y C#.

En su instalación de WebSVN agreguen soporte para C# y VB.net modificando el archivo include/setup.php, busquen la línea que reza:

$extEnscript = array =
(
    '.ada'   => 'ada',

Y agreguen donde quieran (claro, antes que cierre la declaración del arreglo) lo siguiente:

   '.cs'  => 'csharp',
   '.vb'  => 'vbnet',

Luego de eso cambiemos de enscript a pygmentize, primero instalemos Pygments, esto es un paso simple (tomando en cuenta que instalaron WebSVN), la documentación esta en el sitio de Pygments.

Ahora busquemos el archivo include/svnlook.php y lleguemos a la línea que reza lo siguiente:

$config->enscript." --language=html".
($l ? "--color --pretty-print=$l" : "")." -o - | ".

En mi instalación particular de WebSVN esta en la línea 584 aproximadamente. Ahora cambiemosla por algo mas simple: (ya sea comentando la anterior o borrandola)

"pygmentize -f html -l " . $l . " -O noclasses=1,style=colorful");

Listo, ahora WebSVN resaltará el código usando Pygments y no tendrá problemas con nuestro VB.net o C#, simple no?

Cómo muchos recordaran soy “algo fanático” de Opera (el browser) y también muchos ya habrán escuchado de Silverlight, también recordaran que Microsoft anunció soporte para multibrowser y multiplataforma (actualmente funciona en Windows y Mac, tanto en Internet Explorer, Firefox y Safari) y en Linux Icaza y sus amigos estan trabajando en Moonlight para brindar soporte en Linux (algo que a lo que veo va bastante avanzado). Recuerdo también en la primera presentación de Silverlight en el Mix07 la imagen del poster (el cual tengo en la oficina) donde aparece Opera como uno de los browsers soportados, pero que si hasta el sol de hoy no he visto que nativamente funcione Silverlight en Opera como si nada. Cada vez que tengo que ver un demo me veo en la obligación de abrir mi IE7 más cercano para verlo.

Según estube leyendo y averiguando, realmente el modelo de plugin de Opera es muy similar al de Netscape, por lo que sus plugins son compatibles en cierta manera, esto es aprovechado por Opera para usar los plugins de Flash, Quicktime y similares. Qué pasó entonces con Silverlight? si hay para Mozilla Firefox porqué no para Opera?, sigo leyendo y me doy cuenta que en realidad el problema radica en el script de activación de Silverlight (un JS que detecta el browser y toma las acciones correspondientes) y aunque “teóricamente” debería funcionar con Opera, este no esta en la lista. Sigo buscando en internet y encuentro esto, un fanático de Opera escribe un UserScript (una facilidad que tiene Opera, puedes decirle que cada vez que abra una página ejecute un script) que se encarga de modificar el script de Silverlight para que “haga compatible” Opera. Lo único que hay que hacer es lo siguiente:

• Instalar Silverlight
• Irse a la carpeta dónde se instaló Silverlight (Program Files\Microsoft Silverlight)
• Copiar su contenido a la carpeta de plugins de Opera (Program Files\Opera\program\plugins)
• Bajar este userscript y copiarlo hacia la carpeta de tus userscripts (yo lo copie hacia Users\cristian\App Data\Roaming\Opera\profiles\Silverlight) y uso Vista Business
• Reiniciar Opera y probar!!!

Entra a tu sitio Silverlight favorito y prueba, hago la aclaración, Opera esta trabajando en hacer su browser más compatible con Silverlight, espero que eso lo logré para la versión 9.5, actualmente uso la 9.26 y con algunos sitios TRUENA después de unos momentos, porqué? no tengo idea…. Lo importante es que con otros funciona sin muchos problemas, fuera de los que se mencionan en este post.

Saludos y espero que les sirva este post a mas de alguien!

Hace un rato alguien me preguntó el caso específico en el cual el necesitaba separar la configuración del archivo del resto del archivo de configuración (sea web.config o app.config), y no sabía como hacerlo con la EntLib. Bueno, realmente es una facilidad que no solamente tiene la EntLib sino la configuración de la aplicación y permite dividir el archivo de configuración en varios archivos independientes, es lo equivalente a hacer un include de un archivo externo al archivo de configuración.

Para hacerlo es realmente sencillo, el archivo de inclusión NO necesita tener la extensión .config o llamarse de una manera en especial, pero es recomendable ya que así Visual Studio sabe que tipo de archivo es al momento de editarlo. Por ejemplo, guardemos la cadena de conexión en un archivo separado del resto:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <connectionStrings file="connection.config" />
  <!-- aqui va el resto de cosas que vamos a configurar -->
</configuration>

Y el archivo externo (connection.config) tendría la siguiente forma:

<connectionStrings>
<!-- aqui van la cadena de conexion configurada -->
</connectionStrings>

Solamente noten la limitante, el archivo externo debe tener como encabezado o nodo raíz el nodo referente en el archivo principal de conexión, eso involucra primeramente que nuestro archivo externo no debe comenzar con el familiar xml descriptor tag. Intersante no?

Para alguno de ustedes que tengan una copia reciente de Visual Studio 2008 y hayan instalado el release de Febrero 2008 de GAT/GAX para Visual Studio 2008, quizás se hayan topado con la sorpresa al tratar de instalar la EntLib3.1 de Mayo 2007 que no los dejaba, dejando solamente un críptico error con código 2869 y dos ventanas sin ningun mensaje. Claro como el agua verdad?, bueno, el error es al parecer debido al GAT de Febrero, la forma más simple y sencilla de arreglarlo es dandole uncheck a las opciones de la AppBlock Factory GP y al Sign GP, con eso no tendremos las factories para hacer nuestros propios AppBlocks, pero al menos tendremos la EntLib .

Grigori Melnik, el arquitecto y program manager para la Enterprise Library y del grupo de Patterns and Practices ya anunció la fecha oficial de salida de la Enterprise Library 4.0 (por lo menos la CTP) y la release final de Unity, el IoC de Microsoft con capacidad para integrarse con otros IoC como Sprint.NET y Windsor. Según estoy leyendo para el 15 de Marzo (release de Unity y del CTP de la EntLib4) esta versión de la EntLib no poseerá integración con Unity, sino hasta la versión final a finales de Abril. Los dejo con la noticia original en este link.

Recuerdo que a finales del año pasado cuando hablaba sobre generalidades de Windows Vista programming (un tema que como muchos se dieron cuenta me encanta ) alguien preguntó: “El transaction File System de Vista tiene que ver algo con el lento copiado de archivos de Windows Vista?”. Bueno, aunque he leído uno que otro poco sobre Vista Internals realmente en la red he encontrado todo tipo de explicaciones sobre el lento copiado de Windows Vista.

Soy franco al decirles que nada de lo que había leído sobre la velocidad de copiado de Windows Vista me había convencido, fue hasta cuando encontré hace ya varios días esta entrada de Mark Russinovich (de la reputación de Sysinternals) sobre las mejoras de copiado de archivos en el Vista Service Pack 1, y junto con ella la explicación del porqué en el pre-SP1 es tan lento.

En realidad leyendo el artículo me di cuenta que NO es que Windows XP sea más rápido copiando el archivo, simplemente al ser no cachada la copia del archivo el Explorer ignora la copia del archivo y destruye el cuadro de diálogo antes de que realmente el archivo sea copiado. Interesante no?

Aun no corro el SP1 de Vista, pero creanme que con joyas técnicas como estas estoy impaciente por instalarlo!

En la última entrega estubimos hablando de igualdad entre clases y como afectaba nuestra concepción de objetos, usamos para eso una clase simple con una coordenada en el espacio. Hoy modificaremos un poco la clase y usaremos una clase para identificar un número imaginario, recuerdan? aquellos números (también llamados “complejos”) donde existe una raíz imaginaria o compleja que representa o explica que su potencia de dos es igual a menos 1 (para mayor info tenemos a nuestra amiga Wikipedia)

Nuevamente les recalco que las matemáticas no fueron mi fuerte, así que pido perdon a aquellos expertos que encuentren errores conceptuales en el artículo , bueno, comencemos donde quedamos la última vez.

   1: using System;

   2:  

   3: namespace BlogExamples.WellFormedStructures

   4: {

   5:     public class ComplexNumber : IEquatable<ComplexNumber>

   6:     {

   7:         private readonly int _complexPart;

   8:         private readonly int _realPart;

   9:  

  10:         public ComplexNumber(int realPart, int complexPart)

  11:         {

  12:             _realPart = realPart;

  13:             _complexPart = complexPart;

  14:         }

  15:  

  16:         public int RealPart

  17:         {

  18:             get { return _realPart; }

  19:         }

  20:  

  21:         public int ComplexPart

  22:         {

  23:             get { return _complexPart; }

  24:         }

  25:  

  26:         public bool Equals(ComplexNumber other)

  27:         {

  28:             return (_complexPart.Equals(other.ComplexPart) && _realPart.Equals(other.RealPart));

  29:         }

  30:  

  31:         public static bool operator ==(ComplexNumber complex1, ComplexNumber complex2)

  32:         {

  33:             return complex1.Equals(complex2);

  34:         }

  35:  

  36:         public static bool operator !=(ComplexNumber complex1, ComplexNumber complex2)

  37:         {

  38:             return !(complex1 == complex2);

  39:         }

  40:  

  41:         public override int GetHashCode()

  42:         {

  43:             return string.Format("{0}|{1}", _realPart, _complexPart).GetHashCode();

  44:         }

  45:     }

  46: }

Bien, seguimos bajo la premisa que todo esto es solo como ejemplo verdad? si, si, si, más de alguien me dirá que hay una “mejor” forma de hacerlo pero lo único que quiero es explicar esto, ok?. Continuando con el ejemplo una simple unidad de prueba que comprobaría si todo funciona bien sería algo así:

   1: using NUnit.Framework;

   2: using NUnit.Framework.SyntaxHelpers;

   3:  

   4: namespace BlogExamples.WellFormedStructures.Fixtures

   5: {

   6:     [TestFixture]

   7:     public class ComplexNumberFixture

   8:     {

   9:         [Test]

  10:         public void TestGetPropertiesCorrectly()

  11:         {

  12:             ComplexNumber complex = new ComplexNumber(1, 0);

  13:             Assert.That(complex.RealPart, Is.EqualTo(1));

  14:             Assert.That(complex.ComplexPart, Is.EqualTo(0));

  15:         }

  16:  

  17:         [Test]

  18:         public void TestEqualsWorks()

  19:         {

  20:             ComplexNumber complex01 = new ComplexNumber(1, 0);

  21:             ComplexNumber complex02 = new ComplexNumber(0, 1);

  22:             ComplexNumber complex03 = new ComplexNumber(1, 0);

  23:  

  24:             Assert.That(complex01.Equals(complex02), Is.False);

  25:             Assert.That(complex01.Equals(complex03), Is.True);

  26:         }

  27:  

  28:         [Test]

  29:         public void TestEqualOperatorWorks()

  30:         {

  31:             ComplexNumber complex01 = new ComplexNumber(1, 0);

  32:             ComplexNumber complex02 = new ComplexNumber(0, 1);

  33:             ComplexNumber complex03 = new ComplexNumber(1, 0);

  34:  

  35:             Assert.That(complex01 == complex02, Is.False);

  36:             Assert.That(complex01 == complex03, Is.True);

  37:         }

  38:  

  39:         [Test]

  40:         public void TestNotEqualOperatorWorks()

  41:         {

  42:             ComplexNumber complex01 = new ComplexNumber(1, 0);

  43:             ComplexNumber complex02 = new ComplexNumber(0, 1);

  44:             ComplexNumber complex03 = new ComplexNumber(1, 0);

  45:  

  46:             Assert.That(complex01 != complex02, Is.True);

  47:             Assert.That(complex01 != complex03, Is.False);

  48:         }

  49:     }

  50: }

Soy fanático de NUnit, así que si más de alguien no entiende sería bueno que buscara en internet algo de info para ponerse al día (obviamente para correr la unidad de prueba ejemplo necesitas tener NUnit instalado verdad?).

Qué pasó con valores nulos?

Alguien precavido podrá notar que hay una condición que no estamos tomando en cuenta en nuestras pruebas, qué pasaría si uno de los valores de igualdad fuera nulo? Veamos entonces, agreguemos una prueba en la cual “esperaríamos” que si uno de los miebros es Null simplemente retorne false:

   1: [Test]

   2: public void TestEqualNullIsFalse()

   3: {

   4:     ComplexNumber complex01 = new ComplexNumber(1, 0);

   5:     ComplexNumber complex02 = null;

   6:  

   7:     Assert.That(complex01.Equals(complex02), Is.False);

   8: }

Puff, no lo esperabamos! nuestra prueba falla!!!, analicemos un poco nuestro código. Inmediatamente alguien precavido dirá: “podemos agregar un simple if(other == null) return false; y resolveremos totalmente el asunto, pero lo que no contamos es que ya hemos hecho un overload del operador !=, esto nos pone en serios aprietos, ¿cómo podríamos hacer para probar la igualdad a nulo sin usar nuestro operador ya hecho?, claro! usemos el casting al padre de todos los objetos, Object

   1: #region IEquatable<ComplexNumber> Members

   2:  

   3: public bool Equals(ComplexNumber other)

   4: {

   5:     if((object) other != null)

   6:         return (_imaginaryPart.Equals(other.ImaginaryPart) && _realPart.Equals(other.RealPart));

   7:     return false;

   8: }

   9:  

  10: #endregion

Y si al comparar el extremo izquierdo en nuestro operador sobrecargado de igualdad se pasa un elemento nulo? bien arreglemos eso también:

   1: public static bool operator ==(ComplexNumber complex1, ComplexNumber complex2)

   2: {

   3:    if ((object) complex1 == null) return ((object) complex2 == null);

   4:     return complex1.Equals(complex2);

   5: }

Agreguemos una prueba mas a nuestra fixture

   1: [Test]

   2: public void TestEqualOperatorNullWorks()

   3: {

   4:     ComplexNumber complex01 = null;

   5:     ComplexNumber complex02 = new ComplexNumber(1, 1);

   6:  

   7:     Assert.That(complex01 == complex02, Is.False);

   8:     Assert.That(complex02 == complex01, Is.False);

   9: }

Operadores binarios simples

Bien, como lo que nos interesa es representar un número complejo no sería un número si no podríamos operar en el cual número que debería ser, bien, más de alguien dirá: “implementemos un método llamado Add que sirva para añadir, Substract para substraer y así sucesivamente”. Bien, hagamos eso, veamos que resulta.

   1: public ComplexNumber AddComplex(ComplexNumber number)

   2: {

   3:     if(number == null)

   4:         throw new ArgumentNullException("number", "Parameter should not being null");

   5:         

   6:     return new ComplexNumber(_realPart + number.RealPart, _imaginaryPart + number.ImaginaryPart);

   7: }

Por supuesto que debemos implementar el respectivo test de nuestro método

   1: [Test]

   2: public void TestAddComplexNumber()

   3: {

   4:     ComplexNumber complex01 = new ComplexNumber(1, 1);

   5:     ComplexNumber complex02 = new ComplexNumber(1, 2);

   6:  

   7:     ComplexNumber complex03 = complex01.AddComplex(complex02);

   8:     

   9:     Assert.That(complex03.RealPart, Is.EqualTo(2));

  10:     Assert.That(complex03.ImaginaryPart, Is.EqualTo(3));

  11: }

Fácil no?, de igual manera podemos hacer overload de otros operadores matemáticos como -, *, /, % (algo que por tiempo y espacio no haremos, pero en el código de muestra ya incluyo). Para asegurarnos que todo esta bien intentemos un último caso, en el que los miembros sean nulos.

   1: [Test]

   2: [ExpectedException(typeof(ArgumentNullException))]

   3: public void TestAddComplexNumberNull()

   4: {

   5:     ComplexNumber complex01 = new ComplexNumber(1, 1);

   6:     ComplexNumber complex02 = null;

   7:  

   8:     ComplexNumber complex03 = complex01.AddComplex(complex02);

   9:  

  10: }

  11:  

  12: [Test]

  13: [ExpectedException(typeof(ArgumentNullException))]

  14: public void TestAddComplexNumberOperatorNull()

  15: {

  16:     ComplexNumber complex01 = null;

  17:     ComplexNumber complex02 = new ComplexNumber(1, 2);

  18:  

  19:     ComplexNumber complex03 = complex01 + complex02;

  20: }

Bien, hasta aquí llegamos hoy, para la próxima entrega tocaremos el uso de operadores unarios y un par de cositas más, mientras tanto pueden bajar la solución completa con los ejemplos en este link. Como siempre cualquier pregunta o sugerencia estamos a un comment o post de distancia. Saludos!

Parte I

Luego de mucho hablar y con el tiempo restringido terminamos exitosamente de conocer nhibernate por encimita, había mucho que hablar y muy poco tiempo, como siempre los invito a que se lean la documentación y como siempre experimenten, tomen un su proyecto mascota y comienzen a experimentar, no hay mejor forma de aprender

Junto con las diapositivas incluyo el código que usé para ejemplos, recuerden que usé Northwind para explicar relaciones!. Bien aquí esta mi diapositiva y aquí mis ejemplos.

Como siempre cualquier consulta estamos a un correo o comment de distancia.