Avanzis (Blogs Desarrollo)

Utilizar Rhino Mocks y StructureMap en pruebas unitarias con NUnit

Tue, 25 Nov 2008 16:01:37 GMT

En el posts anteriores ya vimos cómo utilizar y configurar StructureMap para poner en práctica la inyección de dependencias.

Tal y como prometí, ahora vamos a ver un pequeño ejemplo de cómo utilizar el StructureMap y el mocking de objetos en las pruebas unitarias.

Quizá te preguntes que es un “Mock”.

Un mock, en el contexto de pruebas unitarias, es un objeto “falso” que simula el comportamiento del objeto real, con el fin de realizar las pruebas. En la wikipedia lo asimilan al maniquí que utilizan los diseñadores coches para realizar las pruebas de accidentes.

Te sugiero si utilizas pruebas unitarias, profundices más sobre este tema.
Existen muchas librerías para realizar mocks en .NET.

En el ejemplo que voy a plantear utilizaré Rhino Mocks, para crear un mock de un servicio de mensajería, ya que no quiero que realmente se envíe el correo electrónico al usuario, simplemente quiero probar que el método se llama convenientemente.

Primero crearé la interfaz de este servicio de mensajería.

    1 public interface IMessagingService
    2 {
    3     void SendMessage(User user, string text);
    4 }

En la aplicación “real”, no en las pruebas unitarias, configuraré StructureMap para que el servicio de mensajería sea una implementación de esta interfaz para enviar correos electrónicos. Pero podría ser cualquier otra cosa, enviar SMS, un texto al Messenger, etc…

    1 private static void ConfigureStructureMap()
    2 {
    3     ObjectFactory.Configure(s => 
    4         s.BuildInstancesOf<IMessagingService>()
    5         .TheDefaultIsConcreteType<EmailMessagingService>());
    6 }

El controlador de asp.net mvc que queremos probar tiene la siguiente acción:

    1 public ActionResult CreateUser(string userName, string password, string email)
    2 {
    3     User user = new User{UserName = userName, Password = password, Email = email};
    4 
    5     UserValidationResult result = userService.Register(user);
    6 
    7     if (result.IsValid)
    8     {
    9         IMessagingService messagingService = ObjectFactory.GetInstance<IMessagingService>();
   10 
   11         messagingService.SendMessage(user, "Tu cuenta ha sido creada correctamente");
   12 
   13         return Authenticate(userName, password, null);
   14     }
   15 
   16     TempData["RegisterErrors"] = result.Errors;
   17 
   18     return RedirectToAction("Register");
   19 }

Y ahora en las pruebas unitarias, comprobaremos que el método SendMessage se llama al crear un nuevo usuario. Utilizaremos NUnit como librería de pruebas y habrá que añadir la referencia al dll de Rhino Mocks de y de StructureMap al proyecto de pruebas.

    1 [Test]
    2 public void CreateUser_Creates_Users_And_Sends_Email()
    3 {
    4     MockRepository mocker = new MockRepository();
    5 
    6     IMessagingService messagingService = mocker.StrictMock<IMessagingService>();
    7 
    8     Expect.Call(() => messagingService.SendMessage(null, null))
    9         .IgnoreArguments();
   10 
   11     mocker.ReplayAll();
   12 
   13     ObjectFactory.Inject(messagingService);
   14 
   15     controller.CreateUser("usuario", "clave", "direccion@correo.es");
   16 
   17     mocker.VerifyAll();
   18 }

Veamos con más detalle el código de esta prueba.

En la línea 1 le indico a NUnit que este método es una prueba.

En la línea 4 creamos el objeto de Rhino Mocks que se encargará de generar los objectos Mocks a partir de la definición de la interfaz.

En la línea 6 creamos obtenemos la implementación simulada del servicio IMessagingService.

En la líneas 8 y 9, le decimos a Rhino Mocks que esperamos que en el futuro se llame al método SendMessage del objeto messagingService y que nos dan igual los argumentos utilizados. El método Expect.Call espera como parámetro un delegado que se lo hemos pasado utilizando una expressión lambda.

En la línea 12, le indicamos al objeto MockRepository que ya hemos fijado todas las expectativas (en nuestro caso, sólo la establecida en la línea 8) y que vamos a empezar las pruebas.

En la línea 13, inyectamos la interfaz simulada a StructureMap para que utilice este objeto, en vez de lo que tenga en su configuración.

En la línea 14, llamamos al objeto que estamos probando con algunos parámetros por defecto.

En la línea 15, le pedimos a Rhino Mocks, que verifique que se han cumplido todas las expectativas establecidas. En nuestro caso queríamos que se llamara al método SendMessage al crear un usuario. Si esto no ocurriera, este método lanzaría una excepción por lo que la prueba unitaria no se pasaría correctamente.

¡Espero que te haya servido de ayuda!

Primeros pasos con StructureMap y la Inyección de Dependencias

Tue, 25 Nov 2008 13:26:48 GMT

Uno de los objetivos que debe tener un buen programador es que su código esté poco acoplado, es decir, que dos componentes con funcionalidades distintas dependan el uno del otro lo mínimo posible. De esta forma conseguirá que sus dos componentes por separado sean reutilizables y más fáciles de mantener.

Para eliminar al máximo la dependencia entre componentes, existe un patrón de diseño conocido como “Inyección de dependencias” (“Dependency Injection” o DI). Este patrón consiste básicamente en que en vez de ser una clase la que crea objetos, estos se inyectan o resuelven en el último momento.

Existen diferentes proyectos en .NET que intentan ayudarnos a aplicar este patrón:

He decidido comenzar a utilizar StructureMap porque que es uno de los más extendidos y además me gusta su sintaxis y facilidad de uso.

Para comenzar a utilizar la inyección de dependencias debes acostumbrarte a utilizar interfaces en vez de objetos concretos ya que esto es lo que te permitirá diferentes implementaciones de esa interfaz.

Por ejemplo, si queremos un componentes que realice el registro de errores o eventos, crearemos una interfaz “ILogger”. Y además, dos implementaciones de esta interfaz, una para guardar los mensajes en una base de datos y otra en un archivo de texto.

public interface ILogger
{
    void Log(string message);
}
 
public class DatabaseLogger : ILogger
{
    public void Log(string message)
    {
        // Lógica para guardar el mensaje en un archivo d texto..
    }
}
 
public class TextLogger :  ILogger
{
    public void Log(string message)
    {
        // Lógica par aguardar el mensaje en un archivo de texto...
    }
}

Muy bien, ya tenemos dado el primer paso. Ahora añadiremos la referencia en nuestro proyecto a StructureMap.dll para poder utilizar esta librería.

Cuando queramos utilizar el objeto ILogger dentro de otra clase, llamaremos método GetInstance() del objeto ObjectFactory que ofrece StructureMap.

Por ejemplo

public class ClaseDePrueba
{
    public void HacerAlgo()
    {
        // ...
        ILogger logger = ObjectFactory.GetInstance<ILogger>();
        logger.Log("Mensaje que queremos registrar");
        // ...
    }
}

Pero te preguntarás, ¿cómo sabe StructureMap cuál de las dos implementaciones de ILogger debe devolver, la de la base de datos o la del archivo de texto? Obviamente eso hay que indicárselo de alguna forma.

Podemos configurar StructureMap o bien utilizando el archivo de configuración App.config o Web.config si es una aplicación web. O mediante código, normalmente al iniciarse el programa o en el archivo Global.asax si trabajas con ASP.NET.

En este ejemplo, le indicaremos por código a StructureMap que queremos utilizar el archivo de texto para guardar los logs.

public void ConfigureStructureMap()
{
    ObjectFactory.Configure(
        s => s.BuildInstancesOf<ILogger>()
            .TheDefaultIsConcreteType<TextLogger>()
    );
}

¡Eso es todo! Ya estamos utilizando StructureMap y a partir de ahora, con cambiar una simple línea de código (o una línea del archivo de configuración si hubiéramos utilizado esa opción) podemos comenzar a utilizar la base de datos para guardar los mensajes en toda la aplicación.

La Inyección de dependencias es un patrón de diseño que todo programador debería conocer y utilizar. Además, esta técnica, unida al “Mocking”, te será realmente útil si utilizas (¡deberías hacerlo!) pruebas unitarias. Pero de esto ya hablaré en el futuro.

¡Espero vuestros comentarios!

El SEO y sus puntos clave.

Wed, 19 Nov 2008 13:38:35 GMT

El SEO, o Search Engine Optimization, se refiere al conjunto de técnicas que debemos aplicar en una Web para que esté optimizada en buscadores y que salgamos bien posicionados.$0$0Técnicas SEO hay muchísimas, pero en mi opinión hay 6 que destacan sobre todas las demás:$0$0$0Tener sitemaps.$0$0La palabra/frase clave debe ser el título de la página.$0$0La palabra/frase clave debe encontrarse dentro de la url de la página.$0$0La palabra/frase clave (debe estar dentro de un)/(debe ser el) H1 en la página.$0$0La palabra/frase clave debe estar repetida varias veces dentro de la página, algunas de ellas con negrita.$0$0Estructura de enlaces internos: todas las páginas de tu Web deben estar enlazadas entre ellas con pocos saltos de diferencia.$0$0Todo ello bajo la premisa de tener un buen contenido. Sin buen contenido no empezamos ni a hablar. Será este buen contenido el que te proporcione enlaces entrantes, y será la constancia el que haga que Google confíe en ti.$0$0Si estás interesado en técnicas SEO más avanzadas, te recomiendo el blog comunactivo.

Jugando con jQuery: emulando el FindControl de ASP.NET

Sun, 05 Oct 2008 10:54:49 GMT

Esto de jQuery es divertido. Igual de divertido que javascript pero más fácil.

Hace unos días di una primero introducción a jQuery e hice mi primer plugin que llamé macEmulator.

Ahora presento un nuevo plugin que responde a una necesidad real y casi diaria de todo programador en ASP.NET (a no ser que trabaje con MVC).

Se trata de emular el FindControl de ASP.NET pero con javascript. Vayamos a un ejemplo:

Tenemos un DataList con un ItemTemplate que tiene dos Panels y un Label en cada Panel










Esto generará un código HTML que convertirá las Label en elementos con un identificador de este estilo: DataList1_ctl00_Label1

Pero yo lo que quiero es acceder a las Label1 por jQuery... ¿cómo lo hago?

No hay una forma directa porque los IDs los genera ASP.NET, pero con el plugin que presento podremos hacer algo como esto:

var controls = $(document).findControl('Label1');
for (i = 0; i < controls.length; i++) { alert(controls[i].innerHTML); }

El plugin no es que sea una obra de arte. Más bien es sencillito, jeje. Lo autoexplican los comentarios:

jQuery.fn.findControl = function(clientId) {
    var ids = new Array();

    // Para cada elemento que tenga un atributo ID dentro de "this"
    $(this).find('*[id]').each(function(i) {
        // Si el ID del elemento termina como el clientId, lo añadimos al array
        if (this.id &&
            (this.id.lastIndexOf(clientId) >= 0) &&
            (this.id.lastIndexOf(clientId) == (this.id.length - clientId.length))) {
                ids.push(this);
            }
        });

    // Devolvemos el array
    return ids;
}

El plugin ya viene con bugs por defecto, como el hecho de que si otro elemento se llamara MyLabel1, el plugin se creería que es Label1... pero bueno, es una primera aproximación.

Jugando con jQuery: macEmulator

Thu, 02 Oct 2008 13:46:17 GMT

Tras la breve introducción a jQuery, propongo un ejemplo que he llamado "macEmulator". La verdad es que soy bastante malo dando nombre a las cosas, y en el mundo de la programación tenemos que estar todo el santo día dando nombres a variables, a funciones, a clases, a ficheros...

El "macEmulator" lo que hace es coger las imágenes ubicadas dentro del "div" que le indiquemos y darles un efecto similar al de los iconos de los Mac. Cuando el ratón está encima de un icono la imagen se hace grande (progresivamente) y cuando sales se hace pequeña (también de forma progresiva).

Lo he puesto dentro de un plugin, de forma que activar la funcionalidad se reduce a una sola línea de código:

$("#divId").macEmulation(100,150,100,500);

Donde:

divId es el "id" del div en el que están ubicadas las imágenes.
El primer parámetro marca la anchura inicial de las imágenes
El segundo parámetro marca la anchura de la imagen cuando el ratón está sobre ella.
El tercer parámetro marca la anchura de la imagen cuando el ratón deja de estar sobre ella.
El cuarto parámetro marca el tiempo que tarda la imagen en transformarse progresivamente de grande a pequeña y de pequeña a grande.

A continuación muestro el código con comentarios para entender el script:

jQuery.fn.macEmulation = function(initialWitdh, hoverWidth, houtWidth, delay) {
    // Cogemos el elemento dentro del cual estarán las imágenes
    var div = $(this);

    // Cuando la página esté cargada, aplicaremos la anchura inicial marcada
    // y pondremos cada imagen dentro de un div con unos estilos predefinidos
    $(document).ready(function() {
        div.find('img').width(initialWitdh);
        div.find('img').wrap('
');

    });

    // Asignamos la anchura de la imagen cuando estamos sobre ella y cuando dejamos de estarlo.
    // Para ello utilizaremos el modo "animate" que hará que la transición sea progresiva.
    div.find('img').hover(
    function() {
        $(this).animate({ width: hoverWidth + "px" }, delay);
    },
    function() {
        $(this).animate({ width: houtWidth + "px" }, delay);
    });
}

Introducción a jQuery

Thu, 02 Oct 2008 13:30:44 GMT

Javascript ha sido siempre un eterno candidato a desaparecer. Sin embargo, con el paso de los años su importancia en el mundo Web ha ido en aumento.

Javascript no suele gustar. Se puede hacer muchísimas cosas con él, pero tiene varios inconvenientes. Empezando por la selectiva incompatibilidad entre navegadores, y acabando por una curva de aprendizaje no lineal (hacer cosas fáciles es fácil, hacer cosas difíciles es muy difícil... y en el medio hay poquito).

Para los que hemos trabajado con javascript desde sus inicios, solemos tener pequeñas librerías que nos hacen todo lo que queremos. Pero suelen ser librerías poco estándar... vamos, que cada uno las tiene de su padre y de su madre.

Es por eso que últimamente en la oficina suena mucho "jQuery", del que Richard ya ha hablado. Básicamente, jQuery es un framework javascript, que nos permite olvidarnos de las incompatibilidades y linealiza mucho la curva de aprendizaje. El framework propone un estándar de trabajo con javascript, que no sólo lo hace más fácil sino que le añade funcionalidades extremadamente útiles en pocas líneas de código.

Para más regocijo, su Web oficial es muy útil, clara y llena de ejemplos, con buenos tutoriales y muchos plugins.

En próximos artículos pondré ejemplos de algunas de las cosas que se puede hacer con jQuery. Serán ejemplo específicos, porque la Web oficial de jQuery ya es muy clara.

ASP.NET MVC Preview 5

Thu, 28 Aug 2008 17:14:20 GMT

!Acaban de lanzar la preview 5 de ASP.NET MVC en Codeplex!

Si eres de los valientes (como nosotros) que estas desarrollando con ASP.NET MVC, recuerda que tendrás que desinstalar la versión anterior antes de instalar este nuevo lanzamiento.

Por si nos os apetece leer, y ya que tengo que revisar los cambios en profundidad, aquí tenéis algunas de las nuevas características respecto a la Preview 4:

Mejoras en los motores de visualización (ViewEngine)
- Ahora, en vez de ser cada controlador el responsable de decidir que motor de visualización se utilizará, los motores se registran de forma global.
- Se ha modificado la interfaz IViewEngine para que añada el método "RenderPartial".
Mejoras en los helpers
- Soporte para la renderización de views parciales.
- Nuevo parámetro para poder indicar a un DropDownList cuál será su opción por defecto.
- Se han movido las extensiones AJAX a otro namespace, teóricamente para que sea más sencillo reemplazarlas por tu propio código.
- Otras mejoras
Mejoras en los controles y los filtros.
- Los parámetros de las acciones ahora soportan también arrays.
  Esto ocurría cuando varios controles tienen el mismo nombre.
- Soporte a para crear tus propios "binders". Los binders asocian los valores que llegan por querystring o form con parámetros de la acción.
- Añadida la interfaz "IActionInvoker" para desacoplar el controlador la implementación específica de "ControllerActionInvoker".
- Añadido el modo actualización (UpdateMode) a la clase del controlador. Es posible utilizar este método para actualizar las propiedades de un modelo a partir de los parámetros pasados en el formulario.
- Se ha modificado "HandleErrorAttribute" para que mientras estás desarrollando aparezca la ventana amarilla de error que proporciona la máxima información posible.
- Nuevo atributo "AcceptVerbs". Permite indicar qué verbos HTTP son aceptados (GET, POST, etc...). Esto permite tener dos acciones con el mismo nombre siempre y cuando acepten verbos diferentes.
- Nuevo atributo "ActionName". Permite indicar un nombre de acción a un método diferente del nombre del método. Su ejemplo para estas dos últimas mejoras es bastante claro:
  
  [AcceptVerb("GET")]
  public ActionResult MyAction(...);
  
  [ActionName("MyAction"), AcceptVerb("POST")]
  public ActionResult MyAction_FormSubmit(...);
  
  [AcceptVerb("GET")]
  public ActionResult OtherActionOverloaded(string id);
  
  [AcceptVerb("POST")]
  public ActionResult OtherActionOverloaded(string id, ...);

Muy bonita toda esta explicación, pero ¿cómo nos ha afectado a nostros en el proyecto que estamos realizando en ASP.NET MVC?

Estos son los problemas que hemos encontrado para que nuestro proyecto compile tras haber actualizado a la preview 5:

El objeto "LinkBuilder" ahora se encuentra en el espacio de nombre "Microsoft.Web.Mvc". Este objeto lo utilizamos para generar un "RouteValueDictionary" a partir de una expresión de Linq.
El método ActionLink que adminte como tipo un controlador, se ha movido también a Microsoft.Web.Mvc.
BindingHelperExtensions ya no existe y aún no he encontrado ningún objeto equivalente.
El controlador ya no tiene la propiedad ViewEngine.ç
Html.RenderUserControl() ya no existe, ahora hay que usar Html.RenderPartial(). Por ejemplo:
<%=Html.RenderUserControl("~/UserControls/TagList.ascx", ViewData.Model.PopularTags)%>
Ahora será:
<% Html.RenderPartial("~/UserControls/TagList.ascx", ViewData.Model.PopularTags);%>
Fíjate que ahora no hay que poner el igual delante, y que tiene que acabar con punto y coma.

¿Alguien más se está peleando con ASP.NET MVC? Me encantaría escuchar vuestros comentarios.

Scrum, Test Driven Development y MVC. Vamos a ser ágiles.

Thu, 24 Jul 2008 00:42:49 GMT

En Avanzis estamos empezando un proyecto que nos ilusiona mucho, y que esperamos que vea la luz antes de final de año. Como todo proyecto que empieza, uno de los primeros aspectos a decidir es qué metodología vamos a seguir y qué plataforma tecnológica. En este proyecto vamos a utilizar Scrum y Test Driven Development. Vale. Y ahora os preguntareis ¿esto qué significa?. Pues básicamente son dos relativamente nuevas metodologías en el desarrollo de software, clasificadas dentro de las llamadas “ágiles”. Estas dos metodologías tienen algo en común. Se asume que el diseño de la arquitectura de clases, la definición de las funcionalidades y la especificación de requisitos, es un proceso que fluye a través de todo el desarrollo del proyecto, y no son una etapa inicial aislada. No hay que esperar a tener el diseño y la especificación completa para empezar a desarrollar. Scrum es una manera de organizarse, y TDD es una manera de desarrollar.

¿Qué es SCRUM?

Scrum es una metodología de trabajo ágil, especialmente diseñada para intentar acortar los ciclos de desarrollo y conseguir una mejor aproximación entre las funcionalidades del software y los requerimientos del cliente. Se trata de evitar la burocracia innecesaria, conseguir una mayor versatilidad frente a los cambios y empezar rápidamente a trabajar, de manera que el cliente puede ir viendo lo antes posible los avances en el proyecto. Es óptima para equipos de trabajo no demasiado grandes y clientes que tengan un alto grado de implicación en el proyecto. El procedimiento básico consiste en crear un repositorio con las funcionalidades requeridas para el proyecto, asignándoles unos puntos de importancia, una estimación en horas y cómo se debe demostrar esta funcionalidad. A esto lo llamaremos “Product Backlog”. A partir de entonces, se crean los “Sprint Backlogs”, que son un conjunto de tareas que se deben completar en un determinado tiempo, entre 2 semanas y un mes. Durante cada dia del sprint, se hace una corta reunión para revisar el estado de las tareas, y al final de cada sprint, una reunión con el cliente para mostrarle los resultados. Así, el cliente va viendo los avances cada corto periodo de tiempo, y se puede reajustar cualquier cambio de funcionalidad en cualquier etapa del proyecto. Obtenemos un feedback que nos permite mejorar en el siguiente sprint.

¿Qué es TDD?

Para tratar de mejorar del código, existen los “Unit Tests”, que consisten en código adicional que se ocupa de probar el código principal. Se trata de probar que pequeñas unidades individuales de código se comportan tal y como esperamos. Para ello existen frameworks como NUnit con el fin de ayudarnos en esta tarea. Mediante los test, tenemos una mayor seguridad en que las cosas funcionan como deben, y además, podemos comprobar que las cosas siguen funcionando bien después de hacer cambios en el código. Pero TDD va más allá. En lugar de programar y luego probar, se intercambia el orden, de manera que primero creamos los test, y a partir de aquí se va creando la funcionalidad. El ciclo que se va repitiendo es: Añadir el test para una nueva funcionalidad. Evidentemente, este test fallará dado que la funcionalidad no está implementada. Programaremos, ejecutaremos todos los tests hasta que todos ellos tengan éxito, y finalmente refactorizaremos y volveremos a empezar. En el modelo habitual, se dedica una parte muy importante del tiempo diseñando completamente los modelos lógicos y físicos antes de escribir ninguna línea de código. Sin embargo, con este modelo, el diseño se deriva de los test de funcionalidad, y es un proceso que discurre al mismo tiempo que el propio desarrollo. Por esto, está metodología de desarrollo encaja perfectamente en la metodología organizativa SCRUM.

MVC

Finalmente, teníamos que elegir una plataforma tecnológica para desarrollar el proyecto siguiendo esta metodología. Para ello, hemos elegido seguir el patrón Model View Controller , y en concreto la implementación de asp.net MVC. Las metodologías anteriores se pueden utilizar con cualquier plataforma, pero MVC proporciona un modelo ideal para realizar los test de una manera mucho más completa, probando no solo la lógica sino también la interacción con la interfaz de usuario. Pero sobre MVC, ya hablaremos en detalle en próximos posts.

Así que ya sabéis, durante un tiempo, hablaremos de nuestras experiencias con SCRUM, TDD y MVC.

Lucene para ASP.NET (Parte III). Búsqueda.

Tue, 22 Jul 2008 10:36:29 GMT

Siguiendo la serie de artículos sobre Lucene (Lucene para ASP.NET (Parte I). Introducción y Lucene para ASP.NET (Parte II). Indexación), dónde conocimos qué era Lucene y cómo indexar contenidos, durante este artículo vamos a hablar de la búsqueda, sin duda, el objetivo último que perseguimos.

Según la estructura del Document planteada en el artículo sobre Indexación, cuando queramos buscar algo atacaremos a los campos "Title" y "Text", pues son los que contendrán la información importante. Es decir, lo que queremos es "buscar palabras que se encuentran en el título o en el texto".

A continuación tenemos un método que busca en ambos campos y devuelve un listado de Document's:

public static List SearchDocuments(string sQuery)
{
    // Creamos el listado documents que vamos a devolver
    List documents = new List();

    // Abrimos el IndexSearcher con el Path del directorio que hace de índice. Aquí usamos una variable global.
    IndexSearcher searcher = new IndexSearcher(IndexPath);

    try
    {
        // Buscamos en Text
        QueryParser qpText = new QueryParser("Text", new SpanishAnalyzer());
        Query queryText = qpText.Parse(sQuery);

        // Buscamos en Title
        QueryParser qpTitle = new QueryParser("Title", new SpanishAnalyzer());
        Query queryTitle = qpTitle.Parse(sQuery);

        // Unimos ambos elementos: queremos que nuestro query se encuentre en uno de los dos sitios.
        // Si puede ser en los dos, mejor.
        BooleanQuery bq = new BooleanQuery();
        bq.Add(queryText, BooleanClause.Occur.SHOULD);
        bq.Add(queryTitle, BooleanClause.Occur.SHOULD);

        // La clase Hits es la clave. Es lo que nos devolverá la Search
        Hits hits = searcher.Search(bq);
        int totalHits = hits.Length();

        // Recorremos todos los Hits, recogemos el document y lo añadimos a nuestro listado genérico
        // Aquí es donde debería hacerse la paginación, etc.
        for (int i = 0; i < totalHits; i++)
        {
            Document document = hits.Doc(i);
            documents.Add(document);
        }
    }
    finally
    {
        searcher.Close();
    }

    return documents;
}

Como vemos, el código se autoexplica bastante.

Lo más importante es saber que QueryParser define dónde queremos buscar y con qué Analyzer, y Query define qué queremos buscar.

Con el BooleanQuery uniremos las búsquedas en ambos campos, indicándole mediante el SHOULD que los resultados deben encontrarse en al menos uno de los dos campos (Title o Text), pero que si puede ser en los dos, mejor que mejor.

Los resultados tras el searcher.Search(...) vienen en forma de Hits. Los Hits contienen el Document, pero también contienen otros campos interesantes como el Score que devuelve la puntuación de 0 a 100 o el Length que devuelve el número de resultados encontrados.

Como véis esto ha sido una búsqueda a pelo. Ahora quedaría paginar, filtrar los resultados con Score bajo, etc.

Cómo obtener únicamente la fecha de un campo DateTime de SQL Server

Tue, 15 Jul 2008 13:50:25 GMT

Estaba realizando una consulta en T-SQL para mostrar el número de pedidos realizados por día entre dos fechas. Algo relativamente simple, ¿verdad?

Pues aunque parezca increíble, SQL Server no proporciona una función sencilla que permita obtener únicamente la fecha de un campo de tipo DateTime ignorando la hora almacenada. En el caso del informe que quería realizar, me impedía agrupar correctamente los pedidos por fecha porque el campo DateTime también almacena la hora.

Afortunadamente, Anatoly Lubarsky nos proporciona una solución bastante sencilla.

SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, CAMPO_FECHA))

Donde CAMPO_FECHA es el nombre del campo de la tabla que contiene la fecha que quieres procesar. También puedes utilizar GETDATE() en vez de CAMPO_FECHA para obtener únicamente la fecha de hoy.

Esta es la consulta SQL resultante:

SELECT DATEADD(dd, 0, DATEDIFF(dd, 0, DateCreated)) as OrderDate, 
COUNT(*) as OrdersCount FROM CommerceOrders
GROUP BY DATEADD(dd, 0, DATEDIFF(dd, 0, DateCreated))
ORDER BY OrderDate

Vuestros comentarios son bienvenidos.

Mejora el rendimiento de Firefox al visitar páginas de tu ordenador

Wed, 09 Jul 2008 13:42:34 GMT

!Firefox me encanta!

Firefox es mi navegador favorito para navegar por Internet por su velocidad y simplicidad, pero sobre todo gracias a extensiones como Firebug que son imprescindibles para cualquier desarrollador web.

Me gustaría utilizar este navegador para realizar las pruebas de las aplicaciones en ASP.NET, pero por algún motivo Firefox se muestra extremadamente lento cuando se conecta a las páginas del ordenador local (localhost). ¡Pero esta mañana he leído la solución a ese problema!

Básicamente, consiste en entrar en la configuración avanzada de Firefox, introduciendo about:config en la URL del navegador, y cambiar el parámetro 'network.dns.ipv4OnlyDomains' a 'localhost'.

Pruébalo, y notarás la diferencia.

Lucene para ASP.NET (Parte II). Indexación.

Thu, 03 Jul 2008 14:55:44 GMT

Tras hablar de buscadores avanzados para Webs e introducir Lucene para ASP.NET, a lo largo de este artículo hablaremos de cómo hacer la indexación con Lucene.

Distinguimos tres pasos básicos cuando hacemos la indexación:

Abrir el índice.
Crear y añadir el Document (del que ya hablamos en el anterior artículo).
Optimizar el índice.

Abrir el índice
Lo primero un ejemplo de cómo se abre un índice:

IndexWriter writer = new IndexWriter(IndexPath, new SpanishAnalyzer(), !Directory.Exists(IndexPath));

El constructor de "IndexWriter" consta de tres parámetros:

IndexPath: donde indicaremos el Path del directorio que hemos creado como índice. Este directorio es muy importante. Evitaremos tocar nada de lo que veamos ahí dentro ;)
Analyzer: una de las características de Lucene es que tiene en cuenta las características del lenguaje a la hora de indexar (así como de buscar). Por ejemplo, el SpanishAnalyzer indica que hay palabras con poca importancia (como las preposiciones), que no tenga demasiado en cuenta los acentos, etc.
Crear índice: por tonto que parezca (a mí me lo parece) hay que indicarle si quieres crear o no el índice... ya podría hacer la comprobación solito, pero bueno, sobreviviremos indicando que si existe el directorio es que existe el índice.

Crear y añadir el Document
Sin duda la fase más importante. Ya sabemos que el Document, en una analogía con una base de datos relacional, sería algo así como la estructura de una tabla.

Debemos definir muy bien qué queremos indexar y cómo. Tenemos diferentes opciones de indexación para cada campo del Document:

Guardar el valor y no separar las palabras.
Guardar el valor, no separar las palabras y no indexar.
No guardar el valor y no separar las palabras.
Separar las palabras y no guarda.

Tener que indicar la opción de "Guardar" puede resultar difícil de entender para los que trabajamos con bases de datos relacionales. Hay que tener en cuenta que Lucene está pensada a lo grande, y todo lo que sea optimizar es poco.

Siempre que podamos debemos indexar y no guardar, sobretodo en lo referente a textos. Por ejemplo, si quisiéramos hacer un buscador para "El Quijote" nos interesaría indexarlo, pero no guardar todo su contenido, dado que no es lo que le vamos a mostrar en los resultados de buscador al usuario. Una técnica habitual cuando se quieren indexar textos largos es crear un campo de "Indexar y no guardar" para el texto completo, y otro de "Guardar y no indexar" para un resumen de ese texto largo.

El concepto de "Separar palabras" también es digno de mención. cuando lo indicamos (usando Field.Index.TOKENIZED) le estamos diciendo a Lucene que aplique los filtros del Analyzer. Sin embargo hay ocasiones en que queremos mantener la información tal cual, sin filtros, para lo que indicaremos Field.Index.UN_TOKENIZED.

Vayamos al grano y creemos el Document de ejemplo:

Document document = new Document();

// Guardar el valor y no separar las palabras
document.Add(new Field("Identificador", ID, Field.Store.YES, Field.Index.UN_TOKENIZED));
document.Add(new Field("Fecha", MyDate, Field.Store.YES, Field.Index.UN_TOKENIZED));

// Guardar el valor, no separar las palabras y no indexar
document.Add(new Field("ResumenDelTexto", Summary, Field.Store.YES, Field.Index.NO));

// Separar la palabras y guardar
document.Add(new Field("Title", Title, Field.Store.YES, Field.Index.TOKENIZED));

// Separar las palabras y no guardar
document.Add(new Field("Texto", Text, Field.Store.NO, Field.Index.TOKENIZED));

writer.AddDocument(document);

Vemos que el modo de trabajar es muy intuitivo. Como Document entendemos a "La estructura" y como Field entendemos "El campo" con sus características.

Llegados aquí, vuelvo a repetir que lo más importante a la hora de hacer un buscador es saber indexarlo bien. Conocidas las opciones posibles para crear un Field del Document, hay que pararse a pensar en qué y cómo queremos indexar.

Optimizar el índice
Lucene provee de la opción de optimizar el índice. Como siempre sucede en estos casos, el proceso de optimizar es muy pesado, pero tiene como consecuencia que las búsquedas serán más rápidas.

De modo que tenemos que encontrar un equilibrio entre el coste computacional de indexar y el coste computacional de buscar. Tendremos desde Webs que no indexen apenas nada y se pasen el día haciendo búsquedas, o la Web que indexa mucho pero que hace pocas búsquedas.

Y como en el centro está la virtud, para Todoexpertos he optado la siguiente opción "artesanal":

if ((DateTime.Now.Millisecond % 500) == 0) writer.Optimize();

Estructura final
Juntando un poquito las piezas, he aquí la estructura básica de la indexación con Lucene que utilizamos en Todoexpertos:

public static void Index(QuestionInfo questionInfo)
{
    IndexWriter writer = null;
    lock (LuceneIndexing)
    {
        try
        {
            // Abrimos el índice
            writer = new IndexWriter(IndexPath, new SpanishAnalyzer(), !Directory.Exists(IndexPath));

            // Accede a un método que crea el Document... aquí es donde hay que pensar :D
            Document document = GetDocument(questionInfo);

            writer.AddDocument(document);

            if ((DateTime.Now.Millisecond % 500) == 0)
                writer.Optimize();
        }
        finally
        {
            // Poniéndolo en el finally nos aseguramos que el writer queda cerrado. Muy importante: SIEMPRE debe quedar cerrado.
            if (writer != null)
                writer.Close();
        }
    }
}

En el próximo artículo veremos cómo podemos buscar con Lucene.

Cómo ignorar los acentos en las búsquedas con SQL Server

Thu, 03 Jul 2008 10:45:08 GMT

Una de los requisitos más habituales para un buscador es que al realizar las búsquedas no distinga las palabras que se diferencian sólo por acentos. Por ejemplo, si buscas la palabra “como”, también se desea que les aparezcan los resultados con las palabra “cómo”.

Hacer esto es SQL Server es muy sencillo, si sabes cómo.

El truco está en cambiar la intercalación (“Collation” en inglés) del campo en el que quieres buscar o bien de la base de datos completa, para que utilice alguna de las intercalaciones que ignoran los acentos, que son aquellas acabadas en “_IA” (Insensitive Accent).

La sentencia para cambiar una base de datos completa para utilizar la intercalación “Modern_Spanish_CI_AI”:

ALTER DATABASE [nombrebasededatos] COLLATE Modern_Spanish_CI_AI

Si lo que queremos es sólo cambiar un campo de una tabla, el administrador de SQL Server te hace la vida más fácil. Sólo tienes que editar las propiedades de la columna, y quitar la opción de “Distinguir acentos” en el formulario que aparece al intentar modificar la propiedad “Intercalación”.

Espero que os haya sido de utilidad.

Elección del CRM

Wed, 18 Jun 2008 17:21:27 GMT

En Avanzis hemos utilizado varios CRM hasta la fecha. Empezamos utilizando el SuperOffice, pero nos resultaba demasiado complejo para realizar algunas tareas simples. Después de intentar sin demasiado éxito la implantación del producto de Microsoft, realizamos un desarrollo simple para uso interno, si bien se queda muy corto para las necesidades actuales.

Así que nos hemos puesto manos a la obra, para realizar una investigación de las alternativas existentes. Una de las primeras alternativas ha sido el SugarCRM. Sin embargo, su modelo de licencias no nos ha convencido. Después de analizar otros como Splendid CRM, Compiere, OTRS, Hipergate o Sinergia, nos hemos decidido a implementar el CRM vtiger.

Nos han convencido varias cosas. Entre ellas, la facilidad para realizar las tareas más comunes, como la gestión de cuentas, contactos, actividades, pedidos, etc.., o la disponibilidad de un "customer portal" donde los clientes puedan introducir sus incidencias o "tickets", todo ello con localización disponible para castellano. También dispone de un plug-in para Outlook para poder realizar desde el programa de la suite de Office algunas de las tareas más comunes. Además, es gratuito y open source. Está desarrollado en PHP sobre MySql. En nuestro caso, lo vamos a utilizar en la primera fase como organizador de contactos y cuentas, y como gestor de incidencias primordialmente, de manera complementaria con la aplicación de gestión de bugs, BugNET.

¿Qué os parece nuestra elección? ¿Usáis algún CRM con el que estéis especialmente contentos?

Lucene para ASP.NET (Parte I). Introducción.

Sun, 15 Jun 2008 10:51:18 GMT

Tras hablar de la necesidad de un buscador avanzado para Web, comentamos que en Todoexpertos.com usamos Lucene para ASP.NET.

En este artículo vamos a introducir qué es exactamente Lucene y los puntos maestros de cómo funciona. Lo primero de todo, obviamente, es descargarse el .sln de Lucene, para poder trabajar con él.

En general, cualquier motor de búsqueda tiene dos elementos clave: la indexación y la búsqueda. Primero hay que definir sobre qué se quiere buscar y cómo, y luego ya buscaremos. Ya anticipo que la parte de indexación es mucho más compleja que la de búsqueda, y es en la que más tiempo nos pasaremos pensando.

Lo bueno de Lucene, es que tanto la indexación como la búsqueda giran entorno a lo mismo: el Document, que es sin duda uno de los elementos más importante. Entendiendo qué es el Document ya tenemos muchísimo ganado.

Además, acostumbrados como estamos a lo que es una Base de Datos, usaremos paralelismos, con la premisa de que sólo sirven para hacernos a una idea:

La "tabla" de la base de datos tiene su analogía en Lucene con el "index". Un "index" acaba siendo un directorio con varios archivos determinados, de los cuales no queremos saber nada. Sólo nos interesa saber su nombre y que todo el directorio debe tener permisos de lectura y escritura.
La "estructura de la tabla" de la base de datos es el "Document". El Document no se define de forma fija desde un principio. Lo vamos a generar en código, "al vuelo".
Los "campos de la tabla" son los "Fields" del Document. Igual que en una base de datos definiríamos el tipo de datos del "Field" o si es Nullable o no, los Fields de Lucene requieren una serie de definiciones que veremos en artículos posteriores.

Expresándolo en pseudocódigo:

Indexación
Función Indexar(parámetros)
{

Indice = AbrirIndice();

Document doc = new Document();
doc.AñadirField(new Field(parametros1));
doc.AñadirField(new Field(parametros2));

Indice.AñadirDocument(doc);

Indice.Cerrar();

}

Búsqueda
Función Buscar(parámetros)
{

Indice = AbrirIndice();

DocumentCollection docs = Indice.Buscar(parámetros);

Indice.Cerrar();

}

En próximos artículos veremos exactamente cómo se hace la indexación y como la búsqueda.